keri-ts 1.0.0 → 2.0.1

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

@@ -1,4 +1,4 @@
-/** Local v2 ACDC schema validation against the inspected 71438328 profile; no network resolution. */
+/** Authenticated local ACDC schema validation and static resource lookups; no network resolution. */
 import { Diger, dumps, ParserError } from "cesr-ts";
 import Ajv2020 from "ajv/dist/2020.js";
 import { ValidationError } from "../core/errors.js";
@@ -160,60 +160,101 @@ function fragment(resource, value) {
     }
     return target;
 }
-/** Local static schema closure plus a synchronous Draft 2020-12 validator; legacy Schemer behavior is unchanged. */
-export function validateSchema(acdc, db, override) {
-    const resources = new Map(), roots = [];
-    const scopes = new Map(), refs = [];
-    const work = [];
-    let missing = null;
+/** Authenticate one local static resource graph before ordinary schema validation. */
+class SchemaResources {
+    constructor(db) {
+        Object.defineProperty(this, "db", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: db
+        });
+        Object.defineProperty(this, "resources", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "roots", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "scopes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "refs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "work", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "missing", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
     /** Cache reads remain outside input-validation catches and retain their infrastructure failures. */
-    function load(said) {
-        const existing = resources.get(said);
+    load(said) {
+        const existing = this.resources.get(said);
         if (existing)
             return existing;
-        const cached = db.schema.get(said);
+        const cached = this.db.schema.get(said);
         if (!cached) {
-            missing = said;
+            this.missing = said;
             return null;
         }
         if (!(cached instanceof Schemer) || cached.kind !== "JSON") {
             throw new InvalidSchema("Unsupported non-JSON schema encoding");
         }
-        return add(cached.sed, true, said);
+        return this.add(cached.sed, true, said);
     }
     /** Verify each original resource before cloning it for compilation. */
-    function add(schema, root, expected) {
+    add(schema, root, expected) {
         const said = identity(schema, root);
         if (expected && said !== expected)
             throw new InvalidSchema("Cached schema does not match its lookup SAID");
-        const existing = resources.get(said);
+        const existing = this.resources.get(said);
         if (existing)
             return existing;
         const resource = { said, schema, anchors: new Map() };
-        resources.set(said, resource);
+        this.resources.set(said, resource);
         if (root)
-            roots.push(schema);
-        work.push({ schema, resource });
+            this.roots.push(schema);
+        this.work.push({ schema, resource });
         return resource;
     }
-    try {
-        const source = override ?? acdc.schema;
-        const root = object(source) ? add(source, true) : typeof source === "string" ? load(digest(source).qb64) : null;
-        if (!root) {
-            return missing
-                ? { kind: "missing", said: missing }
-                : { kind: "invalid", subject: "schema", reason: "Invalid ACDC schema field" };
-        }
+    /** Discover all original resources and static references before any private schema use. */
+    admit(source) {
+        const root = object(source)
+            ? this.add(source, true)
+            : typeof source === "string"
+                ? this.load(digest(source).qb64)
+                : null;
+        if (!root)
+            return null;
         for (;;) {
-            while (work.length) {
-                const item = work.pop();
-                if (typeof item.schema === "boolean" || scopes.has(item.schema))
+            while (this.work.length) {
+                const item = this.work.pop();
+                if (typeof item.schema === "boolean" || this.scopes.has(item.schema))
                     continue;
                 const node = item.schema;
                 let owner = item.resource;
                 if (node !== owner.schema && "$id" in node)
-                    owner = add(node, false);
-                scopes.set(node, owner);
+                    owner = this.add(node, false);
+                this.scopes.set(node, owner);
                 if (dynamic.some((key) => key in node))
                     throw new InvalidSchema("Dynamic schema references are prohibited");
                 if ("$schema" in node && node.$schema !== dialect)
@@ -221,27 +262,41 @@ export function validateSchema(acdc, db, override) {
                 if (typeof node.$anchor === "string")
                     owner.anchors.set(node.$anchor, node);
                 if ("$ref" in node) {
-                    refs.push({ node, resource: owner, value: node.$ref });
+                    this.refs.push({ resource: owner, value: node.$ref });
                 }
                 for (const child of children(node))
-                    work.push({ schema: child, resource: owner });
+                    this.work.push({ schema: child, resource: owner });
             }
             // Finish discovering bundled resources before cache lookup, including fragment targets in annotations.
-            for (const entry of refs) {
+            for (const entry of this.refs) {
                 const parsed = reference(entry.value);
-                const owner = parsed.said ? load(parsed.said) : entry.resource;
+                const owner = parsed.said ? this.load(parsed.said) : entry.resource;
                 if (!owner)
-                    return { kind: "missing", said: missing };
+                    return null;
                 // A just-loaded external resource must discover its anchors before fragment resolution.
-                if (!scopes.has(owner.schema))
+                if (!this.scopes.has(owner.schema))
                     continue;
                 const target = fragment(owner, parsed.fragment);
-                if (object(target) && !scopes.has(target))
-                    work.push({ schema: target, resource: owner });
+                if (object(target) && !this.scopes.has(target))
+                    this.work.push({ schema: target, resource: owner });
             }
-            if (!work.length)
+            if (!this.work.length)
                 break;
         }
+        return root;
+    }
+}
+/** Local static schema closure plus a synchronous Draft 2020-12 validator; legacy Schemer behavior is unchanged. */
+export function validateSchema(acdc, db, override) {
+    const resources = new SchemaResources(db);
+    try {
+        const root = resources.admit(override ?? acdc.schema);
+        if (!root) {
+            return resources.missing
+                ? { kind: "missing", said: resources.missing }
+                : { kind: "invalid", subject: "schema", reason: "Invalid ACDC schema field" };
+        }
+        const { roots, scopes } = resources;
         // Compile only admitted private copies. Canonical local URNs remove URI-alias ambiguity without changing stored IDs.
         const uri = (said) => `urn:said:${said}`;
         const registered = new Set();