keri-ts 0.10.0 → 0.10.2

package/esm/keri/npm/src/core/scheming.js

@@ -0,0 +1,162 @@
+/**
+ * JSON Schema SAD support for schema data OOBIs.
+ *
+ * KERIpy correspondence:
+ * - ports the operational subset of `keri.core.scheming.Schemer`
+ * - schema `$id` is the self-addressing field and must verify as a SAID
+ * - raw schema bytes remain the stored value in `schema.`
+ */
+import { DigDex, dumps, Saider } from "cesr-ts";
+import Ajv from "ajv";
+import Ajv2020 from "ajv/dist/2020.js";
+import { ValidationError } from "./errors.js";
+/**
+ * Verified JSON schema SAD wrapper.
+ *
+ * Responsibilities:
+ * - keep the exact raw bytes fetched or imported
+ * - parse the schema JSON into `sed`
+ * - verify `$id` as the schema SAID
+ * - validate the declared JSON Schema dialect
+ */
+export class Schemer {
+    constructor(init) {
+        Object.defineProperty(this, "raw", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "kind", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "saider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const { raw, sed, kind = "JSON", code = DigDex.Blake3_256, verify = true, } = init;
+        if (raw !== undefined) {
+            const bytes = typeof raw === "string" ? new TextEncoder().encode(raw) : raw;
+            const parsed = parseSchemaJson(bytes);
+            this.raw = new Uint8Array(bytes);
+            this.sed = parsed;
+            this.kind = kind;
+            this.saider = verifySchemaSaid(parsed, kind);
+        }
+        else if (sed !== undefined) {
+            const saidified = Saider.saidifyFields({ ...sed, $id: sed.$id ?? "" }, {
+                kind,
+                saids: { $id: code },
+            });
+            this.raw = saidified.raw;
+            this.sed = saidified.sad;
+            this.kind = kind;
+            const saider = saidified.saiders.$id;
+            if (!saider) {
+                throw new ValidationError("Unable to compute schema SAID.");
+            }
+            this.saider = saider;
+        }
+        else {
+            throw new ValidationError("Schemer requires raw bytes or schema data.");
+        }
+        if (verify && !isValidJsonSchema(this.sed)) {
+            throw new ValidationError("Invalid JSON Schema document.");
+        }
+    }
+    /** Schema SAID encoded in `$id`. */
+    get said() {
+        return this.saider.qb64;
+    }
+    /** Pretty-print the parsed schema for diagnostics. */
+    pretty(size = 1024) {
+        return JSON.stringify(this.sed, null, 1).slice(0, size);
+    }
+    /** Validate one credential body against this schema. */
+    verify(raw) {
+        const data = parseSchemaData(raw);
+        const validator = schemaValidatorFor(this.sed);
+        const validate = validator.compile(this.sed);
+        if (!validate(data)) {
+            throw new ValidationError(`Credential failed schema validation: ${validator.errorsText(validate.errors)}`);
+        }
+        return true;
+    }
+    /** Detect likely JSON Schema bytes using KERIpy's `$schema` heuristic. */
+    static detect(raw) {
+        return new TextDecoder().decode(raw).includes("\"$schema\"");
+    }
+}
+function parseSchemaJson(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(new TextDecoder().decode(raw));
+    }
+    catch (error) {
+        throw new ValidationError(`Error deserializing JSON schema: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!isJsonObject(parsed)) {
+        throw new ValidationError("JSON schema must be an object.");
+    }
+    return parsed;
+}
+function parseSchemaData(raw) {
+    if (raw instanceof Uint8Array) {
+        return JSON.parse(new TextDecoder().decode(raw));
+    }
+    if (typeof raw === "string") {
+        return JSON.parse(raw);
+    }
+    return raw;
+}
+function verifySchemaSaid(sed, kind) {
+    const id = sed.$id;
+    if (typeof id !== "string" || id.length === 0) {
+        throw new ValidationError("Missing schema $id SAID.");
+    }
+    const saider = new Saider({ qb64: id });
+    const actual = Saider.saidifyFields({ ...sed }, {
+        kind,
+        saids: { $id: saider.code },
+    });
+    const actualSaid = actual.saiders.$id?.qb64;
+    if (actualSaid !== id) {
+        throw new ValidationError(`Invalid schema $id SAID ${id}; expected ${actualSaid ?? "<unknown>"}.`);
+    }
+    return saider;
+}
+function isValidJsonSchema(schema) {
+    try {
+        return schemaValidatorFor(schema).validateSchema(schema);
+    }
+    catch {
+        return false;
+    }
+}
+function schemaValidatorFor(schema) {
+    const dialect = typeof schema.$schema === "string" ? schema.$schema : "";
+    if (dialect.includes("2020-12")) {
+        const Ctor = Ajv2020;
+        return new Ctor({ strict: false });
+    }
+    const Ctor = Ajv;
+    return new Ctor({ strict: false });
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Serialize one parsed schema through KERIpy-compatible JSON dumps. */
+export function dumpSchema(sed) {
+    return dumps(sed, "JSON");
+}