@graffiti-garden/api 0.4.4 → 0.6.0

package/dist/tests.mjs

@@ -1,6 +1,13 @@
-// tests/location.ts
-import { it, expect, describe } from "vitest";
-import { GraffitiErrorInvalidUri } from "@graffiti-garden/api";
+// tests/crud.ts
+import { it, expect, describe, beforeAll } from "vitest";
+import {
+  GraffitiErrorNotFound,
+  GraffitiErrorSchemaMismatch,
+  GraffitiErrorInvalidSchema,
+  GraffitiErrorForbidden,
+  GraffitiErrorPatchTestFailed,
+  GraffitiErrorPatchError
+} from "@graffiti-garden/api";
 
 // tests/utils.ts
 import { assert } from "vitest";
@@ -24,56 +31,13 @@ function randomPutObject() {
 async function nextStreamValue(iterator) {
   const result = await iterator.next();
   assert(!result.done && !result.value.error, "result has no value");
+  assert(!result.value.tombstone, "result has been deleted!");
   return result.value.value;
 }
 
-// tests/location.ts
-var graffitiLocationTests = (useGraffiti) => {
-  describe.concurrent("URI and location conversion", () => {
-    it("location to uri and back", async () => {
-      const graffiti = useGraffiti();
-      const location = {
-        name: randomString(),
-        actor: randomString(),
-        source: randomString()
-      };
-      const uri = graffiti.locationToUri(location);
-      const location2 = graffiti.uriToLocation(uri);
-      expect(location).toEqual(location2);
-    });
-    it("collision resistance", async () => {
-      const graffiti = useGraffiti();
-      const location1 = {
-        name: randomString(),
-        actor: randomString(),
-        source: randomString()
-      };
-      for (const prop of ["name", "actor", "source"]) {
-        const location2 = { ...location1, [prop]: randomString() };
-        const uri1 = graffiti.locationToUri(location1);
-        const uri2 = graffiti.locationToUri(location2);
-        expect(uri1).not.toEqual(uri2);
-      }
-    });
-    it("random URI should not be a valid location", async () => {
-      const graffiti = useGraffiti();
-      expect(() => graffiti.uriToLocation("")).toThrow(GraffitiErrorInvalidUri);
-    });
-  });
-};
-
 // tests/crud.ts
-import { it as it2, expect as expect2, describe as describe2, beforeAll } from "vitest";
-import {
-  GraffitiErrorNotFound,
-  GraffitiErrorSchemaMismatch,
-  GraffitiErrorInvalidSchema,
-  GraffitiErrorForbidden,
-  GraffitiErrorPatchTestFailed,
-  GraffitiErrorPatchError
-} from "@graffiti-garden/api";
 var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
-  describe2.concurrent(
+  describe.concurrent(
     "CRUD",
     {
       timeout: 2e4
@@ -89,66 +53,57 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
         session = session1;
         session2 = await useSession2();
       });
-      it2("put, get, delete", async () => {
+      it("put, get, delete", async () => {
         const value = {
           something: "hello, world~ c:"
         };
         const channels = [randomString(), randomString()];
         const previous = await graffiti.put({ value, channels }, session);
-        expect2(previous.value).toEqual({});
-        expect2(previous.channels).toEqual([]);
-        expect2(previous.allowed).toBeUndefined();
-        expect2(previous.actor).toEqual(session.actor);
+        expect(previous.value).toEqual({});
+        expect(previous.channels).toEqual([]);
+        expect(previous.allowed).toEqual([]);
+        expect(previous.actor).toEqual(session.actor);
         const gotten = await graffiti.get(previous, {});
-        expect2(gotten.value).toEqual(value);
-        expect2(gotten.channels).toEqual([]);
-        expect2(gotten.allowed).toBeUndefined();
-        expect2(gotten.name).toEqual(previous.name);
-        expect2(gotten.actor).toEqual(previous.actor);
-        expect2(gotten.source).toEqual(previous.source);
-        expect2(gotten.lastModified).toEqual(previous.lastModified);
+        expect(gotten.value).toEqual(value);
+        expect(gotten.channels).toEqual([]);
+        expect(gotten.allowed).toBeUndefined();
+        expect(gotten.url).toEqual(previous.url);
+        expect(gotten.actor).toEqual(previous.actor);
+        expect(gotten.lastModified).toEqual(previous.lastModified);
         const newValue = {
           something: "goodbye, world~ :c"
         };
         const beforeReplaced = await graffiti.put(
-          { ...previous, value: newValue, channels: [] },
+          {
+            url: previous.url,
+            value: newValue,
+            channels: []
+          },
           session
         );
-        expect2(beforeReplaced.value).toEqual(value);
-        expect2(beforeReplaced.tombstone).toEqual(true);
-        expect2(beforeReplaced.name).toEqual(previous.name);
-        expect2(beforeReplaced.actor).toEqual(previous.actor);
-        expect2(beforeReplaced.source).toEqual(previous.source);
-        expect2(beforeReplaced.lastModified).toBeGreaterThanOrEqual(
+        expect(beforeReplaced.value).toEqual(value);
+        expect(beforeReplaced.url).toEqual(previous.url);
+        expect(beforeReplaced.actor).toEqual(previous.actor);
+        expect(beforeReplaced.lastModified).toBeGreaterThanOrEqual(
           gotten.lastModified
         );
         const afterReplaced = await graffiti.get(previous, {});
-        expect2(afterReplaced.value).toEqual(newValue);
-        expect2(afterReplaced.lastModified).toEqual(beforeReplaced.lastModified);
-        expect2(afterReplaced.tombstone).toEqual(false);
+        expect(afterReplaced.value).toEqual(newValue);
+        expect(afterReplaced.lastModified).toEqual(beforeReplaced.lastModified);
         const beforeDeleted = await graffiti.delete(afterReplaced, session);
-        expect2(beforeDeleted.tombstone).toEqual(true);
-        expect2(beforeDeleted.value).toEqual(newValue);
-        expect2(beforeDeleted.lastModified).toBeGreaterThanOrEqual(
+        expect(beforeDeleted.value).toEqual(newValue);
+        expect(beforeDeleted.lastModified).toBeGreaterThanOrEqual(
           beforeReplaced.lastModified
         );
-        const final = await graffiti.get(afterReplaced, {});
-        expect2(final).toEqual(beforeDeleted);
-      });
-      it2("get non-existant", async () => {
-        const putted = await graffiti.put(randomPutObject(), session);
-        await expect2(
-          graffiti.get(
-            {
-              ...putted,
-              name: randomString()
-            },
-            {}
-          )
-        ).rejects.toBeInstanceOf(GraffitiErrorNotFound);
+        await expect(graffiti.get(afterReplaced, {})).rejects.toBeInstanceOf(
+          GraffitiErrorNotFound
+        );
+        await expect(graffiti.delete(beforeDeleted, session)).rejects.toThrow(
+          GraffitiErrorNotFound
+        );
       });
-      it2("put, get, delete with wrong actor", async () => {
-        await expect2(
+      it("put, delete, patch with wrong actor", async () => {
+        await expect(
           graffiti.put(
             { value: {}, channels: [], actor: session2.actor },
             session1
@@ -158,14 +113,50 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
           { value: {}, channels: [] },
           session2
         );
-        await expect2(graffiti.delete(putted, session1)).rejects.toThrow(
+        await expect(
+          graffiti.put(
+            {
+              url: putted.url,
+              value: {},
+              channels: []
+            },
+            session1
+          )
+        ).rejects.toThrow(GraffitiErrorForbidden);
+        await expect(graffiti.delete(putted, session1)).rejects.toThrow(
           GraffitiErrorForbidden
         );
-        await expect2(graffiti.patch({}, putted, session1)).rejects.toThrow(
+        await expect(graffiti.patch({}, putted, session1)).rejects.toThrow(
           GraffitiErrorForbidden
         );
       });
-      it2("put and get with schema", async () => {
+      it("put, patch, delete object that is not allowed", async () => {
+        const putted = await graffiti.put(
+          {
+            value: {},
+            channels: [],
+            allowed: []
+          },
+          session1
+        );
+        await expect(
+          graffiti.put(
+            {
+              url: putted.url,
+              value: {},
+              channels: []
+            },
+            session2
+          )
+        ).rejects.toThrow(GraffitiErrorNotFound);
+        await expect(graffiti.patch({}, putted, session2)).rejects.toThrow(
+          GraffitiErrorNotFound
+        );
+        await expect(graffiti.delete(putted, session2)).rejects.toThrow(
+          GraffitiErrorNotFound
+        );
+      });
+      it("put and get with schema", async () => {
         const schema = {
           properties: {
             value: {
@@ -208,17 +199,17 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
           session
         );
         const gotten = await graffiti.get(putted, schema);
-        expect2(gotten.value.something).toEqual(goodValue.something);
-        expect2(gotten.value.another).toEqual(goodValue.another);
-        expect2(gotten.value.another[0]).toEqual(1);
-        expect2(gotten.value.deeper.deepProp).toEqual(goodValue.deeper.deepProp);
+        expect(gotten.value.something).toEqual(goodValue.something);
+        expect(gotten.value.another).toEqual(goodValue.another);
+        expect(gotten.value.another[0]).toEqual(1);
+        expect(gotten.value.deeper.deepProp).toEqual(goodValue.deeper.deepProp);
       });
-      it2("put and get with invalid schema", async () => {
+      it("put and get with invalid schema", async () => {
         const putted = await graffiti.put(
           { value: {}, channels: [] },
           session
         );
-        await expect2(
+        await expect(
           graffiti.get(putted, {
             properties: {
               value: {
@@ -229,7 +220,7 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
           })
         ).rejects.toThrow(GraffitiErrorInvalidSchema);
       });
-      it2("put and get with wrong schema", async () => {
+      it("put and get with wrong schema", async () => {
         const putted = await graffiti.put(
           {
             value: {
@@ -239,7 +230,7 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
           },
           session
         );
-        await expect2(
+        await expect(
           graffiti.get(putted, {
             properties: {
               value: {
@@ -253,7 +244,7 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
           })
         ).rejects.toThrow(GraffitiErrorSchemaMismatch);
       });
-      it2("put and get with empty access control", async () => {
+      it("put and get with empty access control", async () => {
         const value = {
           um: "hi"
         };
@@ -264,17 +255,17 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
           session1
         );
         const gotten = await graffiti.get(putted, {}, session1);
-        expect2(gotten.value).toEqual(value);
-        expect2(gotten.allowed).toEqual(allowed);
-        expect2(gotten.channels).toEqual(channels);
-        await expect2(graffiti.get(putted, {})).rejects.toBeInstanceOf(
+        expect(gotten.value).toEqual(value);
+        expect(gotten.allowed).toEqual(allowed);
+        expect(gotten.channels).toEqual(channels);
+        await expect(graffiti.get(putted, {})).rejects.toBeInstanceOf(
           GraffitiErrorNotFound
         );
-        await expect2(graffiti.get(putted, {}, session2)).rejects.toBeInstanceOf(
+        await expect(graffiti.get(putted, {}, session2)).rejects.toBeInstanceOf(
           GraffitiErrorNotFound
         );
       });
-      it2("put and get with specific access control", async () => {
+      it("put and get with specific access control", async () => {
         const value = {
           um: "hi"
         };
@@ -289,18 +280,18 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
           session1
         );
         const gotten = await graffiti.get(putted, {}, session1);
-        expect2(gotten.value).toEqual(value);
-        expect2(gotten.allowed).toEqual(allowed);
-        expect2(gotten.channels).toEqual(channels);
-        await expect2(graffiti.get(putted, {})).rejects.toBeInstanceOf(
+        expect(gotten.value).toEqual(value);
+        expect(gotten.allowed).toEqual(allowed);
+        expect(gotten.channels).toEqual(channels);
+        await expect(graffiti.get(putted, {})).rejects.toBeInstanceOf(
           GraffitiErrorNotFound
         );
         const gotten2 = await graffiti.get(putted, {}, session2);
-        expect2(gotten2.value).toEqual(value);
-        expect2(gotten2.allowed).toEqual([session2.actor]);
-        expect2(gotten2.channels).toEqual([]);
+        expect(gotten2.value).toEqual(value);
+        expect(gotten2.allowed).toEqual([session2.actor]);
+        expect(gotten2.channels).toEqual([]);
       });
-      it2("patch value", async () => {
+      it("patch value", async () => {
         const value = {
           something: "hello, world~ c:"
         };
@@ -312,24 +303,23 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
           ]
         };
         const beforePatched = await graffiti.patch(patch, putted, session);
-        expect2(beforePatched.value).toEqual(value);
-        expect2(beforePatched.tombstone).toBe(true);
-        expect2(beforePatched.lastModified).toBeGreaterThan(putted.lastModified);
+        expect(beforePatched.value).toEqual(value);
+        expect(beforePatched.lastModified).toBeGreaterThan(putted.lastModified);
         const gotten = await graffiti.get(putted, {});
-        expect2(gotten.value).toEqual({
+        expect(gotten.value).toEqual({
           something: "goodbye, world~ :c"
         });
-        expect2(beforePatched.lastModified).toBe(gotten.lastModified);
+        expect(beforePatched.lastModified).toBe(gotten.lastModified);
         await graffiti.delete(putted, session);
       });
-      it2("patch deleted object", async () => {
+      it("patch deleted object", async () => {
         const putted = await graffiti.put(randomPutObject(), session);
         const deleted = await graffiti.delete(putted, session);
-        await expect2(
+        await expect(
           graffiti.patch({}, putted, session)
         ).rejects.toBeInstanceOf(GraffitiErrorNotFound);
       });
-      it2("deep patch", async () => {
+      it("deep patch", async () => {
         const value = {
           something: {
             another: {
@@ -355,8 +345,8 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
           session
         );
         const gotten = await graffiti.get(putted, {});
-        expect2(beforePatch.value).toEqual(value);
-        expect2(gotten.value).toEqual({
+        expect(beforePatch.value).toEqual(value);
+        expect(gotten.value).toEqual({
           something: {
             another: {
               somethingElse: "goodbye"
@@ -364,7 +354,7 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
           }
         });
       });
-      it2("patch channels", async () => {
+      it("patch channels", async () => {
         const channelsBefore = [randomString()];
         const channelsAfter = [randomString()];
         const putted = await graffiti.put(
@@ -375,12 +365,12 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
           channels: [{ op: "replace", path: "/0", value: channelsAfter[0] }]
         };
         const patched = await graffiti.patch(patch, putted, session);
-        expect2(patched.channels).toEqual(channelsBefore);
+        expect(patched.channels).toEqual(channelsBefore);
         const gotten = await graffiti.get(putted, {}, session);
-        expect2(gotten.channels).toEqual(channelsAfter);
+        expect(gotten.channels).toEqual(channelsAfter);
         await graffiti.delete(putted, session);
       });
-      it2("patch 'increment' with test", async () => {
+      it("patch 'increment' with test", async () => {
         const putted = await graffiti.put(
           {
             value: {
@@ -400,7 +390,7 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
           putted,
           session
         );
-        expect2(previous.value).toEqual({ counter: 1 });
+        expect(previous.value).toEqual({ counter: 1 });
         const result = await graffiti.get(previous, {
           properties: {
             value: {
@@ -412,8 +402,8 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
             }
           }
         });
-        expect2(result.value.counter).toEqual(2);
-        await expect2(
+        expect(result.value.counter).toEqual(2);
+        await expect(
           graffiti.patch(
             {
               value: [
@@ -426,10 +416,10 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
           )
         ).rejects.toThrow(GraffitiErrorPatchTestFailed);
       });
-      it2("invalid patch", async () => {
+      it("invalid patch", async () => {
         const object = randomPutObject();
         const putted = await graffiti.put(object, session);
-        await expect2(
+        await expect(
           graffiti.patch(
             {
               value: [
@@ -443,7 +433,7 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
           )
         ).rejects.toThrow(GraffitiErrorPatchError);
       });
-      it2("patch channels to be wrong", async () => {
+      it("patch channels to be wrong", async () => {
         const object = randomPutObject();
         object.allowed = [randomString()];
         const putted = await graffiti.put(object, session);
@@ -477,24 +467,24 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
           }
         ];
         for (const patch of patches) {
-          await expect2(graffiti.patch(patch, putted, session)).rejects.toThrow(
+          await expect(graffiti.patch(patch, putted, session)).rejects.toThrow(
             GraffitiErrorPatchError
           );
         }
         const gotten = await graffiti.get(putted, {}, session);
-        expect2(gotten.value).toEqual(object.value);
-        expect2(gotten.channels).toEqual(object.channels);
-        expect2(gotten.allowed).toEqual(object.allowed);
-        expect2(gotten.lastModified).toEqual(putted.lastModified);
+        expect(gotten.value).toEqual(object.value);
+        expect(gotten.channels).toEqual(object.channels);
+        expect(gotten.allowed).toEqual(object.allowed);
+        expect(gotten.lastModified).toEqual(putted.lastModified);
       });
     }
   );
 };
 
 // tests/discover.ts
-import { it as it3, expect as expect3, describe as describe3, assert as assert2, beforeAll as beforeAll2 } from "vitest";
+import { it as it2, expect as expect2, describe as describe2, assert as assert2, beforeAll as beforeAll2 } from "vitest";
 var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
-  describe3.concurrent("discover", { timeout: 2e4 }, () => {
+  describe2.concurrent("discover", { timeout: 2e4 }, () => {
     let graffiti;
     let session;
     let session1;
@@ -505,63 +495,60 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
       session = session1;
       session2 = await useSession2();
     });
-    it3("discover nothing", async () => {
+    it2("discover nothing", async () => {
       const iterator = graffiti.discover([], {});
-      expect3(await iterator.next()).toHaveProperty("done", true);
+      expect2(await iterator.next()).toHaveProperty("done", true);
     });
-    it3("discover single", async () => {
+    it2("discover single", async () => {
       const object = randomPutObject();
       const putted = await graffiti.put(object, session);
       const queryChannels = [randomString(), object.channels[0]];
       const iterator = graffiti.discover(queryChannels, {});
       const value = await nextStreamValue(iterator);
-      expect3(value.value).toEqual(object.value);
-      expect3(value.channels).toEqual([object.channels[0]]);
-      expect3(value.allowed).toBeUndefined();
-      expect3(value.actor).toEqual(session.actor);
-      expect3(value.tombstone).toBe(false);
-      expect3(value.lastModified).toEqual(putted.lastModified);
+      expect2(value.value).toEqual(object.value);
+      expect2(value.channels).toEqual([object.channels[0]]);
+      expect2(value.allowed).toBeUndefined();
+      expect2(value.actor).toEqual(session.actor);
+      expect2(value.lastModified).toEqual(putted.lastModified);
       const result2 = await iterator.next();
-      expect3(result2.done).toBe(true);
+      expect2(result2.done).toBe(true);
     });
-    it3("discover wrong channel", async () => {
+    it2("discover wrong channel", async () => {
       const object = randomPutObject();
       await graffiti.put(object, session);
       const iterator = graffiti.discover([randomString()], {});
-      await expect3(iterator.next()).resolves.toHaveProperty("done", true);
+      await expect2(iterator.next()).resolves.toHaveProperty("done", true);
     });
-    it3("discover not allowed", async () => {
+    it2("discover not allowed", async () => {
       const object = randomPutObject();
       object.allowed = [randomString(), randomString()];
       const putted = await graffiti.put(object, session1);
       const iteratorSession1 = graffiti.discover(object.channels, {}, session1);
       const value = await nextStreamValue(iteratorSession1);
-      expect3(value.value).toEqual(object.value);
-      expect3(value.channels).toEqual(object.channels);
-      expect3(value.allowed).toEqual(object.allowed);
-      expect3(value.actor).toEqual(session1.actor);
-      expect3(value.tombstone).toBe(false);
-      expect3(value.lastModified).toEqual(putted.lastModified);
+      expect2(value.value).toEqual(object.value);
+      expect2(value.channels).toEqual(object.channels);
+      expect2(value.allowed).toEqual(object.allowed);
+      expect2(value.actor).toEqual(session1.actor);
+      expect2(value.lastModified).toEqual(putted.lastModified);
       const iteratorSession2 = graffiti.discover(object.channels, {}, session2);
-      expect3(await iteratorSession2.next()).toHaveProperty("done", true);
+      expect2(await iteratorSession2.next()).toHaveProperty("done", true);
       const iteratorNoSession = graffiti.discover(object.channels, {});
-      expect3(await iteratorNoSession.next()).toHaveProperty("done", true);
+      expect2(await iteratorNoSession.next()).toHaveProperty("done", true);
     });
-    it3("discover allowed", async () => {
+    it2("discover allowed", async () => {
       const object = randomPutObject();
       object.allowed = [randomString(), session2.actor, randomString()];
       const putted = await graffiti.put(object, session1);
       const iteratorSession2 = graffiti.discover(object.channels, {}, session2);
       const value = await nextStreamValue(iteratorSession2);
-      expect3(value.value).toEqual(object.value);
-      expect3(value.allowed).toEqual([session2.actor]);
-      expect3(value.channels).toEqual(object.channels);
-      expect3(value.actor).toEqual(session1.actor);
-      expect3(value.tombstone).toBe(false);
-      expect3(value.lastModified).toEqual(putted.lastModified);
+      expect2(value.value).toEqual(object.value);
+      expect2(value.allowed).toEqual([session2.actor]);
+      expect2(value.channels).toEqual(object.channels);
+      expect2(value.actor).toEqual(session1.actor);
+      expect2(value.lastModified).toEqual(putted.lastModified);
     });
-    for (const prop of ["name", "actor", "lastModified"]) {
-      it3(`discover for ${prop}`, async () => {
+    for (const prop of ["actor", "lastModified"]) {
+      it2(`discover for ${prop}`, async () => {
         const object1 = randomPutObject();
         const putted1 = await graffiti.put(object1, session1);
         const object2 = randomPutObject();
@@ -576,19 +563,19 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
           }
         });
         const value = await nextStreamValue(iterator);
-        expect3(value.name).toEqual(putted1.name);
-        expect3(value.name).not.toEqual(putted2.name);
-        expect3(value.value).toEqual(object1.value);
-        await expect3(iterator.next()).resolves.toHaveProperty("done", true);
+        expect2(value.url).toEqual(putted1.url);
+        expect2(value.url).not.toEqual(putted2.url);
+        expect2(value.value).toEqual(object1.value);
+        await expect2(iterator.next()).resolves.toHaveProperty("done", true);
       });
     }
-    it3("discover with lastModified range", async () => {
+    it2("discover with lastModified range", async () => {
       const object = randomPutObject();
       const putted1 = await graffiti.put(object, session);
       await new Promise((r) => setTimeout(r, 20));
       const putted2 = await graffiti.put(object, session);
-      expect3(putted1.name).not.toEqual(putted2.name);
-      expect3(putted1.lastModified).toBeLessThan(putted2.lastModified);
+      expect2(putted1.url).not.toEqual(putted2.url);
+      expect2(putted1.lastModified).toBeLessThan(putted2.lastModified);
       const gtIterator = graffiti.discover([object.channels[0]], {
         properties: {
           lastModified: {
@@ -596,7 +583,7 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
           }
         }
       });
-      expect3(await gtIterator.next()).toHaveProperty("done", true);
+      expect2(await gtIterator.next()).toHaveProperty("done", true);
       const gtIteratorEpsilon = graffiti.discover([object.channels[0]], {
         properties: {
           lastModified: {
@@ -605,8 +592,8 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
         }
       });
       const value1 = await nextStreamValue(gtIteratorEpsilon);
-      expect3(value1.name).toEqual(putted2.name);
-      expect3(await gtIteratorEpsilon.next()).toHaveProperty("done", true);
+      expect2(value1.url).toEqual(putted2.url);
+      expect2(await gtIteratorEpsilon.next()).toHaveProperty("done", true);
       const gteIterator = graffiti.discover(object.channels, {
         properties: {
           value: {},
@@ -616,8 +603,8 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
         }
       });
       const value = await nextStreamValue(gteIterator);
-      expect3(value.name).toEqual(putted2.name);
-      expect3(await gteIterator.next()).toHaveProperty("done", true);
+      expect2(value.url).toEqual(putted2.url);
+      expect2(await gteIterator.next()).toHaveProperty("done", true);
       const gteIteratorEpsilon = graffiti.discover(object.channels, {
         properties: {
           lastModified: {
@@ -625,7 +612,7 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
           }
         }
       });
-      expect3(await gteIteratorEpsilon.next()).toHaveProperty("done", true);
+      expect2(await gteIteratorEpsilon.next()).toHaveProperty("done", true);
       const ltIterator = graffiti.discover(object.channels, {
         properties: {
           lastModified: {
@@ -633,7 +620,7 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
           }
         }
       });
-      expect3(await ltIterator.next()).toHaveProperty("done", true);
+      expect2(await ltIterator.next()).toHaveProperty("done", true);
       const ltIteratorEpsilon = graffiti.discover(object.channels, {
         properties: {
           lastModified: {
@@ -642,8 +629,8 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
         }
       });
       const value3 = await nextStreamValue(ltIteratorEpsilon);
-      expect3(value3.name).toEqual(putted1.name);
-      expect3(await ltIteratorEpsilon.next()).toHaveProperty("done", true);
+      expect2(value3.url).toEqual(putted1.url);
+      expect2(await ltIteratorEpsilon.next()).toHaveProperty("done", true);
       const lteIterator = graffiti.discover(object.channels, {
         properties: {
           lastModified: {
@@ -652,8 +639,8 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
         }
       });
       const value2 = await nextStreamValue(lteIterator);
-      expect3(value2.name).toEqual(putted1.name);
-      expect3(await lteIterator.next()).toHaveProperty("done", true);
+      expect2(value2.url).toEqual(putted1.url);
+      expect2(await lteIterator.next()).toHaveProperty("done", true);
       const lteIteratorEpsilon = graffiti.discover(object.channels, {
         properties: {
           lastModified: {
@@ -661,9 +648,9 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
           }
         }
       });
-      expect3(await lteIteratorEpsilon.next()).toHaveProperty("done", true);
+      expect2(await lteIteratorEpsilon.next()).toHaveProperty("done", true);
     });
-    it3("discover schema allowed, as and not as owner", async () => {
+    it2("discover schema allowed, as and not as owner", async () => {
       const object = randomPutObject();
       object.allowed = [randomString(), session2.actor, randomString()];
       await graffiti.put(object, session1);
@@ -687,8 +674,8 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
         session1
       );
       const value = await nextStreamValue(iteratorSession1);
-      expect3(value.value).toEqual(object.value);
-      await expect3(iteratorSession1.next()).resolves.toHaveProperty(
+      expect2(value.value).toEqual(object.value);
+      await expect2(iteratorSession1.next()).resolves.toHaveProperty(
         "done",
         true
       );
@@ -703,7 +690,7 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
         },
         session2
       );
-      await expect3(iteratorSession2BigAllow.next()).resolves.toHaveProperty(
+      await expect2(iteratorSession2BigAllow.next()).resolves.toHaveProperty(
         "done",
         true
       );
@@ -724,7 +711,7 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
         },
         session2
       );
-      await expect3(iteratorSession2PeekOther.next()).resolves.toHaveProperty(
+      await expect2(iteratorSession2PeekOther.next()).resolves.toHaveProperty(
         "done",
         true
       );
@@ -747,12 +734,12 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
         session2
       );
       const value2 = await nextStreamValue(iteratorSession2SmallAllowPeekSelf);
-      expect3(value2.value).toEqual(object.value);
-      await expect3(
+      expect2(value2.value).toEqual(object.value);
+      await expect2(
         iteratorSession2SmallAllowPeekSelf.next()
       ).resolves.toHaveProperty("done", true);
     });
-    it3("discover schema channels, as and not as owner", async () => {
+    it2("discover schema channels, as and not as owner", async () => {
       const object = randomPutObject();
       object.channels = [randomString(), randomString(), randomString()];
       await graffiti.put(object, session1);
@@ -776,8 +763,8 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
         session1
       );
       const value = await nextStreamValue(iteratorSession1);
-      expect3(value.value).toEqual(object.value);
-      await expect3(iteratorSession1.next()).resolves.toHaveProperty(
+      expect2(value.value).toEqual(object.value);
+      await expect2(iteratorSession1.next()).resolves.toHaveProperty(
         "done",
         true
       );
@@ -792,7 +779,7 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
         },
         session2
       );
-      await expect3(iteratorSession2BigAllow.next()).resolves.toHaveProperty(
+      await expect2(iteratorSession2BigAllow.next()).resolves.toHaveProperty(
         "done",
         true
       );
@@ -813,7 +800,7 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
         },
         session2
       );
-      await expect3(iteratorSession2PeekOther.next()).resolves.toHaveProperty(
+      await expect2(iteratorSession2PeekOther.next()).resolves.toHaveProperty(
         "done",
         true
       );
@@ -836,12 +823,12 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
         session2
       );
       const value2 = await nextStreamValue(iteratorSession2SmallAllowPeekSelf);
-      expect3(value2.value).toEqual(object.value);
-      await expect3(
+      expect2(value2.value).toEqual(object.value);
+      await expect2(
         iteratorSession2SmallAllowPeekSelf.next()
       ).resolves.toHaveProperty("done", true);
     });
-    it3("discover query for empty allowed", async () => {
+    it2("discover query for empty allowed", async () => {
       const publicO = randomPutObject();
       const publicSchema = {
         not: {
@@ -855,9 +842,9 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
         session1
       );
       const value = await nextStreamValue(iterator);
-      expect3(value.value).toEqual(publicO.value);
-      expect3(value.allowed).toBeUndefined();
-      await expect3(iterator.next()).resolves.toHaveProperty("done", true);
+      expect2(value.value).toEqual(publicO.value);
+      expect2(value.allowed).toBeUndefined();
+      await expect2(iterator.next()).resolves.toHaveProperty("done", true);
       const restricted = randomPutObject();
       restricted.allowed = [];
       await graffiti.put(restricted, session1);
@@ -866,9 +853,9 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
         publicSchema,
         session1
       );
-      await expect3(iterator2.next()).resolves.toHaveProperty("done", true);
+      await expect2(iterator2.next()).resolves.toHaveProperty("done", true);
     });
-    it3("discover query for values", async () => {
+    it2("discover query for values", async () => {
       const object1 = randomPutObject();
       object1.value = { test: randomString() };
       await graffiti.put(object1, session);
@@ -897,59 +884,84 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
         }
         counts.set(property, count);
       }
-      expect3(counts.get("test")).toBe(2);
-      expect3(counts.get("something")).toBe(2);
-      expect3(counts.get("other")).toBe(1);
+      expect2(counts.get("test")).toBe(2);
+      expect2(counts.get("something")).toBe(2);
+      expect2(counts.get("other")).toBe(1);
     });
-    it3("discover for deleted content", async () => {
+    it2("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);
+      expect2(value1.value).toEqual(object.value);
+      const returnValue = await iterator1.next();
+      assert2(returnValue.done, "value2 is not done");
       const deleted = await graffiti.delete(putted, session);
       const iterator = graffiti.discover(object.channels, {});
-      const value = await nextStreamValue(iterator);
-      expect3(value.tombstone).toBe(true);
-      expect3(value.value).toEqual(object.value);
-      expect3(value.channels).toEqual(object.channels);
-      expect3(value.actor).toEqual(session.actor);
-      expect3(value.lastModified).toEqual(deleted.lastModified);
-      await expect3(iterator.next()).resolves.toHaveProperty("done", true);
+      await expect2(iterator.next()).resolves.toHaveProperty("done", true);
+      const tombIterator = returnValue.value.continue();
+      const value = await tombIterator.next();
+      assert2(!value.done && !value.value.error, "value is done");
+      expect2(value.value.tombstone).toBe(true);
+      expect2(value.value.value.value).toEqual(object.value);
+      expect2(value.value.value.channels).toEqual(object.channels);
+      expect2(value.value.value.actor).toEqual(session.actor);
+      expect2(value.value.value.lastModified).toEqual(deleted.lastModified);
+      await expect2(tombIterator.next()).resolves.toHaveProperty("done", true);
     });
-    it3("discover for replaced channels", async () => {
-      for (let i = 0; i < 10; i++) {
+    it2("discover for replaced channels", async () => {
+      for (let i = 0; i < 20; i++) {
         const object1 = randomPutObject();
         const putted = await graffiti.put(object1, session);
+        const iterator3 = graffiti.discover(object1.channels, {});
+        const value3 = await nextStreamValue(iterator3);
+        expect2(value3.value).toEqual(object1.value);
+        const returnValue = await iterator3.next();
+        assert2(returnValue.done, "value2 is not done");
         const object2 = randomPutObject();
         const replaced = await graffiti.put(
           {
-            ...putted,
-            ...object2
+            ...object2,
+            url: putted.url
           },
           session
         );
         const iterator1 = graffiti.discover(object1.channels, {});
-        const value1 = await nextStreamValue(iterator1);
-        await expect3(iterator1.next()).resolves.toHaveProperty("done", true);
         const iterator2 = graffiti.discover(object2.channels, {});
-        const value2 = await nextStreamValue(iterator2);
-        await expect3(iterator2.next()).resolves.toHaveProperty("done", true);
+        const tombIterator = returnValue.value.continue();
         if (putted.lastModified === replaced.lastModified) {
-          expect3(value1.tombstone || value2.tombstone).toBe(true);
-          expect3(value1.tombstone && value2.tombstone).toBe(false);
-        } else {
-          expect3(value1.tombstone).toBe(true);
-          expect3(value1.value).toEqual(object1.value);
-          expect3(value1.channels).toEqual(object1.channels);
-          expect3(value1.lastModified).toEqual(replaced.lastModified);
-          expect3(value2.tombstone).toBe(false);
-          expect3(value2.value).toEqual(object2.value);
-          expect3(value2.channels).toEqual(object2.channels);
-          expect3(value2.lastModified).toEqual(replaced.lastModified);
+          const value1 = await iterator1.next();
+          const value22 = await iterator2.next();
+          const value32 = await tombIterator.next();
+          expect2(value1.done || value22.done).toBe(true);
+          expect2(value1.done && value22.done).toBe(false);
+          assert2(!value32.done && !value32.value.error, "value is done");
+          expect2(value32.value.tombstone || value22.done).toBe(true);
+          expect2(value32.value.tombstone && value22.done).toBe(false);
+          continue;
         }
+        await expect2(iterator1.next()).resolves.toHaveProperty("done", true);
+        const value4 = await tombIterator.next();
+        assert2(!value4.done && !value4.value.error, "value is done");
+        expect2(value4.value.tombstone).toBe(true);
+        expect2(value4.value.value.value).toEqual(object1.value);
+        expect2(value4.value.value.channels).toEqual(object1.channels);
+        expect2(value4.value.value.lastModified).toEqual(replaced.lastModified);
+        const value2 = await nextStreamValue(iterator2);
+        await expect2(iterator2.next()).resolves.toHaveProperty("done", true);
+        expect2(value2.value).toEqual(object2.value);
+        expect2(value2.channels).toEqual(object2.channels);
+        expect2(value2.lastModified).toEqual(replaced.lastModified);
       }
     });
-    it3("discover for patched allowed", async () => {
+    it2("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);
+      expect2(value1.value).toEqual(object.value);
+      const returnValue = await iterator1.next();
+      assert2(returnValue.done, "value2 is not done");
       await graffiti.patch(
         {
           allowed: [{ op: "add", path: "", value: [] }]
@@ -957,40 +969,51 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
         putted,
         session
       );
-      const iterator = graffiti.discover(object.channels, {});
-      const value = await nextStreamValue(iterator);
-      expect3(value.tombstone).toBe(true);
-      expect3(value.value).toEqual(object.value);
-      expect3(value.channels).toEqual(object.channels);
-      expect3(value.allowed).toBeUndefined();
-      await expect3(iterator.next()).resolves.toHaveProperty("done", true);
+      const iterator2 = graffiti.discover(object.channels, {});
+      expect2(await iterator2.next()).toHaveProperty("done", true);
+      const iterator = returnValue.value.continue();
+      const value = await iterator.next();
+      assert2(!value.done && !value.value.error, "value is done");
+      expect2(value.value.tombstone).toBe(true);
+      expect2(value.value.value.value).toEqual(object.value);
+      expect2(value.value.value.channels).toEqual(object.channels);
+      expect2(value.value.value.allowed).toBeUndefined();
+      await expect2(iterator.next()).resolves.toHaveProperty("done", true);
     });
-    it3("put concurrently and discover one", async () => {
+    it2("put concurrently and discover one", async () => {
       const object = randomPutObject();
-      object.name = randomString();
-      const putPromises = Array(100).fill(0).map(() => graffiti.put(object, session));
+      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) {
         assert2(!result.error, "result has error");
-        if (result.value.tombstone) {
+        if (result.tombstone) {
           tombstoneCount++;
         } else {
           valueCount++;
         }
       }
-      expect3(tombstoneCount).toBe(99);
-      expect3(valueCount).toBe(1);
+      expect2(tombstoneCount).toBe(0);
+      expect2(valueCount).toBe(1);
     });
   });
 };
 
 // tests/orphans.ts
-import { it as it4, expect as expect4, describe as describe4, beforeAll as beforeAll3 } from "vitest";
+import { it as it3, expect as expect3, describe as describe3, assert as assert3, beforeAll as beforeAll3 } from "vitest";
 var graffitiOrphanTests = (useGraffiti, useSession1, useSession2) => {
-  describe4("recoverOrphans", { timeout: 2e4 }, () => {
+  describe3("recoverOrphans", { timeout: 2e4 }, () => {
     let graffiti;
     let session;
     let session1;
@@ -1001,12 +1024,12 @@ var graffitiOrphanTests = (useGraffiti, useSession1, useSession2) => {
       session = session1;
       session2 = await useSession2();
     });
-    it4("list orphans", async () => {
+    it3("list orphans", async () => {
       const existingOrphans = [];
       const orphanIterator1 = graffiti.recoverOrphans({}, session);
       for await (const orphan of orphanIterator1) {
         if (orphan.error) continue;
-        existingOrphans.push(orphan.value.name);
+        existingOrphans.push(orphan.value.url);
       }
       const object = randomPutObject();
       object.channels = [];
@@ -1015,19 +1038,40 @@ var graffitiOrphanTests = (useGraffiti, useSession1, useSession2) => {
       let numResults = 0;
       for await (const orphan of orphanIterator2) {
         if (orphan.error) continue;
-        if (orphan.value.name === putted.name) {
+        assert3(!orphan.tombstone, "orphan is tombstone");
+        if (orphan.value.url === putted.url) {
           numResults++;
-          expect4(orphan.value.source).toBe(putted.source);
-          expect4(orphan.value.lastModified).toBe(putted.lastModified);
+          expect3(orphan.value.lastModified).toBe(putted.lastModified);
         }
       }
-      expect4(numResults).toBe(1);
+      expect3(numResults).toBe(1);
     });
-    it4("replaced orphan, no longer", async () => {
+    it3("replaced orphan, no longer", async () => {
       const object = randomPutObject();
       object.channels = [];
       const putOrphan = await graffiti.put(object, session);
       await new Promise((resolve) => setTimeout(resolve, 10));
+      expect3(Object.keys(object.value).length).toBeGreaterThanOrEqual(1);
+      expect3(Object.keys(object.value)[0]).toBeTypeOf("string");
+      const iterator1 = graffiti.recoverOrphans(
+        {
+          properties: {
+            value: {
+              properties: {
+                [Object.keys(object.value)[0]]: {
+                  type: "string"
+                }
+              },
+              required: [Object.keys(object.value)[0]]
+            }
+          }
+        },
+        session
+      );
+      const value1 = await nextStreamValue(iterator1);
+      expect3(value1.value).toEqual(object.value);
+      const returnValue = await iterator1.next();
+      assert3(returnValue.done, "value2 is not done");
       const putNotOrphan = await graffiti.put(
         {
           ...putOrphan,
@@ -1036,28 +1080,35 @@ var graffitiOrphanTests = (useGraffiti, useSession1, useSession2) => {
         },
         session
       );
-      expect4(putNotOrphan.name).toBe(putOrphan.name);
-      expect4(putNotOrphan.lastModified).toBeGreaterThan(putOrphan.lastModified);
+      expect3(putNotOrphan.url).toBe(putOrphan.url);
+      expect3(putNotOrphan.lastModified).toBeGreaterThan(putOrphan.lastModified);
       const orphanIterator = graffiti.recoverOrphans({}, session);
       let numResults = 0;
       for await (const orphan of orphanIterator) {
         if (orphan.error) continue;
-        if (orphan.value.name === putOrphan.name) {
+        if (orphan.value.url === putOrphan.url) {
           numResults++;
-          expect4(orphan.value.tombstone).toBe(true);
-          expect4(orphan.value.lastModified).toBe(putNotOrphan.lastModified);
-          expect4(orphan.value.channels).toEqual([]);
         }
       }
-      expect4(numResults).toBe(1);
+      expect3(numResults).toBe(0);
+      const iterator2 = returnValue.value.continue();
+      const value2 = await iterator2.next();
+      assert3(
+        !value2.done && !value2.value.error,
+        "value2 is done or has error"
+      );
+      expect3(value2.value.tombstone).toBe(true);
+      expect3(value2.value.value.lastModified).toBe(putNotOrphan.lastModified);
+      expect3(value2.value.value.channels).toEqual([]);
+      await expect3(iterator2.next()).resolves.toHaveProperty("done", true);
     });
   });
 };
 
 // tests/channel-stats.ts
-import { it as it5, expect as expect5, describe as describe5, assert as assert4, beforeAll as beforeAll4 } from "vitest";
+import { it as it4, expect as expect4, describe as describe4, assert as assert4, beforeAll as beforeAll4 } from "vitest";
 var graffitiChannelStatsTests = (useGraffiti, useSession1, useSession2) => {
-  describe5("channel stats", { timeout: 2e4 }, () => {
+  describe4("channel stats", { timeout: 2e4 }, () => {
     let graffiti;
     let session;
     let session1;
@@ -1068,7 +1119,7 @@ var graffitiChannelStatsTests = (useGraffiti, useSession1, useSession2) => {
       session = session1;
       session2 = await useSession2();
     });
-    it5("list channels", async () => {
+    it4("list channels", async () => {
       const existingChannels = /* @__PURE__ */ new Map();
       const channelIterator1 = graffiti.channelStats(session);
       for await (const channel of channelIterator1) {
@@ -1104,12 +1155,12 @@ var graffitiChannelStatsTests = (useGraffiti, useSession1, useSession2) => {
           ([channel, count]) => !existingChannels.has(channel)
         )
       );
-      expect5(newChannels.size).toBe(3);
-      expect5(newChannels.get(channels[0])).toBe(6);
-      expect5(newChannels.get(channels[1])).toBe(5);
-      expect5(newChannels.get(channels[2])).toBe(4);
+      expect4(newChannels.size).toBe(3);
+      expect4(newChannels.get(channels[0])).toBe(6);
+      expect4(newChannels.get(channels[1])).toBe(5);
+      expect4(newChannels.get(channels[2])).toBe(4);
     });
-    it5("list channels with deleted channel", async () => {
+    it4("list channels with deleted channel", async () => {
       const channels = [randomString(), randomString(), randomString()];
       const before = await graffiti.put(
         {
@@ -1141,17 +1192,17 @@ var graffitiChannelStatsTests = (useGraffiti, useSession1, useSession2) => {
           "There should not be an object in channel[0]"
         );
         if (channel === channels[1]) {
-          expect5(count).toBe(1);
-          expect5(lastModified).toBe(before.lastModified);
+          expect4(count).toBe(1);
+          expect4(lastModified).toBe(before.lastModified);
           got1++;
         } else if (channel === channels[2]) {
-          expect5(count).toBe(2);
-          expect5(lastModified).toBe(second.lastModified);
+          expect4(count).toBe(2);
+          expect4(lastModified).toBe(second.lastModified);
           got2++;
         }
       }
-      expect5(got1).toBe(1);
-      expect5(got2).toBe(1);
+      expect4(got1).toBe(1);
+      expect4(got2).toBe(1);
     });
   });
 };
@@ -1159,7 +1210,6 @@ export {
   graffitiCRUDTests,
   graffitiChannelStatsTests,
   graffitiDiscoverTests,
-  graffitiLocationTests,
   graffitiOrphanTests,
   nextStreamValue,
   randomPutObject,