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

package/dist/src/data.js

@@ -419,16 +419,14 @@ class DataClientImpl {
                     schema = liteFromPublishedSchema(published);
             }
             catch {
-                // network / not-found — surface the friendly error below
+                // network / not-found — leave `schema` undefined (reads still work)
             }
         }
-        if (!schema) {
-            throw new Error(`sdk.data: schema "${meta.schema}" not known to the SDK and not published ` +
-                `on the PDS for ${this.#did}. Pass it via createDataClient({ schemas: [...] }) ` +
-                `if it's an app-defined (vendor) schema, register it via registerSchema, ` +
-                `or upgrade the SDK if it's a core schema added in a later release.`);
-        }
-        const state = { name, urn: meta.urn, schema };
+        // Do NOT throw when the schema is unknown: reads decrypt from the CMK +
+        // metadata/payload alone (the schema is only needed to SPLIT on write).
+        // Leaving `schema` undefined keeps the collection fully readable; an
+        // insert/update will surface a precise "schema required to write" error.
+        const state = { name, urn: meta.urn, ...(schema ? { schema } : {}), schemaId: meta.schema };
         this.#colCache.set(name, state);
         return state;
     }
@@ -437,7 +435,7 @@ class DataClientImpl {
         const cmk = this.#cmkCache.get(state.name);
         if (!cmk)
             throw new Error("CMK not loaded");
-        const { metadata, payload } = splitRecord(record, state.schema);
+        const { metadata, payload } = splitRecord(record, requireSchema(state));
         const recordId = `record_${makeUlid()}`;
         const encrypted = this.#encryptPayload({
             collectionName: state.name,
@@ -506,7 +504,7 @@ class DataClientImpl {
         const cmk = this.#cmkCache.get(state.name);
         if (!cmk)
             throw new Error("CMK not loaded");
-        const { metadata, payload } = splitRecord(record, state.schema);
+        const { metadata, payload } = splitRecord(record, requireSchema(state));
         const encrypted = this.#encryptPayload({
             collectionName: state.name,
             recordId,
@@ -757,7 +755,7 @@ class DataClientImpl {
         if (!this.#deposit) {
             throw new Error("sdk.data: _insertDeposit called without a deposit session");
         }
-        const { metadata, payload } = splitRecord(record, state.schema);
+        const { metadata, payload } = splitRecord(record, requireSchema(state));
         const recordId = `record_${makeUlid()}`;
         const encrypted = this.#encryptPayloadForOwner({
             collectionName: state.name,
@@ -777,7 +775,7 @@ class DataClientImpl {
     /** Build a local collection state for the deposit path (no server fetch:
      * append clients are not authorized to read collection metadata). */
     _depositCollectionState(name, schema) {
-        return { name, urn: this.#collectionUrn(name), schema };
+        return { name, urn: this.#collectionUrn(name), schema, schemaId: schema.schema };
     }
 }
 class DataCollectionImpl {
@@ -848,6 +846,21 @@ export function liteFromPublishedSchema(doc) {
         defaults: {},
     };
 }
+/**
+ * Return the collection's write schema or throw a precise error. Writes need
+ * the schema to split a record into indexable metadata vs encrypted payload (and
+ * so the PDS can validate); reads never call this.
+ */
+function requireSchema(state) {
+    if (!state.schema) {
+        const e = new Error(`sdk.data: writing to "${state.name}" needs its schema "${state.schemaId}", which is ` +
+            `neither bundled in this client (createDataClient({ schemas: [...] })) nor published on ` +
+            `the PDS (registerSchema). Reads work without it — only inserts/updates require it.`);
+        e.code = -32602;
+        throw e;
+    }
+    return state.schema;
+}
 function splitRecord(record, schema) {
     const metadata = {};
     const payload = {};

package/dist/src/index.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "0.1.0-alpha.55";
+export declare const VERSION = "0.1.0-alpha.56";
 export { AithosSDK } from "./sdk.js";
 export type { AithosSDKConfig } from "./types.js";
 export { AithosSDKError } from "./types.js";

package/dist/src/index.js

@@ -17,7 +17,7 @@
 // Public types specific to the SDK (`AithosSDKConfig`, `AithosSDKError`)
 // are exported from here. Endpoint config (`AithosSdkEndpoints`,
 // `DEFAULT_SDK_ENDPOINTS`) likewise.
-export const VERSION = "0.1.0-alpha.55";
+export const VERSION = "0.1.0-alpha.56";
 export { AithosSDK } from "./sdk.js";
 export { AithosSDKError } from "./types.js";
 // Re-export protocol-client's JSON-RPC error type so consumers can

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

@@ -109,7 +109,7 @@ test("a reader without the bundled vendor lite decodes via the published schema"
     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 () => {
+test("schema-less READ still works (decrypts); only WRITE requires the schema", async () => {
     const seed = new Uint8Array(randomBytes(32));
     const pub = ed.getPublicKey(seed);
     let n = 0n;
@@ -126,11 +126,21 @@ test("a reader still fails cleanly when the schema is neither bundled nor publis
     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.
+    // Writer bundles the lite, creates the collection + a record, but does NOT
+    // register the schema on the PDS (simulates an app like delie that keeps its
+    // schema local). So no client can auto-resolve it.
     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 recId = await writer.collection("memos").insert({ title: "Hi", body: "encrypted secret" });
+    // Reader has NEITHER the bundled lite NOR a published schema to fetch.
     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/);
+    // READ still works — records decrypt from the CMK + metadata/payload; the
+    // schema is only needed to SPLIT on write. This is what makes a migrated
+    // collection directly usable under #data by any client.
+    const got = await reader.collection("memos").get(recId);
+    assert.equal(got.title, "Hi", "indexable field (plaintext metadata) present");
+    assert.equal(got.body, "encrypted secret", "encrypted field decrypted WITHOUT the schema");
+    // WRITE fails cleanly (can't split/validate without the schema).
+    await assert.rejects(() => reader.collection("memos").insert({ title: "no", body: "go" }), /needs its schema/);
 });
 //# sourceMappingURL=schema-autoresolve.test.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aithos/sdk",
-  "version": "0.1.0-alpha.55",
+  "version": "0.1.0-alpha.56",
   "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",