@graffiti-garden/api 1.0.0 → 1.0.1

package/dist/tests.mjs

@@ -1,3 +1,12 @@
+// tests/crud.ts
+import { it, expect, describe, beforeAll } from "vitest";
+import {
+  GraffitiErrorNotFound,
+  GraffitiErrorSchemaMismatch,
+  GraffitiErrorInvalidSchema,
+  GraffitiErrorForbidden
+} from "@graffiti-garden/api";
+
 // tests/utils.ts
 import { assert } from "vitest";
 function randomString() {
@@ -33,8 +42,682 @@ 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("post, get, delete", async () => {
+        const value = {
+          something: "hello, world~ c:"
+        };
+        const channels = [randomString(), randomString()];
+        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);
+        expect(gotten.channels).toEqual([]);
+        expect(gotten.allowed).toBeUndefined();
+        expect(gotten.url).toEqual(previous.url);
+        expect(gotten.actor).toEqual(previous.actor);
+        await graffiti.delete(gotten, session);
+        await expect(graffiti.get(gotten, {})).rejects.toBeInstanceOf(
+          GraffitiErrorNotFound
+        );
+        await expect(graffiti.delete(gotten, session)).rejects.toThrow(
+          GraffitiErrorNotFound
+        );
+      });
+      it("post then delete with wrong actor", async () => {
+        const posted = await graffiti.post(
+          { value: {}, channels: [] },
+          session2
+        );
+        await expect(graffiti.delete(posted, session1)).rejects.toThrow(
+          GraffitiErrorForbidden
+        );
+      });
+      it("post 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 posted = await graffiti.post(
+          {
+            value: goodValue,
+            channels: []
+          },
+          session
+        );
+        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("post and get with invalid schema", async () => {
+        const posted = await graffiti.post(
+          { value: {}, channels: [] },
+          session
+        );
+        await expect(
+          graffiti.get(posted, {
+            properties: {
+              value: {
+                //@ts-ignore
+                type: "asdf"
+              }
+            }
+          })
+        ).rejects.toThrow(GraffitiErrorInvalidSchema);
+      });
+      it("post and get with wrong schema", async () => {
+        const posted = await graffiti.post(
+          {
+            value: {
+              hello: "world"
+            },
+            channels: []
+          },
+          session
+        );
+        await expect(
+          graffiti.get(posted, {
+            properties: {
+              value: {
+                properties: {
+                  hello: {
+                    type: "number"
+                  }
+                }
+              }
+            }
+          })
+        ).rejects.toThrow(GraffitiErrorSchemaMismatch);
+      });
+      it("post and get with empty access control", async () => {
+        const value = {
+          um: "hi"
+        };
+        const allowed = [randomString()];
+        const channels = [randomString()];
+        const posted = await graffiti.post(
+          { value, allowed, channels },
+          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(posted, {})).rejects.toBeInstanceOf(
+          GraffitiErrorNotFound
+        );
+        await expect(graffiti.get(posted, {}, session2)).rejects.toBeInstanceOf(
+          GraffitiErrorNotFound
+        );
+      });
+      it("post and get with specific access control", async () => {
+        const value = {
+          um: "hi"
+        };
+        const allowed = [randomString(), session2.actor, randomString()];
+        const channels = [randomString()];
+        const posted = await graffiti.post(
+          {
+            value,
+            allowed,
+            channels
+          },
+          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(posted, {})).rejects.toBeInstanceOf(
+          GraffitiErrorNotFound
+        );
+        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([]);
+      });
+    }
+  );
+};
+
+// 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 = 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);
+      const result2 = await iterator.next();
+      expect2(result2.done).toBe(true);
+    });
+    it2("discover wrong channel", async () => {
+      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 = randomPostObject();
+      object.allowed = [randomString(), randomString()];
+      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);
+      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 = randomPostObject();
+      object.allowed = [randomString(), session2.actor, randomString()];
+      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);
+    });
+    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: {
+          actor: { const: posted1.actor }
+        }
+      });
+      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 = randomPostObject();
+      object.allowed = [randomString(), session2.actor, randomString()];
+      await graffiti.post(object, session1);
+      const iteratorSession1 = graffiti.discover(
+        object.channels,
+        {
+          properties: {
+            allowed: {
+              minItems: 3,
+              // Make sure session2.actor is in the allow list
+              not: {
+                items: {
+                  not: { const: 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: { const: object.allowed[0] }
+                }
+              }
+            }
+          }
+        },
+        session2
+      );
+      await expect2(iteratorSession2PeekOther.next()).resolves.toHaveProperty(
+        "done",
+        true
+      );
+      const iteratorSession2SmallAllowPeekSelf = graffiti.discover(
+        object.channels,
+        {
+          properties: {
+            allowed: {
+              maxItems: 1,
+              not: {
+                items: {
+                  not: { const: 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 = randomPostObject();
+      object.channels = [randomString(), randomString(), randomString()];
+      await graffiti.post(object, session1);
+      const iteratorSession1 = graffiti.discover(
+        [object.channels[0], object.channels[2]],
+        {
+          properties: {
+            channels: {
+              minItems: 3,
+              // Make sure channel 1 is in the allow list
+              not: {
+                items: {
+                  not: { const: 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: { const: 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: { const: 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 = randomPostObject();
+      const publicSchema = {
+        not: {
+          required: ["allowed"]
+        }
+      };
+      await graffiti.post(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 = randomPostObject();
+      restricted.allowed = [];
+      await graffiti.post(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 = randomPostObject();
+      object1.value = { test: randomString() };
+      await graffiti.post(object1, session);
+      const object2 = randomPostObject();
+      object2.channels = object1.channels;
+      object2.value = { test: randomString(), something: randomString() };
+      await graffiti.post(object2, session);
+      const object3 = randomPostObject();
+      object3.channels = object1.channels;
+      object3.value = { other: randomString(), something: randomString() };
+      await graffiti.post(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 = 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");
+          await graffiti.delete(posted, 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(posted.url);
+          await expect2(tombIterator.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);
+      });
+      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
+        );
+        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,
+  graffitiDiscoverTests,
+  graffitiMediaTests,
   nextStreamValue,
   randomPostObject,
   randomString,