@lakutata/core 1.0.60 → 3.0.0-beta.1

package/dist/esm/lib/validation/engine/json-schema/parsers/open-api-3.1.js

@@ -0,0 +1,34 @@
+/**
+ * Derived from the upstream lib/parsers/open-api-3.1.js (see UPSTREAM.md; MIT, see THIRD_PARTY_NOTICES.md)
+ */
+import * as _ from '../helpers.js';
+import { JsonDraft202012SchemaParser } from './json-2020-12.js';
+import { openApiNumberFormat } from './open-api.js';
+/**
+ * Converts schema descriptions into OpenAPI 3.1 schema objects
+ */
+export class OpenApi31SchemaParser extends JsonDraft202012SchemaParser {
+    constructor(opts = {}) {
+        super(opts);
+        this.$schema = undefined;
+    }
+    parse(spec, definitions = {}, level = 0) {
+        const schema = super.parse(spec, definitions, level);
+        if (level === 0 && !_.isEmpty(definitions))
+            schema.schemas = definitions;
+        delete schema.components;
+        return schema;
+    }
+    _getNumberFormat(rules) {
+        return openApiNumberFormat(rules);
+    }
+    _getBinaryFormat() {
+        return 'binary';
+    }
+    _getLocalSchemaBasePath() {
+        return '#/components/schemas';
+    }
+    _isKnownMetaKey(key) {
+        return key.startsWith('x-') || key === 'deprecated' || key === 'readOnly' || key === 'writeOnly';
+    }
+}

package/dist/esm/lib/validation/engine/json-schema/parsers/open-api.js

