@noeos/verification-engine 0.0.0

package/dist/cjs/rules/rule-set.js

@@ -0,0 +1,211 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleSet = void 0;
+exports.createReadonlyByteView = createReadonlyByteView;
+const operation_result_js_1 = require("../domain/operation-result.js");
+const diagnostic_collector_js_1 = require("../validation/diagnostic-collector.js");
+const object_inspection_js_1 = require("../validation/object-inspection.js");
+const version_validation_js_1 = require("../validation/version-validation.js");
+const ruleIdPattern = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/u;
+const EMPTY_DIAGNOSTICS = Object.freeze([]);
+class RuleSet {
+    rules;
+    constructor(rules) {
+        this.rules = rules;
+        Object.freeze(this);
+    }
+    static create(value, limits) {
+        if (value === undefined)
+            return (0, operation_result_js_1.success)(new RuleSet(Object.freeze([])));
+        if (!Array.isArray(value))
+            return ruleFailure("RULE_VERSION_CONFLICT", limits);
+        const rules = [];
+        const keys = new Set();
+        for (const candidate of value) {
+            const validated = validateRule(candidate, limits);
+            if (!validated.ok)
+                return validated;
+            const key = `${validated.value.id}\u0000${validated.value.version}`;
+            if (keys.has(key))
+                return ruleFailure("RULE_VERSION_CONFLICT", limits);
+            keys.add(key);
+            rules.push(validated.value);
+        }
+        rules.sort((left, right) => compareText(left.id, right.id) || compareText(left.version, right.version));
+        return (0, operation_result_js_1.success)(new RuleSet(Object.freeze(rules)));
+    }
+    evaluate(context, limits) {
+        if (this.rules.length === 0)
+            return EMPTY_DIAGNOSTICS;
+        const collector = new diagnostic_collector_js_1.DiagnosticCollector(limits);
+        for (const rule of this.rules) {
+            if (!rule.phases.includes(context.phase))
+                continue;
+            try {
+                const findings = rule.evaluate(context);
+                if (!Array.isArray(findings)) {
+                    collector.addCode("RULE_EXECUTION_FAILED", context.phase, failureOptions(context, "RULE_RESULT_INVALID"));
+                    continue;
+                }
+                for (const finding of findings) {
+                    const diagnostic = toDiagnostic(rule, finding, context);
+                    if (diagnostic === undefined) {
+                        collector.addCode("RULE_EXECUTION_FAILED", context.phase, failureOptions(context, "RULE_RESULT_INVALID"));
+                    }
+                    else {
+                        collector.add(diagnostic);
+                    }
+                }
+            }
+            catch {
+                collector.addCode("RULE_EXECUTION_FAILED", context.phase, failureOptions(context, "RULE_EVALUATION_FAILED"));
+            }
+        }
+        return collector.finish();
+    }
+    hasRules() {
+        return this.rules.length !== 0;
+    }
+    toArray() {
+        return this.rules;
+    }
+}
+exports.RuleSet = RuleSet;
+function createReadonlyByteView(bytes) {
+    const copy = Uint8Array.from(bytes);
+    return Object.freeze({
+        byteLength: copy.length,
+        copySlice(start, end) {
+            return Uint8Array.from(copy.slice(start, end));
+        },
+    });
+}
+function validateRule(value, limits) {
+    const entries = (0, object_inspection_js_1.inspectPlainObject)(value);
+    if (entries === undefined)
+        return ruleFailure("RULE_VERSION_CONFLICT", limits);
+    const fields = new Map(entries);
+    if (fields.size !== 5 ||
+        !fields.has("id") ||
+        !fields.has("version") ||
+        !fields.has("phases") ||
+        !fields.has("defaultSeverity") ||
+        !fields.has("evaluate")) {
+        return ruleFailure("RULE_VERSION_CONFLICT", limits);
+    }
+    const id = fields.get("id");
+    const version = fields.get("version");
+    const phases = fields.get("phases");
+    const defaultSeverity = fields.get("defaultSeverity");
+    const evaluate = fields.get("evaluate");
+    if (typeof id !== "string" || !ruleIdPattern.test(id) || id.length > 128) {
+        return ruleFailure("RULE_VERSION_CONFLICT", limits);
+    }
+    const validatedVersion = (0, version_validation_js_1.validateProfileVersion)(version);
+    if (!validatedVersion.ok || !Array.isArray(phases) || typeof evaluate !== "function") {
+        return ruleFailure("RULE_VERSION_CONFLICT", limits);
+    }
+    if (defaultSeverity !== "error" && defaultSeverity !== "warning" && defaultSeverity !== "info") {
+        return ruleFailure("RULE_VERSION_CONFLICT", limits);
+    }
+    const normalizedPhases = [];
+    for (const phase of phases) {
+        if (!isRulePhase(phase) || normalizedPhases.includes(phase)) {
+            return ruleFailure("RULE_VERSION_CONFLICT", limits);
+        }
+        normalizedPhases.push(phase);
+    }
+    if (normalizedPhases.length === 0)
+        return ruleFailure("RULE_VERSION_CONFLICT", limits);
+    return (0, operation_result_js_1.success)(Object.freeze({
+        id,
+        version: validatedVersion.value.value,
+        phases: Object.freeze([...normalizedPhases]),
+        defaultSeverity,
+        evaluate(context) {
+            return Reflect.apply(evaluate, undefined, [context]);
+        },
+    }));
+}
+function toDiagnostic(rule, value, context) {
+    const entries = (0, object_inspection_js_1.inspectPlainObject)(value);
+    if (entries === undefined)
+        return undefined;
+    const fields = new Map(entries);
+    for (const key of fields.keys()) {
+        if (key !== "messageKey" && key !== "path" && key !== "details" && key !== "severity")
+            return undefined;
+    }
+    const messageKey = fields.get("messageKey");
+    const path = fields.get("path");
+    const details = fields.get("details");
+    const severity = fields.get("severity");
+    if (typeof messageKey !== "string")
+        return undefined;
+    if (path !== undefined && typeof path !== "string")
+        return undefined;
+    if (severity !== undefined &&
+        severity !== "error" &&
+        severity !== "warning" &&
+        severity !== "info") {
+        return undefined;
+    }
+    const ruleDetails = {
+        "rule-id": rule.id,
+        "rule-version": rule.version,
+    };
+    if (details !== undefined) {
+        const detailEntries = (0, object_inspection_js_1.inspectPlainObject)(details);
+        if (detailEntries === undefined)
+            return undefined;
+        for (const [key, item] of detailEntries) {
+            if (key === "rule-id" || key === "rule-version")
+                return undefined;
+            if (item !== null &&
+                typeof item !== "string" &&
+                typeof item !== "number" &&
+                typeof item !== "boolean") {
+                return undefined;
+            }
+            ruleDetails[key] = item;
+        }
+    }
+    return (0, diagnostic_collector_js_1.createDiagnostic)("RULE_FAILED", context.phase, {
+        messageKey,
+        details: ruleDetails,
+        severity: severity ?? rule.defaultSeverity,
+        ...optionalDiagnosticFields(context, path),
+    });
+}
+function isRulePhase(value) {
+    return (value === "input" ||
+        value === "normalization" ||
+        value === "record" ||
+        value === "link" ||
+        value === "chain");
+}
+function ruleFailure(code, limits) {
+    void limits;
+    return (0, operation_result_js_1.failure)([(0, diagnostic_collector_js_1.createDiagnostic)(code, "input")]);
+}
+function failureOptions(context, causeCode) {
+    return {
+        causeCode,
+        ...optionalDiagnosticFields(context),
+    };
+}
+function optionalDiagnosticFields(context, path) {
+    return {
+        ...(path === undefined ? {} : { path }),
+        ...(context.recordId === undefined ? {} : { recordId: context.recordId }),
+        ...(context.position === undefined ? {} : { position: context.position }),
+    };
+}
+function compareText(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}

