@graffiti-garden/implementation-decentralized 0.1.3 → 0.1.4

package/dist/esm/1-services/4-inboxes.js

@@ -14,19 +14,42 @@ import {
 } from "@ipld/dag-cbor";
 import {
   string,
-  url,
-  array,
-  optional,
-  nullable,
   strictObject,
   looseObject,
   nonnegative,
   int,
   boolean,
-  custom,
-  number,
   union
 } from "zod/mini";
+import {
+  LabeledMessageBaseSchema,
+  SendResponseSchema,
+  MessageResultSchema,
+  LABELED_MESSAGE_MESSAGE_KEY,
+  MESSAGE_OBJECT_KEY
+} from "./4-inboxes/messages";
+import {
+  canUseIDB,
+  createCache,
+  getMessageCacheKey,
+  getMessageIdsCacheKey,
+  replayQuery,
+  storeQueryPage
+} from "./4-inboxes/cache";
+import {
+  Uint8ArraySchema,
+  TagsSchema,
+  MESSAGE_TAGS_KEY,
+  MESSAGE_OBJECT_KEY as MESSAGE_OBJECT_KEY2,
+  MESSAGE_METADATA_KEY,
+  MessageBaseSchema,
+  LABELED_MESSAGE_ID_KEY,
+  LABELED_MESSAGE_MESSAGE_KEY as LABELED_MESSAGE_MESSAGE_KEY2,
+  LABELED_MESSAGE_LABEL_KEY,
+  LabeledMessageBaseSchema as LabeledMessageBaseSchema2
+} from "./4-inboxes/messages";
+const INBOX_REQUEST_TIMEOUT_MS = 3e4;
+const INBOX_LOCK_WAIT_TIMEOUT_MS = 3e4;
 class Inboxes {
   getAuthorizationEndpoint = getAuthorizationEndpoint;
   cache_ = null;
@@ -38,8 +61,8 @@ class Inboxes {
   }
   async send(inboxUrl, message) {
     verifyHTTPSEndpoint(inboxUrl);
-    const url2 = `${inboxUrl}/send`;
-    const response = await fetchWithErrorHandling(url2, {
+    const url = `${inboxUrl}/send`;
+    const response = await fetchWithErrorHandling(url, {
       method: "PUT",
       headers: {
         "Content-Type": "application/cbor"
@@ -56,10 +79,10 @@ class Inboxes {
     const cache = await this.cache;
     const cached = await cache.messages.get(messageCacheKey);
     if (cached !== void 0) return cached;
-    const url2 = `${inboxUrl}/message/${messageId}`;
+    const url = `${inboxUrl}/message/${messageId}`;
     let response = null;
     try {
-      response = await fetchWithErrorHandling(url2, {
+      response = await fetchWithErrorHandling(url, {
         method: "GET",
         headers: {
           ...inboxToken ? {
@@ -83,8 +106,8 @@ class Inboxes {
   async label(inboxUrl, messageId, label, inboxToken) {
     verifyHTTPSEndpoint(inboxUrl);
     if (inboxToken) {
-      const url2 = `${inboxUrl}/label/${messageId}`;
-      await fetchWithErrorHandling(url2, {
+      const url = `${inboxUrl}/label/${messageId}`;
+      await fetchWithErrorHandling(url, {
         method: "PUT",
         headers: {
           "Content-Type": "application/cbor",
@@ -104,6 +127,7 @@ class Inboxes {
     }
   }
   async fetchMessageBatch(inboxUrl, type, body, inboxToken, cursor, signal) {
+    const timeout = AbortSignal.timeout(INBOX_REQUEST_TIMEOUT_MS);
     const response = await fetchWithErrorHandling(
       `${inboxUrl}/${type}${cursor ? `?cursor=${encodeURIComponent(cursor)}` : ""}`,
       {
@@ -115,7 +139,7 @@ class Inboxes {
           } : {}
         },
         body,
-        signal
+        signal: signal ? AbortSignal.any([signal, timeout]) : timeout
       }
     );
     const retryAfterHeader = response.headers.get("Retry-After");
@@ -123,421 +147,236 @@ class Inboxes {
     const waitTil = retryAfter && Number.isFinite(retryAfter) ? Date.now() + retryAfter * 1e3 : void 0;
     return { response, waitTil };
   }
-  async *yieldFromCache(cache, inboxUrl, messageIdsCacheKey, cachedMessageIds, cacheNumSeen = 0) {
-    const messageIds = cachedMessageIds.messageIds.slice(cacheNumSeen);
-    const messages = await Promise.all(
-      messageIds.map(async (id) => {
-        const message = await cache.messages.get(
-          getMessageCacheKey(inboxUrl, id)
-        );
-        if (!message) {
-          try {
-            await cache.messageIds.del(messageIdsCacheKey);
-          } catch {
-          }
-          throw new Error("Cache out of sync - perhaps clear browser storage");
-        }
-        return message;
-      })
-    );
-    yield* messages;
-  }
-  async *lockedMessageStreamer(...args) {
-    if (typeof window === "undefined" || !await canUseIDB()) {
-      const streamer = this.messageStreamer(...args);
-      while (true) {
-        const next = await streamer.next();
-        if (next.done) return next.value;
-        yield next.value;
-      }
-    }
-    const messageIdsCacheKey = await args[0];
-    const lockKey = `graffiti:inbox:${messageIdsCacheKey}`;
-    let releaseLock = () => {
-    };
-    let hasLock = false;
-    await new Promise((resolvehasLock) => {
-      window.navigator.locks.request(
-        lockKey,
+  async withQueryLock(messageIdsCacheKey, useLock, work, signal) {
+    if (!useLock) return work();
+    const timeout = AbortSignal.timeout(INBOX_LOCK_WAIT_TIMEOUT_MS);
+    let acquired = false;
+    try {
+      return await window.navigator.locks.request(
+        `graffiti:inbox:${messageIdsCacheKey}`,
         {
           mode: "exclusive",
-          ifAvailable: true
+          signal: signal ? AbortSignal.any([signal, timeout]) : timeout
         },
-        async (lock) => {
-          hasLock = !!lock;
-          resolvehasLock();
-          await new Promise((r) => releaseLock = r);
+        async () => {
+          acquired = true;
+          return work();
         }
       );
-    });
-    if (hasLock) {
-      try {
-        const streamer = this.messageStreamer(...args);
-        while (true) {
-          const next = await streamer.next();
-          if (next.done) return next.value;
-          yield next.value;
-        }
-      } finally {
-        releaseLock();
+    } catch (error) {
+      if (!acquired && timeout.aborted) {
+        throw new Error("Timed out waiting for another tab's inbox query", {
+          cause: error
+        });
       }
+      throw error;
     }
-    releaseLock();
-    await window.navigator.locks.request(lockKey, () => {
-    });
-    const inboxUrl = args[1];
-    const objectSchema = args[5] ?? {};
-    const cacheVersion = args[6];
-    const cacheNumSeen = args[7];
-    const cache = await this.cache;
-    const cachedMessageIds = await cache.messageIds.get(messageIdsCacheKey);
-    if (!cachedMessageIds) {
-      throw new Error("Cache not found");
-    }
-    if (cacheVersion !== void 0 && cacheVersion !== cachedMessageIds.version) {
-      throw new GraffitiErrorCursorExpired("Cursor is stale");
-    }
-    const iterator = this.yieldFromCache(
-      cache,
-      inboxUrl,
-      messageIdsCacheKey,
-      cachedMessageIds,
-      cacheNumSeen
-    );
-    for await (const m of iterator) yield m;
-    const outputCursor = {
-      numSeen: cachedMessageIds.messageIds.length,
-      version: cachedMessageIds.version,
-      messageIdsCacheKey,
-      objectSchema
-    };
-    return JSON.stringify(outputCursor);
   }
-  async *messageStreamer(messageIdsCacheKey_, inboxUrl, type, body, inboxToken, objectSchema = {}, cacheVersion, cacheNumSeen = 0) {
+  async *messageStreamer(source) {
+    const { inboxUrl, inboxToken } = source;
+    const type = source.kind === "export" ? "export" : "query";
+    const objectSchema = source.kind === "query" ? source.schema : source.kind === "continue" ? source.cursor.objectSchema : {};
     const validator = await compileGraffitiObjectSchema(objectSchema);
-    const messageIdsCacheKey = await messageIdsCacheKey_;
+    const body = source.kind === "query" ? source.body : void 0;
+    const messageIdsCacheKey = source.kind === "continue" ? source.cursor.messageIdsCacheKey : await getMessageIdsCacheKey(inboxUrl, type, body);
+    const cacheVersion = source.kind === "continue" ? source.cursor.version : void 0;
     const cache = await this.cache;
-    let cachedMessageIds = await cache.messageIds.get(messageIdsCacheKey);
-    if (cacheVersion !== void 0 && cacheVersion !== cachedMessageIds?.version) {
-      throw new GraffitiErrorCursorExpired("Cursor is stale");
-    }
-    let waitTil = cachedMessageIds?.waitTil;
-    await waitFor(waitTil);
-    const cachedCursor = cachedMessageIds?.cursor;
-    let firstResponse = void 0;
-    try {
-      const out = await this.fetchMessageBatch(
-        inboxUrl,
-        type,
-        body,
-        inboxToken,
-        cachedCursor
-      );
-      firstResponse = out.response;
-      waitTil = out.waitTil;
-    } catch (e) {
-      if (!(e instanceof GraffitiErrorCursorExpired && cachedCursor)) {
-        console.error(
-          "Unexpected error in stream, waiting 5 seconds before continuing..."
+    const useLock = typeof window !== "undefined" && await canUseIDB();
+    const initialQuery = await cache.messageIds.get(messageIdsCacheKey);
+    let seenGeneration = initialQuery?.generation;
+    let seenVersion = initialQuery?.version;
+    let numSeen = source.kind === "continue" ? source.cursor.numSeen : 0;
+    let firstPage = true;
+    const fetchPage = async (signal) => {
+      while (true) {
+        signal?.throwIfAborted();
+        const step = await this.withQueryLock(
+          messageIdsCacheKey,
+          useLock,
+          async () => {
+            signal?.throwIfAborted();
+            let query = await cache.messageIds.get(messageIdsCacheKey);
+            if (cacheVersion !== void 0 && cacheVersion !== query?.version) {
+              throw new GraffitiErrorCursorExpired("Cursor is stale");
+            }
+            if (query?.version !== seenVersion) {
+              if (!firstPage) throw new GraffitiErrorCursorExpired("Cursor is stale");
+              numSeen = 0;
+            }
+            if (query?.generation && query.generation !== seenGeneration) {
+              return { query };
+            }
+            if (query?.waitTil !== void 0 && query.waitTil > Date.now()) {
+              return { waitTil: query.waitTil };
+            }
+            let batch;
+            try {
+              batch = await this.fetchMessageBatch(
+                inboxUrl,
+                type,
+                firstPage ? body : void 0,
+                // Later pages send no body.
+                inboxToken,
+                query?.cursor,
+                signal
+              );
+            } catch (error) {
+              if (!(error instanceof GraffitiErrorCursorExpired && query?.cursor)) {
+                if (firstPage && !signal?.aborted) {
+                  return { initialFetchError: error };
+                }
+                throw error;
+              }
+              if (!firstPage) throw error;
+              await cache.messageIds.del(messageIdsCacheKey);
+              if (cacheVersion !== void 0) throw error;
+              query = void 0;
+              numSeen = 0;
+              batch = await this.fetchMessageBatch(
+                inboxUrl,
+                type,
+                body,
+                inboxToken,
+                void 0,
+                signal
+              );
+            }
+            const decoded = dagCborDecode(
+              new Uint8Array(await batch.response.arrayBuffer())
+            );
+            const { results, hasMore, cursor } = MessageResultSchema.parse(decoded);
+            const labeledMessages = results.map(
+              (result) => {
+                const object = result[LABELED_MESSAGE_MESSAGE_KEY][MESSAGE_OBJECT_KEY];
+                if (!validator(object)) {
+                  throw new Error("Server returned data that does not match schema");
+                }
+                return {
+                  ...result,
+                  [LABELED_MESSAGE_MESSAGE_KEY]: {
+                    ...result[LABELED_MESSAGE_MESSAGE_KEY],
+                    [MESSAGE_OBJECT_KEY]: object
+                  }
+                };
+              }
+            );
+            query = await storeQueryPage(
+              cache,
+              inboxUrl,
+              messageIdsCacheKey,
+              query,
+              {
+                messages: labeledMessages,
+                cursor,
+                hasMore,
+                waitTil: batch.waitTil
+              }
+            );
+            return { query };
+          },
+          signal
         );
-        await new Promise((resolve) => setTimeout(resolve, 5e3));
-        throw e;
-      }
-      await cache.messageIds.del(messageIdsCacheKey);
-      if (cacheVersion === void 0) {
-        cachedMessageIds = void 0;
-      } else {
-        throw e;
+        if ("initialFetchError" in step) {
+          console.error(
+            "Unexpected error in stream, waiting 5 seconds before continuing..."
+          );
+          await new Promise((resolve) => setTimeout(resolve, 5e3));
+          throw step.initialFetchError;
+        }
+        if ("waitTil" in step) {
+          await waitFor(step.waitTil);
+          continue;
+        }
+        return step.query;
       }
-    }
-    if (firstResponse !== void 0 && cachedMessageIds) {
-      const iterator = this.yieldFromCache(
+    };
+    let nextPage;
+    while (true) {
+      const result = nextPage ? await nextPage : await fetchPage().then(
+        (query2) => ({ query: query2 }),
+        (error) => ({ error })
+      );
+      nextPage = void 0;
+      if ("error" in result) throw result.error;
+      const query = result.query;
+      const messages = await replayQuery(
         cache,
         inboxUrl,
         messageIdsCacheKey,
-        cachedMessageIds,
-        cacheNumSeen
-      );
-      for await (const m of iterator) yield m;
-    }
-    if (firstResponse === void 0) {
-      const out = await this.fetchMessageBatch(
-        inboxUrl,
-        type,
-        body,
-        inboxToken
+        query,
+        numSeen
       );
-      firstResponse = out.response;
-      waitTil = out.waitTil;
-    }
-    let response = firstResponse;
-    let cursor;
-    const version = cachedMessageIds?.version ?? crypto.randomUUID();
-    let messageIds = cachedMessageIds?.messageIds ?? [];
-    while (true) {
-      const blob = await response.blob();
-      const decoded = dagCborDecode(await blob.arrayBuffer());
-      const {
-        results,
-        hasMore,
-        cursor: nextCursor
-      } = MessageResultSchema.parse(decoded);
-      cursor = nextCursor;
-      const labeledMessages = results.map(
-        (result) => {
-          const object = result[LABELED_MESSAGE_MESSAGE_KEY][MESSAGE_OBJECT_KEY];
-          if (!validator(object)) {
-            throw new Error("Server returned data that does not match schema");
-          }
-          return {
-            ...result,
-            [LABELED_MESSAGE_MESSAGE_KEY]: {
-              ...result[LABELED_MESSAGE_MESSAGE_KEY],
-              [MESSAGE_OBJECT_KEY]: object
-            }
-          };
-        }
-      );
-      await cache.messages.setMany(
-        labeledMessages.map((m) => [
-          getMessageCacheKey(inboxUrl, m[LABELED_MESSAGE_ID_KEY]),
-          m
-        ])
-      );
-      messageIds = [
-        ...messageIds,
-        ...labeledMessages.map(
-          (m) => m[LABELED_MESSAGE_ID_KEY]
-        )
-      ];
-      await cache.messageIds.set(messageIdsCacheKey, {
-        cursor,
-        version,
-        messageIds,
-        waitTil
-      });
-      cacheNumSeen += labeledMessages.length;
+      numSeen = query.messageIds.length;
+      seenGeneration = query.generation;
+      seenVersion = query.version;
+      firstPage = false;
       const prefetchController = new AbortController();
-      const nextPage = hasMore ? waitFor(waitTil).then(() => this.fetchMessageBatch(
-        inboxUrl,
-        type,
-        void 0,
-        // Body is never past the first time
-        inboxToken,
-        cursor,
-        prefetchController.signal
-      )).then((value) => ({ value }), (error) => ({ error })) : null;
+      if (query.hasMore) {
+        nextPage = fetchPage(prefetchController.signal).then(
+          (query2) => ({ query: query2 }),
+          (error) => ({ error })
+        );
+      }
       let consumedPage = false;
       try {
-        for (const m of labeledMessages) yield m;
+        for (const message of messages) {
+          yield message;
+        }
         consumedPage = true;
       } finally {
         if (!consumedPage) prefetchController.abort();
       }
-      if (!hasMore) break;
-      const out = await nextPage;
-      if ("error" in out) throw out.error;
-      response = out.value.response;
-      waitTil = out.value.waitTil;
+      if (!query.hasMore) {
+        const outputCursor = {
+          numSeen,
+          version: query.version,
+          messageIdsCacheKey,
+          objectSchema
+        };
+        return JSON.stringify(outputCursor);
+      }
     }
-    const outputCursor = {
-      numSeen: cacheNumSeen,
-      version,
-      messageIdsCacheKey,
-      objectSchema
-    };
-    return JSON.stringify(outputCursor);
   }
   query(inboxUrl, tags, objectSchema, inboxToken) {
     verifyHTTPSEndpoint(inboxUrl);
-    const body = dagCborEncode({
+    const body = new Uint8Array(dagCborEncode({
       tags,
       schema: objectSchema
-    });
-    const messageIdsCacheKey = getMessageIdsCacheKey(inboxUrl, "query", body);
-    return this.lockedMessageStreamer(
-      messageIdsCacheKey,
+    }));
+    return this.messageStreamer({
+      kind: "query",
       inboxUrl,
-      "query",
-      new Uint8Array(body),
-      inboxToken,
-      objectSchema
-    );
+      body,
+      schema: objectSchema,
+      inboxToken
+    });
   }
   continueQuery(inboxUrl, cursor, inboxToken) {
     verifyHTTPSEndpoint(inboxUrl);
     const decodedCursor = JSON.parse(cursor);
-    const { messageIdsCacheKey, numSeen, objectSchema, version } = CursorSchema.parse(decodedCursor);
-    return this.lockedMessageStreamer(
-      Promise.resolve(messageIdsCacheKey),
+    const parsedCursor = CursorSchema.parse(decodedCursor);
+    return this.messageStreamer({
+      kind: "continue",
       inboxUrl,
-      "query",
-      void 0,
-      inboxToken,
-      objectSchema,
-      version,
-      numSeen
-    );
+      cursor: parsedCursor,
+      inboxToken
+    });
   }
   export(inboxUrl, inboxToken) {
     verifyHTTPSEndpoint(inboxUrl);
-    const messageIdsCacheKey = getMessageIdsCacheKey(inboxUrl, "export");
-    return this.lockedMessageStreamer(
-      messageIdsCacheKey,
+    return this.messageStreamer({
+      kind: "export",
       inboxUrl,
-      "export",
-      void 0,
       inboxToken
-    );
+    });
   }
 }
-const GraffitiObjectSchema = strictObject({
-  value: looseObject({}),
-  channels: array(string()),
-  allowed: optional(nullable(array(url()))),
-  url: url(),
-  actor: url()
-});
-const Uint8ArraySchema = custom(
-  (v) => v instanceof Uint8Array
-);
-const TagsSchema = array(Uint8ArraySchema);
-const MESSAGE_TAGS_KEY = "t";
-const MESSAGE_OBJECT_KEY = "o";
-const MESSAGE_METADATA_KEY = "m";
-const MessageBaseSchema = strictObject({
-  [MESSAGE_TAGS_KEY]: TagsSchema,
-  [MESSAGE_OBJECT_KEY]: GraffitiObjectSchema,
-  [MESSAGE_METADATA_KEY]: Uint8ArraySchema
-});
-const LABELED_MESSAGE_ID_KEY = "id";
-const LABELED_MESSAGE_MESSAGE_KEY = "m";
-const LABELED_MESSAGE_LABEL_KEY = "l";
-const LabeledMessageBaseSchema = strictObject({
-  [LABELED_MESSAGE_ID_KEY]: string(),
-  [LABELED_MESSAGE_MESSAGE_KEY]: MessageBaseSchema,
-  [LABELED_MESSAGE_LABEL_KEY]: number()
-});
-const SendResponseSchema = strictObject({ id: string() });
-const MessageResultSchema = strictObject({
-  results: array(LabeledMessageBaseSchema),
-  hasMore: boolean(),
-  cursor: string()
-});
 const CursorSchema = strictObject({
   messageIdsCacheKey: string(),
   version: string(),
   numSeen: int().check(nonnegative()),
   objectSchema: union([looseObject({}), boolean()])
 });
-async function canUseIDB() {
-  try {
-    if (!globalThis.indexedDB) return false;
-    await new Promise((resolve, reject) => {
-      const req = indexedDB.open("__idb_probe__", 1);
-      req.onupgradeneeded = () => req.result.createObjectStore("k");
-      req.onsuccess = () => {
-        req.result.close();
-        resolve();
-      };
-      req.onerror = () => reject(req.error);
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getMessageCacheKey(inboxUrl, messageId) {
-  return `${encodeURIComponent(inboxUrl)}:${encodeURIComponent(messageId)}`;
-}
-async function getMessageIdsCacheKey(inboxUrl, type, body) {
-  const cacheIdData = dagCborEncode({
-    inboxUrl,
-    type,
-    body: body ?? null
-  });
-  return crypto.subtle.digest("SHA-256", new Uint8Array(cacheIdData)).then(
-    (bytes) => Array.from(new Uint8Array(bytes)).map((byte) => byte.toString(16).padStart(2, "0")).join("")
-  );
-}
-async function resetCacheDB() {
-  await new Promise((resolve) => {
-    const req = indexedDB.deleteDatabase("graffiti-inbox-cache");
-    req.onsuccess = () => resolve();
-    req.onerror = () => resolve();
-    req.onblocked = () => resolve();
-  });
-}
-async function createCache() {
-  if (await canUseIDB()) {
-    const { openDB } = await import("idb");
-    const db = await openDB("graffiti-inbox-cache", 1, {
-      upgrade(db2) {
-        if (!db2.objectStoreNames.contains("m")) db2.createObjectStore("m");
-        if (!db2.objectStoreNames.contains("q")) db2.createObjectStore("q");
-      }
-    });
-    return {
-      messages: {
-        get: async (k) => {
-          try {
-            return db.get("m", k);
-          } catch (error) {
-            console.error("Error getting message from cache:", error);
-            console.error("resetting cache...");
-            await resetCacheDB();
-            return void 0;
-          }
-        },
-        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: {
-        get: async (k) => {
-          try {
-            return await db.get("q", k);
-          } catch (error) {
-            console.error("Error getting message IDs from cache:", error);
-            console.error("resetting cache...");
-            await resetCacheDB();
-            return void 0;
-          }
-        },
-        set: async (k, v) => {
-          await db.put("q", v, k);
-        },
-        del: (k) => db.delete("q", k)
-      }
-    };
-  }
-  const m = /* @__PURE__ */ new Map();
-  const q = /* @__PURE__ */ new Map();
-  return {
-    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: {
-      get: async (k) => q.get(k),
-      set: async (k, v) => void q.set(k, v),
-      del: async (k) => void q.delete(k)
-    }
-  };
-}
 async function waitFor(waitTil) {
   if (waitTil !== void 0) {
     const waitFor2 = waitTil - Date.now();
@@ -550,10 +389,10 @@ export {
   Inboxes,
   LABELED_MESSAGE_ID_KEY,
   LABELED_MESSAGE_LABEL_KEY,
-  LABELED_MESSAGE_MESSAGE_KEY,
-  LabeledMessageBaseSchema,
+  LABELED_MESSAGE_MESSAGE_KEY2 as LABELED_MESSAGE_MESSAGE_KEY,
+  LabeledMessageBaseSchema2 as LabeledMessageBaseSchema,
   MESSAGE_METADATA_KEY,
-  MESSAGE_OBJECT_KEY,
+  MESSAGE_OBJECT_KEY2 as MESSAGE_OBJECT_KEY,
   MESSAGE_TAGS_KEY,
   MessageBaseSchema,
   TagsSchema,