@graffiti-garden/implementation-decentralized 0.0.1

package/dist/cjs/1-services/2-dids-tests.js

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dids_tests_exports = {};
+__export(dids_tests_exports, {
+  didTests: () => didTests
+});
+module.exports = __toCommonJS(dids_tests_exports);
+var import_vitest = require("vitest");
+var import_dids = require("./2-dids");
+function didTests() {
+  return (0, import_vitest.describe)("DecentralizedIdentifiers", () => {
+    const dids = new import_dids.DecentralizedIdentifiers();
+    (0, import_vitest.test)("invalid method", async () => {
+      await (0, import_vitest.expect)(dids.resolve("did:invalid:12345")).rejects.toThrowError();
+    });
+    (0, import_vitest.test)("did:web", async () => {
+      const did = "did:web:identity.foundation";
+      const result = await dids.resolve(did);
+      (0, import_vitest.expect)(result).toHaveProperty("id", did);
+    });
+    (0, import_vitest.test)("did:plc", async () => {
+      const did = "did:plc:44ybard66vv44zksje25o7dz";
+      const result = await dids.resolve(did);
+      (0, import_vitest.expect)(result).toHaveProperty("id", did);
+    });
+  });
+}
+//# sourceMappingURL=2-dids-tests.js.map

package/dist/cjs/1-services/2-dids-tests.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/1-services/2-dids-tests.ts"],
+  "sourcesContent": ["import { describe, expect, test } from \"vitest\";\nimport { DecentralizedIdentifiers } from \"./2-dids\";\n\nexport function didTests() {\n  return describe(\"DecentralizedIdentifiers\", () => {\n    const dids = new DecentralizedIdentifiers();\n\n    test(\"invalid method\", async () => {\n      await expect(dids.resolve(\"did:invalid:12345\")).rejects.toThrowError();\n    });\n\n    test(\"did:web\", async () => {\n      const did = \"did:web:identity.foundation\";\n      const result = await dids.resolve(did);\n      expect(result).toHaveProperty(\"id\", did);\n    });\n\n    test(\"did:plc\", async () => {\n      const did = \"did:plc:44ybard66vv44zksje25o7dz\";\n      const result = await dids.resolve(did);\n      expect(result).toHaveProperty(\"id\", did);\n    });\n  });\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAuC;AACvC,kBAAyC;AAElC,SAAS,WAAW;AACzB,aAAO,wBAAS,4BAA4B,MAAM;AAChD,UAAM,OAAO,IAAI,qCAAyB;AAE1C,4BAAK,kBAAkB,YAAY;AACjC,gBAAM,sBAAO,KAAK,QAAQ,mBAAmB,CAAC,EAAE,QAAQ,aAAa;AAAA,IACvE,CAAC;AAED,4BAAK,WAAW,YAAY;AAC1B,YAAM,MAAM;AACZ,YAAM,SAAS,MAAM,KAAK,QAAQ,GAAG;AACrC,gCAAO,MAAM,EAAE,eAAe,MAAM,GAAG;AAAA,IACzC,CAAC;AAED,4BAAK,WAAW,YAAY;AAC1B,YAAM,MAAM;AACZ,YAAM,SAAS,MAAM,KAAK,QAAQ,GAAG;AACrC,gCAAO,MAAM,EAAE,eAAe,MAAM,GAAG;AAAA,IACzC,CAAC;AAAA,EACH,CAAC;AACH;",
+  "names": []
+}

package/dist/cjs/1-services/2-dids.js

@@ -0,0 +1,47 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dids_exports = {};
+__export(dids_exports, {
+  DecentralizedIdentifiers: () => DecentralizedIdentifiers
+});
+module.exports = __toCommonJS(dids_exports);
+var import_api = require("@graffiti-garden/api");
+var import_did_resolver = require("did-resolver");
+var import_plc_did_resolver = require("plc-did-resolver");
+var import_web_did_resolver = require("web-did-resolver");
+class DecentralizedIdentifiers {
+  methods = {
+    ...(0, import_plc_did_resolver.getResolver)(),
+    ...(0, import_web_did_resolver.getResolver)()
+  };
+  resolver = new import_did_resolver.Resolver(this.methods, { cache: true });
+  async resolve(did) {
+    if (!Object.keys(this.methods).some(
+      (method) => did.startsWith(`did:${method}:`)
+    )) {
+      throw new Error(`Unrecognized DID method: ${did}`);
+    }
+    const { didDocument } = await this.resolver.resolve(did);
+    if (!didDocument) {
+      throw new import_api.GraffitiErrorNotFound(`DID not found: ${did}`);
+    }
+    return didDocument;
+  }
+}
+//# sourceMappingURL=2-dids.js.map

