@graffiti-garden/wrapper-synchronize 0.1.1 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graffiti-garden/wrapper-synchronize",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "Internal synchronization for the Graffiti API",
   "types": "./dist/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -53,8 +53,8 @@
     "vitest": "^3.0.5"
   },
   "dependencies": {
-    "@graffiti-garden/api": "^0.5.1",
-    "@graffiti-garden/implementation-local": "^0.5.1",
+    "@graffiti-garden/api": "^0.6.1",
+    "@graffiti-garden/implementation-local": "^0.6.1",
     "@repeaterjs/repeater": "^3.0.6",
     "ajv": "^8.17.1",
     "esbuild-plugin-polyfill-node": "^0.3.0",

package/src/index.spec.ts

@@ -37,16 +37,17 @@ describe.concurrent("synchronizeDiscover", () => {
 
     const graffiti2 = useGraffiti();
     const next = graffiti2.synchronizeDiscover(channels, {}).next();
+    await new Promise((resolve) => setTimeout(resolve, 100));
     const gotten = await graffiti2.get(putted, {}, session);
 
-    const result = (await next).value;
-    if (!result || result.error) {
+    const result = await next;
+    if (result.done || result.value.error) {
       throw new Error("Error in synchronize");
     }
-    expect(result.value.value).toEqual(object.value);
-    expect(result.value.channels).toEqual(channels);
-    expect(result.value.tombstone).toBe(false);
-    expect(result.value.lastModified).toEqual(gotten.lastModified);
+    assert(!result.value.tombstone);
+    expect(result.value.object.value).toEqual(object.value);
+    expect(result.value.object.channels).toEqual(channels);
+    expect(result.value.object.lastModified).toEqual(gotten.lastModified);
   });
 
   it("put", async () => {
@@ -54,6 +55,11 @@ describe.concurrent("synchronizeDiscover", () => {
     const afterChannel = randomString();
     const sharedChannel = randomString();
 
+    // Start listening for changes...
+    const beforeIterator = graffiti.synchronizeDiscover([beforeChannel], {});
+    // Skip the first result
+    beforeIterator.next();
+
     const oldValue = { hello: "world" };
     const oldChannels = [beforeChannel, sharedChannel];
     const putted = await graffiti.put<{}>(
@@ -64,15 +70,17 @@ describe.concurrent("synchronizeDiscover", () => {
       session,
     );
 
-    // Start listening for changes...
-    const before = graffiti.synchronizeDiscover([beforeChannel], {}).next();
+    const beforeButAfter = graffiti
+      .synchronizeDiscover([beforeChannel], {})
+      .next();
+    const before = beforeIterator.next();
     const after = graffiti.synchronizeDiscover([afterChannel], {}).next();
     const shared = graffiti.synchronizeDiscover([sharedChannel], {}).next();
 
     // Replace the object
     const newValue = { goodbye: "world" };
     const newChannels = [afterChannel, sharedChannel];
-    await graffiti.put<{}>(
+    const putted2 = await graffiti.put<{}>(
       {
         url: putted.url,
         value: newValue,
@@ -81,34 +89,40 @@ describe.concurrent("synchronizeDiscover", () => {
       session,
     );
 
-    const beforeResult = (await before).value;
-    const afterResult = (await after).value;
-    const sharedResult = (await shared).value;
-    if (
-      !beforeResult ||
-      beforeResult.error ||
-      !afterResult ||
-      afterResult.error ||
-      !sharedResult ||
-      sharedResult.error
-    ) {
-      throw new Error("Error in synchronize");
-    }
+    // If you just start synchronizing after the first put,
+    // it won't show the deletion because it never saw the object.
+    await expect(
+      // @ts-ignore
+      Promise.race([
+        beforeButAfter,
+        new Promise((resolve, reject) => setTimeout(reject, 100, "Timeout")),
+      ]),
+    ).rejects.toThrow("Timeout");
 
-    expect(beforeResult.value.value).toEqual(oldValue);
-    expect(beforeResult.value.channels).toEqual([beforeChannel]);
-    expect(beforeResult.value.tombstone).toBe(true);
-    expect(afterResult.value.value).toEqual(newValue);
-    expect(afterResult.value.channels).toEqual([afterChannel]);
-    expect(afterResult.value.tombstone).toBe(false);
-    expect(sharedResult.value.value).toEqual(newValue);
-    expect(sharedResult.value.channels).toEqual([sharedChannel]);
-    expect(sharedResult.value.tombstone).toBe(false);
-    expect(beforeResult.value.lastModified).toEqual(
-      afterResult.value.lastModified,
+    const beforeResult = await before;
+    const afterResult = await after;
+    const sharedResult = await shared;
+    assert(!beforeResult.done && !beforeResult.value.error, "Error in before");
+    assert(!afterResult.done && !afterResult.value.error, "Error in after");
+    assert(!sharedResult.done && !sharedResult.value.error, "Error in shared");
+
+    assert(beforeResult.value.tombstone, "Before is not tombstone");
+    assert(!afterResult.value.tombstone, "After is tombstone");
+    assert(!sharedResult.value.tombstone, "Shared is tombstone");
+
+    expect(beforeResult.value.object.url).toEqual(putted.url);
+    expect(beforeResult.value.object.lastModified).toEqual(
+      putted2.lastModified,
+    );
+    expect(afterResult.value.object.value).toEqual(newValue);
+    expect(afterResult.value.object.channels).toEqual([afterChannel]);
+    expect(sharedResult.value.object.value).toEqual(newValue);
+    expect(sharedResult.value.object.channels).toEqual([sharedChannel]);
+    expect(beforeResult.value.object.lastModified).toEqual(
+      afterResult.value.object.lastModified,
     );
-    expect(sharedResult.value.lastModified).toEqual(
-      afterResult.value.lastModified,
+    expect(sharedResult.value.object.lastModified).toEqual(
+      afterResult.value.object.lastModified,
     );
   });
 
@@ -117,6 +131,11 @@ describe.concurrent("synchronizeDiscover", () => {
     const afterChannel = randomString();
     const sharedChannel = randomString();
 
+    // Start listening for changes...
+    const beforeIterator = graffiti.synchronizeDiscover([beforeChannel], {});
+    // Skip the first result
+    beforeIterator.next();
+
     const oldValue = { hello: "world" };
     const oldChannels = [beforeChannel, sharedChannel];
     const putted = await graffiti.put<{}>(
@@ -127,12 +146,14 @@ describe.concurrent("synchronizeDiscover", () => {
       session,
     );
 
-    // Start listening for changes...
-    const before = graffiti.synchronizeDiscover([beforeChannel], {}).next();
+    const beforeButAfter = graffiti
+      .synchronizeDiscover([beforeChannel], {})
+      .next();
+    const before = beforeIterator.next();
     const after = graffiti.synchronizeDiscover([afterChannel], {}).next();
     const shared = graffiti.synchronizeDiscover([sharedChannel], {}).next();
 
-    await graffiti.patch(
+    const patched = await graffiti.patch(
       {
         value: [
           {
@@ -157,42 +178,52 @@ describe.concurrent("synchronizeDiscover", () => {
       session,
     );
 
-    const beforeResult = (await before).value;
-    const afterResult = (await after).value;
-    const sharedResult = (await shared).value;
-    if (
-      !beforeResult ||
-      beforeResult.error ||
-      !afterResult ||
-      afterResult.error ||
-      !sharedResult ||
-      sharedResult.error
-    ) {
-      throw new Error("Error in synchronize");
-    }
+    // If you just start synchronizing after the first put,
+    // it won't show the deletion because it never saw the object.
+    await expect(
+      // @ts-ignore
+      Promise.race([
+        beforeButAfter,
+        new Promise((resolve, reject) => setTimeout(reject, 100, "Timeout")),
+      ]),
+    ).rejects.toThrow("Timeout");
+
+    const beforeResult = await before;
+    const afterResult = await after;
+    const sharedResult = await shared;
+    assert(!beforeResult.done && !beforeResult.value.error, "Error in before");
+    assert(!afterResult.done && !afterResult.value.error, "Error in after");
+    assert(!sharedResult.done && !sharedResult.value.error, "Error in shared");
+
+    assert(beforeResult.value.tombstone, "Before is not tombstone");
+    assert(!afterResult.value.tombstone, "After is tombstone");
+    assert(!sharedResult.value.tombstone, "Shared is tombstone");
 
     const newValue = { ...oldValue, something: "new value" };
-    const newChannels = [sharedChannel, afterChannel];
-    expect(beforeResult.value.value).toEqual(oldValue);
-    expect(beforeResult.value.channels).toEqual([beforeChannel]);
-    expect(beforeResult.value.tombstone).toBe(true);
-    expect(afterResult.value.value).toEqual(newValue);
-    expect(afterResult.value.channels).toEqual([afterChannel]);
-    expect(afterResult.value.tombstone).toBe(false);
-    expect(sharedResult.value.value).toEqual(newValue);
-    expect(sharedResult.value.channels).toEqual([sharedChannel]);
-    expect(sharedResult.value.tombstone).toBe(false);
-    expect(beforeResult.value.lastModified).toEqual(
-      afterResult.value.lastModified,
+    expect(beforeResult.value.object.url).toEqual(putted.url);
+    expect(beforeResult.value.object.lastModified).toEqual(
+      patched.lastModified,
+    );
+    expect(afterResult.value.object.value).toEqual(newValue);
+    expect(afterResult.value.object.channels).toEqual([afterChannel]);
+    expect(sharedResult.value.object.value).toEqual(newValue);
+    expect(sharedResult.value.object.channels).toEqual([sharedChannel]);
+    expect(beforeResult.value.object.lastModified).toEqual(
+      afterResult.value.object.lastModified,
     );
-    expect(sharedResult.value.lastModified).toEqual(
-      afterResult.value.lastModified,
+    expect(sharedResult.value.object.lastModified).toEqual(
+      afterResult.value.object.lastModified,
     );
   });
 
   it("delete", async () => {
     const channels = [randomString(), randomString(), randomString()];
 
+    // Start listening for changes...
+    const beforeIterator = graffiti.synchronizeDiscover(channels, {});
+    // Skip the first result
+    beforeIterator.next();
+
     const oldValue = { hello: "world" };
     const oldChannels = [randomString(), ...channels.slice(1)];
     const putted = await graffiti.put<{}>(
@@ -203,19 +234,26 @@ describe.concurrent("synchronizeDiscover", () => {
       session,
     );
 
-    const next = graffiti.synchronizeDiscover(channels, {}).next();
+    const beforeButAfter = graffiti.synchronizeDiscover(channels, {}).next();
+    const next = beforeIterator.next();
 
-    graffiti.delete(putted, session);
+    const deleted = await graffiti.delete(putted, session);
 
-    const result = (await next).value;
-    if (!result || result.error) {
-      throw new Error("Error in synchronize");
-    }
-    expect(result.value.tombstone).toBe(true);
-    expect(result.value.value).toEqual(oldValue);
-    expect(result.value.channels).toEqual(
-      channels.filter((c) => oldChannels.includes(c)),
-    );
+    // If you just start synchronizing after the first put,
+    // it won't show the deletion because it never saw the object.
+    await expect(
+      // @ts-ignore
+      Promise.race([
+        beforeButAfter,
+        new Promise((resolve, reject) => setTimeout(reject, 100, "Timeout")),
+      ]),
+    ).rejects.toThrow("Timeout");
+
+    const result = await next;
+    assert(!result.done && !result.value.error, "Error in before");
+    assert(result.value.tombstone, "Before is not tombstone");
+    expect(result.value.object.url).toEqual(putted.url);
+    expect(result.value.object.lastModified).toEqual(deleted.lastModified);
   });
 
   it("synchronize happens before putters", async () => {
@@ -267,7 +305,10 @@ describe.concurrent("synchronizeDiscover", () => {
     }
 
     // Try returning...
-    iterator.return();
+    iterator.return({
+      continue: () => iterator,
+      cursor: "",
+    });
   });
 
   it("not allowed", async () => {
@@ -299,24 +340,28 @@ describe.concurrent("synchronizeDiscover", () => {
       ]),
     ).rejects.toThrow("Timeout");
 
-    const creatorResult = (await creatorNext).value;
-    const allowedResult = (await allowedNext).value;
+    const creatorResult = await creatorNext;
+    const allowedResult = await allowedNext;
 
-    if (
-      !creatorResult ||
-      creatorResult.error ||
-      !allowedResult ||
-      allowedResult.error
-    ) {
-      throw new Error("Error in synchronize");
-    }
+    assert(
+      !creatorResult.done &&
+        !creatorResult.value.error &&
+        !creatorResult.value.tombstone,
+      "Error in creator",
+    );
+    assert(
+      !allowedResult.done &&
+        !allowedResult.value.error &&
+        !allowedResult.value.tombstone,
+      "Error in allowed",
+    );
 
-    expect(creatorResult.value.value).toEqual(value);
-    expect(creatorResult.value.allowed).toEqual(allowed);
-    expect(creatorResult.value.channels).toEqual(allChannels);
-    expect(allowedResult.value.value).toEqual(value);
-    expect(allowedResult.value.allowed).toEqual([session2.actor]);
-    expect(allowedResult.value.channels).toEqual(channels);
+    expect(creatorResult.value.object.value).toEqual(value);
+    expect(creatorResult.value.object.allowed).toEqual(allowed);
+    expect(creatorResult.value.object.channels).toEqual(allChannels);
+    expect(allowedResult.value.object.value).toEqual(value);
+    expect(allowedResult.value.object.allowed).toEqual([session2.actor]);
+    expect(allowedResult.value.object.channels).toEqual(channels);
   });
 });
 
@@ -350,22 +395,21 @@ describe.concurrent("synchronizeGet", () => {
       session,
     );
 
-    const result = (await next).value;
-    assert(result && !result.error);
+    const result = await next;
+    assert(!result.done && !result.value.error && !result.value.tombstone);
 
-    expect(result.value.value).toEqual(newValue);
-    expect(result.value.actor).toEqual(session.actor);
-    expect(result.value.channels).toEqual([]);
-    expect(result.value.tombstone).toBe(false);
-    expect(result.value.lastModified).toEqual(putted2.lastModified);
-    expect(result.value.allowed).toBeUndefined();
+    expect(result.value.object.value).toEqual(newValue);
+    expect(result.value.object.actor).toEqual(session.actor);
+    expect(result.value.object.channels).toEqual([]);
+    expect(result.value.object.lastModified).toEqual(putted2.lastModified);
+    expect(result.value.object.allowed).toBeUndefined();
 
     // Delete the object
     const deleted = await graffiti.delete(putted2, session);
-    const result2 = (await iterator.next()).value;
-    assert(result2 && !result2.error);
+    const result2 = await iterator.next();
+    assert(!result2.done && !result2.value.error);
     expect(result2.value.tombstone).toBe(true);
-    expect(result2.value.lastModified).toEqual(deleted.lastModified);
+    expect(result2.value.object.lastModified).toEqual(deleted.lastModified);
 
     // Put something else
     await graffiti.put<{}>(randomPutObject(), session);
@@ -387,6 +431,11 @@ describe.concurrent("synchronizeGet", () => {
     const iterator1 = graffiti.synchronizeGet(putted, {}, session1);
     const iterator2 = graffiti.synchronizeGet(putted, {}, session2);
 
+    // Do a get to trigger the synchronize
+    graffiti.get<{}>(putted, {}, session1);
+    iterator1.next();
+    iterator2.next();
+
     const next1 = iterator1.next();
     const next2 = iterator2.next();
 
@@ -400,21 +449,20 @@ describe.concurrent("synchronizeGet", () => {
       },
       session1,
     );
-    const result1 = (await next1).value;
-    const result2 = (await next2).value;
-    assert(result1 && !result1.error);
-    assert(result2 && !result2.error);
-
-    expect(result1.value.value).toEqual(newValue);
-    expect(result2.value.value).toEqual(object.value);
-    expect(result1.value.actor).toEqual(session1.actor);
-    expect(result2.value.actor).toEqual(session1.actor);
-    expect(result1.value.channels).toEqual(object.channels);
-    expect(result2.value.channels).toEqual([]);
-    expect(result1.value.tombstone).toBe(false);
-    expect(result2.value.tombstone).toBe(true);
-    expect(result1.value.lastModified).toEqual(putted2.lastModified);
-    expect(result2.value.lastModified).toEqual(putted2.lastModified);
+
+    const result1 = await next1;
+    const result2 = await next2;
+    assert(!result1.done && !result1.value.error);
+    assert(!result2.done && !result2.value.error);
+    assert(!result1.value.tombstone);
+    assert(result2.value.tombstone);
+
+    expect(result1.value.object.value).toEqual(newValue);
+    expect(result1.value.object.actor).toEqual(session1.actor);
+    expect(result1.value.object.channels).toEqual(object.channels);
+    expect(result1.value.object.lastModified).toEqual(putted2.lastModified);
+    expect(result2.value.object.url).toEqual(putted.url);
+    expect(result2.value.object.lastModified).toEqual(putted2.lastModified);
   });
 });
 
@@ -435,7 +483,7 @@ describe("synchronizeAll", () => {
 
     expect(object1.channels).not.toEqual(object2.channels);
 
-    const iterator = graffiti.synchronizeAll();
+    const iterator = graffiti.synchronizeAll({});
 
     const next1 = iterator.next();
     const next2 = iterator.next();
@@ -443,14 +491,14 @@ describe("synchronizeAll", () => {
     await graffiti.put<{}>(object1, session1);
     await graffiti.put<{}>(object2, session2);
 
-    const result1 = (await next1).value;
-    const result2 = (await next2).value;
-    assert(result1 && !result1.error);
-    assert(result2 && !result2.error);
+    const result1 = await next1;
+    const result2 = await next2;
+    assert(!result1.done && !result1.value.error && !result1.value.tombstone);
+    assert(!result2.done && !result2.value.error && !result2.value.tombstone);
 
-    expect(result1.value.value).toEqual(object1.value);
-    expect(result1.value.channels).toEqual([]);
-    expect(result2.value.value).toEqual(object2.value);
+    expect(result1.value.object.value).toEqual(object1.value);
+    expect(result1.value.object.channels).toEqual([]);
+    expect(result2.value.object.value).toEqual(object2.value);
   });
 
   it("omniscient", async () => {
@@ -461,15 +509,15 @@ describe("synchronizeAll", () => {
     const object1 = randomPutObject();
     object1.allowed = [randomString()];
 
-    const iterator = graffiti.synchronizeAll();
+    const iterator = graffiti.synchronizeAll({});
     const next = iterator.next();
 
     await graffiti.put<{}>(object1, session1);
 
-    const result = (await next).value;
-    assert(result && !result.error);
-    expect(result.value.value).toEqual(object1.value);
-    expect(result.value.channels).toEqual(object1.channels);
-    expect(result.value.allowed).toEqual(object1.allowed);
+    const result = await next;
+    assert(!result.done && !result.value.error && !result.value.tombstone);
+    expect(result.value.object.value).toEqual(object1.value);
+    expect(result.value.object.channels).toEqual(object1.channels);
+    expect(result.value.object.allowed).toEqual(object1.allowed);
   });
 });