@graffiti-garden/implementation-decentralized 0.1.0 → 0.1.2

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

@@ -4,10 +4,33 @@ import {
   verifyHTTPSEndpoint,
 } from "./utilities";
 import { string, array, object, optional, nullable } from "zod/mini";
-import { decode as dagCborDecode } from "@ipld/dag-cbor";
+import { encode as dagCborEncode, decode as dagCborDecode } from "@ipld/dag-cbor";
+import { GraffitiErrorNotFound, GraffitiErrorTooLarge } from "@graffiti-garden/api";
+
+// All batch-capable bucket servers accept these transport limits.
+const BATCH_KEYS = 32; // total number of keys in a batch request
+const BATCH_TOTAL_VALUE_BYTES = 1024 * 1024; // total response limit
+
+// This is a heuristic for how long to wait to fill a batch request
+// before sending it. Just enough waiting to capture a few more requests,
+// but not so long that it adds noticeable latency.
+const BATCH_WAIT_MS = 2;
+
+function batchWidth(maxBytes: number) {
+  return Math.min(BATCH_KEYS, Math.floor(BATCH_TOTAL_VALUE_BYTES / maxBytes));
+}
+
+type PendingGet = {
+  key: string;
+  resolve: (value: Uint8Array) => void;
+  reject: (reason: unknown) => void;
+};
+type BatchQueue = { requests: PendingGet[]; timer?: ReturnType<typeof setTimeout> };
 
 export class StorageBuckets {
   getAuthorizationEndpoint = getAuthorizationEndpoint;
+  private readonly queues = new Map<string, Map<number, BatchQueue>>();
+  private readonly unsupportedBatchEndpoints = new Set<string>();
 
   async put(
     storageBucketEndpoint: string,
@@ -50,6 +73,111 @@ export class StorageBuckets {
     maxBytes?: number,
   ): Promise<Uint8Array> {
     verifyHTTPSEndpoint(storageBucketEndpoint);
+    if (
+      maxBytes !== undefined &&
+      Number.isSafeInteger(maxBytes) &&
+      maxBytes > 0 &&
+      batchWidth(maxBytes) >= 2 &&
+      !this.unsupportedBatchEndpoints.has(storageBucketEndpoint)
+    ) {
+      return new Promise<Uint8Array>((resolve, reject) => {
+        let queuesByMaxBytes = this.queues.get(storageBucketEndpoint);
+        if (!queuesByMaxBytes) {
+          queuesByMaxBytes = new Map();
+          this.queues.set(storageBucketEndpoint, queuesByMaxBytes);
+        }
+        let queue = queuesByMaxBytes.get(maxBytes);
+        if (!queue) {
+          queue = { requests: [] };
+          queuesByMaxBytes.set(maxBytes, queue);
+        }
+        queue.requests.push({ key, resolve, reject });
+        if (queue.requests.length === batchWidth(maxBytes)) {
+          this.flush(storageBucketEndpoint, maxBytes, queue);
+        } else if (queue.timer === undefined) {
+          queue.timer = setTimeout(
+            () => this.flush(storageBucketEndpoint, maxBytes, queue),
+            BATCH_WAIT_MS,
+          );
+        }
+      });
+    }
+    return this.getOne(storageBucketEndpoint, key, maxBytes);
+  }
+
+  private flush(endpoint: string, maxBytes: number, queue: BatchQueue) {
+    if (queue.timer !== undefined) clearTimeout(queue.timer);
+    const requests = queue.requests;
+    const queuesByMaxBytes = this.queues.get(endpoint)!;
+    queuesByMaxBytes.delete(maxBytes);
+    if (queuesByMaxBytes.size === 0) this.queues.delete(endpoint);
+    if (requests.length === 1 || this.unsupportedBatchEndpoints.has(endpoint)) {
+      requests.forEach(({ key, resolve, reject }) => {
+        void this.getOne(endpoint, key, maxBytes).then(resolve, reject);
+      });
+    } else {
+      void this.getBatch(endpoint, maxBytes, requests);
+    }
+  }
+
+  private async getBatch(endpoint: string, maxBytes: number, requests: PendingGet[]) {
+    try {
+      const response = await fetch(`${endpoint}/values`, {
+        method: "POST",
+        headers: { "Content-Type": "application/cbor", Accept: "application/cbor" },
+        body: dagCborEncode({
+          keys: requests.map(({ key }) => key),
+          maxValueBytes: maxBytes,
+        }).slice(),
+      });
+      if (response.status === 404) {
+        // An older bucket server has no /values route but still serves GETs.
+        this.unsupportedBatchEndpoints.add(endpoint);
+        await Promise.all(requests.map(async ({ key, resolve, reject }) => {
+          try {
+            resolve(await this.getOne(endpoint, key, maxBytes));
+          } catch (error) {
+            reject(error);
+          }
+        }));
+        return;
+      }
+      if (!response.ok) throw new Error(await response.text());
+      const decoded = dagCborDecode(await response.arrayBuffer());
+      if (
+        !decoded || typeof decoded !== "object" ||
+        !("results" in decoded) || !Array.isArray(decoded.results) ||
+        decoded.results.length !== requests.length
+      ) throw new Error("Invalid storage batch response");
+
+      decoded.results.forEach((result: unknown, index: number) => {
+        const { resolve, reject } = requests[index];
+        if (!result || typeof result !== "object" || !("status" in result)) {
+          reject(new Error("Invalid storage batch result"));
+        } else if (
+          result.status === 200 && "value" in result &&
+          result.value instanceof Uint8Array &&
+          result.value.byteLength <= maxBytes
+        ) {
+          resolve(result.value);
+        } else if (result.status === 404) {
+          reject(new GraffitiErrorNotFound("Value not found"));
+        } else if (result.status === 413) {
+          reject(new GraffitiErrorTooLarge("Value exceeds maximum byte limit"));
+        } else {
+          reject(new Error("Invalid storage batch result"));
+        }
+      });
+    } catch (error) {
+      requests.forEach(({ reject }) => reject(error));
+    }
+  }
+
+  private async getOne(
+    storageBucketEndpoint: string,
+    key: string,
+    maxBytes?: number,
+  ): Promise<Uint8Array> {
     const url = `${storageBucketEndpoint}/value/${encodeURIComponent(key)}`;
 
     const response = await fetchWithErrorHandling(url);

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

@@ -3,6 +3,7 @@ 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";
+import { encode as dagCborEncode, decode as dagCborDecode } from "@ipld/dag-cbor";
 
 export function inboxTests(inboxEndpoint: string, inboxToken: string) {
   describe("Inboxes", async () => {
@@ -138,6 +139,30 @@ export function inboxTests(inboxEndpoint: string, inboxToken: string) {
         });
       }
 
+      let cursor: string | undefined;
+      for (const [page, expectedCount] of [10, 100, 101].entries()) {
+        const response = await fetch(
+          `${inboxEndpoint}/query${cursor ? `?cursor=${encodeURIComponent(cursor)}` : ""}`,
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/cbor",
+              Authorization: `Bearer ${inboxToken}`,
+            },
+            body: cursor ? undefined : dagCborEncode({ tags: [tags[1]], schema: {} }).slice(),
+          },
+        );
+        expect(response.status).toBe(200);
+        const pageResult = dagCborDecode(new Uint8Array(await response.arrayBuffer())) as {
+          results: unknown[];
+          hasMore: boolean;
+          cursor: string;
+        };
+        expect(pageResult.results).toHaveLength(expectedCount);
+        expect(pageResult.hasMore).toBe(page < 2);
+        cursor = pageResult.cursor;
+      }
+
       const iterator = inboxes.query(
         inboxEndpoint,
         [randomBytes(), tags[1], randomBytes()],

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

@@ -138,6 +138,7 @@ export class Inboxes {
     body: Uint8Array<ArrayBuffer> | undefined,
     inboxToken?: string | null,
     cursor?: string,
+    signal?: AbortSignal,
   ) {
     const response = await fetchWithErrorHandling(
       `${inboxUrl}/${type}${cursor ? `?cursor=${encodeURIComponent(cursor)}` : ""}`,
@@ -152,6 +153,7 @@ export class Inboxes {
             : {}),
         },
         body,
+        signal,
       },
     );
     const retryAfterHeader = response.headers.get("Retry-After");
@@ -414,13 +416,11 @@ export class Inboxes {
       );
 
       // First cache the messages with their labels
-      await Promise.all(
-        labeledMessages.map((m: LabeledMessageBase) =>
-          cache.messages.set(
-            getMessageCacheKey(inboxUrl, m[LABELED_MESSAGE_ID_KEY]),
-            m,
-          ),
-        ),
+      await cache.messages.setMany(
+        labeledMessages.map((m: LabeledMessageBase) => [
+          getMessageCacheKey(inboxUrl, m[LABELED_MESSAGE_ID_KEY]),
+          m,
+        ]),
       );
       // Then store all the messageids
       messageIds = [
@@ -439,22 +439,38 @@ export class Inboxes {
       // Update how many we've seen
       cacheNumSeen += labeledMessages.length;
 
+      // Fetch the next page while the caller processes the current page.
+      const prefetchController = new AbortController();
+      // Otherwise get another response (after waiting for rate-limit)
+      const nextPage = hasMore
+        ? waitFor(waitTil)
+            .then(() => this.fetchMessageBatch(
+              inboxUrl,
+              type,
+              undefined, // Body is never past the first time
+              inboxToken,
+              cursor,
+              prefetchController.signal,
+            ))
+            // A consumer may stop before awaiting this request.
+            .then((value) => ({ value }), (error) => ({ error }))
+        : null;
+
       // Return the values
-      for (const m of labeledMessages) yield m;
+      let consumedPage = false;
+      try {
+        for (const m of labeledMessages) yield m;
+        consumedPage = true;
+      } finally {
+        if (!consumedPage) prefetchController.abort();
+      }
 
       if (!hasMore) break;
 
-      // Otherwise get another response (after waiting for rate-limit)
-      await waitFor(waitTil);
-      const out = await this.fetchMessageBatch(
-        inboxUrl,
-        type,
-        undefined, // Body is never past the first time
-        inboxToken,
-        cursor,
-      );
-      response = out.response;
-      waitTil = out.waitTil;
+      const out = await nextPage!;
+      if ("error" in out) throw out.error;
+      response = out.value.response;
+      waitTil = out.value.waitTil;
     }
 
     const outputCursor: infer_<typeof CursorSchema> = {
@@ -619,6 +635,7 @@ type Cache = {
   messages: {
     get(k: string): Promise<LabeledMessageBase | null | undefined>;
     set(k: string, value: LabeledMessageBase | null): Promise<void>;
+    setMany(entries: [string, LabeledMessageBase][]): Promise<void>;
     del(k: string): Promise<void>;
   };
   messageIds: {
@@ -684,6 +701,14 @@ async function createCache(): Promise<Cache> {
         set: async (k, v) => {
           await db.put("m", v, k);
         },
+        setMany: async (entries) => {
+          if (entries.length === 0) return;
+          const tx = db.transaction("m", "readwrite");
+          await Promise.all([
+            ...entries.map(([k, v]) => tx.store.put(v, k)),
+            tx.done,
+          ]);
+        },
         del: (k) => db.delete("m", k),
       },
       messageIds: {
@@ -712,6 +737,9 @@ async function createCache(): Promise<Cache> {
     messages: {
       get: async (k) => m.get(k),
       set: async (k, v) => void m.set(k, v),
+      setMany: async (entries) => {
+        for (const [k, v] of entries) m.set(k, v);
+      },
       del: async (k) => void m.delete(k),
     },
     messageIds: {

package/src/3-protocol/4-graffiti.ts

@@ -133,7 +133,7 @@ export interface GraffitiDecentralizedOptions {
   defaultInboxEndpoints?: string[];
 }
 
-const CONCURRENCY = 16;
+const CONCURRENCY = 128;
 const LOCAL_STORAGE_REMEMBERED_HANDLE_KEY = "graffiti-login-remembered-handle";
 
 export class GraffitiDecentralized implements Graffiti {