package/dist/cjs/1-services/2-dids.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/1-services/2-dids.ts"],
+  "sourcesContent": ["import { GraffitiErrorNotFound } from \"@graffiti-garden/api\";\nimport { Resolver, type DIDDocument } from \"did-resolver\";\nimport { getResolver as plcResolver } from \"plc-did-resolver\";\nimport { getResolver as webResolver } from \"web-did-resolver\";\n\nexport class DecentralizedIdentifiers {\n  protected readonly methods = {\n    ...plcResolver(),\n    ...webResolver(),\n  };\n\n  protected readonly resolver = new Resolver(this.methods, { cache: true });\n\n  async resolve(did: string): Promise<DIDDocument> {\n    if (\n      !Object.keys(this.methods).some((method) =>\n        did.startsWith(`did:${method}:`),\n      )\n    ) {\n      throw new Error(`Unrecognized DID method: ${did}`);\n    }\n\n    const { didDocument } = await this.resolver.resolve(did);\n    if (!didDocument) {\n      throw new GraffitiErrorNotFound(`DID not found: ${did}`);\n    }\n\n    return didDocument;\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAAsC;AACtC,0BAA2C;AAC3C,8BAA2C;AAC3C,8BAA2C;AAEpC,MAAM,yBAAyB;AAAA,EACjB,UAAU;AAAA,IAC3B,OAAG,wBAAAA,aAAY;AAAA,IACf,OAAG,wBAAAC,aAAY;AAAA,EACjB;AAAA,EAEmB,WAAW,IAAI,6BAAS,KAAK,SAAS,EAAE,OAAO,KAAK,CAAC;AAAA,EAExE,MAAM,QAAQ,KAAmC;AAC/C,QACE,CAAC,OAAO,KAAK,KAAK,OAAO,EAAE;AAAA,MAAK,CAAC,WAC/B,IAAI,WAAW,OAAO,MAAM,GAAG;AAAA,IACjC,GACA;AACA,YAAM,IAAI,MAAM,4BAA4B,GAAG,EAAE;AAAA,IACnD;AAEA,UAAM,EAAE,YAAY,IAAI,MAAM,KAAK,SAAS,QAAQ,GAAG;AACvD,QAAI,CAAC,aAAa;AAChB,YAAM,IAAI,iCAAsB,kBAAkB,GAAG,EAAE;AAAA,IACzD;AAEA,WAAO;AAAA,EACT;AACF;",
+  "names": ["plcResolver", "webResolver"]
+}

package/dist/cjs/1-services/3-storage-buckets-tests.js