package/dist/cjs/schemas.js

@@ -0,0 +1,6 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCHEMA_ASSETS = void 0;
+var schema_assets_js_1 = require("./contracts/schema-assets.js");
+Object.defineProperty(exports, "SCHEMA_ASSETS", { enumerable: true, get: function () { return schema_assets_js_1.SCHEMA_ASSETS; } });

package/dist/cjs/validation/algorithm-validation.js

@@ -0,0 +1,12 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAlgorithmId = validateAlgorithmId;
+const operation_result_js_1 = require("../domain/operation-result.js");
+const result_helpers_js_1 = require("./result-helpers.js");
+function validateAlgorithmId(value) {
+    if (value === "sha-256" || value === "sha-384" || value === "sha-512") {
+        return (0, operation_result_js_1.success)(value);
+    }
+    return (0, result_helpers_js_1.failureWithCode)("ALGORITHM_UNKNOWN", "input");
+}

package/dist/cjs/validation/diagnostic-collector.js

@@ -0,0 +1,159 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiagnosticCollector = void 0;
+exports.createDiagnostic = createDiagnostic;
+const generated_js_1 = require("../contracts/generated.js");
+const diagnostic_js_1 = require("../domain/diagnostic.js");
+const object_inspection_js_1 = require("./object-inspection.js");
+function createDiagnostic(code, phase, options = {}) {
+    const metadata = generated_js_1.DIAGNOSTIC_CODES.find((entry) => entry.code === code);
+    if (metadata === undefined) {
+        throw new Error(`Unknown generated diagnostic code: ${code}`);
+    }
+    const details = options.details === undefined ? undefined : tryCopyDetails(options.details);
+    const path = safePath(options.path);
+    const recordId = safeString(options.recordId, /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/u, 128);
+    const causeCode = safeString(options.causeCode, /^[A-Z][A-Z0-9_]{1,127}$/u, 128);
+    const position = safePosition(options.position);
+    const diagnostic = {
+        $schema: diagnostic_js_1.DIAGNOSTIC_SCHEMA,
+        code,
+        severity: code === "RULE_FAILED" && options.severity !== undefined
+            ? options.severity
+            : metadata.severity,
+        phase,
+        messageKey: safeString(options.messageKey, /^[a-z][a-z0-9.-]{0,127}$/u, 128) ??
+            code.toLowerCase().replaceAll("_", "."),
+        ...(path === undefined ? {} : { path }),
+        ...(recordId === undefined ? {} : { recordId }),
+        ...(position === undefined ? {} : { position }),
+        ...(details === undefined ? {} : { details }),
+        ...(causeCode === undefined ? {} : { causeCode }),
+    };
+    return Object.freeze(diagnostic);
+}
+function tryCopyDetails(value) {
+    try {
+        return copyDetails(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function safeString(value, pattern, maxLength) {
+    return typeof value === "string" && value.length <= maxLength && pattern.test(value)
+        ? value
+        : undefined;
+}
+function safePath(value) {
+    if (typeof value !== "string" || value.length > 512) {
+        return undefined;
+    }
+    if (value === "" || /^[a-z][a-z0-9.-]{0,127}$/u.test(value)) {
+        return value;
+    }
+    if (!value.startsWith("/")) {
+        return undefined;
+    }
+    const segments = value.split("/");
+    return segments.slice(1).every(isJsonPointerSegment) ? value : undefined;
+}
+function isJsonPointerSegment(segment) {
+    if (segment.length === 0) {
+        return false;
+    }
+    for (let index = 0; index < segment.length; index += 1) {
+        const character = segment[index];
+        if (character === "~") {
+            const escape = segment[index + 1];
+            if (escape !== "0" && escape !== "1") {
+                return false;
+            }
+            index += 1;
+            continue;
+        }
+        if (character === undefined || !/[A-Za-z0-9._~-]/u.test(character)) {
+            return false;
+        }
+    }
+    return true;
+}
+function safePosition(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+function copyDetails(value) {
+    const keys = Object.keys(value);
+    if (Object.getOwnPropertySymbols(value).length !== 0 || keys.length > 32) {
+        throw new Error("invalid diagnostic details");
+    }
+    const output = {};
+    for (const key of keys) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!/^[a-z][a-z0-9.-]{0,63}$/u.test(key) ||
+            descriptor === undefined ||
+            !(0, object_inspection_js_1.isDataPropertyDescriptor)(descriptor)) {
+            throw new Error("invalid diagnostic details");
+        }
+        const detail = descriptor.value;
+        if (detail !== null &&
+            typeof detail !== "boolean" &&
+            (typeof detail !== "number" || !Number.isFinite(detail)) &&
+            (typeof detail !== "string" || detail.length > 256)) {
+            throw new Error("invalid diagnostic details");
+        }
+        Object.defineProperty(output, key, {
+            configurable: false,
+            enumerable: true,
+            value: detail,
+            writable: false,
+        });
+    }
+    return Object.freeze(output);
+}
+class DiagnosticCollector {
+    limits;
+    entries = [];
+    truncated = false;
+    constructor(limits) {
+        this.limits = limits;
+    }
+    add(diagnostic) {
+        if (this.entries.length < this.limits.maxDiagnostics) {
+            this.entries.push(diagnostic);
+            return;
+        }
+        if (!this.truncated) {
+            this.truncated = true;
+            this.entries[this.entries.length - 1] = createDiagnostic("DIAGNOSTIC_LIMIT_REACHED", "output");
+        }
+    }
+    addCode(code, phase, options) {
+        this.add(createDiagnostic(code, phase, options));
+    }
+    hasErrors() {
+        return this.entries.some(({ severity }) => severity === "error");
+    }
+    finish() {
+        if (this.entries.length === 0)
+            return Object.freeze([]);
+        const sorted = [...this.entries].sort(compareDiagnostics);
+        return Object.freeze(sorted);
+    }
+}
+exports.DiagnosticCollector = DiagnosticCollector;
+function compareDiagnostics(left, right) {
+    const leftPosition = left.position ?? Number.MAX_SAFE_INTEGER;
+    const rightPosition = right.position ?? Number.MAX_SAFE_INTEGER;
+    return (leftPosition - rightPosition ||
+        compareText(left.phase, right.phase) ||
+        compareText(left.code, right.code) ||
+        compareText(left.path ?? "", right.path ?? ""));
+}
+function compareText(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}

package/dist/cjs/validation/digest-validation.js

@@ -0,0 +1,48 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.digestLength = digestLength;
+exports.validateDigest = validateDigest;
+exports.equalDigest = equalDigest;
+const digest_js_1 = require("../domain/digest.js");
+const operation_result_js_1 = require("../domain/operation-result.js");
+const result_helpers_js_1 = require("./result-helpers.js");
+const algorithm_validation_js_1 = require("./algorithm-validation.js");
+const digestLengths = Object.freeze({
+    "sha-256": 32,
+    "sha-384": 48,
+    "sha-512": 64,
+});
+function digestLength(algorithm) {
+    return digestLengths[algorithm];
+}
+function validateDigest(value, algorithm) {
+    const algorithmResult = (0, algorithm_validation_js_1.validateAlgorithmId)(algorithm);
+    if (!algorithmResult.ok)
+        return algorithmResult;
+    if (typeof value !== "string" || !/^(?:[0-9a-f]{2})+$/u.test(value)) {
+        return (0, result_helpers_js_1.failureWithCode)("DIGEST_ENCODING_INVALID", "input");
+    }
+    const expectedLength = digestLength(algorithmResult.value) * 2;
+    if (value.length !== expectedLength) {
+        return (0, result_helpers_js_1.failureWithCode)("DIGEST_LENGTH_INVALID", "input");
+    }
+    const bytes = new Uint8Array(expectedLength / 2);
+    for (let index = 0; index < bytes.length; index += 1) {
+        bytes[index] = Number.parseInt(value.slice(index * 2, index * 2 + 2), 16);
+    }
+    return (0, operation_result_js_1.success)(digest_js_1.Digest.fromValidated(algorithmResult.value, bytes));
+}
+function equalDigest(left, right) {
+    if (left.algorithm !== right.algorithm)
+        return false;
+    const leftBytes = left.toBytes();
+    const rightBytes = right.toBytes();
+    const leftView = new DataView(leftBytes.buffer, leftBytes.byteOffset, leftBytes.byteLength);
+    const rightView = new DataView(rightBytes.buffer, rightBytes.byteOffset, rightBytes.byteLength);
+    let difference = 0;
+    for (let index = 0; index < leftBytes.length; index += 1) {
+        difference |= leftView.getUint8(index) ^ rightView.getUint8(index);
+    }
+    return difference === 0;
+}

package/dist/cjs/validation/identifier-validation.js

@@ -0,0 +1,33 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRecordId = validateRecordId;
+exports.validateSequenceId = validateSequenceId;
+exports.validateContextId = validateContextId;
+exports.validateProfileId = validateProfileId;
+const identifiers_js_1 = require("../domain/identifiers.js");
+const operation_result_js_1 = require("../domain/operation-result.js");
+const result_helpers_js_1 = require("./result-helpers.js");
+const identifierPattern = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/u;
+const profilePattern = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/u;
+function validateRecordId(value) {
+    return validateIdentifier(value, (input) => identifiers_js_1.RecordId.fromValidated(input));
+}
+function validateSequenceId(value) {
+    return validateIdentifier(value, (input) => identifiers_js_1.SequenceId.fromValidated(input));
+}
+function validateContextId(value) {
+    return validateIdentifier(value, (input) => identifiers_js_1.ContextId.fromValidated(input));
+}
+function validateProfileId(value) {
+    if (typeof value !== "string" || !profilePattern.test(value) || value.length > 128) {
+        return (0, result_helpers_js_1.failureWithCode)("IDENTIFIER_INVALID", "input");
+    }
+    return (0, operation_result_js_1.success)(identifiers_js_1.ProfileId.fromValidated(value));
+}
+function validateIdentifier(value, create) {
+    if (typeof value !== "string" || !identifierPattern.test(value) || value.length > 128) {
+        return (0, result_helpers_js_1.failureWithCode)("IDENTIFIER_INVALID", "input");
+    }
+    return (0, operation_result_js_1.success)(create(value));
+}