@graffiti-garden/implementation-decentralized 0.0.10 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graffiti-garden/implementation-decentralized",
-  "version": "0.0.10",
+  "version": "0.1.1",
   "description": "A client for a decentralized implementation of the Graffiti API",
   "types": "./dist/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -27,35 +27,40 @@
   "author": "Theia Henderson",
   "license": "GPL-3.0-or-later",
   "scripts": {
-    "test": "NODE_TLS_REJECT_UNAUTHORIZED=0 vitest run",
-    "test:watch": "NODE_TLS_REJECT_UNAUTHORIZED=0 vitest --watch",
-    "test:coverage": "NODE_TLS_REJECT_UNAUTHORIZED=0 vitest --coverage",
+    "check": "tsc --noEmit && tsc -p tsconfig.test.json",
+    "test": "vitest run",
+    "test:watch": "vitest --watch",
+    "test:coverage": "vitest --coverage",
     "build:types": "tsc --declaration --emitDeclarationOnly",
     "build:js": "tsx esbuild.config.mts",
     "build": "rm -rf dist && npm run build:types && npm run build:js",
-    "prepublishOnly": "npm update && npm test && npm run build"
+    "prepublishOnly": "npm test && npm run build"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/graffiti-garden/implementation-decentralized.git"
+    "url": "git+https://github.com/graffiti-garden/graffiti.git",
+    "directory": "implementations/decentralized/client"
   },
   "bugs": {
-    "url": "https://github.com/graffiti-garden/implementation-decentralized/issues"
+    "url": "https://github.com/graffiti-garden/graffiti/issues"
   },
   "devDependencies": {
     "@types/js-cookie": "^3.0.6",
     "@types/node": "^26.1.1",
     "@vitest/coverage-v8": "^4.0.18",
+    "esbuild": "^0.28.1",
+    "miniflare": "4.20260730.0",
     "tsx": "^4.23.1",
     "typescript": "^7.0.2",
     "vitest": "^4.0.18"
   },
   "dependencies": {
-    "@graffiti-garden/api": "^1.2.0",
-    "@graffiti-garden/modal": "^1.0.4",
+    "@graffiti-garden/api": "^1.3.0",
+    "@graffiti-garden/modal": "^1.1.0",
+    "@graffiti-garden/wrapper-runtime-types": "^0.1.0",
     "@ipld/dag-cbor": "^10.0.1",
     "@noble/ed25519": "^3.1.0",
-    "@noble/hashes": "2.2",
+    "@noble/hashes": "2.4",
     "did-resolver": "^5.0.1",
     "idb": "^8.0.3",
     "js-cookie": "^3.0.8",

package/src/1-services/2-dids-tests.ts

@@ -1,4 +1,5 @@
-import { describe, expect, test } from "vitest";
+import type { DIDResolutionResult, Resolver } from "did-resolver";
+import { describe, expect, test, vi } from "vitest";
 import { DecentralizedIdentifiers } from "./2-dids";
 
 export function didTests() {
@@ -20,5 +21,65 @@ export function didTests() {
       const result = await dids.resolve(did);
       expect(result).toHaveProperty("id", did);
     });
+
+    test("coalesces simultaneous resolutions", async () => {
+      const dids = new DecentralizedIdentifiers();
+      const did = "did:web:example.com";
+      const found: DIDResolutionResult = {
+        didDocument: { id: did },
+        didDocumentMetadata: {},
+        didResolutionMetadata: {},
+      };
+      let finish!: (result: DIDResolutionResult) => void;
+      const lookup = vi.fn<Resolver["resolve"]>().mockImplementation(
+        () => new Promise((resolve) => { finish = resolve; }),
+      );
+      Object.defineProperty(dids, "resolver", { value: { resolve: lookup } });
+
+      const first = dids.resolve(did);
+      const second = dids.resolve(did);
+      expect(lookup).toHaveBeenCalledTimes(1);
+
+      finish(found);
+      await expect(Promise.all([first, second])).resolves.toEqual([
+        found.didDocument,
+        found.didDocument,
+      ]);
+
+      lookup.mockResolvedValue(found);
+      await expect(dids.resolve(did)).resolves.toEqual(found.didDocument);
+      expect(lookup).toHaveBeenCalledTimes(2);
+    });
+
+    test("retries a failed resolution", async () => {
+      const dids = new DecentralizedIdentifiers();
+      const did = "did:web:example.com";
+      const found: DIDResolutionResult = {
+        didDocument: { id: did },
+        didDocumentMetadata: {},
+        didResolutionMetadata: {},
+      };
+      const lookup = vi.fn<Resolver["resolve"]>()
+        .mockResolvedValueOnce({
+          didDocument: null,
+          didDocumentMetadata: {},
+          didResolutionMetadata: { error: "notFound" },
+        })
+        .mockResolvedValueOnce(found);
+      Object.defineProperty(dids, "resolver", { value: { resolve: lookup } });
+
+      const failed = await Promise.allSettled([
+        dids.resolve(did),
+        dids.resolve(did),
+      ]);
+      expect(lookup).toHaveBeenCalledTimes(1);
+      expect(failed.map((result) => result.status)).toEqual([
+        "rejected",
+        "rejected",
+      ]);
+
+      await expect(dids.resolve(did)).resolves.toEqual(found.didDocument);
+      expect(lookup).toHaveBeenCalledTimes(2);
+    });
   });
 }