@@ -0,0 +1,123 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var storage_buckets_tests_exports = {};
+__export(storage_buckets_tests_exports, {
+  storageBucketTests: () => storageBucketTests
+});
+module.exports = __toCommonJS(storage_buckets_tests_exports);
+var import_vitest = require("vitest");
+var import_storage_buckets = require("./3-storage-buckets");
+var import_utilities = require("./utilities");
+var import_api = require("@graffiti-garden/api");
+function storageBucketTests(storageBucketEndpoint, storageBucketToken) {
+  (0, import_vitest.describe)("Storage buckets", async () => {
+    const storageBuckets = new import_storage_buckets.StorageBuckets();
+    (0, import_vitest.test)("put, get, delete", async () => {
+      const key = Math.random().toString(36).substring(2, 15);
+      const input = "Hello world";
+      const bytes = new TextEncoder().encode(input);
+      await (0, import_vitest.expect)(
+        storageBuckets.get(storageBucketEndpoint, key)
+      ).rejects.toThrow(import_api.GraffitiErrorNotFound);
+      await storageBuckets.put(
+        storageBucketEndpoint,
+        key,
+        bytes,
+        storageBucketToken
+      );
+      const resultBytes = await storageBuckets.get(
+        storageBucketEndpoint,
+        key,
+        bytes.length
+      );
+      const result = new TextDecoder().decode(resultBytes);
+      (0, import_vitest.expect)(result).toEqual(input);
+      await storageBuckets.delete(
+        storageBucketEndpoint,
+        key,
+        storageBucketToken
+      );
+      await (0, import_vitest.expect)(
+        storageBuckets.get(storageBucketEndpoint, key)
+      ).rejects.toThrow(import_api.GraffitiErrorNotFound);
+    });
+    (0, import_vitest.test)("get with limit less than object", async () => {
+      const key = Math.random().toString(36).substring(2, 15);
+      const input = "Hello world";
+      const bytes = new TextEncoder().encode(input);
+      await storageBuckets.put(
+        storageBucketEndpoint,
+        key,
+        bytes,
+        storageBucketToken
+      );
+      await (0, import_vitest.expect)(
+        storageBuckets.get(storageBucketEndpoint, key, bytes.length - 1)
+      ).rejects.toThrow();
+    });
+    (0, import_vitest.test)("unauthorized", async () => {
+      const key = Math.random().toString(36).substring(2, 15);
+      const input = "Hello world";
+      const bytes = new TextEncoder().encode(input);
+      await (0, import_vitest.expect)(
+        storageBuckets.put(storageBucketEndpoint, key, bytes, "invalid-token")
+      ).rejects.toThrow(import_utilities.GraffitiErrorUnauthorized);
+      await (0, import_vitest.expect)(
+        storageBuckets.delete(storageBucketEndpoint, key, "invalid-token")
+      ).rejects.toThrow(import_utilities.GraffitiErrorUnauthorized);
+      await (0, import_vitest.expect)(
+        storageBuckets.export(storageBucketEndpoint, "invalid-token").next()
+      ).rejects.toThrow(import_utilities.GraffitiErrorUnauthorized);
+    });
+    (0, import_vitest.test)("export", async () => {
+      const keys = /* @__PURE__ */ new Set();
+      for (let i = 0; i < 256; i++) {
+        const key = Math.random().toString(36).substring(2, 15);
+        keys.add(key);
+        const input = "Hello world " + i;
+        const bytes = new TextEncoder().encode(input);
+        await storageBuckets.put(
+          storageBucketEndpoint,
+          key,
+          bytes,
+          storageBucketToken
+        );
+      }
+      const retrievedKeys = /* @__PURE__ */ new Set();
+      const iterator = storageBuckets.export(
+        storageBucketEndpoint,
+        storageBucketToken
+      );
+      for await (const result of iterator) {
+        if (keys.has(result.key)) {
+          retrievedKeys.add(result.key);
+        }
+      }
+      (0, import_vitest.expect)(retrievedKeys.size).toEqual(keys.size);
+      for (const key of keys) {
+        await storageBuckets.delete(
+          storageBucketEndpoint,
+          key,
+          storageBucketToken
+        );
+      }
+    }, 1e6);
+  });
+}
+//# sourceMappingURL=3-storage-buckets-tests.js.map

