@graffiti-garden/api 0.6.4 → 1.0.1

package/tests/media.ts

@@ -0,0 +1,158 @@
+import {
+  GraffitiErrorNotAcceptable,
+  GraffitiErrorNotFound,
+  GraffitiErrorTooLarge,
+  type Graffiti,
+  type GraffitiSession,
+} from "@graffiti-garden/api";
+import { it, expect, describe, beforeAll } from "vitest";
+import { randomString } from "./utils";
+
+export const graffitiMediaTests = (
+  useGraffiti: () => Pick<Graffiti, "postMedia" | "getMedia" | "deleteMedia">,
+  useSession1: () => GraffitiSession | Promise<GraffitiSession>,
+  useSession2: () => GraffitiSession | Promise<GraffitiSession>,
+) => {
+  describe.concurrent(
+    "media",
+    {
+      timeout: 20000,
+    },
+    () => {
+      let graffiti: ReturnType<typeof useGraffiti>;
+      let session: GraffitiSession;
+      let session1: GraffitiSession;
+      let session2: GraffitiSession;
+      beforeAll(async () => {
+        graffiti = useGraffiti();
+        session1 = await useSession1();
+        session = session1;
+        session2 = await useSession2();
+      });
+
+      it("post, get, delete media", async () => {
+        // Post media
+        const text = randomString();
+        const data = new Blob([text], { type: "text/plain" });
+        const mediaUrl = await graffiti.postMedia({ data }, session);
+
+        // Get the media back
+        const media = await graffiti.getMedia(mediaUrl, {});
+        expect(await media.data.text()).toEqual(text);
+        expect(media.data.type).toEqual("text/plain");
+        expect(media.allowed).toBeUndefined();
+        expect(media.actor).toBe(session.actor);
+
+        // Delete the media
+        await graffiti.deleteMedia(mediaUrl, session);
+
+        // Try to get the media again
+        await expect(graffiti.getMedia(mediaUrl, {})).rejects.toThrow(
+          GraffitiErrorNotFound,
+        );
+      });
+
+      it("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/*",
+        });
+        expect(await media.data.text()).toEqual(text);
+        expect(media.data.type).toEqual("text/plain");
+        expect(media.allowed).toBeUndefined();
+        expect(media.actor).toBe(session.actor);
+      });
+
+      it("unacceptable type", async () => {
+        const text = randomString();
+        const data = new Blob([text], { type: "text/plain" });
+        const mediaUrl = await graffiti.postMedia({ data }, session);
+
+        await expect(
+          graffiti.getMedia(mediaUrl, {
+            accept: "image/*",
+          }),
+        ).rejects.toThrow(GraffitiErrorNotAcceptable);
+      });
+
+      it("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,
+        });
+        expect(await media.data.text()).toEqual(text);
+        expect(media.data.type).toEqual("text/plain");
+        expect(media.allowed).toBeUndefined();
+        expect(media.actor).toBe(session.actor);
+      });
+
+      it("unacceptable size", async () => {
+        const text = randomString();
+        const data = new Blob([text], { type: "text/plain" });
+        const mediaUrl = await graffiti.postMedia({ data }, session);
+
+        await expect(
+          graffiti.getMedia(mediaUrl, {
+            maxBytes: data.size - 1,
+          }),
+        ).rejects.toThrow(GraffitiErrorTooLarge);
+      });
+
+      it("empty allowed", async () => {
+        const text = randomString();
+        const data = new Blob([text], { type: "text/plain" });
+        const allowed: string[] = [];
+        const mediaUrl = await graffiti.postMedia({ data, allowed }, session1);
+
+        // Get it with the authorized user
+        const media = await graffiti.getMedia(mediaUrl, {}, session1);
+        expect(await media.data.text()).toEqual(text);
+        expect(media.data.type).toEqual("text/plain");
+        expect(media.allowed).toEqual([]);
+        expect(media.actor).toBe(session1.actor);
+
+        // Get it with the unauthorized user
+        await expect(graffiti.getMedia(mediaUrl, {}, session2)).rejects.toThrow(
+          GraffitiErrorNotFound,
+        );
+
+        // Get it without authorization
+        await expect(graffiti.getMedia(mediaUrl, {})).rejects.toThrow(
+          GraffitiErrorNotFound,
+        );
+      });
+
+      it("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);
+
+        // Get it with the authorized user
+        const media = await graffiti.getMedia(mediaUrl, {}, session1);
+        expect(await media.data.text()).toEqual(text);
+        expect(media.data.type).toEqual("text/plain");
+        expect(media.allowed).toEqual(allowed);
+        expect(media.actor).toBe(session1.actor);
+
+        // Get it with the allowed user
+        const media2 = await graffiti.getMedia(mediaUrl, {}, session2);
+        expect(await media2.data.text()).toEqual(text);
+        expect(media2.data.type).toEqual("text/plain");
+        expect(media2.allowed).toEqual([session2.actor]);
+        expect(media2.actor).toBe(session1.actor);
+
+        // Get it without authorization
+        await expect(graffiti.getMedia(mediaUrl, {})).rejects.toThrow(
+          GraffitiErrorNotFound,
+        );
+      });
+    },
+  );
+};

package/tests/utils.ts

@@ -1,6 +1,6 @@
 import { assert } from "vitest";
 import type {
-  GraffitiPutObject,
+  GraffitiPostObject,
   GraffitiObjectStream,
   JSONSchema,
   GraffitiObject,
@@ -27,7 +27,7 @@ export function randomValue() {
   };
 }
 
