@aithos/sdk 0.1.0-alpha.53 → 0.1.0-alpha.55

package/dist/test/schema-autoresolve.test.js

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright 2026 Mathieu Colla
+// A reader that did NOT bundle a vendor schema can still read a collection that
+// uses it, by auto-resolving the PUBLISHED JSON Schema from the PDS and
+// deriving the field split from its aithos:indexable / aithos:auto annotations.
+// This is what lets the strangler reference app (and any latest-SDK client)
+// read any collection without hardcoding VENDOR_SCHEMAS.
+import { test } from "node:test";
+import { strict as assert } from "node:assert";
+import { randomBytes } from "node:crypto";
+import { createDataClient, liteFromPublishedSchema } from "../src/data.js";
+import * as ed from "@noble/ed25519";
+import { sha512 } from "@noble/hashes/sha2.js";
+ed.etc.sha512Sync = (...m) => sha512(ed.etc.concatBytes(...m));
+const MEMO_ID = "aithos.x.demo.memo.v1";
+const memoLite = {
+    schema: MEMO_ID,
+    indexable: new Set(["title"]),
+    encrypted: new Set(["body"]),
+    auto: new Set(),
+    defaults: {},
+};
+const memoJson = {
+    "aithos:schema": MEMO_ID,
+    "aithos:version": "1.0.0",
+    type: "object",
+    additionalProperties: false,
+    required: ["title"],
+    properties: {
+        title: { type: "string", "aithos:indexable": true },
+        body: { type: "string" },
+    },
+};
+test("liteFromPublishedSchema derives the field split from annotations", () => {
+    const lite = liteFromPublishedSchema(memoJson);
+    assert.equal(lite.schema, MEMO_ID);
+    assert.deepEqual([...lite.indexable].sort(), ["title"]);
+    assert.deepEqual([...lite.encrypted].sort(), ["body"]);
+    assert.equal(lite.auto.size, 0);
+});
+function makePds() {
+    const collections = new Map();
+    const records = new Map();
+    const schemas = new Map();
+    const fetchImpl = (async (_url, init) => {
+        const body = JSON.parse(init.body);
+        const p = body.params ?? {};
+        const ok = (result) => new Response(JSON.stringify({ jsonrpc: "2.0", id: body.id, result }), { status: 200 });
+        const er = (code, m) => new Response(JSON.stringify({ jsonrpc: "2.0", id: body.id, error: { code, message: m } }), { status: 200 });
+        const urn = (did, n) => `urn:aithos:collection:${did}:${n}`;
+        switch (body.method) {
+            case "aithos.data.register_schema":
+                schemas.set(p.schema_doc["aithos:schema"], p.schema_doc);
+                return ok({ schema_id: p.schema_doc["aithos:schema"], doc_hash: "h", created: true });
+            case "aithos.data.get_schema": {
+                const d = schemas.get(p.schema);
+                return d ? ok({ schema: d }) : er(-32070, "unknown schema");
+            }
+            case "aithos.data.create_collection": {
+                const u = urn(p.subject_did, p.collection_name);
+                collections.set(u, { urn: u, name: p.collection_name, schema: p.schema, subject_did: p.subject_did, cmk_envelope: p.cmk_envelope, record_count: 0 });
+                records.set(u, new Map());
+                return ok({ urn: u, name: p.collection_name, schema: p.schema, cmk_envelope: p.cmk_envelope });
+            }
+            case "aithos.data.get_collection": {
+                const c = collections.get(urn(p.subject_did, p.collection_name));
+                return c ? ok({ urn: c.urn, name: c.name, schema: c.schema, cmk_envelope: c.cmk_envelope, record_count: c.record_count }) : er(-32020, "nf");
+            }
+            case "aithos.data.insert_record": {
+                records.get(p.collection_urn).set(p.record_id, { record_id: p.record_id, metadata: p.metadata, payload: p.payload });
+                return ok({ record_id: p.record_id });
+            }
+            case "aithos.data.get_record": {
+                const r = records.get(p.collection_urn)?.get(p.record_id);
+                return r ? ok(r) : er(-32020, "nf");
+            }
+            default:
+                return er(-32601, body.method);
+        }
+    });
+    return { fetchImpl, schemas };
+}
+test("a reader without the bundled vendor lite decodes via the published schema", async () => {
+    const seed = new Uint8Array(randomBytes(32));
+    const pub = ed.getPublicKey(seed);
+    // did:key style (single-key) — fine for the data PDS owner path in this mock.
+    let n = 0n;
+    const mc = new Uint8Array([0xed, 0x01, ...pub]);
+    for (const b of mc)
+        n = (n << 8n) | BigInt(b);
+    const alpha = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    let mb = "";
+    let x = n;
+    while (x > 0n) {
+        mb = alpha[Number(x % 58n)] + mb;
+        x /= 58n;
+    }
+    const did = `did:key:z${mb}`;
+    const vm = `${did}#z${mb}`;
+    const pds = makePds();
+    // Writer: bundles the lite, registers the JSON schema, writes a record.
+    const writer = createDataClient({ pdsUrl: "https://pds.test", did, sphereSeed: seed, verificationMethod: vm, schemas: [memoLite], fetch: pds.fetchImpl });
+    await writer.registerSchema(memoJson);
+    await writer.createCollection({ name: "memos", schema: MEMO_ID });
+    const recId = await writer.collection("memos").insert({ title: "Hello", body: "top secret body" });
+    // Reader: NO bundled schema. Must auto-resolve from the PDS-published schema.
+    const reader = createDataClient({ pdsUrl: "https://pds.test", did, sphereSeed: seed, verificationMethod: vm, fetch: pds.fetchImpl });
+    const got = await reader.collection("memos").get(recId);
+    assert.equal(got.title, "Hello", "indexable field present");
+    assert.equal(got.body, "top secret body", "encrypted field decoded via auto-resolved schema");
+});
+test("a reader still fails cleanly when the schema is neither bundled nor published", async () => {
+    const seed = new Uint8Array(randomBytes(32));
+    const pub = ed.getPublicKey(seed);
+    let n = 0n;
+    const mc = new Uint8Array([0xed, 0x01, ...pub]);
+    for (const b of mc)
+        n = (n << 8n) | BigInt(b);
+    const alpha = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    let mb = "";
+    let x = n;
+    while (x > 0n) {
+        mb = alpha[Number(x % 58n)] + mb;
+        x /= 58n;
+    }
+    const did = `did:key:z${mb}`;
+    const vm = `${did}#z${mb}`;
+    const pds = makePds();
+    // Writer creates the collection WITHOUT registering the schema on the PDS.
+    const writer = createDataClient({ pdsUrl: "https://pds.test", did, sphereSeed: seed, verificationMethod: vm, schemas: [memoLite], fetch: pds.fetchImpl });
+    await writer.createCollection({ name: "memos", schema: MEMO_ID });
+    await writer.collection("memos").insert({ title: "x", body: "y" });
+    const reader = createDataClient({ pdsUrl: "https://pds.test", did, sphereSeed: seed, verificationMethod: vm, fetch: pds.fetchImpl });
+    await assert.rejects(() => reader.collection("memos").get("anything"), /not known to the SDK and not published/);
+});
+//# sourceMappingURL=schema-autoresolve.test.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aithos/sdk",
-  "version": "0.1.0-alpha.53",
+  "version": "0.1.0-alpha.55",
   "description": "Aithos SDK — high-level TypeScript developer kit for building agentic apps on the Aithos protocol. Wraps @aithos/protocol-client and exposes the Aithos compute proxy and wallet (Stripe top-up) endpoints.",
   "keywords": [
     "aithos",