Log inside locks

frontend/sync-client/src/sync-operations/document-locks.test.ts

@@ -1,91 +0,0 @@
-import type { RelativePath } from "../persistence/database";
-import { DocumentLocks } from "./document-locks";
-
-describe("Document lock", () => {
-	const testPath: RelativePath = "test/document/path";
-	let locks = new DocumentLocks();
-
-	beforeEach(() => {
-		locks = new DocumentLocks();
-	});
-
-	test("should lock a document successfully", () => {
-		const result = locks.tryLockDocument(testPath);
-		expect(result).toBe(true);
-	});
-
-	test("should not lock a document that is already locked", () => {
-		locks.tryLockDocument(testPath);
-		const result = locks.tryLockDocument(testPath);
-		expect(result).toBe(false);
-	});
-
-	test("should unlock a locked document", () => {
-		locks.tryLockDocument(testPath);
-		locks.unlockDocument(testPath);
-		const result = locks.tryLockDocument(testPath);
-		expect(result).toBe(true);
-		locks.unlockDocument(testPath);
-	});
-
-	test("should throw an error when unlocking a document that is not locked", () => {
-		expect(() => {
-			locks.unlockDocument(testPath);
-		}).toThrow(`Document ${testPath} is not locked, cannot unlock`);
-	});
-
-	test("should wait for a document lock and resolve when unlocked", async () => {
-		locks.tryLockDocument(testPath);
-
-		let resolved = false;
-		const waitPromise = locks.waitForDocumentLock(testPath).then(() => {
-			resolved = true;
-		});
-
-		locks.unlockDocument(testPath);
-		await waitPromise;
-
-		expect(resolved).toBe(true);
-	});
-
-	test("should resolve multiple waiters in FIFO order", async () => {
-		locks.tryLockDocument(testPath);
-
-		let firstResolved = false;
-		let secondResolved = false;
-		let thirdResolved = false;
-
-		const firstWaitPromise = locks
-			.waitForDocumentLock(testPath)
-			.then(() => {
-				firstResolved = true;
-			});
-
-		const secondWaitPromise = locks
-			.waitForDocumentLock(testPath)
-			.then(() => {
-				secondResolved = true;
-			});
-
-		const thirdWaitPromise = locks
-			.waitForDocumentLock(testPath)
-			.then(() => {
-				thirdResolved = true;
-			});
-
-		locks.unlockDocument(testPath);
-		await firstWaitPromise;
-		expect(firstResolved).toBe(true);
-		expect(secondResolved).toBe(false);
-		expect(thirdResolved).toBe(false);
-
-		locks.unlockDocument(testPath);
-		await secondWaitPromise;
-		expect(secondResolved).toBe(true);
-		expect(thirdResolved).toBe(false);
-
-		locks.unlockDocument(testPath);
-		await thirdWaitPromise;
-		expect(thirdResolved).toBe(true);
-	});
-});

frontend/sync-client/src/sync-operations/document-locks.ts

@@ -1,55 +0,0 @@
-import type { RelativePath } from "../persistence/database";
-
-export class DocumentLocks {
-	private readonly locked = new Set<RelativePath>();
-	private readonly waiters = new Map<RelativePath, (() => void)[]>();
-
-	public tryLockDocument(relativePath: RelativePath): boolean {
-		if (this.locked.has(relativePath)) {
-			return false;
-		}
-
-		this.locked.add(relativePath);
-		return true;
-	}
-
-	public async waitForDocumentLock(
-		relativePath: RelativePath
-	): Promise<void> {
-		if (this.tryLockDocument(relativePath)) {
-			return Promise.resolve();
-		}
-
-		return new Promise((resolve) => {
-			let waiting = this.waiters.get(relativePath);
-			if (!waiting) {
-				waiting = [];
-				this.waiters.set(relativePath, waiting);
-			}
-
-			waiting.push(resolve);
-		});
-	}
-
-	public unlockDocument(relativePath: RelativePath): void {
-		if (!this.locked.has(relativePath)) {
-			throw new Error(
-				`Document ${relativePath} is not locked, cannot unlock`
-			);
-		}
-
-		// Remove the first element to ensure FIFO unblocking order
-		const nextWaiting = this.waiters.get(relativePath)?.shift();
-
-		if (nextWaiting) {
-			nextWaiting();
-		} else {
-			this.locked.delete(relativePath);
-		}
-	}
-
-	public reset(): void {
-		this.locked.clear();
-		this.waiters.clear();
-	}
-}