keri-ts 0.11.0 → 2.0.0

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

@@ -1,5 +1,5 @@
-/** Bounded v2 ACDC schema validation against the inspected 71438328 profile; no network resolution. */
-import { Diger, dumps, ParserError, ResourceLimitError } from "cesr-ts";
+/** 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";
 import { Schemer } from "../core/scheming.js";
@@ -39,57 +39,6 @@ const singles = [
 ];
 const maps = ["$defs", "properties", "patternProperties", "dependentSchemas"];
 const arrays = ["prefixItems", "allOf", "anyOf", "oneOf"];
-/** Admission counts values/depth as well as bytes before cloning or compiling; native row allocation remains separate. */
-class Credit {
-    constructor() {
-        Object.defineProperty(this, "bytes", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 8 * 1024 ** 2
-        });
-        Object.defineProperty(this, "values", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 4096
-        });
-        Object.defineProperty(this, "refs", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 4096
-        });
-    }
-    take(schema) {
-        const work = [[schema, 0]];
-        let characters = this.bytes;
-        while (work.length) {
-            const [value, depth] = work.pop();
-            if (--this.values < 0 || depth > 64)
-                throw new ResourceLimitError("ACDC schema value/depth credit exhausted");
-            if (typeof value === "string")
-                characters -= value.length;
-            if (characters < 0)
-                throw new ResourceLimitError("ACDC schema byte credit exhausted");
-            if (value && typeof value === "object") {
-                for (const key in value) {
-                    if (!Object.hasOwn(value, key))
-                        continue;
-                    characters -= key.length;
-                    if (characters < 0)
-                        throw new ResourceLimitError("ACDC schema byte credit exhausted");
-                    if (work.length >= this.values)
-                        throw new ResourceLimitError("ACDC schema value credit exhausted");
-                    work.push([value[key], depth + 1]);
-                }
-            }
-        }
-        this.bytes -= dumps(schema, "JSON").length;
-        if (this.bytes < 0)
-            throw new ResourceLimitError("ACDC schema byte credit exhausted");
-    }
-}
 /** Plain maps and booleans are the only JSON Schema resource/fragment targets. */
 function object(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -102,7 +51,7 @@ function digest(value) {
             return diger;
     }
     catch (error) {
-        if (!(error instanceof ParserError) || error instanceof ResourceLimitError)
+        if (!(error instanceof ParserError))
             throw error;
     }
     throw new InvalidSchema("Schema reference must contain a complete SAID");
@@ -211,66 +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) {
-    if (acdc.raw.length > 8 * 1024 ** 2)
-        throw new ResourceLimitError("ACDC schema input exceeds finite body limit");
-    const credit = new Credit(), 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);
     }
-    /** Admit a complete original resource before charging dependent schemas or cloning it. */
-    function add(schema, root, expected) {
-        if (root)
-            credit.take(schema);
+    /** Verify each original resource before cloning it for compilation. */
+    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;
-        if (resources.size >= 128)
-            throw new ResourceLimitError("ACDC schema resource credit exhausted");
         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", 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)
@@ -278,29 +262,41 @@ export function validateSchema(acdc, db, override) {
                 if (typeof node.$anchor === "string")
                     owner.anchors.set(node.$anchor, node);
                 if ("$ref" in node) {
-                    if (--credit.refs < 0)
-                        throw new ResourceLimitError("ACDC schema reference credit exhausted");
-                    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();
@@ -344,20 +340,22 @@ export function validateSchema(acdc, db, override) {
         }
         catch (error) {
             if (error instanceof SyntaxError && error.message.includes("regular expression")) {
-                return { kind: "invalid", reason: error.message };
+                return { kind: "invalid", subject: "schema", reason: error.message };
             }
             if (error instanceof Error && /^reference "urn:said:[^"]+" resolves to more than one schema$/.test(error.message)) {
-                return { kind: "invalid", reason: error.message };
+                return { kind: "invalid", subject: "schema", reason: error.message };
             }
             throw error;
         }
         if (!validate)
             throw new Error("Admitted schema was not registered");
-        return validate(acdc.sad) ? { kind: "valid" } : { kind: "invalid", reason: validator.errorsText(validate.errors) };
+        return validate(acdc.sad)
+            ? { kind: "valid" }
+            : { kind: "invalid", subject: "credential", reason: validator.errorsText(validate.errors) };
     }
     catch (error) {
         if (error instanceof InvalidSchema)
-            return { kind: "invalid", reason: error.message };
+            return { kind: "invalid", subject: "schema", reason: error.message };
         throw error;
     }
 }