@graffiti-garden/api 0.6.1 → 0.6.3

package/tests/discover.ts

@@ -2,14 +2,21 @@ import { it, expect, describe, assert, beforeAll } from "vitest";
 import type {
   Graffiti,
   GraffitiObjectBase,
-  GraffitiObjectStreamEntry,
   GraffitiSession,
   JSONSchema,
 } from "@graffiti-garden/api";
-import { randomString, nextStreamValue, randomPutObject } from "./utils";
+import {
+  randomString,
+  nextStreamValue,
+  randomPutObject,
+  continueStream,
+} from "./utils";
 
 export const graffitiDiscoverTests = (
-  useGraffiti: () => Pick<Graffiti, "discover" | "put" | "delete" | "patch">,
+  useGraffiti: () => Pick<
+    Graffiti,
+    "discover" | "put" | "delete" | "patch" | "continueObjectStream"
+  >,
   useSession1: () => GraffitiSession | Promise<GraffitiSession>,
   useSession2: () => GraffitiSession | Promise<GraffitiSession>,
 ) => {
@@ -469,197 +476,230 @@ export const graffitiDiscoverTests = (
       expect(counts.get("other")).toBe(1);
     });
 
-    it("discover for deleted content", async () => {
-      const object = randomPutObject();
-
-      const putted = await graffiti.put<{}>(object, session);
-
-      const iterator1 = graffiti.discover<{}>(object.channels, {});
-      const value1 = await nextStreamValue<{}>(iterator1);
-      expect(value1.value).toEqual(object.value);
-      const returnValue = await iterator1.next();
-      assert(returnValue.done, "value2 is not done");
-
-      const deleted = await graffiti.delete(putted, session);
-
-      const iterator = graffiti.discover(object.channels, {});
-      await expect(iterator.next()).resolves.toHaveProperty("done", true);
+    for (const continueType of ["cursor", "continue"] as const) {
+      describe(`continue discover with ${continueType}`, () => {
+        it("discover for deleted content", async () => {
+          const object = randomPutObject();
+
+          const putted = await graffiti.put<{}>(object, session);
+
+          const iterator1 = graffiti.discover<{}>(object.channels, {});
+          const value1 = await nextStreamValue<{}>(iterator1);
+          expect(value1.value).toEqual(object.value);
+          const returnValue = await iterator1.next();
+          assert(returnValue.done, "value2 is not done");
+
+          const deleted = await graffiti.delete(putted, session);
+
+          const iterator = graffiti.discover(object.channels, {});
+          await expect(iterator.next()).resolves.toHaveProperty("done", true);
+
+          const tombIterator = continueStream<{}>(
+            graffiti,
+            returnValue.value,
+            continueType,
+          );
+          const value = await tombIterator.next();
+          assert(!value.done && !value.value.error, "value is done");
+          assert(value.value.tombstone, "value is not tombstone");
+          expect(value.value.object.url).toEqual(putted.url);
+          await expect(tombIterator.next()).resolves.toHaveProperty(
+            "done",
+            true,
+          );
+        });
 
-      const tombIterator = returnValue.value.continue();
-      const value = await tombIterator.next();
-      assert(!value.done && !value.value.error, "value is done");
-      assert(value.value.tombstone, "value is not tombstone");
-      expect(value.value.object.url).toEqual(putted.url);
-      await expect(tombIterator.next()).resolves.toHaveProperty("done", true);
-    });
+        it("discover for replaced channels", async () => {
+          // Do this a bunch to check for concurrency issues
+          async function runTest() {
+            const object1 = randomPutObject();
+            const putted = await graffiti.put<{}>(object1, session);
+
+            const iterator3 = graffiti.discover<{}>(object1.channels, {});
+            const value3 = await nextStreamValue<{}>(iterator3);
+            expect(value3.value).toEqual(object1.value);
+            const returnValue = await iterator3.next();
+            assert(returnValue.done, "value2 is not done");
+
+            const object2 = randomPutObject();
+            const replaced = await graffiti.put<{}>(
+              {
+                ...object2,
+                url: putted.url,
+              },
+              session,
+            );
+
+            const iterator1 = graffiti.discover<{}>(object1.channels, {});
+            const iterator2 = graffiti.discover<{}>(object2.channels, {});
+            const tombIterator = continueStream<{}>(
+              graffiti,
+              returnValue.value,
+              continueType,
+            );
+
+            if (putted.lastModified === replaced.lastModified) {
+              const value1 = await iterator1.next();
+              const value2 = await iterator2.next();
+              const value3 = await tombIterator.next();
+
+              // Only one should be done
+              expect(value1.done || value2.done).toBe(true);
+              expect(value1.done && value2.done).toBe(false);
+
+              assert(!value3.done && !value3.value.error, "value is done");
+              expect(value3.value.tombstone || value2.done).toBe(true);
+              expect(value3.value.tombstone && value2.done).toBe(false);
+              return;
+            }
 
-    it("discover for replaced channels", async () => {
-      // Do this a bunch to check for concurrency issues
-      for (let i = 0; i < 20; i++) {
-        const object1 = randomPutObject();
-        const putted = await graffiti.put<{}>(object1, session);
+            // Otherwise 1 should be done and 2 should not
+            const value5 = await iterator1.next();
+            assert(value5.done, "value5 is not done");
+
+            const value4 = await tombIterator.next();
+            assert(!value4.done && !value4.value.error, "value is done");
+
+            assert(value4.value.tombstone, "value is not tombstone");
+            expect(value4.value.object.url).toEqual(putted.url);
+            expect(value4.value.object.lastModified).toEqual(
+              replaced.lastModified,
+            );
+
+            const value2 = await nextStreamValue<{}>(iterator2);
+            await expect(iterator2.next()).resolves.toHaveProperty(
+              "done",
+              true,
+            );
+
+            expect(value2.value).toEqual(object2.value);
+            expect(value2.channels).toEqual(object2.channels);
+            expect(value2.lastModified).toEqual(replaced.lastModified);
+
+            // Replace the channels back
+            const patched = await graffiti.patch(
+              {
+                channels: [
+                  { op: "replace", path: "", value: object1.channels },
+                ],
+              },
+              replaced,
+              session,
+            );
+
+            const tombIterator2 = continueStream<{}>(
+              graffiti,
+              value5.value,
+              continueType,
+            );
+
+            let result:
+              | {
+                  tombstone: true;
+                  object: {
+                    url: string;
+                    lastModified: number;
+                  };
+                }
+              | {
+                  tombstone?: undefined;
+                  object: GraffitiObjectBase;
+                }
+              | undefined;
+            for await (const value of tombIterator2) {
+              if (value.error) continue;
+              if (!result) {
+                result = value;
+                continue;
+              }
+              if (
+                value.object.lastModified > result.object.lastModified ||
+                (value.object.lastModified === result.object.lastModified &&
+                  !value.tombstone &&
+                  result.tombstone)
+              ) {
+                result = value;
+              }
+            }
 
-        const iterator3 = graffiti.discover<{}>(object1.channels, {});
-        const value3 = await nextStreamValue<{}>(iterator3);
-        expect(value3.value).toEqual(object1.value);
-        const returnValue = await iterator3.next();
-        assert(returnValue.done, "value2 is not done");
+            assert(result, "result is not defined");
+            assert(!result.tombstone, "result is tombstone");
+            expect(result.object.url).toEqual(replaced.url);
+            expect(result.object.lastModified).toEqual(patched.lastModified);
+            expect(result.object.channels).toEqual(object1.channels);
+            expect(result.object.value).toEqual(object2.value);
+          }
 
-        const object2 = randomPutObject();
-        const replaced = await graffiti.put<{}>(
-          {
-            ...object2,
-            url: putted.url,
-          },
-          session,
-        );
-
-        const iterator1 = graffiti.discover(object1.channels, {});
-        const iterator2 = graffiti.discover<{}>(object2.channels, {});
-        const tombIterator = returnValue.value.continue();
-
-        if (putted.lastModified === replaced.lastModified) {
-          const value1 = await iterator1.next();
-          const value2 = await iterator2.next();
-          const value3 = await tombIterator.next();
-
-          // Only one should be done
-          expect(value1.done || value2.done).toBe(true);
-          expect(value1.done && value2.done).toBe(false);
-
-          assert(!value3.done && !value3.value.error, "value is done");
-          expect(value3.value.tombstone || value2.done).toBe(true);
-          expect(value3.value.tombstone && value2.done).toBe(false);
-          continue;
-        }
+          // Run the test 20 times in parallel to check for concurrency issues
+          await Promise.allSettled(Array.from({ length: 20 }, () => runTest()));
+        });
 
-        // Otherwise 1 should be done and 2 should not
-        const value5 = await iterator1.next();
-        assert(value5.done, "value5 is not done");
+        it("discover for patched allowed", async () => {
+          const object = randomPutObject();
+          const putted = await graffiti.put<{}>(object, session);
 
-        const value4 = await tombIterator.next();
-        assert(!value4.done && !value4.value.error, "value is done");
+          const iterator1 = graffiti.discover<{}>(object.channels, {});
+          const value1 = await nextStreamValue<{}>(iterator1);
+          expect(value1.value).toEqual(object.value);
+          const returnValue = await iterator1.next();
+          assert(returnValue.done, "value2 is not done");
 
-        assert(value4.value.tombstone, "value is not tombstone");
-        expect(value4.value.object.url).toEqual(putted.url);
-        expect(value4.value.object.lastModified).toEqual(replaced.lastModified);
+          await graffiti.patch(
+            {
+              allowed: [{ op: "add", path: "", value: [] }],
+            },
+            putted,
+            session,
+          );
+          const iterator2 = graffiti.discover(object.channels, {});
+          expect(await iterator2.next()).toHaveProperty("done", true);
+
+          const iterator = continueStream<{}>(
+            graffiti,
+            returnValue.value,
+            continueType,
+          );
+          const value = await iterator.next();
+          assert(!value.done && !value.value.error, "value is done");
+          assert(value.value.tombstone, "value is not tombstone");
+          expect(value.value.object.url).toEqual(putted.url);
+          await expect(iterator.next()).resolves.toHaveProperty("done", true);
+        });
 
-        const value2 = await nextStreamValue<{}>(iterator2);
-        await expect(iterator2.next()).resolves.toHaveProperty("done", true);
+        it("put concurrently and discover one", async () => {
+          const object = randomPutObject();
 
-        expect(value2.value).toEqual(object2.value);
-        expect(value2.channels).toEqual(object2.channels);
-        expect(value2.lastModified).toEqual(replaced.lastModified);
+          // Put a first one to get a URI
+          const putted = await graffiti.put<{}>(object, session);
 
-        // Replace the channels back
-        const patched = await graffiti.patch(
-          {
-            channels: [{ op: "replace", path: "", value: object1.channels }],
-          },
-          replaced,
-          session,
-        );
-
-        const tombIterator2 = value5.value.continue();
-
-        let result:
-          | {
-              tombstone: true;
-              object: {
-                url: string;
-                lastModified: number;
-              };
-            }
-          | {
-              tombstone?: undefined;
-              object: GraffitiObjectBase;
+          const putPromises = Array(99)
+            .fill(0)
+            .map(() =>
+              graffiti.put<{}>(
+                {
+                  ...object,
+                  url: putted.url,
+                },
+                session,
+              ),
+            );
+          await Promise.all(putPromises);
+
+          const iterator = graffiti.discover(object.channels, {});
+          let tombstoneCount = 0;
+          let valueCount = 0;
+          for await (const result of iterator) {
+            assert(!result.error, "result has error");
+            if (result.tombstone) {
+              tombstoneCount++;
+            } else {
+              valueCount++;
             }
-          | undefined;
-        for await (const value of tombIterator2) {
-          if (value.error) continue;
-          if (!result) {
-            result = value;
-            continue;
-          }
-          if (
-            value.object.lastModified > result.object.lastModified ||
-            (value.object.lastModified === result.object.lastModified &&
-              !value.tombstone &&
-              result.tombstone)
-          ) {
-            result = value;
           }
-        }
-
-        assert(result, "result is not defined");
-        assert(!result.tombstone, "result is tombstone");
-        expect(result.object.url).toEqual(replaced.url);
-        expect(result.object.lastModified).toEqual(patched.lastModified);
-        expect(result.object.channels).toEqual(object1.channels);
-        expect(result.object.value).toEqual(object2.value);
-      }
-    });
-
-    it("discover for patched allowed", async () => {
-      const object = randomPutObject();
-      const putted = await graffiti.put<{}>(object, session);
-
-      const iterator1 = graffiti.discover<{}>(object.channels, {});
-      const value1 = await nextStreamValue<{}>(iterator1);
-      expect(value1.value).toEqual(object.value);
-      const returnValue = await iterator1.next();
-      assert(returnValue.done, "value2 is not done");
-
-      await graffiti.patch(
-        {
-          allowed: [{ op: "add", path: "", value: [] }],
-        },
-        putted,
-        session,
-      );
-      const iterator2 = graffiti.discover(object.channels, {});
-      expect(await iterator2.next()).toHaveProperty("done", true);
-
-      const iterator = returnValue.value.continue();
-      const value = await iterator.next();
-      assert(!value.done && !value.value.error, "value is done");
-      assert(value.value.tombstone, "value is not tombstone");
-      expect(value.value.object.url).toEqual(putted.url);
-      await expect(iterator.next()).resolves.toHaveProperty("done", true);
-    });
-
-    it("put concurrently and discover one", async () => {
-      const object = randomPutObject();
-
-      // Put a first one to get a URI
-      const putted = await graffiti.put<{}>(object, session);
-
-      const putPromises = Array(99)
-        .fill(0)
-        .map(() =>
-          graffiti.put<{}>(
-            {
-              ...object,
-              url: putted.url,
-            },
-            session,
-          ),
-        );
-      await Promise.all(putPromises);
-
-      const iterator = graffiti.discover(object.channels, {});
-      let tombstoneCount = 0;
-      let valueCount = 0;
-      for await (const result of iterator) {
-        assert(!result.error, "result has error");
-        if (result.tombstone) {
-          tombstoneCount++;
-        } else {
-          valueCount++;
-        }
-      }
-      expect(tombstoneCount).toBe(0);
-      expect(valueCount).toBe(1);
-    });
+          expect(tombstoneCount).toBe(0);
+          expect(valueCount).toBe(1);
+        });
+      });
+    }
   });
 };