@@ -0,0 +1,169 @@
+/**
+ * Derived from the upstream lib/parsers/open-api.js (see UPSTREAM.md; MIT, see THIRD_PARTY_NOTICES.md)
+ */
+import * as _ from '../helpers.js';
+import { JsonDraft04SchemaParser } from './json-draft-04.js';
+/**
+ * The OpenAPI format of a number schema: the formats of the integer and floating point types (lakutata's own)
+ * @param rules
+ */
+export function openApiNumberFormat(rules) {
+    const names = rules.map((rule) => rule.name);
+    if (names.some((name) => ['int8', 'uint8', 'int16', 'uint16', 'int32', 'port'].includes(name)))
+        return 'int32';
+    if (names.some((name) => ['uint32', 'int64', 'uint64'].includes(name)))
+        return 'int64';
+    if (names.includes('float'))
+        return 'float';
+    if (names.includes('double'))
+        return 'double';
+    return undefined;
+}
+/**
+ * Converts schema descriptions into OpenAPI 3.0 schema objects
+ */
+export class OpenApiSchemaParser extends JsonDraft04SchemaParser {
+    constructor(opts = {}) {
+        super(_.merge({
+            logicalOpParser: {
+                xor: null,
+                with: null,
+                without: null
+            }
+        }, opts));
+        this.$schema = undefined;
+        this.knownKeys = [
+            '$ref',
+            'title',
+            'multipleOf',
+            'maximum',
+            'exclusiveMaximum',
+            'minimum',
+            'exclusiveMinimum',
+            'maxLength',
+            'minLength',
+            'pattern',
+            'maxItems',
+            'minItems',
+            'uniqueItems',
+            'maxProperties',
+            'minProperties',
+            'required',
+            'enum',
+            'description',
+            'format',
+            'default',
+            'type',
+            'allOf',
+            'oneOf',
+            'anyOf',
+            'not',
+            'items',
+            'properties',
+            'additionalProperties',
+            'example',
+            'nullable'
+        ];
+    }
+    parse(spec, definitions = {}, level = 0) {
+        const schema = super.parse(spec, definitions, level);
+        if (level === 0 && !_.isEmpty(definitions))
+            schema.schemas = definitions;
+        delete schema.components;
+        //Unreachable, as const is not a known key (upstream reads the former fullSchema variable here)
+        if (schema.const)
+            schema.enum = [schema.const];
+        return schema;
+    }
+    _isIfThenElseSupported() {
+        return false;
+    }
+    _getNumberFormat(rules) {
+        return openApiNumberFormat(rules);
+    }
+    _setAnyProperties(schema) {
+        //Any value: no type (upstream lists the types, which become anyOf branches merged into the anyOf of conditions)
+        if (schema.type === 'any')
+            delete schema.type;
+    }
+    _getBinaryFormat() {
+        return 'binary';
+    }
+    _setTuple(schema, ordered, rest) {
+        //OpenAPI 3.0 has no ordered items: every item matches one of the item schemas
+        this._inexact();
+        schema.items = { anyOf: rest === undefined ? ordered : [...ordered, rest] };
+        if (rest === undefined && !(typeof schema.maxItems === 'number' && schema.maxItems <= ordered.length))
+            schema.maxItems = ordered.length;
+    }
+    _setObjectProperties(schema, spec, definitions, level) {
+        super._setObjectProperties(schema, spec, definitions, level);
+        if (!schema.patternProperties)
+            return;
+        //OpenAPI 3.0 has no patternProperties: the keys they match are additional properties (lakutata)
+        const patterns = Object.values(schema.patternProperties);
+        delete schema.patternProperties;
+        this._inexact();
+        if (schema.additionalProperties === true)
+            return;
+        const additional = typeof schema.additionalProperties === 'object' ? [...patterns, schema.additionalProperties] : patterns;
+        schema.additionalProperties = additional.length === 1 ? additional[0] : { anyOf: additional };
+    }
+    _getLocalSchemaBasePath() {
+        return '#/components/schemas';
+    }
+    _setBasicProperties(fieldSchema, fieldDefn) {
+        super._setBasicProperties(fieldSchema, fieldDefn);
+        if (!_.isEmpty(fieldSchema.examples)) {
+            fieldSchema.example = fieldSchema.examples[0];
+            delete fieldSchema.examples;
+        }
+    }
+    _addNullTypeIfNullable(fieldSchema, fieldDefn) {
+        super._addNullTypeIfNullable(fieldSchema, fieldDefn);
+        if (fieldSchema.type === 'null') {
+            //OpenAPI 3.0 does not support type with value 'null', so we need to set type to 'object' and nullable to true
+            fieldSchema.type = 'object';
+            fieldSchema.nullable = true;
+        }
+        else if (Array.isArray(fieldSchema.type) && fieldSchema.type.includes('null')) {
+            _.remove(fieldSchema.type, (i) => {
+                return i === 'null';
+            });
+            fieldSchema.nullable = true;
+            if (fieldSchema.type.length === 1) {
+                fieldSchema.type = fieldSchema.type[0];
+            }
+            else if (!fieldSchema.type) {
+                //Like upstream (unreachable, an array is truthy): if the only type is null, we need to set type to object
+                //because open-api 3.0 does not support type with value 'null'
+                fieldSchema.type = 'object';
+            }
+        }
+        if (Array.isArray(fieldSchema.type)) {
+            //anyOf is used for When / Alternative case because open-api 3.0 does not support type with array value
+            const anyOf = fieldSchema.anyOf || [];
+            fieldSchema.anyOf = anyOf;
+            _.each(fieldSchema.type, (t) => {
+                const typeExisted = _.some(anyOf, (condition) => {
+                    return condition.type === t;
+                });
+                if (!typeExisted) {
+                    const def = { type: t };
+                    if (t === 'array')
+                        def.items = {};
+                    anyOf.push(def);
+                }
+            });
+            _.each(anyOf, (condition) => {
+                if (fieldSchema.nullable)
+                    condition.nullable = true;
+            });
+            delete fieldSchema.type;
+            delete fieldSchema.nullable;
+        }
+    }
+    _isKnownMetaKey(key) {
+        return key.startsWith('x-') || key === 'deprecated' || key === 'readOnly' || key === 'writeOnly';
+    }
+}

package/dist/esm/lib/validation/engine/location/index.js

