Add cursor moving (#19)

frontend/sync-client/src/file-operations/file-operations.test.ts

@@ -6,7 +6,10 @@ import type {
 import { FileOperations } from "./file-operations";
 import { Logger } from "../tracing/logger";
 import { assertSetContainsExactly } from "../utils/assert-set-contains-exactly";
-import type { FileSystemOperations } from "./filesystem-operations";
+import type {
+	FileSystemOperations,
+	TextWithCursors
+} from "./filesystem-operations";
 import init, { base64ToBytes } from "sync_lib";
 import fs from "fs";
 
@@ -43,7 +46,7 @@ class FakeFileSystemOperations implements FileSystemOperations {
 	}
 	public async atomicUpdateText(
 		_path: RelativePath,
-		_updater: (currentContent: string) => string
+		_updater: (current: TextWithCursors) => TextWithCursors
 	): Promise<string> {
 		throw new Error("Method not implemented.");
 	}

frontend/sync-client/src/file-operations/file-operations.ts

@@ -1,7 +1,16 @@
 import type { Logger } from "../tracing/logger";
-import type { FileSystemOperations } from "./filesystem-operations";
+import type {
+	FileSystemOperations,
+	TextWithCursors
+} from "./filesystem-operations";
 import type { Database, RelativePath } from "../persistence/database";
-import { isBinary, isFileTypeMergable, mergeText } from "sync_lib";
+import {
+	CursorPosition,
+	isBinary,
+	isFileTypeMergable,
+	mergeTextWithCursors,
+	TextWithCursors as RustTextWithCursors
+} from "sync_lib";
 import { SafeFileSystemOperations } from "./safe-filesystem-operations";
 
 export class FileOperations {
@@ -90,18 +99,45 @@ export class FileOperations {
 		const expectedText = new TextDecoder().decode(expectedContent); // this comes from a previous read which must only have \n line endings
 		const newText = new TextDecoder().decode(newContent); // this comes from the server which stores text with \n line endings
 
-		await this.fs.atomicUpdateText(path, (currentText) => {
-			currentText = currentText.replace(this.nativeLineEndings, "\n");
+		await this.fs.atomicUpdateText(
+			path,
+			({ text, cursors }: TextWithCursors): TextWithCursors => {
+				text = text.replace(this.nativeLineEndings, "\n");
 
-			this.logger.debug(
-				`Performing a 3-way merge for ${path} with the expected content`
-			);
+				this.logger.debug(
+					`Performing a 3-way merge for ${path} with the expected content`
+				);
 
-			return mergeText(expectedText, currentText, newText).replace(
-				"\n",
-				this.nativeLineEndings
-			);
-		});
+				const left = new RustTextWithCursors(
+					text,
+					cursors.map(
+						(cursor) =>
+							new CursorPosition(
+								cursor.id,
+								cursor.characterPosition
+							)
+					)
+				);
+				const right = new RustTextWithCursors(newText, []);
+				const merged = mergeTextWithCursors(expectedText, left, right);
+
+				const resultText = merged
+					.text()
+					.replace("\n", this.nativeLineEndings);
+
+				const resultCursors = merged.cursors().map((cursor) => ({
+					id: cursor.id(),
+					characterPosition: cursor.characterPosition()
+				}));
+
+				merged.free();
+
+				return {
+					text: resultText,
+					cursors: resultCursors
+				};
+			}
+		);
 	}
 
 	public async delete(path: RelativePath): Promise<void> {

frontend/sync-client/src/file-operations/filesystem-operations.ts

@@ -1,5 +1,15 @@
 import type { RelativePath } from "../persistence/database";
 
+export interface Cursor {
+	id: number;
+	characterPosition: number;
+}
+
+export interface TextWithCursors {
+	text: string;
+	cursors: Cursor[];
+}
+
 export interface FileSystemOperations {
 	// List all files that should be synced.
 	listAllFiles: () => Promise<RelativePath[]>;
@@ -13,7 +23,7 @@ export interface FileSystemOperations {
 	// Atomically update the content of a text file.
 	atomicUpdateText: (
 		path: RelativePath,
-		updater: (currentContent: string) => string
+		updater: (current: TextWithCursors) => TextWithCursors
 	) => Promise<string>;
 
 	// Get the size of a file in bytes.

frontend/sync-client/src/file-operations/safe-filesystem-operations.ts

@@ -1,5 +1,8 @@
 import type { RelativePath } from "../persistence/database";
-import type { FileSystemOperations } from "./filesystem-operations";
+import type {
+	FileSystemOperations,
+	TextWithCursors
+} from "./filesystem-operations";
 import type { Logger } from "../tracing/logger";
 import { Locks } from "../utils/locks";
 import { FileNotFoundError } from "./file-not-found-error";
@@ -44,7 +47,7 @@ export class SafeFileSystemOperations implements FileSystemOperations {
 
 	public async atomicUpdateText(
 		path: RelativePath,
-		updater: (currentContent: string) => string
+		updater: (current: TextWithCursors) => TextWithCursors
 	): Promise<string> {
 		this.logger.debug(`Atomically updating file '${path}'`);
 		return this.safeOperation(

frontend/sync-client/src/index.ts

@@ -8,7 +8,11 @@ export { Logger, LogLevel, LogLine } from "./tracing/logger";
 export { type SyncSettings } from "./persistence/settings";
 export { rateLimit } from "./utils/rate-limit";
 export type { RelativePath, StoredDatabase } from "./persistence/database";
-export type { FileSystemOperations } from "./file-operations/filesystem-operations";
+export type {
+	FileSystemOperations,
+	TextWithCursors,
+	Cursor
+} from "./file-operations/filesystem-operations";
 export type { PersistenceProvider } from "./persistence/persistence";
 
 export type { NetworkConnectionStatus } from "./sync-client";

frontend/sync-client/src/sync-operations/syncer.ts

@@ -266,6 +266,8 @@ export class Syncer {
 		wsUri.protocol = wsUri.protocol === "https" ? "wss" : "ws";
 		wsUri.pathname = `/vaults/${settings.vaultName}/ws`;
 
+		this.logger.info(`Connecting to WebSocket at ${wsUri.toString()}`);
+
 		if (
 			typeof globalThis !== "undefined" &&
 			typeof globalThis.WebSocket === "undefined"
@@ -288,6 +290,7 @@ export class Syncer {
 
 		// The JS WebSocket API doesn't support setting headers, so we have to send the token as a message
 		this.applyRemoteChangesWebSocket.onopen = (): void => {
+			this.logger.info("WebSocket connection opened");
 			this.applyRemoteChangesWebSocket?.send(settings.token);
 			this.webSocketStatusChangeListeners.forEach((listener) => {
 				listener();
@@ -476,7 +479,10 @@ export class Syncer {
 				.filter(
 					(remoteDocument) =>
 						allLocalFiles.includes(remoteDocument.relativePath) &&
-						!remoteDocument.isDeleted
+						!remoteDocument.isDeleted &&
+						this.database.getDocumentByDocumentId(
+							remoteDocument.documentId
+						) === undefined
 				)
 				.forEach((remoteDocument) => {
 					this.database.createNewEmptyDocument(