package/dist/cjs/1-services/3-storage-buckets-tests.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/1-services/3-storage-buckets-tests.ts"],
+  "sourcesContent": ["import { describe, expect, test } from \"vitest\";\nimport { StorageBuckets } from \"./3-storage-buckets\";\nimport { GraffitiErrorUnauthorized } from \"./utilities\";\nimport { GraffitiErrorNotFound } from \"@graffiti-garden/api\";\n\nexport function storageBucketTests(\n  storageBucketEndpoint: string,\n  storageBucketToken: string,\n) {\n  describe(\"Storage buckets\", async () => {\n    const storageBuckets = new StorageBuckets();\n\n    test(\"put, get, delete\", async () => {\n      const key = Math.random().toString(36).substring(2, 15);\n      const input = \"Hello world\";\n      const bytes = new TextEncoder().encode(input);\n\n      await expect(\n        storageBuckets.get(storageBucketEndpoint, key),\n      ).rejects.toThrow(GraffitiErrorNotFound);\n\n      await storageBuckets.put(\n        storageBucketEndpoint,\n        key,\n        bytes,\n        storageBucketToken,\n      );\n\n      const resultBytes = await storageBuckets.get(\n        storageBucketEndpoint,\n        key,\n        bytes.length,\n      );\n      const result = new TextDecoder().decode(resultBytes);\n      expect(result).toEqual(input);\n\n      await storageBuckets.delete(\n        storageBucketEndpoint,\n        key,\n        storageBucketToken,\n      );\n\n      await expect(\n        storageBuckets.get(storageBucketEndpoint, key),\n      ).rejects.toThrow(GraffitiErrorNotFound);\n    });\n\n    test(\"get with limit less than object\", async () => {\n      const key = Math.random().toString(36).substring(2, 15);\n      const input = \"Hello world\";\n      const bytes = new TextEncoder().encode(input);\n\n      await storageBuckets.put(\n        storageBucketEndpoint,\n        key,\n        bytes,\n        storageBucketToken,\n      );\n\n      await expect(\n        storageBuckets.get(storageBucketEndpoint, key, bytes.length - 1),\n      ).rejects.toThrow();\n    });\n\n    test(\"unauthorized\", async () => {\n      const key = Math.random().toString(36).substring(2, 15);\n      const input = \"Hello world\";\n      const bytes = new TextEncoder().encode(input);\n\n      await expect(\n        storageBuckets.put(storageBucketEndpoint, key, bytes, \"invalid-token\"),\n      ).rejects.toThrow(GraffitiErrorUnauthorized);\n      await expect(\n        storageBuckets.delete(storageBucketEndpoint, key, \"invalid-token\"),\n      ).rejects.toThrow(GraffitiErrorUnauthorized);\n      await expect(\n        storageBuckets.export(storageBucketEndpoint, \"invalid-token\").next(),\n      ).rejects.toThrow(GraffitiErrorUnauthorized);\n    });\n\n    test(\"export\", async () => {\n      // Put a whole bunch of stuff so the export needs to page\n      const keys = new Set<string>();\n      for (let i = 0; i < 256; i++) {\n        const key = Math.random().toString(36).substring(2, 15);\n        keys.add(key);\n\n        const input = \"Hello world \" + i;\n        const bytes = new TextEncoder().encode(input);\n        await storageBuckets.put(\n          storageBucketEndpoint,\n          key,\n          bytes,\n          storageBucketToken,\n        );\n      }\n\n      // Export\n      const retrievedKeys = new Set<string>();\n      const iterator = storageBuckets.export(\n        storageBucketEndpoint,\n        storageBucketToken,\n      );\n      for await (const result of iterator) {\n        if (keys.has(result.key)) {\n          retrievedKeys.add(result.key);\n        }\n      }\n      expect(retrievedKeys.size).toEqual(keys.size);\n\n      // Delete all the keys\n      for (const key of keys) {\n        await storageBuckets.delete(\n          storageBucketEndpoint,\n          key,\n          storageBucketToken,\n        );\n      }\n    }, 1000000);\n  });\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAuC;AACvC,6BAA+B;AAC/B,uBAA0C;AAC1C,iBAAsC;AAE/B,SAAS,mBACd,uBACA,oBACA;AACA,8BAAS,mBAAmB,YAAY;AACtC,UAAM,iBAAiB,IAAI,sCAAe;AAE1C,4BAAK,oBAAoB,YAAY;AACnC,YAAM,MAAM,KAAK,OAAO,EAAE,SAAS,EAAE,EAAE,UAAU,GAAG,EAAE;AACtD,YAAM,QAAQ;AACd,YAAM,QAAQ,IAAI,YAAY,EAAE,OAAO,KAAK;AAE5C,gBAAM;AAAA,QACJ,eAAe,IAAI,uBAAuB,GAAG;AAAA,MAC/C,EAAE,QAAQ,QAAQ,gCAAqB;AAEvC,YAAM,eAAe;AAAA,QACnB;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAEA,YAAM,cAAc,MAAM,eAAe;AAAA,QACvC;AAAA,QACA;AAAA,QACA,MAAM;AAAA,MACR;AACA,YAAM,SAAS,IAAI,YAAY,EAAE,OAAO,WAAW;AACnD,gCAAO,MAAM,EAAE,QAAQ,KAAK;AAE5B,YAAM,eAAe;AAAA,QACnB;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAEA,gBAAM;AAAA,QACJ,eAAe,IAAI,uBAAuB,GAAG;AAAA,MAC/C,EAAE,QAAQ,QAAQ,gCAAqB;AAAA,IACzC,CAAC;AAED,4BAAK,mCAAmC,YAAY;AAClD,YAAM,MAAM,KAAK,OAAO,EAAE,SAAS,EAAE,EAAE,UAAU,GAAG,EAAE;AACtD,YAAM,QAAQ;AACd,YAAM,QAAQ,IAAI,YAAY,EAAE,OAAO,KAAK;AAE5C,YAAM,eAAe;AAAA,QACnB;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAEA,gBAAM;AAAA,QACJ,eAAe,IAAI,uBAAuB,KAAK,MAAM,SAAS,CAAC;AAAA,MACjE,EAAE,QAAQ,QAAQ;AAAA,IACpB,CAAC;AAED,4BAAK,gBAAgB,YAAY;AAC/B,YAAM,MAAM,KAAK,OAAO,EAAE,SAAS,EAAE,EAAE,UAAU,GAAG,EAAE;AACtD,YAAM,QAAQ;AACd,YAAM,QAAQ,IAAI,YAAY,EAAE,OAAO,KAAK;AAE5C,gBAAM;AAAA,QACJ,eAAe,IAAI,uBAAuB,KAAK,OAAO,eAAe;AAAA,MACvE,EAAE,QAAQ,QAAQ,0CAAyB;AAC3C,gBAAM;AAAA,QACJ,eAAe,OAAO,uBAAuB,KAAK,eAAe;AAAA,MACnE,EAAE,QAAQ,QAAQ,0CAAyB;AAC3C,gBAAM;AAAA,QACJ,eAAe,OAAO,uBAAuB,eAAe,EAAE,KAAK;AAAA,MACrE,EAAE,QAAQ,QAAQ,0CAAyB;AAAA,IAC7C,CAAC;AAED,4BAAK,UAAU,YAAY;AAEzB,YAAM,OAAO,oBAAI,IAAY;AAC7B,eAAS,IAAI,GAAG,IAAI,KAAK,KAAK;AAC5B,cAAM,MAAM,KAAK,OAAO,EAAE,SAAS,EAAE,EAAE,UAAU,GAAG,EAAE;AACtD,aAAK,IAAI,GAAG;AAEZ,cAAM,QAAQ,iBAAiB;AAC/B,cAAM,QAAQ,IAAI,YAAY,EAAE,OAAO,KAAK;AAC5C,cAAM,eAAe;AAAA,UACnB;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QACF;AAAA,MACF;AAGA,YAAM,gBAAgB,oBAAI,IAAY;AACtC,YAAM,WAAW,eAAe;AAAA,QAC9B;AAAA,QACA;AAAA,MACF;AACA,uBAAiB,UAAU,UAAU;AACnC,YAAI,KAAK,IAAI,OAAO,GAAG,GAAG;AACxB,wBAAc,IAAI,OAAO,GAAG;AAAA,QAC9B;AAAA,MACF;AACA,gCAAO,cAAc,IAAI,EAAE,QAAQ,KAAK,IAAI;AAG5C,iBAAW,OAAO,MAAM;AACtB,cAAM,eAAe;AAAA,UACnB;AAAA,UACA;AAAA,UACA;AAAA,QACF;AAAA,MACF;AAAA,IACF,GAAG,GAAO;AAAA,EACZ,CAAC;AACH;",
+  "names": []
+}