@@ -0,0 +1,20 @@
+/**
+ * Derived from the upstream lib/index.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+/**
+ * Get the filename and line number of a caller in the call stack
+ * @param depth distance from the location function in the call stack, defaults to 0 (location's caller)
+ */
+export function location(depth = 0) {
+    const orig = Error.prepareStackTrace;
+    Error.prepareStackTrace = (_error, stack) => stack;
+    const capture = {};
+    //No constructor: like upstream, the frame of location() itself is kept
+    Error.captureStackTrace(capture);
+    const line = capture.stack[depth + 1];
+    Error.prepareStackTrace = orig;
+    return {
+        filename: line.getFileName(),
+        line: line.getLineNumber()
+    };
+}

package/dist/esm/lib/validation/engine/schema/annotate.js

@@ -0,0 +1,126 @@
+/**
+ * Derived from the upstream lib/annotate.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { clone, isArray } from '../utils/index.js';
+import * as Common from './common.js';
+const annotations = Symbol('annotations');
+/**
+ * Render the validated value with the errors marked in place (SchemaValidationException.annotate())
+ * @param stripColorCodes
+ */
+export function error(stripColorCodes) {
+    if (!this._original || typeof this._original !== 'object')
+        return this.details[0].message;
+    const redFgEscape = stripColorCodes ? '' : '\u001b[31m';
+    const redBgEscape = stripColorCodes ? '' : '\u001b[41m';
+    const endColor = stripColorCodes ? '' : '\u001b[0m';
+    const obj = clone(this._original);
+    //Reverse order to process deepest child first
+    for (let i = this.details.length - 1; i >= 0; --i) {
+        const pos = i + 1;
+        const error = this.details[i];
+        const path = error.path;
+        let node = obj;
+        for (let j = 0;; ++j) {
+            const seg = path[j];
+            //Schemas are not cloned by clone(), we have to take this extra step
+            if (Common.isSchema(node))
+                node = node.clone();
+            if (j + 1 < path.length && typeof node[seg] !== 'string') {
+                node = node[seg];
+            }
+            else {
+                const refAnnotations = node[annotations] || { errors: {}, missing: {} };
+                node[annotations] = refAnnotations;
+                const cacheKey = seg || error.context?.key;
+                if (node[seg] !== undefined) {
+                    refAnnotations.errors[cacheKey] = refAnnotations.errors[cacheKey] || [];
+                    refAnnotations.errors[cacheKey].push(pos);
+                }
+                else {
+                    refAnnotations.missing[cacheKey] = pos;
+                }
+                break;
+            }
+        }
+    }
+    const replacers = {
+        key: /_\$key\$_([, \d]+)_\$end\$_"/g,
+        missing: /"_\$miss\$_([^|]+)\|(\d+)_\$end\$_": "__missing__"/g,
+        arrayIndex: /\s*"_\$idx\$_([, \d]+)_\$end\$_",?\n(.*)/g,
+        specials: /"\[(NaN|Symbol.*|-?Infinity|function.*|\(.*)]"/g
+    };
+    let message = safeStringify(obj, 2)
+        .replace(replacers.key, ($0, $1) => `" ${redFgEscape}[${$1}]${endColor}`)
+        .replace(replacers.missing, ($0, $1, $2) => `${redBgEscape}"${$1}"${endColor}${redFgEscape} [${$2}]: -- missing --${endColor}`)
+        .replace(replacers.arrayIndex, ($0, $1, $2) => `\n${$2} ${redFgEscape}[${$1}]${endColor}`)
+        .replace(replacers.specials, ($0, $1) => $1);
+    message = `${message}\n${redFgEscape}`;
+    for (let i = 0; i < this.details.length; ++i) {
+        const pos = i + 1;
+        message = `${message}\n[${pos}] ${this.details[i].message}`;
+    }
+    message = message + endColor;
+    return message;
+}
+//Inspired by json-stringify-safe
+function safeStringify(obj, spaces) {
+    return JSON.stringify(obj, serializer(), spaces);
+}
+function serializer() {
+    const keys = [];
+    const stack = [];
+    const cycleReplacer = (key, value) => {
+        if (stack[0] === value)
+            return '[Circular ~]';
+        return '[Circular ~.' + keys.slice(0, stack.indexOf(value)).join('.') + ']';
+    };
+    return function (key, value) {
+        if (stack.length > 0) {
+            const thisPos = stack.indexOf(this);
+            if (~thisPos) {
+                stack.length = thisPos + 1;
+                keys.length = thisPos + 1;
+                keys[thisPos] = key;
+            }
+            else {
+                stack.push(this);
+                keys.push(key);
+            }
+            if (~stack.indexOf(value))
+                value = cycleReplacer.call(this, key, value);
+        }
+        else {
+            stack.push(value);
+        }
+        if (value) {
+            const valueAnnotations = value[annotations];
+            if (valueAnnotations) {
+                if (isArray(value)) {
+                    const annotated = [];
+                    for (let i = 0; i < value.length; ++i) {
+                        if (valueAnnotations.errors[i])
+                            annotated.push(`_$idx$_${valueAnnotations.errors[i].sort().join(', ')}_$end$_`);
+                        annotated.push(value[i]);
+                    }
+                    value = annotated;
+                }
+                else {
+                    const record = value;
+                    for (const errorKey in valueAnnotations.errors) {
+                        record[`${errorKey}_$key$_${valueAnnotations.errors[errorKey].sort().join(', ')}_$end$_`] = record[errorKey];
+                        record[errorKey] = undefined;
+                    }
+                    for (const missingKey in valueAnnotations.missing) {
+                        record[`_$miss$_${missingKey}|${valueAnnotations.missing[missingKey]}_$end$_`] = '__missing__';
+                    }
+                }
+                return value;
+            }
+        }
+        if (value === Infinity || value === -Infinity || Number.isNaN(value) || typeof value === 'function' || typeof value === 'symbol') {
+            return '[' + value.toString() + ']';
+        }
+        return value;
+    };
+}

