514 lines
19 KiB
TypeScript
514 lines
19 KiB
TypeScript
import { describe, it } from "node:test";
|
|
import assert from "node:assert";
|
|
import { SyncEventQueue } from "./sync-event-queue";
|
|
import { Settings } from "../persistence/settings";
|
|
import { Logger } from "../tracing/logger";
|
|
import type { DocumentVersionWithoutContent } from "../services/types/DocumentVersionWithoutContent";
|
|
import { SyncEventType } from "./types";
|
|
|
|
function createQueue(ignorePatterns: string[] = []): SyncEventQueue {
|
|
const logger = new Logger();
|
|
const settings = new Settings(logger, { ignorePatterns }, async () => { });
|
|
return new SyncEventQueue(settings, logger, undefined, async () => { });
|
|
}
|
|
|
|
function fakeRemoteVersion(
|
|
documentId: string,
|
|
overrides: Partial<DocumentVersionWithoutContent> = {}
|
|
): DocumentVersionWithoutContent {
|
|
return {
|
|
vaultUpdateId: 1,
|
|
documentId,
|
|
relativePath: `${documentId}.md`,
|
|
updatedDate: "2026-01-01",
|
|
isDeleted: false,
|
|
userId: "user",
|
|
deviceId: "device",
|
|
contentSize: 100,
|
|
...overrides
|
|
};
|
|
}
|
|
|
|
describe("SyncEventQueue", () => {
|
|
it("sync-local followed by delete for the same document returns only the delete", async () => {
|
|
const queue = createQueue();
|
|
queue.setDocument("a.md", {
|
|
documentId: "A",
|
|
parentVersionId: 1,
|
|
remoteHash: "hash-a"
|
|
});
|
|
|
|
queue.enqueue({ type: SyncEventType.LocalUpdate, path: "a.md" });
|
|
queue.enqueue({ type: SyncEventType.LocalUpdate, path: "a.md" });
|
|
queue.enqueue({ type: SyncEventType.LocalDelete, path: "a.md" });
|
|
|
|
const event = await queue.next();
|
|
assert.strictEqual(event?.type, SyncEventType.LocalDelete);
|
|
if (event?.type === SyncEventType.LocalDelete) {
|
|
assert.strictEqual(event.documentId, "A");
|
|
}
|
|
assert.strictEqual(await queue.next(), undefined);
|
|
});
|
|
|
|
it("sync-local events for the same document coalesce to one", async () => {
|
|
const queue = createQueue();
|
|
queue.setDocument("a.md", {
|
|
documentId: "A",
|
|
parentVersionId: 1,
|
|
remoteHash: "hash-a"
|
|
});
|
|
|
|
queue.enqueue({ type: SyncEventType.LocalUpdate, path: "a.md" });
|
|
queue.enqueue({ type: SyncEventType.LocalUpdate, path: "a.md" });
|
|
queue.enqueue({ type: SyncEventType.LocalUpdate, path: "a.md" });
|
|
|
|
const event = await queue.next();
|
|
assert.strictEqual(event?.type, SyncEventType.LocalUpdate);
|
|
assert.strictEqual(await queue.next(), undefined);
|
|
});
|
|
|
|
it("sync-remote-content events for the same documentId coalesce to the last one", async () => {
|
|
const queue = createQueue();
|
|
|
|
queue.enqueue({
|
|
type: SyncEventType.RemoteUpdate,
|
|
remoteVersion: fakeRemoteVersion("A", { vaultUpdateId: 1 })
|
|
});
|
|
queue.enqueue({
|
|
type: SyncEventType.RemoteUpdate,
|
|
remoteVersion: fakeRemoteVersion("A", { vaultUpdateId: 2 })
|
|
});
|
|
queue.enqueue({
|
|
type: SyncEventType.RemoteUpdate,
|
|
remoteVersion: fakeRemoteVersion("A", { vaultUpdateId: 3 })
|
|
});
|
|
|
|
const event = await queue.next();
|
|
assert.strictEqual(event?.type, SyncEventType.RemoteUpdate);
|
|
if (event?.type === SyncEventType.RemoteUpdate) {
|
|
assert.strictEqual(event.remoteVersion.vaultUpdateId, 3);
|
|
}
|
|
assert.strictEqual(await queue.next(), undefined);
|
|
});
|
|
|
|
it("create events are returned FIFO", async () => {
|
|
const queue = createQueue();
|
|
queue.enqueue({ type: SyncEventType.LocalCreate, path: "a.md" });
|
|
queue.enqueue({ type: SyncEventType.LocalCreate, path: "b.md" });
|
|
|
|
const first = await queue.next();
|
|
assert.strictEqual(first?.type, SyncEventType.LocalCreate);
|
|
if (first?.type === SyncEventType.LocalCreate) {
|
|
assert.strictEqual(first.path, "a.md");
|
|
}
|
|
|
|
const second = await queue.next();
|
|
assert.strictEqual(second?.type, SyncEventType.LocalCreate);
|
|
if (second?.type === SyncEventType.LocalCreate) {
|
|
assert.strictEqual(second.path, "b.md");
|
|
}
|
|
});
|
|
|
|
it("delete resolves documentId from path", async () => {
|
|
const queue = createQueue();
|
|
queue.setDocument("a.md", {
|
|
documentId: "A",
|
|
parentVersionId: 1,
|
|
remoteHash: "hash-a"
|
|
});
|
|
|
|
queue.enqueue({ type: SyncEventType.LocalDelete, path: "a.md" });
|
|
|
|
const event = await queue.next();
|
|
assert.strictEqual(event?.type, SyncEventType.LocalDelete);
|
|
if (event?.type === SyncEventType.LocalDelete) {
|
|
assert.strictEqual(event.documentId, "A");
|
|
}
|
|
});
|
|
|
|
it("delete for unknown path is silently ignored", () => {
|
|
const queue = createQueue();
|
|
queue.enqueue({ type: SyncEventType.LocalDelete, path: "unknown.md" });
|
|
assert.strictEqual(queue.pendingUpdateCount, 0);
|
|
});
|
|
|
|
it("document store CRUD operations work correctly", () => {
|
|
const queue = createQueue();
|
|
|
|
assert.strictEqual(queue.getSettledDocumentByPath("a.md"), undefined);
|
|
assert.strictEqual(queue.syncedDocumentCount, 0);
|
|
|
|
queue.setDocument("a.md", {
|
|
documentId: "A",
|
|
parentVersionId: 1,
|
|
remoteHash: "hash-a"
|
|
});
|
|
assert.strictEqual(queue.syncedDocumentCount, 1);
|
|
assert.deepStrictEqual(queue.getSettledDocumentByPath("a.md"), {
|
|
documentId: "A",
|
|
parentVersionId: 1,
|
|
remoteHash: "hash-a"
|
|
});
|
|
|
|
const found = queue.getDocumentByDocumentId("A");
|
|
assert.strictEqual(found?.path, "a.md");
|
|
assert.strictEqual(found?.record.documentId, "A");
|
|
|
|
queue.removeDocument("a.md");
|
|
assert.strictEqual(queue.syncedDocumentCount, 0);
|
|
assert.strictEqual(queue.getSettledDocumentByPath("a.md"), undefined);
|
|
});
|
|
|
|
it("SyncLocal with oldPath moves the document in the store", () => {
|
|
const queue = createQueue();
|
|
queue.setDocument("a.md", {
|
|
documentId: "A",
|
|
parentVersionId: 1,
|
|
remoteHash: "hash-a"
|
|
});
|
|
|
|
queue.enqueue({ type: SyncEventType.LocalUpdate, path: "b.md", oldPath: "a.md" });
|
|
assert.strictEqual(queue.getSettledDocumentByPath("a.md"), undefined);
|
|
assert.strictEqual(queue.getSettledDocumentByPath("b.md")?.documentId, "A");
|
|
});
|
|
|
|
it("interleaved events for different documents are not confused", async () => {
|
|
const queue = createQueue();
|
|
queue.setDocument("a.md", {
|
|
documentId: "A",
|
|
parentVersionId: 1,
|
|
remoteHash: "hash-a"
|
|
});
|
|
queue.setDocument("b.md", {
|
|
documentId: "B",
|
|
parentVersionId: 2,
|
|
remoteHash: "hash-b"
|
|
});
|
|
|
|
queue.enqueue({ type: SyncEventType.LocalUpdate, path: "a.md" });
|
|
queue.enqueue({ type: SyncEventType.LocalUpdate, path: "b.md" });
|
|
queue.enqueue({ type: SyncEventType.LocalDelete, path: "a.md" });
|
|
queue.enqueue({ type: SyncEventType.LocalUpdate, path: "b.md" });
|
|
|
|
// First next() should see the delete for A (coalescing sync-local + delete)
|
|
const first = await queue.next();
|
|
assert.strictEqual(first?.type, SyncEventType.LocalDelete);
|
|
if (first?.type === SyncEventType.LocalDelete) {
|
|
assert.strictEqual(first.documentId, "A");
|
|
}
|
|
|
|
// Remaining should be the coalesced sync-local for B
|
|
const second = await queue.next();
|
|
assert.strictEqual(second?.type, SyncEventType.LocalUpdate);
|
|
if (second?.type === SyncEventType.LocalUpdate) {
|
|
assert.strictEqual(second.documentId, "B");
|
|
}
|
|
|
|
assert.strictEqual(await queue.next(), undefined);
|
|
});
|
|
|
|
it("delete discards subsequent sync-remote-content events for the same document", async () => {
|
|
const queue = createQueue();
|
|
queue.setDocument("a.md", {
|
|
documentId: "A",
|
|
parentVersionId: 1,
|
|
remoteHash: "hash-a"
|
|
});
|
|
|
|
queue.enqueue({ type: SyncEventType.LocalDelete, path: "a.md" });
|
|
queue.enqueue({
|
|
type: SyncEventType.RemoteUpdate,
|
|
remoteVersion: fakeRemoteVersion("A", { vaultUpdateId: 5 })
|
|
});
|
|
|
|
const event = await queue.next();
|
|
assert.strictEqual(event?.type, SyncEventType.LocalDelete);
|
|
assert.strictEqual(await queue.next(), undefined);
|
|
});
|
|
|
|
it("delete discards subsequent sync-local and sync-remote-content for the same document", async () => {
|
|
const queue = createQueue();
|
|
queue.setDocument("a.md", {
|
|
documentId: "A",
|
|
parentVersionId: 1,
|
|
remoteHash: "hash-a"
|
|
});
|
|
|
|
queue.enqueue({ type: SyncEventType.LocalDelete, path: "a.md" });
|
|
queue.enqueue({ type: SyncEventType.LocalUpdate, path: "a.md" });
|
|
queue.enqueue({ type: SyncEventType.LocalCreate, path: "b.md" });
|
|
queue.enqueue({
|
|
type: SyncEventType.RemoteUpdate,
|
|
remoteVersion: fakeRemoteVersion("A", { vaultUpdateId: 5 })
|
|
});
|
|
|
|
const first = await queue.next();
|
|
assert.strictEqual(first?.type, SyncEventType.LocalDelete);
|
|
|
|
// Only the unrelated create should remain
|
|
const second = await queue.next();
|
|
assert.strictEqual(second?.type, SyncEventType.LocalCreate);
|
|
assert.strictEqual(await queue.next(), undefined);
|
|
});
|
|
|
|
it("delete with promise documentId does not discard other events", async () => {
|
|
const queue = createQueue();
|
|
queue.setDocument("a.md", {
|
|
documentId: "A",
|
|
parentVersionId: 1,
|
|
remoteHash: "hash-a"
|
|
});
|
|
|
|
// Create is pending — Delete for same path gets a promise documentId
|
|
queue.enqueue({ type: SyncEventType.LocalCreate, path: "unknown.md" });
|
|
queue.enqueue({ type: SyncEventType.LocalDelete, path: "unknown.md" });
|
|
queue.enqueue({ type: SyncEventType.LocalUpdate, path: "a.md" });
|
|
|
|
// Dequeue and resolve the Create
|
|
const event = await queue.next();
|
|
assert.ok(event?.type === SyncEventType.LocalCreate);
|
|
event.resolvers!.resolve("NEW");
|
|
|
|
await queue.next(); // delete
|
|
const second = await queue.next();
|
|
assert.strictEqual(second?.type, SyncEventType.LocalUpdate);
|
|
});
|
|
|
|
it("getCreatePromise returns a promise resolved by the event's resolvers", async () => {
|
|
const queue = createQueue();
|
|
queue.enqueue({ type: SyncEventType.LocalCreate, path: "a.md" });
|
|
|
|
const promise = queue.getLatestCreatePromise("a.md");
|
|
assert.ok(promise !== undefined);
|
|
|
|
// The syncer resolves via event.resolvers after dequeuing
|
|
const event = await queue.next();
|
|
assert.ok(event?.type === SyncEventType.LocalCreate);
|
|
assert.ok(event.resolvers !== undefined);
|
|
event.resolvers.resolve("resolved-id");
|
|
|
|
assert.strictEqual(await promise, "resolved-id");
|
|
});
|
|
|
|
it("rejecting the event's resolvers rejects the create promise", async () => {
|
|
const queue = createQueue();
|
|
queue.enqueue({ type: SyncEventType.LocalCreate, path: "a.md" });
|
|
|
|
const promise = queue.getLatestCreatePromise("a.md");
|
|
assert.ok(promise !== undefined);
|
|
|
|
const event = await queue.next();
|
|
assert.ok(event?.type === SyncEventType.LocalCreate);
|
|
assert.ok(event.resolvers !== undefined);
|
|
event.resolvers.promise.catch(() => { });
|
|
event.resolvers.reject(new Error("cancelled"));
|
|
|
|
await assert.rejects(promise);
|
|
});
|
|
|
|
it("clear rejects all pending create promises", async () => {
|
|
const queue = createQueue();
|
|
queue.enqueue({ type: SyncEventType.LocalCreate, path: "a.md" });
|
|
queue.enqueue({ type: SyncEventType.LocalCreate, path: "b.md" });
|
|
|
|
const promiseA = queue.getLatestCreatePromise("a.md");
|
|
const promiseB = queue.getLatestCreatePromise("b.md");
|
|
assert.ok(promiseA !== undefined);
|
|
assert.ok(promiseB !== undefined);
|
|
|
|
queue.clear();
|
|
|
|
await assert.rejects(promiseA);
|
|
await assert.rejects(promiseB);
|
|
});
|
|
|
|
it("create can be re-enqueued after being dequeued", async () => {
|
|
const queue = createQueue();
|
|
queue.enqueue({ type: SyncEventType.LocalCreate, path: "a.md" });
|
|
await queue.next();
|
|
|
|
queue.enqueue({ type: SyncEventType.LocalCreate, path: "a.md" });
|
|
assert.strictEqual(queue.pendingUpdateCount, 1);
|
|
});
|
|
|
|
it("silently ignores create events matching ignore patterns", () => {
|
|
const queue = createQueue(["*.tmp", ".hidden/**"]);
|
|
|
|
queue.enqueue({ type: SyncEventType.LocalCreate, path: "scratch.tmp" });
|
|
queue.enqueue({ type: SyncEventType.LocalCreate, path: ".hidden/secret.md" });
|
|
assert.strictEqual(queue.pendingUpdateCount, 0);
|
|
|
|
queue.enqueue({ type: SyncEventType.LocalCreate, path: "notes-new.md" });
|
|
assert.strictEqual(queue.pendingUpdateCount, 1);
|
|
|
|
queue.enqueue({
|
|
type: SyncEventType.RemoteUpdate,
|
|
remoteVersion: fakeRemoteVersion("N")
|
|
});
|
|
assert.strictEqual(queue.pendingUpdateCount, 2);
|
|
});
|
|
|
|
it("clear removes events but keeps documents", () => {
|
|
const queue = createQueue();
|
|
queue.setDocument("a.md", {
|
|
documentId: "A",
|
|
parentVersionId: 1,
|
|
remoteHash: "hash-a"
|
|
});
|
|
queue.enqueue({ type: SyncEventType.LocalCreate, path: "b.md" });
|
|
queue.enqueue({ type: SyncEventType.LocalUpdate, path: "a.md" });
|
|
|
|
assert.strictEqual(queue.pendingUpdateCount, 2);
|
|
|
|
queue.clear();
|
|
|
|
assert.strictEqual(queue.pendingUpdateCount, 0);
|
|
assert.strictEqual(queue.syncedDocumentCount, 1);
|
|
assert.strictEqual(queue.getSettledDocumentByPath("a.md")?.documentId, "A");
|
|
});
|
|
|
|
it("allDocuments returns all tracked documents", () => {
|
|
const queue = createQueue();
|
|
queue.setDocument("a.md", {
|
|
documentId: "A",
|
|
parentVersionId: 1,
|
|
remoteHash: "hash-a"
|
|
});
|
|
queue.setDocument("b.md", {
|
|
documentId: "B",
|
|
parentVersionId: 2,
|
|
remoteHash: "hash-b"
|
|
});
|
|
|
|
const docs = queue.allSettledDocuments();
|
|
assert.strictEqual(docs.length, 2);
|
|
const paths = docs.map(([p]) => p).sort();
|
|
assert.deepStrictEqual(paths, ["a.md", "b.md"]);
|
|
});
|
|
|
|
it("loads initial state from persistence", () => {
|
|
const logger = new Logger();
|
|
const settings = new Settings(logger, {}, async () => { });
|
|
const queue = new SyncEventQueue(settings, logger, {
|
|
documents: [
|
|
{
|
|
relativePath: "a.md",
|
|
documentId: "A",
|
|
parentVersionId: 5,
|
|
remoteHash: "hash-a"
|
|
},
|
|
{
|
|
relativePath: "b.md",
|
|
documentId: "B",
|
|
parentVersionId: 3,
|
|
remoteHash: "hash-b"
|
|
}
|
|
],
|
|
lastSeenUpdateId: 4
|
|
}, async () => { });
|
|
|
|
assert.strictEqual(queue.syncedDocumentCount, 2);
|
|
assert.strictEqual(queue.getSettledDocumentByPath("a.md")?.documentId, "A");
|
|
assert.strictEqual(queue.getSettledDocumentByPath("b.md")?.documentId, "B");
|
|
assert.strictEqual(queue.lastSeenUpdateId, 5);
|
|
});
|
|
|
|
it("trackedPaths combines documents and pending events", () => {
|
|
const queue = createQueue();
|
|
queue.setDocument("a.md", {
|
|
documentId: "A",
|
|
parentVersionId: 1,
|
|
remoteHash: "hash-a"
|
|
});
|
|
queue.setDocument("b.md", {
|
|
documentId: "B",
|
|
parentVersionId: 2,
|
|
remoteHash: "hash-b"
|
|
});
|
|
|
|
// Pending create adds a path
|
|
queue.enqueue({ type: SyncEventType.LocalCreate, path: "c.md" });
|
|
// Pending delete removes a path
|
|
queue.enqueue({ type: SyncEventType.LocalDelete, path: "a.md" });
|
|
|
|
const paths = queue.trackedPaths();
|
|
assert.deepStrictEqual(
|
|
[...paths].sort(),
|
|
["b.md", "c.md"]
|
|
);
|
|
});
|
|
|
|
it("trackedPaths handles create-delete-create for the same path", () => {
|
|
const queue = createQueue();
|
|
|
|
queue.enqueue({ type: SyncEventType.LocalCreate, path: "a.md" });
|
|
// Delete gets promise documentId from pending Create
|
|
queue.enqueue({ type: SyncEventType.LocalDelete, path: "a.md" });
|
|
queue.enqueue({ type: SyncEventType.LocalCreate, path: "a.md" });
|
|
|
|
const paths = queue.trackedPaths();
|
|
assert.ok(paths.has("a.md"));
|
|
});
|
|
|
|
it("trackedPaths applies moves for pending SyncLocal events", () => {
|
|
const queue = createQueue();
|
|
|
|
queue.enqueue({ type: SyncEventType.LocalCreate, path: "a.md" });
|
|
|
|
// File was renamed from a.md to b.md
|
|
queue.enqueue({ type: SyncEventType.LocalUpdate, path: "b.md", oldPath: "a.md" });
|
|
|
|
const paths = queue.trackedPaths();
|
|
assert.ok(!paths.has("a.md"));
|
|
assert.ok(paths.has("b.md"));
|
|
});
|
|
|
|
it("trackedPaths tracks multiple moves for the same pending create", () => {
|
|
const queue = createQueue();
|
|
|
|
queue.enqueue({ type: SyncEventType.LocalCreate, path: "a.md" });
|
|
|
|
queue.enqueue({ type: SyncEventType.LocalUpdate, path: "b.md", oldPath: "a.md" });
|
|
queue.enqueue({ type: SyncEventType.LocalUpdate, path: "c.md", oldPath: "b.md" });
|
|
|
|
const paths = queue.trackedPaths();
|
|
assert.ok(!paths.has("a.md"));
|
|
assert.ok(!paths.has("b.md"));
|
|
assert.ok(paths.has("c.md"));
|
|
});
|
|
|
|
it("resolveCreate settles the document and replaces promise documentIds in the queue", async () => {
|
|
const queue = createQueue();
|
|
|
|
queue.enqueue({ type: SyncEventType.LocalCreate, path: "a.md" });
|
|
const createPromise = queue.getLatestCreatePromise("a.md")!;
|
|
|
|
// Dependent events enqueued while create is still pending
|
|
queue.enqueue({ type: SyncEventType.LocalUpdate, path: "a.md" });
|
|
queue.enqueue({ type: SyncEventType.LocalDelete, path: "a.md" });
|
|
|
|
const event = await queue.next(); // dequeue the create
|
|
assert.ok(event?.type === SyncEventType.LocalCreate);
|
|
|
|
queue.resolveCreate(event, {
|
|
documentId: "DOC-1",
|
|
parentVersionId: 5,
|
|
remoteHash: "hash-1",
|
|
});
|
|
|
|
// Document is now settled
|
|
assert.strictEqual(queue.getSettledDocumentByPath("a.md")?.documentId, "DOC-1");
|
|
|
|
// Promise was resolved
|
|
assert.strictEqual(await createPromise, "DOC-1");
|
|
|
|
// Remaining events have string documentIds instead of promises.
|
|
// The SyncLocal + Delete for "DOC-1" coalesce: sync-local is
|
|
// discarded and the delete is returned (standard coalescing).
|
|
const deleteEvt = await queue.next();
|
|
assert.ok(deleteEvt?.type === SyncEventType.LocalDelete);
|
|
assert.strictEqual(deleteEvt.documentId, "DOC-1");
|
|
|
|
assert.strictEqual(await queue.next(), undefined);
|
|
});
|
|
});
|