package/dist/cjs/1-services/3-storage-buckets.js

@@ -0,0 +1,148 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var storage_buckets_exports = {};
+__export(storage_buckets_exports, {
+  StorageBuckets: () => StorageBuckets
+});
+module.exports = __toCommonJS(storage_buckets_exports);
+var import_utilities = require("./utilities");
+var import_mini = require("zod/mini");
+var import_dag_cbor = require("@ipld/dag-cbor");
+class StorageBuckets {
+  getAuthorizationEndpoint = import_utilities.getAuthorizationEndpoint;
+  async put(storageBucketEndpoint, key, value, authorizationToken) {
+    (0, import_utilities.verifyHTTPSEndpoint)(storageBucketEndpoint);
+    const url = `${storageBucketEndpoint}/value/${encodeURIComponent(key)}`;
+    await (0, import_utilities.fetchWithErrorHandling)(url, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/octet-stream",
+        Authorization: `Bearer ${authorizationToken}`
+      },
+      body: value.slice()
+    });
+  }
+  async delete(storageBucketEndpoint, key, authorizationToken) {
+    (0, import_utilities.verifyHTTPSEndpoint)(storageBucketEndpoint);
+    const url = `${storageBucketEndpoint}/value/${encodeURIComponent(key)}`;
+    await (0, import_utilities.fetchWithErrorHandling)(url, {
+      method: "DELETE",
+      headers: {
+        Authorization: `Bearer ${authorizationToken}`
+      }
+    });
+  }
+  async get(storageBucketEndpoint, key, maxBytes) {
+    (0, import_utilities.verifyHTTPSEndpoint)(storageBucketEndpoint);
+    const url = `${storageBucketEndpoint}/value/${encodeURIComponent(key)}`;
+    const response = await (0, import_utilities.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) : void 0;
+    const hasValidContentLength = !!parsedContentLength && !!Number.isFinite(parsedContentLength) && parsedContentLength >= 0;
+    if (hasValidContentLength) {
+      const contentLength = parsedContentLength;
+      if (maxBytes !== void 0 && contentLength > maxBytes) {
+        throw new Error("Value exceeds maximum byte limit");
+      }
+      const out2 = new Uint8Array(contentLength);
+      let offset2 = 0;
+      let completed = false;
+      try {
+        while (offset2 <= out2.length) {
+          const { done, value } = await reader.read();
+          if (done) {
+            completed = true;
+            break;
+          }
+          if (!value || value.length === 0) continue;
+          const nextOffset = offset2 + value.length;
+          if (nextOffset > out2.length) {
+            throw new Error("Received more data than expected");
+          }
+          out2.set(value, offset2);
+          offset2 = nextOffset;
+        }
+      } finally {
+        reader.releaseLock();
+      }
+      if (!completed) {
+        throw new Error("Failed to read complete value from storage bucket");
+      }
+      return offset2 === contentLength ? out2 : out2.slice(0, offset2);
+    }
+    const chunks = [];
+    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 !== void 0 && total > maxBytes) {
+          throw new Error("Value exceeds maximum byte limit");
+        }
+        chunks.push(value.slice());
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    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, authorizationToken) {
+    (0, import_utilities.verifyHTTPSEndpoint)(storageBucketEndpoint);
+    const url = `${storageBucketEndpoint}/export`;
+    let cursor = void 0;
+    while (true) {
+      const response = await (0, import_utilities.fetchWithErrorHandling)(
+        cursor ? `${url}?cursor=${encodeURIComponent(cursor)}` : url,
+        {
+          headers: {
+            Authorization: `Bearer ${authorizationToken}`
+          }
+        }
+      );
+      const blob = await response.blob();
+      const cbor = (0, import_dag_cbor.decode)(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 = (0, import_mini.object)({
+  keys: (0, import_mini.array)((0, import_mini.string)()),
+  cursor: (0, import_mini.optional)((0, import_mini.nullable)((0, import_mini.string)()))
+});
+//# sourceMappingURL=3-storage-buckets.js.map

package/dist/cjs/1-services/3-storage-buckets.js.map

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

package/dist/cjs/1-services/4-inboxes-tests.js

@@ -0,0 +1,145 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var inboxes_tests_exports = {};
+__export(inboxes_tests_exports, {
+  inboxTests: () => inboxTests
+});
+module.exports = __toCommonJS(inboxes_tests_exports);
+var import_vitest = require("vitest");
+var import_inboxes = require("./4-inboxes");
+var import_utilities = require("./utilities");
+var import_utils = require("@noble/hashes/utils.js");
+function inboxTests(inboxEndpoint, inboxToken) {
+  (0, import_vitest.describe)("Inboxes", async () => {
+    const inboxes = new import_inboxes.Inboxes();
+    (0, import_vitest.test)("send, get", async () => {
+      const tags = [(0, import_utils.randomBytes)(), (0, import_utils.randomBytes)()];
+      const metadata = (0, import_utils.randomBytes)();
+      const object = {
+        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);
+      const message = await inboxes.get(inboxEndpoint, messageId, inboxToken);
+      (0, import_vitest.expect)(message.m).toEqual(sending);
+      (0, import_vitest.expect)(message.l).toEqual(0);
+      const iterator = inboxes.query(inboxEndpoint, tags, {}, inboxToken);
+      const result = await iterator.next();
+      (0, import_vitest.assert)(!result.done);
+      (0, import_vitest.expect)(result.value.l).toEqual(0);
+      (0, import_vitest.expect)(result.value.m.t).toEqual(tags);
+      (0, import_vitest.expect)(result.value.m.o).toEqual(object);
+      (0, import_vitest.expect)(result.value.id).toEqual(messageId);
+      const endResult = await iterator.next();
+      (0, import_vitest.expect)(endResult.done).toBe(true);
+      await inboxes.label(inboxEndpoint, messageId, 42, inboxToken);
+      const iterator2 = inboxes.query(inboxEndpoint, tags, {}, inboxToken);
+      const result2 = await iterator2.next();
+      (0, import_vitest.assert)(!result2.done);
+      (0, import_vitest.expect)(result2.value.l).toEqual(42);
+      const endResult2 = await iterator2.next();
+      (0, import_vitest.expect)(endResult2.done).toBe(true);
+      const message2 = await inboxes.get(inboxEndpoint, messageId, inboxToken);
+      (0, import_vitest.expect)(message2.m).toEqual(sending);
+      (0, import_vitest.expect)(message2.l).toEqual(42);
+    });
+    (0, import_vitest.test)("query with continue", async () => {
+      const tags = [(0, import_utils.randomBytes)(), (0, import_utils.randomBytes)()];
+      const nullResult = await inboxes.query(inboxEndpoint, tags, {}, inboxToken).next();
+      (0, import_vitest.assert)(nullResult.done);
+      const cursor = nullResult.value;
+      const metadata = (0, import_utils.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: [(0, import_utils.randomBytes)(), tags[0]],
+        m: metadata
+      });
+      const result = await inboxes.continueQuery(inboxEndpoint, cursor, inboxToken).next();
+      (0, import_vitest.assert)(!result.done);
+      (0, import_vitest.expect)(result.value.id).toEqual(messageId);
+    });
+    (0, import_vitest.test)("unauthorized access", async () => {
+      const tags = [(0, import_utils.randomBytes)()];
+      await (0, import_vitest.expect)(
+        inboxes.query(inboxEndpoint, tags, {}, "invalid-token").next()
+      ).rejects.toThrowError(import_utilities.GraffitiErrorUnauthorized);
+      await (0, import_vitest.expect)(
+        inboxes.label(inboxEndpoint, "1", 1, "invalid-token")
+      ).rejects.toThrowError(import_utilities.GraffitiErrorUnauthorized);
+      await (0, import_vitest.expect)(
+        inboxes.export(inboxEndpoint, "invalid-token").next()
+      ).rejects.toThrowError(import_utilities.GraffitiErrorUnauthorized);
+    }, 3e4);
+    (0, import_vitest.test)("query paged", async () => {
+      const tags = [(0, import_utils.randomBytes)(), (0, import_utils.randomBytes)()];
+      const numSends = 211;
+      for (let i = 0; i < numSends; i++) {
+        await inboxes.send(inboxEndpoint, {
+          t: tags,
+          m: (0, import_utils.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,
+        [(0, import_utils.randomBytes)(), tags[1], (0, import_utils.randomBytes)()],
+        {},
+        inboxToken
+      );
+      let count = 0;
+      for await (const _ of iterator) {
+        count++;
+      }
+      (0, import_vitest.expect)(count).toBe(numSends);
+    }, 1e5);
+  });
+}
+//# sourceMappingURL=4-inboxes-tests.js.map

package/dist/cjs/1-services/4-inboxes-tests.js.map

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