@graffiti-garden/implementation-decentralized 0.0.1

package/src/1-services/3-storage-buckets.ts

@@ -0,0 +1,183 @@
+import {
+  fetchWithErrorHandling,
+  getAuthorizationEndpoint,
+  verifyHTTPSEndpoint,
+} from "./utilities";
+import { string, array, object, optional, nullable } from "zod/mini";
+import { decode as dagCborDecode } from "@ipld/dag-cbor";
+
+export class StorageBuckets {
+  getAuthorizationEndpoint = getAuthorizationEndpoint;
+
+  async put(
+    storageBucketEndpoint: string,
+    key: string,
+    value: Uint8Array,
+    authorizationToken: string,
+  ): Promise<void> {
+    verifyHTTPSEndpoint(storageBucketEndpoint);
+    const url = `${storageBucketEndpoint}/value/${encodeURIComponent(key)}`;
+
+    await fetchWithErrorHandling(url, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/octet-stream",
+        Authorization: `Bearer ${authorizationToken}`,
+      },
+      body: value.slice(),
+    });
+  }
+
+  async delete(
+    storageBucketEndpoint: string,
+    key: string,
+    authorizationToken: string,
+  ): Promise<void> {
+    verifyHTTPSEndpoint(storageBucketEndpoint);
+    const url = `${storageBucketEndpoint}/value/${encodeURIComponent(key)}`;
+
+    await fetchWithErrorHandling(url, {
+      method: "DELETE",
+      headers: {
+        Authorization: `Bearer ${authorizationToken}`,
+      },
+    });
+  }
+
+  async get(
+    storageBucketEndpoint: string,
+    key: string,
+    maxBytes?: number,
+  ): Promise<Uint8Array> {
+    verifyHTTPSEndpoint(storageBucketEndpoint);
+    const url = `${storageBucketEndpoint}/value/${encodeURIComponent(key)}`;
+
+    const response = await fetchWithErrorHandling(url);
+
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("Failed to read value from storage bucket");
+    }
+
+    const contentLengthHeader = response.headers.get("Content-Length");
+    const parsedContentLength = contentLengthHeader
+      ? Number(contentLengthHeader)
+      : undefined;
+
+    const hasValidContentLength =
+      !!parsedContentLength &&
+      !!Number.isFinite(parsedContentLength) &&
+      parsedContentLength >= 0;
+
+    // Fast path: Content-Length exists and is valid
+    if (hasValidContentLength) {
+      const contentLength = parsedContentLength!;
+      if (maxBytes !== undefined && contentLength > maxBytes) {
+        throw new Error("Value exceeds maximum byte limit");
+      }
+
+      const out = new Uint8Array(contentLength);
+      let offset = 0;
+      let completed = false;
+
+      try {
+        while (offset <= out.length) {
+          const { done, value } = await reader.read();
+
+          if (done) {
+            completed = true;
+            break;
+          }
+          if (!value || value.length === 0) continue;
+
+          const nextOffset = offset + value.length;
+          if (nextOffset > out.length) {
+            throw new Error("Received more data than expected");
+          }
+
+          out.set(value, offset);
+          offset = nextOffset;
+        }
+      } finally {
+        reader.releaseLock();
+      }
+
+      if (!completed) {
+        throw new Error("Failed to read complete value from storage bucket");
+      }
+
+      return offset === contentLength ? out : out.slice(0, offset);
+    }
+
+    // Fallback path: no (usable) Content-Length
+    const chunks: Uint8Array[] = [];
+    let total = 0;
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+
+        if (done) break;
+        if (!value || value.length === 0) continue;
+
+        total += value.length;
+        if (maxBytes !== undefined && total > maxBytes) {
+          throw new Error("Value exceeds maximum byte limit");
+        }
+
+        // Copy because some implementations reuse the underlying buffer
+        chunks.push(value.slice());
+      }
+    } finally {
+      reader.releaseLock();
+    }
+
+    // Concatenate chunks into one Uint8Array
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const c of chunks) {
+      out.set(c, offset);
+      offset += c.length;
+    }
+    return out;
+  }
+
+  async *export(
+    storageBucketEndpoint: string,
+    authorizationToken: string,
+  ): AsyncGenerator<{ key: string }> {
+    verifyHTTPSEndpoint(storageBucketEndpoint);
+    const url = `${storageBucketEndpoint}/export`;
+
+    let cursor: string | undefined = undefined;
+    while (true) {
+      const response = await fetchWithErrorHandling(
+        cursor ? `${url}?cursor=${encodeURIComponent(cursor)}` : url,
+        {
+          headers: {
+            Authorization: `Bearer ${authorizationToken}`,
+          },
+        },
+      );
+
+      const blob = await response.blob();
+      const cbor = dagCborDecode(await blob.arrayBuffer());
+      const data = ExportSchema.parse(cbor);
+
+      for (const key of data.keys) {
+        yield { key };
+      }
+
+      if (data.cursor) {
+        cursor = data.cursor;
+      } else {
+        break;
+      }
+    }
+  }
+}
+
+const ExportSchema = object({
+  keys: array(string()),
+  cursor: optional(nullable(string())),
+});