package/dist/esm/lib/validation/engine/schema/assert.js

@@ -0,0 +1,60 @@
+/**
+ * Assertions of the schema definitions: a failed assertion throws a SchemaDefinitionException (the message is built like
+ * the assertions of the utilities, see utils/assert.ts)
+ */
+import { Exception } from '../../../foundation/Exception.js';
+import { SchemaDefinitionException } from '../../exceptions/SchemaDefinitionException.js';
+import { AssertError, stringify } from '../utils/index.js';
+/**
+ * A definition exception, with the stack from the caller of the given function
+ * @param message
+ * @param caller
+ * @param cause
+ */
+export function definitionException(message, caller, cause) {
+    const exception = new SchemaDefinitionException(message || 'Unknown error');
+    if (typeof Error.captureStackTrace === 'function')
+        Error.captureStackTrace(exception, caller);
+    if (cause !== undefined)
+        exception.cause = cause;
+    return exception;
+}
+/**
+ * Set the message of an error (lakutata: a framework exception keeps its message in errMsg too)
+ * @param err
+ * @param message
+ */
+export function setMessage(err, message) {
+    err.message = message;
+    if (err instanceof Exception)
+        err.errMsg = message;
+}
+/**
+ * Assert a condition of a schema definition
+ * @param condition
+ * @param args the message parts (an Error alone is thrown as is)
+ */
+export function assert(condition, ...args) {
+    if (condition)
+        return;
+    if (args.length === 1 && args[0] instanceof Error)
+        throw args[0];
+    const msgs = args
+        .filter((arg) => arg !== '')
+        .map((arg) => typeof arg === 'string' ? arg : arg instanceof Error ? arg.message : stringify(arg));
+    throw definitionException(msgs.join(' '), assert);
+}
+/**
+ * Call a utility (utils, sorter, address) with definition inputs: its assertion errors become definition exceptions
+ * @param fn
+ */
+export function definition(fn) {
+    try {
+        return fn();
+    }
+    catch (err) {
+        if (err instanceof AssertError)
+            throw definitionException(err.message, definition, err);
+        throw err;
+    }
+}