package/src/1-services/2-dids.ts

@@ -14,6 +14,8 @@ export class DecentralizedIdentifiers {
     { cache: true },
   );
 
+  protected readonly inFlight = new Map<string, Promise<DIDDocument>>();
+
   async resolve(did: string): Promise<DIDDocument> {
     if (
       !Object.keys(this.methods).some((method) =>
@@ -23,11 +25,21 @@ export class DecentralizedIdentifiers {
       throw new Error(`Unrecognized DID method: ${did}`);
     }
 
-    const { didDocument } = await this.resolver.resolve(did);
-    if (!didDocument) {
-      throw new GraffitiErrorNotFound(`DID not found: ${did}`);
-    }
+    const inFlight = this.inFlight.get(did);
+    if (inFlight) return inFlight;
 
-    return didDocument;
+    const resolution = this.resolver.resolve(did).then(({ didDocument }) => {
+      if (!didDocument) {
+        throw new GraffitiErrorNotFound(`DID not found: ${did}`);
+      }
+      return didDocument;
+    });
+    this.inFlight.set(did, resolution);
+
+    try {
+      return await resolution;
+    } finally {
+      this.inFlight.delete(did);
+    }
   }
 }

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 {
@@ -710,6 +710,13 @@ export class GraffitiDecentralized implements Graffiti {
   getMedia: Graffiti["getMedia"] = async (...args) => {
     const [mediaUrl, accept, session] = args;
 
+    if (
+      accept?.maxBytes !== undefined &&
+      (!Number.isSafeInteger(accept.maxBytes) || accept.maxBytes < 0)
+    ) {
+      throw new TypeError("maxBytes must be a nonnegative safe integer");
+    }
+
     const object = await this.get<typeof MEDIA_OBJECT_SCHEMA>(
       mediaUrl,
       MEDIA_OBJECT_SCHEMA,
@@ -718,7 +725,7 @@ export class GraffitiDecentralized implements Graffiti {
 
     const { key, type, size } = object.value;
 
-    if (accept?.maxBytes && size > accept.maxBytes) {
+    if (accept?.maxBytes !== undefined && size > accept.maxBytes) {
       throw new GraffitiErrorTooLarge("File size exceeds limit");
     }
 

package/src/index.spec.ts

@@ -13,7 +13,7 @@ import { Authorization } from "./1-services/1-authorization";
 import { StorageBuckets } from "./1-services/3-storage-buckets";
 import { Inboxes } from "./1-services/4-inboxes";
 import { Sessions } from "./3-protocol/1-sessions";
-import { afterAll, describe } from "vitest";
+import { afterAll, beforeAll, describe } from "vitest";
 import { Handles } from "./3-protocol/2-handles";
 import { didTests } from "./1-services/2-dids-tests";
 import { storageBucketTests } from "./1-services/3-storage-buckets-tests";
@@ -25,48 +25,55 @@ import { allowedAttestationTests } from "./2-primitives/4-allowed-attestations-t
 import { handleTests } from "./3-protocol/2-handles-tests";
 import { objectEncodingTests } from "./3-protocol/3-object-encoding-tests";
 import { GraffitiDecentralized } from "./3-protocol/4-graffiti";
+import {
+  DecentralizedTestEnvironment,
+  decentralizedSharedInbox,
+  decentralizedTestUsers,
+} from "../test/environment";
 
-describe("GraffitiDecentralized Tests", async () => {
-  // Initialize structures for log in/out
-  const dids = new DecentralizedIdentifiers();
-  const sessionMethods = new Sessions({
-    dids,
-    authorization: new Authorization(),
-    inboxes: new Inboxes(),
-    storageBuckets: new StorageBuckets(),
-  });
-  const handleMethods = new Handles({ dids });
-
-  // Login
-  const handles = [
-    "localhost%3A5173:app:handles:handle:test1",
-    "localhost%3A5173:app:handles:handle:test2",
-  ];
+describe("GraffitiDecentralized Tests", () => {
+  const environment = new DecentralizedTestEnvironment();
+  const handles = decentralizedTestUsers.map((user) => user.handle);
   let sessions: GraffitiSession[] = [];
-  for (const handle of handles) {
-    sessions.push(await login(handle));
-  }
-  const resolvedSessions = sessions.map((s) => {
-    const resolved = sessionMethods.resolveSession(s);
-    if (!resolved) throw new Error("Error logging in");
-    return resolved;
+  let sessionMethods: Sessions;
+  let handleMethods: Handles;
+
+  beforeAll(async () => {
+    await environment.start();
+
+    const dids = new DecentralizedIdentifiers();
+    sessionMethods = new Sessions({
+      dids,
+      authorization: new Authorization(),
+      inboxes: new Inboxes(),
+      storageBuckets: new StorageBuckets(),
+    });
+    handleMethods = new Handles({ dids });
+
+    for (const handle of handles) {
+      sessions.push(await login(handle));
+    }
   });
-  // Logout on cleanup
+
   afterAll(async () => {
-    for (const session of sessions) {
-      await logout(session.actor);
+    try {
+      for (const session of sessions) {
+        await logout(session.actor);
+      }
+    } finally {
+      await environment.stop();
     }
   });
 
   // Service tests
   didTests();
   storageBucketTests(
-    resolvedSessions[0].storageBucket.serviceEndpoint,
-    resolvedSessions[0].storageBucket.token,
+    decentralizedTestUsers[0].bucketEndpoint,
+    decentralizedTestUsers[0].token,
   );
   inboxTests(
-    resolvedSessions[0].personalInbox.serviceEndpoint,
-    resolvedSessions[0].personalInbox.token,
+    decentralizedTestUsers[0].inboxEndpoint,
+    decentralizedTestUsers[0].token,
   );
 
   // Primitive tests
@@ -79,13 +86,10 @@ describe("GraffitiDecentralized Tests", async () => {
   handleTests(handles[0]);
   objectEncodingTests();
 
-  const useGraffiti = () => {
-    return new GraffitiDecentralized(
-      {
-        defaultInboxEndpoints: ["https://localhost:5173/i/shared"],
-      },
-    );
-  };
+  const useGraffiti = () =>
+    new GraffitiDecentralized({
+      defaultInboxEndpoints: [decentralizedSharedInbox],
+    });
   graffitiCRUDTests(
     useGraffiti,
     () => sessions[0],
@@ -107,9 +111,16 @@ describe("GraffitiDecentralized Tests", async () => {
     const actor = await handleMethods.handleToActor(handle);
 
     return await new Promise<GraffitiSession>((resolve, reject) => {
+      let timeout: ReturnType<typeof setTimeout>;
+      const cleanup = () => {
+        clearTimeout(timeout);
+        sessionMethods.sessionEvents.removeEventListener("login", listener);
+      };
       const listener = (e: unknown) => {
         if (!(e instanceof CustomEvent)) return;
         const detail = e.detail as GraffitiLoginEvent["detail"];
+        if (detail.session?.actor !== actor) return;
+        cleanup();
         if (detail.error) {
           reject(detail.error);
         } else {
@@ -118,23 +129,30 @@ describe("GraffitiDecentralized Tests", async () => {
       };
       sessionMethods.sessionEvents.addEventListener("login", listener);
 
-      setTimeout(
+      timeout = setTimeout(
         () => {
-          sessionMethods.sessionEvents.removeEventListener("login", listener);
+          cleanup();
           reject(new Error("Authorization timed out"));
         },
-        5 * 60 * 1000,
-      ); // 5 minutes timeout
+        30 * 1000,
+      );
 
-      sessionMethods.login(actor);
+      void sessionMethods.login(actor);
     });
   }
 
   async function logout(actor: string) {
     return await new Promise<void>((resolve, reject) => {
+      let timeout: ReturnType<typeof setTimeout>;
+      const cleanup = () => {
+        clearTimeout(timeout);
+        sessionMethods.sessionEvents.removeEventListener("logout", listener);
+      };
       const listener = (e: unknown) => {
         if (!(e instanceof CustomEvent)) return;
         const detail = e.detail as GraffitiLogoutEvent["detail"];
+        if (detail.actor !== actor) return;
+        cleanup();
 
         if (detail.error) {
           reject(detail.error);
@@ -144,15 +162,15 @@ describe("GraffitiDecentralized Tests", async () => {
       };
       sessionMethods.sessionEvents.addEventListener("logout", listener);
 
-      setTimeout(
+      timeout = setTimeout(
         () => {
-          sessionMethods.sessionEvents.removeEventListener("logout", listener);
+          cleanup();
           reject(new Error("Logout timed out"));
         },
-        5 * 60 * 1000,
-      ); // 5 minutes timeout
+        30 * 1000,
+      );
 
-      sessionMethods.logout(actor);
+      void sessionMethods.logout(actor);
     });
   }
 });

package/src/index.ts

@@ -1,4 +1,5 @@
-import { Graffiti, GraffitiRuntimeTypes } from "@graffiti-garden/api";
+import type { Graffiti } from "@graffiti-garden/api";
+import { GraffitiRuntimeTypes } from "@graffiti-garden/wrapper-runtime-types";
 import {
   GraffitiDecentralized as GraffitiDecentralized_,
   type GraffitiDecentralizedOptions,

package/dist/1-services/2-dids-tests.d.ts

@@ -1,2 +0,0 @@
-export declare function didTests(): import("vitest").SuiteCollector<object>;
-//# sourceMappingURL=2-dids-tests.d.ts.map

package/dist/1-services/2-dids-tests.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"2-dids-tests.d.ts","sourceRoot":"","sources":["../../src/1-services/2-dids-tests.ts"],"names":[],"mappings":"AAGA,wBAAgB,QAAQ,4CAoBvB"}

package/dist/1-services/3-storage-buckets-tests.d.ts

@@ -1,2 +0,0 @@
-export declare function storageBucketTests(storageBucketEndpoint: string, storageBucketToken: string): void;
-//# sourceMappingURL=3-storage-buckets-tests.d.ts.map

package/dist/1-services/3-storage-buckets-tests.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"3-storage-buckets-tests.d.ts","sourceRoot":"","sources":["../../src/1-services/3-storage-buckets-tests.ts"],"names":[],"mappings":"AAKA,wBAAgB,kBAAkB,CAChC,qBAAqB,EAAE,MAAM,EAC7B,kBAAkB,EAAE,MAAM,QAiH3B"}

package/dist/1-services/4-inboxes-tests.d.ts

@@ -1,2 +0,0 @@
-export declare function inboxTests(inboxEndpoint: string, inboxToken: string): void;
-//# sourceMappingURL=4-inboxes-tests.d.ts.map

package/dist/1-services/4-inboxes-tests.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"4-inboxes-tests.d.ts","sourceRoot":"","sources":["../../src/1-services/4-inboxes-tests.ts"],"names":[],"mappings":"AAMA,wBAAgB,UAAU,CAAC,aAAa,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,QAqJnE"}

package/dist/2-primitives/1-string-encoding-tests.d.ts

@@ -1,2 +0,0 @@
-export declare function stringEncodingTests(): void;
-//# sourceMappingURL=1-string-encoding-tests.d.ts.map

package/dist/2-primitives/1-string-encoding-tests.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"1-string-encoding-tests.d.ts","sourceRoot":"","sources":["../../src/2-primitives/1-string-encoding-tests.ts"],"names":[],"mappings":"AAOA,wBAAgB,mBAAmB,SAyBlC"}

package/dist/2-primitives/2-content-addresses-tests.d.ts

@@ -1,2 +0,0 @@
-export declare function contentAddressesTests(): void;
-//# sourceMappingURL=2-content-addresses-tests.d.ts.map

package/dist/2-primitives/2-content-addresses-tests.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"2-content-addresses-tests.d.ts","sourceRoot":"","sources":["../../src/2-primitives/2-content-addresses-tests.ts"],"names":[],"mappings":"AAOA,wBAAgB,qBAAqB,SAsCpC"}

package/dist/2-primitives/3-channel-attestations-tests.d.ts

@@ -1,2 +0,0 @@
-export declare function channelAttestationTests(): void;
-//# sourceMappingURL=3-channel-attestations-tests.d.ts.map

package/dist/2-primitives/3-channel-attestations-tests.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"3-channel-attestations-tests.d.ts","sourceRoot":"","sources":["../../src/2-primitives/3-channel-attestations-tests.ts"],"names":[],"mappings":"AAWA,wBAAgB,uBAAuB,SAiHtC"}

package/dist/2-primitives/4-allowed-attestations-tests.d.ts

@@ -1,2 +0,0 @@
-export declare function allowedAttestationTests(): void;
-//# sourceMappingURL=4-allowed-attestations-tests.d.ts.map

package/dist/2-primitives/4-allowed-attestations-tests.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"4-allowed-attestations-tests.d.ts","sourceRoot":"","sources":["../../src/2-primitives/4-allowed-attestations-tests.ts"],"names":[],"mappings":"AAWA,wBAAgB,uBAAuB,SA0EtC"}

package/dist/3-protocol/2-handles-tests.d.ts

@@ -1,2 +0,0 @@
-export declare function handleTests(handle: string): void;
-//# sourceMappingURL=2-handles-tests.d.ts.map

package/dist/3-protocol/2-handles-tests.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"2-handles-tests.d.ts","sourceRoot":"","sources":["../../src/3-protocol/2-handles-tests.ts"],"names":[],"mappings":"AAIA,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,QAYzC"}

package/dist/3-protocol/3-object-encoding-tests.d.ts

@@ -1,2 +0,0 @@
-export declare function objectEncodingTests(): void;
-//# sourceMappingURL=3-object-encoding-tests.d.ts.map

package/dist/3-protocol/3-object-encoding-tests.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"3-object-encoding-tests.d.ts","sourceRoot":"","sources":["../../src/3-protocol/3-object-encoding-tests.ts"],"names":[],"mappings":"AA2BA,wBAAgB,mBAAmB,SAiPlC"}