package/src/1-services/4-inboxes-tests.ts

@@ -0,0 +1,154 @@
+import { assert, describe, expect, test } from "vitest";
+import { Inboxes, LABELED_MESSAGE_LABEL_KEY } from "./4-inboxes";
+import { GraffitiErrorUnauthorized } from "./utilities";
+import { randomBytes } from "@noble/hashes/utils.js";
+import type { GraffitiObjectBase } from "@graffiti-garden/api";
+
+export function inboxTests(inboxEndpoint: string, inboxToken: string) {
+  describe("Inboxes", async () => {
+    const inboxes = new Inboxes();
+
+    test("send, get", async () => {
+      const tags = [randomBytes(), randomBytes()];
+      const metadata = randomBytes();
+      const object: GraffitiObjectBase = {
+        url: "url:example",
+        actor: "did:example",
+        channels: ["example", "something"],
+        value: {
+          nested: {
+            property: [1, "askdfj", null],
+          },
+        },
+        allowed: ["did:example2"],
+      };
+
+      const sending = {
+        m: metadata,
+        o: object,
+        t: tags,
+      };
+      const messageId = await inboxes.send(inboxEndpoint, sending);
+
+      // Get the message back
+      const message = await inboxes.get(inboxEndpoint, messageId, inboxToken);
+      expect(message.m).toEqual(sending);
+      expect(message.l).toEqual(0);
+
+      const iterator = inboxes.query<{}>(inboxEndpoint, tags, {}, inboxToken);
+
+      const result = await iterator.next();
+      assert(!result.done);
+
+      // No label yet so it must be zero
+      expect(result.value.l).toEqual(0);
+
+      expect(result.value.m.t).toEqual(tags);
+      expect(result.value.m.o).toEqual(object);
+      expect(result.value.id).toEqual(messageId);
+
+      const endResult = await iterator.next();
+      expect(endResult.done).toBe(true);
+
+      // Label the message
+      await inboxes.label(inboxEndpoint, messageId, 42, inboxToken);
+
+      const iterator2 = inboxes.query<{}>(inboxEndpoint, tags, {}, inboxToken);
+
+      const result2 = await iterator2.next();
+      assert(!result2.done);
+      expect(result2.value.l).toEqual(42);
+      const endResult2 = await iterator2.next();
+      expect(endResult2.done).toBe(true);
+
+      const message2 = await inboxes.get(inboxEndpoint, messageId, inboxToken);
+      expect(message2.m).toEqual(sending);
+      expect(message2.l).toEqual(42);
+    });
+
+    test("query with continue", async () => {
+      const tags = [randomBytes(), randomBytes()];
+
+      const nullResult = await inboxes
+        .query<{}>(inboxEndpoint, tags, {}, inboxToken)
+        .next();
+      assert(nullResult.done);
+      const cursor = nullResult.value;
+
+      const metadata = randomBytes();
+
+      const messageId = await inboxes.send(inboxEndpoint, {
+        o: {
+          url: "url:example",
+          actor: "did:example",
+          channels: ["example", "something"],
+          value: {
+            nested: {
+              property: [1, "askdfj", null],
+            },
+          },
+          allowed: ["did:example2"],
+        },
+        t: [randomBytes(), tags[0]],
+        m: metadata,
+      });
+
+      const result = await inboxes
+        .continueQuery(inboxEndpoint, cursor, inboxToken)
+        .next();
+      assert(!result.done);
+      expect(result.value.id).toEqual(messageId);
+    });
+
+    test("unauthorized access", async () => {
+      const tags = [randomBytes()];
+
+      await expect(
+        inboxes.query(inboxEndpoint, tags, {}, "invalid-token").next(),
+      ).rejects.toThrowError(GraffitiErrorUnauthorized);
+      await expect(
+        inboxes.label(inboxEndpoint, "1", 1, "invalid-token"),
+      ).rejects.toThrowError(GraffitiErrorUnauthorized);
+      await expect(
+        inboxes.export(inboxEndpoint, "invalid-token").next(),
+      ).rejects.toThrowError(GraffitiErrorUnauthorized);
+    }, 30000);
+
+    test("query paged", async () => {
+      const tags = [randomBytes(), randomBytes()];
+
+      const numSends = 211;
+      for (let i = 0; i < numSends; i++) {
+        await inboxes.send(inboxEndpoint, {
+          t: tags,
+          m: randomBytes(),
+          o: {
+            url: "url:example",
+            actor: "did:example",
+            channels: ["example", "something"],
+            value: {
+              nested: {
+                property: [1, "askdfj", null],
+              },
+            },
+            allowed: ["did:example2"],
+          },
+        });
+      }
+
+      const iterator = inboxes.query(
+        inboxEndpoint,
+        [randomBytes(), tags[1], randomBytes()],
+        {},
+        inboxToken,
+      );
+
+      let count = 0;
+      for await (const _ of iterator) {
+        count++;
+      }
+
+      expect(count).toBe(numSends);
+    }, 100000);
+  });
+}