-export function randomPutObject(): GraffitiPutObject<{}> {
+export function randomPostObject(): GraffitiPostObject<{}> {
   return {
     value: randomValue(),
     channels: [randomString(), randomString()],
@@ -44,13 +44,13 @@ export async function nextStreamValue<Schema extends JSONSchema>(
 }
 
 export function continueStream<Schema extends JSONSchema>(
-  graffiti: Pick<Graffiti, "continueObjectStream">,
+  graffiti: Pick<Graffiti, "continueDiscover">,
   streamReturn: GraffitiObjectStreamReturn<Schema>,
   type: "cursor" | "continue",
   session?: GraffitiSession | null,
 ): GraffitiObjectStreamContinue<Schema> {
   if (type === "cursor") {
-    return graffiti.continueObjectStream(
+    return graffiti.continueDiscover(
       streamReturn.cursor,
       session,
     ) as unknown as GraffitiObjectStreamContinue<Schema>;

package/dist/tests/channel-stats.d.ts

@@ -1,3 +0,0 @@
-import type { Graffiti, GraffitiSession } from "@graffiti-garden/api";
-export declare const graffitiChannelStatsTests: (useGraffiti: () => Pick<Graffiti, "channelStats" | "put" | "delete" | "patch">, useSession1: () => GraffitiSession | Promise<GraffitiSession>, useSession2: () => GraffitiSession | Promise<GraffitiSession>) => void;
-//# sourceMappingURL=channel-stats.d.ts.map

package/dist/tests/channel-stats.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"channel-stats.d.ts","sourceRoot":"","sources":["../../tests/channel-stats.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAGtE,eAAO,MAAM,yBAAyB,GACpC,aAAa,MAAM,IAAI,CACrB,QAAQ,EACR,cAAc,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,CAC5C,EACD,aAAa,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,EAC7D,aAAa,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,SAsH9D,CAAC"}

package/dist/tests/orphans.d.ts

@@ -1,3 +0,0 @@
-import type { Graffiti, GraffitiSession } from "@graffiti-garden/api";
-export declare const graffitiOrphanTests: (useGraffiti: () => Pick<Graffiti, "recoverOrphans" | "put" | "delete" | "patch" | "continueObjectStream">, useSession1: () => GraffitiSession | Promise<GraffitiSession>, useSession2: () => GraffitiSession | Promise<GraffitiSession>) => void;
-//# sourceMappingURL=orphans.d.ts.map

package/dist/tests/orphans.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"orphans.d.ts","sourceRoot":"","sources":["../../tests/orphans.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAQtE,eAAO,MAAM,mBAAmB,GAC9B,aAAa,MAAM,IAAI,CACrB,QAAQ,EACR,gBAAgB,GAAG,KAAK,GAAG,QAAQ,GAAG,OAAO,GAAG,sBAAsB,CACvE,EACD,aAAa,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,EAC7D,aAAa,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,SAgH9D,CAAC"}

package/tests/channel-stats.ts

@@ -1,129 +0,0 @@
-import { it, expect, describe, assert, beforeAll } from "vitest";
-import type { Graffiti, GraffitiSession } from "@graffiti-garden/api";
-import { randomString } from "./utils";
-
-export const graffitiChannelStatsTests = (
-  useGraffiti: () => Pick<
-    Graffiti,
-    "channelStats" | "put" | "delete" | "patch"
-  >,
-  useSession1: () => GraffitiSession | Promise<GraffitiSession>,
-  useSession2: () => GraffitiSession | Promise<GraffitiSession>,
-) => {
-  describe("channel stats", { timeout: 20000 }, () => {
-    let graffiti: ReturnType<typeof useGraffiti>;
-    let session: GraffitiSession;
-    let session1: GraffitiSession;
-    let session2: GraffitiSession;
-    beforeAll(async () => {
-      graffiti = useGraffiti();
-      session1 = await useSession1();
-      session = session1;
-      session2 = await useSession2();
-    });
-
-    it("list channels", async () => {
-      const existingChannels: Map<string, number> = 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()];
-
-      // Add one value to channels[0],
-      // two values to both channels[0] and channels[1],
-      // three values to all channels
-      // one value to channels[2]
-      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: Map<string, number> = new Map();
-      for await (const channel of channelIterator2) {
-        if (channel.error) continue;
-        newChannels.set(channel.value.channel, channel.value.count);
-      }
-      // Filter out existing channels
-      newChannels = new Map(
-        Array.from(newChannels).filter(
-          ([channel, count]) => !existingChannels.has(channel),
-        ),
-      );
-      expect(newChannels.size).toBe(3);
-      expect(newChannels.get(channels[0])).toBe(6);
-      expect(newChannels.get(channels[1])).toBe(5);
-      expect(newChannels.get(channels[2])).toBe(4);
-    });
-
-    it("list channels with deleted channel", async () => {
-      const channels = [randomString(), randomString(), randomString()];
-
-      // Add an item with two channels
-      const before = await graffiti.put<{}>(
-        {
-          value: { index: 2 },
-          channels: channels.slice(1),
-        },
-        session,
-      );
-
-      // Add an item with all channels
-      const first = await graffiti.put<{}>(
-        { value: { index: 0 }, channels },
-        session,
-      );
-      // But then delete it
-      await graffiti.delete(first, session);
-
-      // Create a new object with only one channel
-      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;
-        assert(
-          channel !== channels[0],
-          "There should not be an object in channel[0]",
-        );
-        if (channel === channels[1]) {
-          expect(count).toBe(1);
-          expect(lastModified).toBe(before.lastModified);
-          got1++;
-        } else if (channel === channels[2]) {
-          expect(count).toBe(2);
-          expect(lastModified).toBe(second.lastModified);
-          got2++;
-        }
-      }
-      expect(got1).toBe(1);
-      expect(got2).toBe(1);
-    });
-  });
-};

package/tests/orphans.ts

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