package/tests/orphans.ts

@@ -1,11 +1,16 @@
 import { it, expect, describe, assert, beforeAll } from "vitest";
 import type { Graffiti, GraffitiSession } from "@graffiti-garden/api";
-import { randomPutObject, randomString, nextStreamValue } from "./utils";
+import {
+  randomPutObject,
+  randomString,
+  nextStreamValue,
+  continueStream,
+} from "./utils";
 
 export const graffitiOrphanTests = (
   useGraffiti: () => Pick<
     Graffiti,
-    "recoverOrphans" | "put" | "delete" | "patch"
+    "recoverOrphans" | "put" | "delete" | "patch" | "continueObjectStream"
   >,
   useSession1: () => GraffitiSession | Promise<GraffitiSession>,
   useSession2: () => GraffitiSession | Promise<GraffitiSession>,
@@ -46,67 +51,78 @@ export const graffitiOrphanTests = (
       expect(numResults).toBe(1);
     });
 
-    it("replaced orphan, no longer", async () => {
-      const object = randomPutObject();
-      object.channels = [];
-      const putOrphan = await graffiti.put<{}>(object, session);
+    for (const continueType of ["continue", "cursor"] as const) {
+      describe(`continue orphans with ${continueType}`, () => {
+        it("replaced orphan, no longer", async () => {
+          const object = randomPutObject();
+          object.channels = [];
+          const putOrphan = await graffiti.put<{}>(object, session);
 
-      // Wait for the put to be processed
-      await new Promise((resolve) => setTimeout(resolve, 10));
+          // Wait for the put to be processed
+          await new Promise((resolve) => setTimeout(resolve, 10));
 
-      expect(Object.keys(object.value).length).toBeGreaterThanOrEqual(1);
-      expect(Object.keys(object.value)[0]).toBeTypeOf("string");
-      const iterator1 = graffiti.recoverOrphans<{}>(
-        {
-          properties: {
-            value: {
+          expect(Object.keys(object.value).length).toBeGreaterThanOrEqual(1);
+          expect(Object.keys(object.value)[0]).toBeTypeOf("string");
+          const iterator1 = graffiti.recoverOrphans<{}>(
+            {
               properties: {
-                [Object.keys(object.value)[0]]: {
-                  type: "string",
+                value: {
+                  properties: {
+                    [Object.keys(object.value)[0]]: {
+                      type: "string",
+                    },
+                  },
+                  required: [Object.keys(object.value)[0]],
                 },
               },
-              required: [Object.keys(object.value)[0]],
             },
-          },
-        },
-        session,
-      );
-      const value1 = await nextStreamValue<{}>(iterator1);
-      expect(value1.value).toEqual(object.value);
-      const returnValue = await iterator1.next();
-      assert(returnValue.done, "value2 is not done");
+            session,
+          );
+          const value1 = await nextStreamValue<{}>(iterator1);
+          expect(value1.value).toEqual(object.value);
+          const returnValue = await iterator1.next();
+          assert(returnValue.done, "value2 is not done");
 
-      const putNotOrphan = await graffiti.put<{}>(
-        {
-          ...putOrphan,
-          ...object,
-          channels: [randomString()],
-        },
-        session,
-      );
-      expect(putNotOrphan.url).toBe(putOrphan.url);
-      expect(putNotOrphan.lastModified).toBeGreaterThan(putOrphan.lastModified);
+          const putNotOrphan = await graffiti.put<{}>(
+            {
+              ...putOrphan,
+              ...object,
+              channels: [randomString()],
+            },
+            session,
+          );
+          expect(putNotOrphan.url).toBe(putOrphan.url);
+          expect(putNotOrphan.lastModified).toBeGreaterThan(
+            putOrphan.lastModified,
+          );
 
-      // The tombstone will not appear to a fresh iterator
-      const orphanIterator = graffiti.recoverOrphans({}, session);
-      let numResults = 0;
-      for await (const orphan of orphanIterator) {
-        if (orphan.error) continue;
-        if (orphan.object.url === putOrphan.url) {
-          numResults++;
-        }
-      }
-      expect(numResults).toBe(0);
+          // The tombstone will not appear to a fresh iterator
+          const orphanIterator = graffiti.recoverOrphans({}, session);
+          let numResults = 0;
+          for await (const orphan of orphanIterator) {
+            if (orphan.error) continue;
+            if (orphan.object.url === putOrphan.url) {
+              numResults++;
+            }
+          }
+          expect(numResults).toBe(0);
 
-      const iterator2 = returnValue.value.continue();
-      const value2 = await iterator2.next();
-      assert(
-        !value2.done && !value2.value.error,
-        "value2 is done or has error",
-      );
-      assert(value2.value.tombstone, "value2 is not tombstone");
-      expect(value2.value.object.url).toBe(putOrphan.url);
-      await expect(iterator2.next()).resolves.toHaveProperty("done", true);
-    });
+          const iterator2 = continueStream<{}>(
+            graffiti,
+            returnValue.value,
+            continueType,
+            session,
+          );
+          const value2 = await iterator2.next();
+          assert(
+            !value2.done && !value2.value.error,
+            "value2 is done or has error",
+          );
+          assert(value2.value.tombstone, "value2 is not tombstone");
+          expect(value2.value.object.url).toBe(putOrphan.url);
+          await expect(iterator2.next()).resolves.toHaveProperty("done", true);
+        });
+      });
+    }
   });
 };

package/tests/utils.ts

@@ -4,6 +4,10 @@ import type {
   GraffitiObjectStream,
   JSONSchema,
   GraffitiObject,
+  GraffitiObjectStreamReturn,
+  GraffitiObjectStreamContinue,
+  Graffiti,
+  GraffitiSession,
 } from "@graffiti-garden/api";
 
 export function randomString(): string {
@@ -38,3 +42,19 @@ export async function nextStreamValue<Schema extends JSONSchema>(
   assert(!result.value.tombstone, "result has been deleted!");
   return result.value.object;
 }
+
+export function continueStream<Schema extends JSONSchema>(
+  graffiti: Pick<Graffiti, "continueObjectStream">,
+  streamReturn: GraffitiObjectStreamReturn<Schema>,
+  type: "cursor" | "continue",
+  session?: GraffitiSession | null,
+): GraffitiObjectStreamContinue<Schema> {
+  if (type === "cursor") {
+    return graffiti.continueObjectStream(
+      streamReturn.cursor,
+      session,
+    ) as unknown as GraffitiObjectStreamContinue<Schema>;
+  } else {
+    return streamReturn.continue();
+  }
+}