@graffiti-garden/api 0.6.3 → 1.0.0

package/dist/tests.mjs

@@ -1,14 +1,3 @@
-// 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";
 function randomString() {
@@ -22,7 +11,7 @@ function randomValue() {
     [randomString()]: randomString()
   };
 }
-function randomPutObject() {
+function randomPostObject() {
   return {
     value: randomValue(),
     channels: [randomString(), randomString()]
@@ -36,7 +25,7 @@ async function nextStreamValue(iterator) {
 }
 function continueStream(graffiti, streamReturn, type, session) {
   if (type === "cursor") {
-    return graffiti.continueObjectStream(
+    return graffiti.continueDiscover(
       streamReturn.cursor,
       session
     );
@@ -44,1265 +33,10 @@ function continueStream(graffiti, streamReturn, type, session) {
     return streamReturn.continue();
   }
 }
-
-// tests/crud.ts
-var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
-  describe.concurrent(
-    "CRUD",
-    {
-      timeout: 2e4
-    },
-    () => {
-      let graffiti;
-      let session;
-      let session1;
-      let session2;
-      beforeAll(async () => {
-        graffiti = useGraffiti();
-        session1 = await useSession1();
-        session = session1;
-        session2 = await useSession2();
-      });
-      it("put, get, delete", async () => {
-        const value = {
-          something: "hello, world~ c:"
-        };
-        const channels = [randomString(), randomString()];
-        const previous = await graffiti.put({ value, channels }, session);
-        expect(previous.value).toEqual({});
-        expect(previous.channels).toEqual([]);
-        expect(previous.allowed).toEqual([]);
-        expect(previous.actor).toEqual(session.actor);
-        const gotten = await graffiti.get(previous, {});
-        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(
-          {
-            url: previous.url,
-            value: newValue,
-            channels: []
-          },
-          session
-        );
-        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, {});
-        expect(afterReplaced.value).toEqual(newValue);
-        expect(afterReplaced.lastModified).toEqual(beforeReplaced.lastModified);
-        const beforeDeleted = await graffiti.delete(afterReplaced, session);
-        expect(beforeDeleted.value).toEqual(newValue);
-        expect(beforeDeleted.lastModified).toBeGreaterThanOrEqual(
-          beforeReplaced.lastModified
-        );
-        await expect(graffiti.get(afterReplaced, {})).rejects.toBeInstanceOf(
-          GraffitiErrorNotFound
-        );
-        await expect(graffiti.delete(beforeDeleted, session)).rejects.toThrow(
-          GraffitiErrorNotFound
-        );
-        await expect(
-          graffiti.put(
-            { url: beforeDeleted.url, value: {}, channels: [] },
-            session
-          )
-        ).rejects.toThrow(GraffitiErrorNotFound);
-      });
-      it("put, delete, patch with wrong actor", async () => {
-        await expect(
-          graffiti.put(
-            { value: {}, channels: [], actor: session2.actor },
-            session1
-          )
-        ).rejects.toThrow(GraffitiErrorForbidden);
-        const putted = await graffiti.put(
-          { value: {}, channels: [] },
-          session2
-        );
-        await expect(
-          graffiti.put(
-            {
-              url: putted.url,
-              value: {},
-              channels: []
-            },
-            session1
-          )
-        ).rejects.toThrow(GraffitiErrorForbidden);
-        await expect(graffiti.delete(putted, session1)).rejects.toThrow(
-          GraffitiErrorForbidden
-        );
-        await expect(graffiti.patch({}, putted, session1)).rejects.toThrow(
-          GraffitiErrorForbidden
-        );
-      });
-      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: {
-              properties: {
-                something: {
-                  type: "string"
-                },
-                another: {
-                  type: "array",
-                  items: {
-                    type: "number"
-                  }
-                },
-                deeper: {
-                  type: "object",
-                  properties: {
-                    deepProp: {
-                      type: "string"
-                    }
-                  },
-                  required: ["deepProp"]
-                }
-              },
-              required: ["another", "deeper"]
-            }
-          }
-        };
-        const goodValue = {
-          something: "hello",
-          another: [1, 2, 3],
-          deeper: {
-            deepProp: "hello"
-          }
-        };
-        const putted = await graffiti.put(
-          {
-            value: goodValue,
-            channels: []
-          },
-          session
-        );
-        const gotten = await graffiti.get(putted, schema);
-        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);
-      });
-      it("put and get with invalid schema", async () => {
-        const putted = await graffiti.put(
-          { value: {}, channels: [] },
-          session
-        );
-        await expect(
-          graffiti.get(putted, {
-            properties: {
-              value: {
-                //@ts-ignore
-                type: "asdf"
-              }
-            }
-          })
-        ).rejects.toThrow(GraffitiErrorInvalidSchema);
-      });
-      it("put and get with wrong schema", async () => {
-        const putted = await graffiti.put(
-          {
-            value: {
-              hello: "world"
-            },
-            channels: []
-          },
-          session
-        );
-        await expect(
-          graffiti.get(putted, {
-            properties: {
-              value: {
-                properties: {
-                  hello: {
-                    type: "number"
-                  }
-                }
-              }
-            }
-          })
-        ).rejects.toThrow(GraffitiErrorSchemaMismatch);
-      });
-      it("put and get with empty access control", async () => {
-        const value = {
-          um: "hi"
-        };
-        const allowed = [randomString()];
-        const channels = [randomString()];
-        const putted = await graffiti.put(
-          { value, allowed, channels },
-          session1
-        );
-        const gotten = await graffiti.get(putted, {}, session1);
-        expect(gotten.value).toEqual(value);
-        expect(gotten.allowed).toEqual(allowed);
-        expect(gotten.channels).toEqual(channels);
-        await expect(graffiti.get(putted, {})).rejects.toBeInstanceOf(
-          GraffitiErrorNotFound
-        );
-        await expect(graffiti.get(putted, {}, session2)).rejects.toBeInstanceOf(
-          GraffitiErrorNotFound
-        );
-      });
-      it("put and get with specific access control", async () => {
-        const value = {
-          um: "hi"
-        };
-        const allowed = [randomString(), session2.actor, randomString()];
-        const channels = [randomString()];
-        const putted = await graffiti.put(
-          {
-            value,
-            allowed,
-            channels
-          },
-          session1
-        );
-        const gotten = await graffiti.get(putted, {}, session1);
-        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);
-        expect(gotten2.value).toEqual(value);
-        expect(gotten2.allowed).toEqual([session2.actor]);
-        expect(gotten2.channels).toEqual([]);
-      });
-      it("patch value", async () => {
-        const value = {
-          something: "hello, world~ c:"
-        };
-        const putted = await graffiti.put({ value, channels: [] }, session);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        const patch = {
-          value: [
-            { op: "replace", path: "/something", value: "goodbye, world~ :c" }
-          ]
-        };
-        const beforePatched = await graffiti.patch(patch, putted, session);
-        expect(beforePatched.value).toEqual(value);
-        expect(beforePatched.lastModified).toBeGreaterThan(putted.lastModified);
-        const gotten = await graffiti.get(putted, {});
-        expect(gotten.value).toEqual({
-          something: "goodbye, world~ :c"
-        });
-        expect(beforePatched.lastModified).toBe(gotten.lastModified);
-        await graffiti.delete(putted, session);
-      });
-      it("patch deleted object", async () => {
-        const putted = await graffiti.put(randomPutObject(), session);
-        const deleted = await graffiti.delete(putted, session);
-        await expect(
-          graffiti.patch({}, putted, session)
-        ).rejects.toBeInstanceOf(GraffitiErrorNotFound);
-      });
-      it("deep patch", async () => {
-        const value = {
-          something: {
-            another: {
-              somethingElse: "hello"
-            }
-          }
-        };
-        const putted = await graffiti.put(
-          { value, channels: [] },
-          session
-        );
-        const beforePatch = await graffiti.patch(
-          {
-            value: [
-              {
-                op: "replace",
-                path: "/something/another/somethingElse",
-                value: "goodbye"
-              }
-            ]
-          },
-          putted,
-          session
-        );
-        const gotten = await graffiti.get(putted, {});
-        expect(beforePatch.value).toEqual(value);
-        expect(gotten.value).toEqual({
-          something: {
-            another: {
-              somethingElse: "goodbye"
-            }
-          }
-        });
-      });
-      it("patch channels", async () => {
-        const channelsBefore = [randomString()];
-        const channelsAfter = [randomString()];
-        const putted = await graffiti.put(
-          { value: {}, channels: channelsBefore },
-          session
-        );
-        const patch = {
-          channels: [{ op: "replace", path: "/0", value: channelsAfter[0] }]
-        };
-        const patched = await graffiti.patch(patch, putted, session);
-        expect(patched.channels).toEqual(channelsBefore);
-        const gotten = await graffiti.get(putted, {}, session);
-        expect(gotten.channels).toEqual(channelsAfter);
-        await graffiti.delete(putted, session);
-      });
-      it("patch 'increment' with test", async () => {
-        const putted = await graffiti.put(
-          {
-            value: {
-              counter: 1
-            },
-            channels: []
-          },
-          session
-        );
-        const previous = await graffiti.patch(
-          {
-            value: [
-              { op: "test", path: "/counter", value: 1 },
-              { op: "replace", path: "/counter", value: 2 }
-            ]
-          },
-          putted,
-          session
-        );
-        expect(previous.value).toEqual({ counter: 1 });
-        const result = await graffiti.get(previous, {
-          properties: {
-            value: {
-              properties: {
-                counter: {
-                  type: "integer"
-                }
-              }
-            }
-          }
-        });
-        expect(result.value.counter).toEqual(2);
-        await expect(
-          graffiti.patch(
-            {
-              value: [
-                { op: "test", path: "/counter", value: 1 },
-                { op: "replace", path: "/counter", value: 3 }
-              ]
-            },
-            putted,
-            session
-          )
-        ).rejects.toThrow(GraffitiErrorPatchTestFailed);
-      });
-      it("invalid patch", async () => {
-        const object = randomPutObject();
-        const putted = await graffiti.put(object, session);
-        await expect(
-          graffiti.patch(
-            {
-              value: [
-                { op: "add", path: "/root", value: [] },
-                { op: "add", path: "/root/2", value: 2 }
-                // out of bounds
-              ]
-            },
-            putted,
-            session
-          )
-        ).rejects.toThrow(GraffitiErrorPatchError);
-      });
-      it("patch channels to be wrong", async () => {
-        const object = randomPutObject();
-        object.allowed = [randomString()];
-        const putted = await graffiti.put(object, session);
-        const patches = [
-          {
-            channels: [{ op: "replace", path: "", value: null }]
-          },
-          {
-            channels: [{ op: "replace", path: "", value: {} }]
-          },
-          {
-            channels: [{ op: "replace", path: "", value: ["hello", ["hi"]] }]
-          },
-          {
-            channels: [{ op: "add", path: "/0", value: 1 }]
-          },
-          {
-            value: [{ op: "replace", path: "", value: "not an object" }]
-          },
-          {
-            value: [{ op: "replace", path: "", value: null }]
-          },
-          {
-            value: [{ op: "replace", path: "", value: [] }]
-          },
-          {
-            allowed: [{ op: "replace", path: "", value: {} }]
-          },
-          {
-            allowed: [{ op: "replace", path: "", value: ["hello", ["hi"]] }]
-          }
-        ];
-        for (const patch of patches) {
-          await expect(graffiti.patch(patch, putted, session)).rejects.toThrow(
-            GraffitiErrorPatchError
-          );
-        }
-        const gotten = await graffiti.get(putted, {}, session);
-        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 it2, expect as expect2, describe as describe2, assert as assert2, beforeAll as beforeAll2 } from "vitest";
-var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
-  describe2.concurrent("discover", { timeout: 2e4 }, () => {
-    let graffiti;
-    let session;
-    let session1;
-    let session2;
-    beforeAll2(async () => {
-      graffiti = useGraffiti();
-      session1 = await useSession1();
-      session = session1;
-      session2 = await useSession2();
-    });
-    it2("discover nothing", async () => {
-      const iterator = graffiti.discover([], {});
-      expect2(await iterator.next()).toHaveProperty("done", true);
-    });
-    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);
-      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();
-      expect2(result2.done).toBe(true);
-    });
-    it2("discover wrong channel", async () => {
-      const object = randomPutObject();
-      await graffiti.put(object, session);
-      const iterator = graffiti.discover([randomString()], {});
-      await expect2(iterator.next()).resolves.toHaveProperty("done", true);
-    });
-    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);
-      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);
-      expect2(await iteratorSession2.next()).toHaveProperty("done", true);
-      const iteratorNoSession = graffiti.discover(object.channels, {});
-      expect2(await iteratorNoSession.next()).toHaveProperty("done", true);
-    });
-    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);
-      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 ["actor", "lastModified"]) {
-      it2(`discover for ${prop}`, async () => {
-        const object1 = randomPutObject();
-        const putted1 = await graffiti.put(object1, session1);
-        const object2 = randomPutObject();
-        object2.channels = object1.channels;
-        await new Promise((r) => setTimeout(r, 20));
-        const putted2 = await graffiti.put(object2, session2);
-        const iterator = graffiti.discover(object1.channels, {
-          properties: {
-            [prop]: {
-              enum: [putted1[prop]]
-            }
-          }
-        });
-        const value = await nextStreamValue(iterator);
-        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);
-      });
-    }
-    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);
-      expect2(putted1.url).not.toEqual(putted2.url);
-      expect2(putted1.lastModified).toBeLessThan(putted2.lastModified);
-      const gtIterator = graffiti.discover([object.channels[0]], {
-        properties: {
-          lastModified: {
-            exclusiveMinimum: putted2.lastModified
-          }
-        }
-      });
-      expect2(await gtIterator.next()).toHaveProperty("done", true);
-      const gtIteratorEpsilon = graffiti.discover([object.channels[0]], {
-        properties: {
-          lastModified: {
-            exclusiveMinimum: putted2.lastModified - 0.1
-          }
-        }
-      });
-      const value1 = await nextStreamValue(gtIteratorEpsilon);
-      expect2(value1.url).toEqual(putted2.url);
-      expect2(await gtIteratorEpsilon.next()).toHaveProperty("done", true);
-      const gteIterator = graffiti.discover(object.channels, {
-        properties: {
-          value: {},
-          lastModified: {
-            minimum: putted2.lastModified
-          }
-        }
-      });
-      const value = await nextStreamValue(gteIterator);
-      expect2(value.url).toEqual(putted2.url);
-      expect2(await gteIterator.next()).toHaveProperty("done", true);
-      const gteIteratorEpsilon = graffiti.discover(object.channels, {
-        properties: {
-          lastModified: {
-            minimum: putted2.lastModified + 0.1
-          }
-        }
-      });
-      expect2(await gteIteratorEpsilon.next()).toHaveProperty("done", true);
-      const ltIterator = graffiti.discover(object.channels, {
-        properties: {
-          lastModified: {
-            exclusiveMaximum: putted1.lastModified
-          }
-        }
-      });
-      expect2(await ltIterator.next()).toHaveProperty("done", true);
-      const ltIteratorEpsilon = graffiti.discover(object.channels, {
-        properties: {
-          lastModified: {
-            exclusiveMaximum: putted1.lastModified + 0.1
-          }
-        }
-      });
-      const value3 = await nextStreamValue(ltIteratorEpsilon);
-      expect2(value3.url).toEqual(putted1.url);
-      expect2(await ltIteratorEpsilon.next()).toHaveProperty("done", true);
-      const lteIterator = graffiti.discover(object.channels, {
-        properties: {
-          lastModified: {
-            maximum: putted1.lastModified
-          }
-        }
-      });
-      const value2 = await nextStreamValue(lteIterator);
-      expect2(value2.url).toEqual(putted1.url);
-      expect2(await lteIterator.next()).toHaveProperty("done", true);
-      const lteIteratorEpsilon = graffiti.discover(object.channels, {
-        properties: {
-          lastModified: {
-            maximum: putted1.lastModified - 0.1
-          }
-        }
-      });
-      expect2(await lteIteratorEpsilon.next()).toHaveProperty("done", true);
-    });
-    it2("discover schema allowed, as and not as owner", async () => {
-      const object = randomPutObject();
-      object.allowed = [randomString(), session2.actor, randomString()];
-      await graffiti.put(object, session1);
-      const iteratorSession1 = graffiti.discover(
-        object.channels,
-        {
-          properties: {
-            allowed: {
-              minItems: 3,
-              // Make sure session2.actor is in the allow list
-              not: {
-                items: {
-                  not: {
-                    enum: [session2.actor]
-                  }
-                }
-              }
-            }
-          }
-        },
-        session1
-      );
-      const value = await nextStreamValue(iteratorSession1);
-      expect2(value.value).toEqual(object.value);
-      await expect2(iteratorSession1.next()).resolves.toHaveProperty(
-        "done",
-        true
-      );
-      const iteratorSession2BigAllow = graffiti.discover(
-        object.channels,
-        {
-          properties: {
-            allowed: {
-              minItems: 3
-            }
-          }
-        },
-        session2
-      );
-      await expect2(iteratorSession2BigAllow.next()).resolves.toHaveProperty(
-        "done",
-        true
-      );
-      const iteratorSession2PeekOther = graffiti.discover(
-        object.channels,
-        {
-          properties: {
-            allowed: {
-              not: {
-                items: {
-                  not: {
-                    enum: [object.channels[0]]
-                  }
-                }
-              }
-            }
-          }
-        },
-        session2
-      );
-      await expect2(iteratorSession2PeekOther.next()).resolves.toHaveProperty(
-        "done",
-        true
-      );
-      const iteratorSession2SmallAllowPeekSelf = graffiti.discover(
-        object.channels,
-        {
-          properties: {
-            allowed: {
-              maxItems: 1,
-              not: {
-                items: {
-                  not: {
-                    enum: [session2.actor]
-                  }
-                }
-              }
-            }
-          }
-        },
-        session2
-      );
-      const value2 = await nextStreamValue(
-        iteratorSession2SmallAllowPeekSelf
-      );
-      expect2(value2.value).toEqual(object.value);
-      await expect2(
-        iteratorSession2SmallAllowPeekSelf.next()
-      ).resolves.toHaveProperty("done", true);
-    });
-    it2("discover schema channels, as and not as owner", async () => {
-      const object = randomPutObject();
-      object.channels = [randomString(), randomString(), randomString()];
-      await graffiti.put(object, session1);
-      const iteratorSession1 = graffiti.discover(
-        [object.channels[0], object.channels[2]],
-        {
-          properties: {
-            channels: {
-              minItems: 3,
-              // Make sure session2.actor is in the allow list
-              not: {
-                items: {
-                  not: {
-                    enum: [object.channels[1]]
-                  }
-                }
-              }
-            }
-          }
-        },
-        session1
-      );
-      const value = await nextStreamValue(iteratorSession1);
-      expect2(value.value).toEqual(object.value);
-      await expect2(iteratorSession1.next()).resolves.toHaveProperty(
-        "done",
-        true
-      );
-      const iteratorSession2BigAllow = graffiti.discover(
-        [object.channels[0], object.channels[2]],
-        {
-          properties: {
-            channels: {
-              minItems: 3
-            }
-          }
-        },
-        session2
-      );
-      await expect2(iteratorSession2BigAllow.next()).resolves.toHaveProperty(
-        "done",
-        true
-      );
-      const iteratorSession2PeekOther = graffiti.discover(
-        [object.channels[0], object.channels[2]],
-        {
-          properties: {
-            channels: {
-              not: {
-                items: {
-                  not: {
-                    enum: [object.channels[1]]
-                  }
-                }
-              }
-            }
-          }
-        },
-        session2
-      );
-      await expect2(iteratorSession2PeekOther.next()).resolves.toHaveProperty(
-        "done",
-        true
-      );
-      const iteratorSession2SmallAllowPeekSelf = graffiti.discover(
-        [object.channels[0], object.channels[2]],
-        {
-          properties: {
-            allowed: {
-              maxItems: 2,
-              not: {
-                items: {
-                  not: {
-                    enum: [object.channels[2]]
-                  }
-                }
-              }
-            }
-          }
-        },
-        session2
-      );
-      const value2 = await nextStreamValue(
-        iteratorSession2SmallAllowPeekSelf
-      );
-      expect2(value2.value).toEqual(object.value);
-      await expect2(
-        iteratorSession2SmallAllowPeekSelf.next()
-      ).resolves.toHaveProperty("done", true);
-    });
-    it2("discover query for empty allowed", async () => {
-      const publicO = randomPutObject();
-      const publicSchema = {
-        not: {
-          required: ["allowed"]
-        }
-      };
-      await graffiti.put(publicO, session1);
-      const iterator = graffiti.discover(
-        publicO.channels,
-        publicSchema,
-        session1
-      );
-      const value = await nextStreamValue(iterator);
-      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);
-      const iterator2 = graffiti.discover(
-        restricted.channels,
-        publicSchema,
-        session1
-      );
-      await expect2(iterator2.next()).resolves.toHaveProperty("done", true);
-    });
-    it2("discover query for values", async () => {
-      const object1 = randomPutObject();
-      object1.value = { test: randomString() };
-      await graffiti.put(object1, session);
-      const object2 = randomPutObject();
-      object2.channels = object1.channels;
-      object2.value = { test: randomString(), something: randomString() };
-      await graffiti.put(object2, session);
-      const object3 = randomPutObject();
-      object3.channels = object1.channels;
-      object3.value = { other: randomString(), something: randomString() };
-      await graffiti.put(object3, session);
-      const counts = /* @__PURE__ */ new Map();
-      for (const property of ["test", "something", "other"]) {
-        let count = 0;
-        for await (const result of graffiti.discover(object1.channels, {
-          properties: {
-            value: {
-              required: [property]
-            }
-          }
-        })) {
-          assert2(!result.error, "result has error");
-          if (property in result.object.value) {
-            count++;
-          }
-        }
-        counts.set(property, count);
-      }
-      expect2(counts.get("test")).toBe(2);
-      expect2(counts.get("something")).toBe(2);
-      expect2(counts.get("other")).toBe(1);
-    });
-    for (const continueType of ["cursor", "continue"]) {
-      describe2(`continue discover with ${continueType}`, () => {
-        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, {});
-          await expect2(iterator.next()).resolves.toHaveProperty("done", true);
-          const tombIterator = continueStream(
-            graffiti,
-            returnValue.value,
-            continueType
-          );
-          const value = await tombIterator.next();
-          assert2(!value.done && !value.value.error, "value is done");
-          assert2(value.value.tombstone, "value is not tombstone");
-          expect2(value.value.object.url).toEqual(putted.url);
-          await expect2(tombIterator.next()).resolves.toHaveProperty(
-            "done",
-            true
-          );
-        });
-        it2("discover for replaced channels", async () => {
-          async function runTest() {
-            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(
-              {
-                ...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 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);
-              return;
-            }
-            const value5 = await iterator1.next();
-            assert2(value5.done, "value5 is not done");
-            const value4 = await tombIterator.next();
-            assert2(!value4.done && !value4.value.error, "value is done");
-            assert2(value4.value.tombstone, "value is not tombstone");
-            expect2(value4.value.object.url).toEqual(putted.url);
-            expect2(value4.value.object.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);
-            const patched = await graffiti.patch(
-              {
-                channels: [
-                  { op: "replace", path: "", value: object1.channels }
-                ]
-              },
-              replaced,
-              session
-            );
-            const tombIterator2 = continueStream(
-              graffiti,
-              value5.value,
-              continueType
-            );
-            let result;
-            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;
-              }
-            }
-            assert2(result, "result is not defined");
-            assert2(!result.tombstone, "result is tombstone");
-            expect2(result.object.url).toEqual(replaced.url);
-            expect2(result.object.lastModified).toEqual(patched.lastModified);
-            expect2(result.object.channels).toEqual(object1.channels);
-            expect2(result.object.value).toEqual(object2.value);
-          }
-          await Promise.allSettled(Array.from({ length: 20 }, () => runTest()));
-        });
-        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: [] }]
-            },
-            putted,
-            session
-          );
-          const iterator2 = graffiti.discover(object.channels, {});
-          expect2(await iterator2.next()).toHaveProperty("done", true);
-          const iterator = continueStream(
-            graffiti,
-            returnValue.value,
-            continueType
-          );
-          const value = await iterator.next();
-          assert2(!value.done && !value.value.error, "value is done");
-          assert2(value.value.tombstone, "value is not tombstone");
-          expect2(value.value.object.url).toEqual(putted.url);
-          await expect2(iterator.next()).resolves.toHaveProperty("done", true);
-        });
-        it2("put concurrently and discover one", async () => {
-          const object = randomPutObject();
-          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.tombstone) {
-              tombstoneCount++;
-            } else {
-              valueCount++;
-            }
-          }
-          expect2(tombstoneCount).toBe(0);
-          expect2(valueCount).toBe(1);
-        });
-      });
-    }
-  });
-};
-
-// tests/orphans.ts
-import { it as it3, expect as expect3, describe as describe3, assert as assert3, beforeAll as beforeAll3 } from "vitest";
-var graffitiOrphanTests = (useGraffiti, useSession1, useSession2) => {
-  describe3("recoverOrphans", { timeout: 2e4 }, () => {
-    let graffiti;
-    let session;
-    let session1;
-    let session2;
-    beforeAll3(async () => {
-      graffiti = useGraffiti();
-      session1 = await useSession1();
-      session = session1;
-      session2 = await useSession2();
-    });
-    it3("list orphans", async () => {
-      const existingOrphans = [];
-      const orphanIterator1 = graffiti.recoverOrphans({}, session);
-      for await (const orphan of orphanIterator1) {
-        if (orphan.error) continue;
-        existingOrphans.push(orphan.object.url);
-      }
-      const object = randomPutObject();
-      object.channels = [];
-      const putted = await graffiti.put(object, session);
-      const orphanIterator2 = graffiti.recoverOrphans({}, session);
-      let numResults = 0;
-      for await (const orphan of orphanIterator2) {
-        if (orphan.error) continue;
-        assert3(!orphan.tombstone, "orphan is tombstone");
-        if (orphan.object.url === putted.url) {
-          numResults++;
-          expect3(orphan.object.lastModified).toBe(putted.lastModified);
-        }
-      }
-      expect3(numResults).toBe(1);
-    });
-    for (const continueType of ["continue", "cursor"]) {
-      describe3(`continue orphans with ${continueType}`, () => {
-        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,
-              ...object,
-              channels: [randomString()]
-            },
-            session
-          );
-          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.object.url === putOrphan.url) {
-              numResults++;
-            }
-          }
-          expect3(numResults).toBe(0);
-          const iterator2 = continueStream(
-            graffiti,
-            returnValue.value,
-            continueType,
-            session
-          );
-          const value2 = await iterator2.next();
-          assert3(
-            !value2.done && !value2.value.error,
-            "value2 is done or has error"
-          );
-          assert3(value2.value.tombstone, "value2 is not tombstone");
-          expect3(value2.value.object.url).toBe(putOrphan.url);
-          await expect3(iterator2.next()).resolves.toHaveProperty("done", true);
-        });
-      });
-    }
-  });
-};
-
-// tests/channel-stats.ts
-import { it as it4, expect as expect4, describe as describe4, assert as assert4, beforeAll as beforeAll4 } from "vitest";
-var graffitiChannelStatsTests = (useGraffiti, useSession1, useSession2) => {
-  describe4("channel stats", { timeout: 2e4 }, () => {
-    let graffiti;
-    let session;
-    let session1;
-    let session2;
-    beforeAll4(async () => {
-      graffiti = useGraffiti();
-      session1 = await useSession1();
-      session = session1;
-      session2 = await useSession2();
-    });
-    it4("list channels", async () => {
-      const existingChannels = /* @__PURE__ */ new Map();
-      const channelIterator1 = graffiti.channelStats(session);
-      for await (const channel of channelIterator1) {
-        if (channel.error) continue;
-        existingChannels.set(channel.value.channel, channel.value.count);
-      }
-      const channels = [randomString(), randomString(), randomString()];
-      for (let i = 0; i < 3; i++) {
-        for (let j = 0; j < i + 1; j++) {
-          await graffiti.put(
-            {
-              value: {
-                index: j
-              },
-              channels: channels.slice(0, i + 1)
-            },
-            session
-          );
-        }
-      }
-      await graffiti.put(
-        { value: { index: 3 }, channels: [channels[2]] },
-        session
-      );
-      const channelIterator2 = graffiti.channelStats(session);
-      let newChannels = /* @__PURE__ */ new Map();
-      for await (const channel of channelIterator2) {
-        if (channel.error) continue;
-        newChannels.set(channel.value.channel, channel.value.count);
-      }
-      newChannels = new Map(
-        Array.from(newChannels).filter(
-          ([channel, count]) => !existingChannels.has(channel)
-        )
-      );
-      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);
-    });
-    it4("list channels with deleted channel", async () => {
-      const channels = [randomString(), randomString(), randomString()];
-      const before = await graffiti.put(
-        {
-          value: { index: 2 },
-          channels: channels.slice(1)
-        },
-        session
-      );
-      const first = await graffiti.put(
-        { value: { index: 0 }, channels },
-        session
-      );
-      await graffiti.delete(first, session);
-      const second = await graffiti.put(
-        {
-          value: { index: 1 },
-          channels: channels.slice(2)
-        },
-        session
-      );
-      const channelIterator = graffiti.channelStats(session);
-      let got1 = 0;
-      let got2 = 0;
-      for await (const result of channelIterator) {
-        if (result.error) continue;
-        const { channel, count, lastModified } = result.value;
-        assert4(
-          channel !== channels[0],
-          "There should not be an object in channel[0]"
-        );
-        if (channel === channels[1]) {
-          expect4(count).toBe(1);
-          expect4(lastModified).toBe(before.lastModified);
-          got1++;
-        } else if (channel === channels[2]) {
-          expect4(count).toBe(2);
-          expect4(lastModified).toBe(second.lastModified);
-          got2++;
-        }
-      }
-      expect4(got1).toBe(1);
-      expect4(got2).toBe(1);
-    });
-  });
-};
 export {
   continueStream,
-  graffitiCRUDTests,
-  graffitiChannelStatsTests,
-  graffitiDiscoverTests,
-  graffitiOrphanTests,
   nextStreamValue,
-  randomPutObject,
+  randomPostObject,
   randomString,
   randomValue
 };