@graffiti-garden/api 0.6.4 → 1.0.1

package/dist/tests.mjs

@@ -4,9 +4,7 @@ import {
   GraffitiErrorNotFound,
   GraffitiErrorSchemaMismatch,
   GraffitiErrorInvalidSchema,
-  GraffitiErrorForbidden,
-  GraffitiErrorPatchTestFailed,
-  GraffitiErrorPatchError
+  GraffitiErrorForbidden
 } from "@graffiti-garden/api";
 
 // tests/utils.ts
@@ -22,7 +20,7 @@ function randomValue() {
     [randomString()]: randomString()
   };
 }
-function randomPutObject() {
+function randomPostObject() {
   return {
     value: randomValue(),
     channels: [randomString(), randomString()]
@@ -36,7 +34,7 @@ async function nextStreamValue(iterator) {
 }
 function continueStream(graffiti, streamReturn, type, session) {
   if (type === "cursor") {
-    return graffiti.continueObjectStream(
+    return graffiti.continueDiscover(
       streamReturn.cursor,
       session
     );
@@ -63,15 +61,15 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
         session = session1;
         session2 = await useSession2();
       });
-      it("put, get, delete", async () => {
+      it("post, 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([]);
+        const previous = await graffiti.post({ value, channels }, session);
+        expect(previous.value).toEqual(value);
+        expect(previous.channels).toEqual(channels);
+        expect(previous.allowed).toEqual(void 0);
         expect(previous.actor).toEqual(session.actor);
         const gotten = await graffiti.get(previous, {});
         expect(gotten.value).toEqual(value);
@@ -79,100 +77,24 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
         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(
+        await graffiti.delete(gotten, session);
+        await expect(graffiti.get(gotten, {})).rejects.toBeInstanceOf(
           GraffitiErrorNotFound
         );
-        await expect(graffiti.delete(beforeDeleted, session)).rejects.toThrow(
+        await expect(graffiti.delete(gotten, 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(
+      it("post then delete with wrong actor", async () => {
+        const posted = await graffiti.post(
           { 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(
+        await expect(graffiti.delete(posted, 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 () => {
+      it("post and get with schema", async () => {
         const schema = {
           properties: {
             value: {
@@ -207,26 +129,26 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
             deepProp: "hello"
           }
         };
-        const putted = await graffiti.put(
+        const posted = await graffiti.post(
           {
             value: goodValue,
             channels: []
           },
           session
         );
-        const gotten = await graffiti.get(putted, schema);
+        const gotten = await graffiti.get(posted, 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(
+      it("post and get with invalid schema", async () => {
+        const posted = await graffiti.post(
           { value: {}, channels: [] },
           session
         );
         await expect(
-          graffiti.get(putted, {
+          graffiti.get(posted, {
             properties: {
               value: {
                 //@ts-ignore
@@ -236,8 +158,8 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
           })
         ).rejects.toThrow(GraffitiErrorInvalidSchema);
       });
-      it("put and get with wrong schema", async () => {
-        const putted = await graffiti.put(
+      it("post and get with wrong schema", async () => {
+        const posted = await graffiti.post(
           {
             value: {
               hello: "world"
@@ -247,7 +169,7 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
           session
         );
         await expect(
-          graffiti.get(putted, {
+          graffiti.get(posted, {
             properties: {
               value: {
                 properties: {
@@ -260,34 +182,36 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
           })
         ).rejects.toThrow(GraffitiErrorSchemaMismatch);
       });
-      it("put and get with empty access control", async () => {
+      it("post and get with empty access control", async () => {
         const value = {
           um: "hi"
         };
         const allowed = [randomString()];
         const channels = [randomString()];
-        const putted = await graffiti.put(
+        const posted = await graffiti.post(
           { value, allowed, channels },
           session1
         );
-        const gotten = await graffiti.get(putted, {}, session1);
+        const gotten = await graffiti.get(posted, {}, session1);
+        expect(gotten.url).toEqual(posted.url);
+        expect(gotten.actor).toEqual(session1.actor);
         expect(gotten.value).toEqual(value);
         expect(gotten.allowed).toEqual(allowed);
         expect(gotten.channels).toEqual(channels);
-        await expect(graffiti.get(putted, {})).rejects.toBeInstanceOf(
+        await expect(graffiti.get(posted, {})).rejects.toBeInstanceOf(
           GraffitiErrorNotFound
         );
-        await expect(graffiti.get(putted, {}, session2)).rejects.toBeInstanceOf(
+        await expect(graffiti.get(posted, {}, session2)).rejects.toBeInstanceOf(
           GraffitiErrorNotFound
         );
       });
-      it("put and get with specific access control", async () => {
+      it("post 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(
+        const posted = await graffiti.post(
           {
             value,
             allowed,
@@ -295,204 +219,22 @@ var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
           },
           session1
         );
-        const gotten = await graffiti.get(putted, {}, session1);
+        const gotten = await graffiti.get(posted, {}, session1);
+        expect(gotten.url).toEqual(posted.url);
+        expect(gotten.actor).toEqual(session1.actor);
         expect(gotten.value).toEqual(value);
         expect(gotten.allowed).toEqual(allowed);
         expect(gotten.channels).toEqual(channels);
-        await expect(graffiti.get(putted, {})).rejects.toBeInstanceOf(
+        await expect(graffiti.get(posted, {})).rejects.toBeInstanceOf(
           GraffitiErrorNotFound
         );
-        const gotten2 = await graffiti.get(putted, {}, session2);
+        const gotten2 = await graffiti.get(posted, {}, session2);
+        expect(gotten.url).toEqual(posted.url);
+        expect(gotten.actor).toEqual(session1.actor);
         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);
-      });
     }
   );
 };
@@ -516,168 +258,82 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
       expect2(await iterator.next()).toHaveProperty("done", true);
     });
     it2("discover single", async () => {
-      const object = randomPutObject();
-      const putted = await graffiti.put(object, session);
+      const object = randomPostObject();
+      const posted = await graffiti.post(object, session);
       const queryChannels = [randomString(), object.channels[0]];
       const iterator = graffiti.discover(queryChannels, {});
       const value = await nextStreamValue(iterator);
+      expect2(value.url).toEqual(posted.url);
       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 object = randomPostObject();
+      await graffiti.post(object, session);
       const iterator = graffiti.discover([randomString()], {});
       await expect2(iterator.next()).resolves.toHaveProperty("done", true);
     });
     it2("discover not allowed", async () => {
-      const object = randomPutObject();
+      const object = randomPostObject();
       object.allowed = [randomString(), randomString()];
-      const putted = await graffiti.put(object, session1);
+      const posted = await graffiti.post(object, session1);
       const iteratorSession1 = graffiti.discover(
         object.channels,
         {},
         session1
       );
       const value = await nextStreamValue(iteratorSession1);
+      expect2(value.url).toEqual(posted.url);
       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();
+      const object = randomPostObject();
       object.allowed = [randomString(), session2.actor, randomString()];
-      const putted = await graffiti.put(object, session1);
+      const posted = await graffiti.post(object, session1);
       const iteratorSession2 = graffiti.discover(
         object.channels,
         {},
         session2
       );
       const value = await nextStreamValue(iteratorSession2);
+      expect2(value.url).toEqual(posted.url);
       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, {
+    it2("discover for actor", async () => {
+      const object1 = randomPostObject();
+      const posted1 = await graffiti.post(object1, session1);
+      const object2 = randomPostObject();
+      object2.channels = object1.channels;
+      const posted2 = await graffiti.post(object2, session2);
+      const iterator = graffiti.discover(object1.channels, {
         properties: {
-          lastModified: {
-            maximum: putted1.lastModified - 0.1
-          }
+          actor: { const: posted1.actor }
         }
       });
-      expect2(await lteIteratorEpsilon.next()).toHaveProperty("done", true);
+      const value = await nextStreamValue(iterator);
+      expect2(value.url).toEqual(posted1.url);
+      expect2(value.url).not.toEqual(posted2.url);
+      expect2(value.value).toEqual(object1.value);
+      await expect2(iterator.next()).resolves.toHaveProperty("done", true);
     });
     it2("discover schema allowed, as and not as owner", async () => {
-      const object = randomPutObject();
+      const object = randomPostObject();
       object.allowed = [randomString(), session2.actor, randomString()];
-      await graffiti.put(object, session1);
+      await graffiti.post(object, session1);
       const iteratorSession1 = graffiti.discover(
         object.channels,
         {
@@ -687,9 +343,7 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
               // Make sure session2.actor is in the allow list
               not: {
                 items: {
-                  not: {
-                    enum: [session2.actor]
-                  }
+                  not: { const: session2.actor }
                 }
               }
             }
@@ -725,9 +379,7 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
             allowed: {
               not: {
                 items: {
-                  not: {
-                    enum: [object.channels[0]]
-                  }
+                  not: { const: object.allowed[0] }
                 }
               }
             }
@@ -747,9 +399,7 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
               maxItems: 1,
               not: {
                 items: {
-                  not: {
-                    enum: [session2.actor]
-                  }
+                  not: { const: session2.actor }
                 }
               }
             }
@@ -766,21 +416,19 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
       ).resolves.toHaveProperty("done", true);
     });
     it2("discover schema channels, as and not as owner", async () => {
-      const object = randomPutObject();
+      const object = randomPostObject();
       object.channels = [randomString(), randomString(), randomString()];
-      await graffiti.put(object, session1);
+      await graffiti.post(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
+              // Make sure channel 1 is in the allow list
               not: {
                 items: {
-                  not: {
-                    enum: [object.channels[1]]
-                  }
+                  not: { const: object.channels[1] }
                 }
               }
             }
@@ -816,9 +464,7 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
             channels: {
               not: {
                 items: {
-                  not: {
-                    enum: [object.channels[1]]
-                  }
+                  not: { const: object.channels[1] }
                 }
               }
             }
@@ -838,9 +484,7 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
               maxItems: 2,
               not: {
                 items: {
-                  not: {
-                    enum: [object.channels[2]]
-                  }
+                  not: { const: object.channels[2] }
                 }
               }
             }
@@ -857,13 +501,13 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
       ).resolves.toHaveProperty("done", true);
     });
     it2("discover query for empty allowed", async () => {
-      const publicO = randomPutObject();
+      const publicO = randomPostObject();
       const publicSchema = {
         not: {
           required: ["allowed"]
         }
       };
-      await graffiti.put(publicO, session1);
+      await graffiti.post(publicO, session1);
       const iterator = graffiti.discover(
         publicO.channels,
         publicSchema,
@@ -873,9 +517,9 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
       expect2(value.value).toEqual(publicO.value);
       expect2(value.allowed).toBeUndefined();
       await expect2(iterator.next()).resolves.toHaveProperty("done", true);
-      const restricted = randomPutObject();
+      const restricted = randomPostObject();
       restricted.allowed = [];
-      await graffiti.put(restricted, session1);
+      await graffiti.post(restricted, session1);
       const iterator2 = graffiti.discover(
         restricted.channels,
         publicSchema,
@@ -884,17 +528,17 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
       await expect2(iterator2.next()).resolves.toHaveProperty("done", true);
     });
     it2("discover query for values", async () => {
-      const object1 = randomPutObject();
+      const object1 = randomPostObject();
       object1.value = { test: randomString() };
-      await graffiti.put(object1, session);
-      const object2 = randomPutObject();
+      await graffiti.post(object1, session);
+      const object2 = randomPostObject();
       object2.channels = object1.channels;
       object2.value = { test: randomString(), something: randomString() };
-      await graffiti.put(object2, session);
-      const object3 = randomPutObject();
+      await graffiti.post(object2, session);
+      const object3 = randomPostObject();
       object3.channels = object1.channels;
       object3.value = { other: randomString(), something: randomString() };
-      await graffiti.put(object3, session);
+      await graffiti.post(object3, session);
       const counts = /* @__PURE__ */ new Map();
       for (const property of ["test", "something", "other"]) {
         let count = 0;
@@ -919,14 +563,14 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
     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 object = randomPostObject();
+          const posted = await graffiti.post(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);
+          await graffiti.delete(posted, session);
           const iterator = graffiti.discover(object.channels, {});
           await expect2(iterator.next()).resolves.toHaveProperty("done", true);
           const tombIterator = continueStream(
@@ -937,372 +581,145 @@ var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
           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);
+          expect2(value.value.object.url).toEqual(posted.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/media.ts
+import {
+  GraffitiErrorNotAcceptable,
+  GraffitiErrorNotFound as GraffitiErrorNotFound2,
+  GraffitiErrorTooLarge
+} from "@graffiti-garden/api";
+import { it as it3, expect as expect3, describe as describe3, beforeAll as beforeAll3 } from "vitest";
+var graffitiMediaTests = (useGraffiti, useSession1, useSession2) => {
+  describe3.concurrent(
+    "media",
+    {
+      timeout: 2e4
+    },
+    () => {
+      let graffiti;
+      let session;
+      let session1;
+      let session2;
+      beforeAll3(async () => {
+        graffiti = useGraffiti();
+        session1 = await useSession1();
+        session = session1;
+        session2 = await useSession2();
+      });
+      it3("post, get, delete media", async () => {
+        const text = randomString();
+        const data = new Blob([text], { type: "text/plain" });
+        const mediaUrl = await graffiti.postMedia({ data }, session);
+        const media = await graffiti.getMedia(mediaUrl, {});
+        expect3(await media.data.text()).toEqual(text);
+        expect3(media.data.type).toEqual("text/plain");
+        expect3(media.allowed).toBeUndefined();
+        expect3(media.actor).toBe(session.actor);
+        await graffiti.deleteMedia(mediaUrl, session);
+        await expect3(graffiti.getMedia(mediaUrl, {})).rejects.toThrow(
+          GraffitiErrorNotFound2
+        );
+      });
+      it3("acceptable type", async () => {
+        const text = randomString();
+        const data = new Blob([text], { type: "text/plain" });
+        const mediaUrl = await graffiti.postMedia({ data }, session);
+        const media = await graffiti.getMedia(mediaUrl, {
+          accept: "text/*"
         });
+        expect3(await media.data.text()).toEqual(text);
+        expect3(media.data.type).toEqual("text/plain");
+        expect3(media.allowed).toBeUndefined();
+        expect3(media.actor).toBe(session.actor);
       });
-    }
-  });
-};
-
-// 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]"
+      it3("unacceptable type", async () => {
+        const text = randomString();
+        const data = new Blob([text], { type: "text/plain" });
+        const mediaUrl = await graffiti.postMedia({ data }, session);
+        await expect3(
+          graffiti.getMedia(mediaUrl, {
+            accept: "image/*"
+          })
+        ).rejects.toThrow(GraffitiErrorNotAcceptable);
+      });
+      it3("acceptable size", async () => {
+        const text = randomString();
+        const data = new Blob([text], { type: "text/plain" });
+        const mediaUrl = await graffiti.postMedia({ data }, session);
+        const media = await graffiti.getMedia(mediaUrl, {
+          maxBytes: data.size
+        });
+        expect3(await media.data.text()).toEqual(text);
+        expect3(media.data.type).toEqual("text/plain");
+        expect3(media.allowed).toBeUndefined();
+        expect3(media.actor).toBe(session.actor);
+      });
+      it3("unacceptable size", async () => {
+        const text = randomString();
+        const data = new Blob([text], { type: "text/plain" });
+        const mediaUrl = await graffiti.postMedia({ data }, session);
+        await expect3(
+          graffiti.getMedia(mediaUrl, {
+            maxBytes: data.size - 1
+          })
+        ).rejects.toThrow(GraffitiErrorTooLarge);
+      });
+      it3("empty allowed", async () => {
+        const text = randomString();
+        const data = new Blob([text], { type: "text/plain" });
+        const allowed = [];
+        const mediaUrl = await graffiti.postMedia({ data, allowed }, session1);
+        const media = await graffiti.getMedia(mediaUrl, {}, session1);
+        expect3(await media.data.text()).toEqual(text);
+        expect3(media.data.type).toEqual("text/plain");
+        expect3(media.allowed).toEqual([]);
+        expect3(media.actor).toBe(session1.actor);
+        await expect3(graffiti.getMedia(mediaUrl, {}, session2)).rejects.toThrow(
+          GraffitiErrorNotFound2
         );
-        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);
-    });
-  });
+        await expect3(graffiti.getMedia(mediaUrl, {})).rejects.toThrow(
+          GraffitiErrorNotFound2
+        );
+      });
+      it3("allowed", async () => {
+        const text = randomString();
+        const data = new Blob([text], { type: "text/plain" });
+        const allowed = [randomString(), session2.actor, randomString()];
+        const mediaUrl = await graffiti.postMedia({ data, allowed }, session1);
+        const media = await graffiti.getMedia(mediaUrl, {}, session1);
+        expect3(await media.data.text()).toEqual(text);
+        expect3(media.data.type).toEqual("text/plain");
+        expect3(media.allowed).toEqual(allowed);
+        expect3(media.actor).toBe(session1.actor);
+        const media2 = await graffiti.getMedia(mediaUrl, {}, session2);
+        expect3(await media2.data.text()).toEqual(text);
+        expect3(media2.data.type).toEqual("text/plain");
+        expect3(media2.allowed).toEqual([session2.actor]);
+        expect3(media2.actor).toBe(session1.actor);
+        await expect3(graffiti.getMedia(mediaUrl, {})).rejects.toThrow(
+          GraffitiErrorNotFound2
+        );
+      });
+    }
+  );
 };
 export {
   continueStream,
   graffitiCRUDTests,
-  graffitiChannelStatsTests,
   graffitiDiscoverTests,
-  graffitiOrphanTests,
+  graffitiMediaTests,
   nextStreamValue,
-  randomPutObject,
+  randomPostObject,
   randomString,
   randomValue
 };