@lakutata/core 1.0.60 → 3.0.0-beta.1

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

@@ -0,0 +1,94 @@
+/**
+ * Derived from the upstream lib/cache.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { clone } from '../utils/index.js';
+import { assert } from './assert.js';
+import * as Common from './common.js';
+const defaultMax = 1000;
+const supported = new Set(['undefined', 'boolean', 'number', 'string']);
+/**
+ * Doubly linked list of cache nodes (most recently used in head)
+ */
+class List {
+    constructor() {
+        this.tail = null;
+        this.head = null;
+    }
+    unshift(node) {
+        node.next = null;
+        node.prev = this.head;
+        if (this.head)
+            this.head.next = node;
+        this.head = node;
+        if (!this.tail)
+            this.tail = node;
+        return node;
+    }
+    first(node) {
+        if (node === this.head)
+            return;
+        this._remove(node);
+        this.unshift(node);
+    }
+    pop() {
+        return this._remove(this.tail);
+    }
+    _remove(node) {
+        const { next, prev } = node;
+        next.prev = prev;
+        if (prev)
+            prev.next = next;
+        if (node === this.tail)
+            this.tail = next;
+        node.prev = null;
+        node.next = null;
+        return node;
+    }
+}
+/**
+ * Least Recently Used (LRU) cache
+ */
+export class Cache {
+    constructor(options = {}) {
+        Common.assertOptions(options, ['max']);
+        assert(options.max === undefined || options.max && options.max > 0 && isFinite(options.max), 'Invalid max cache size');
+        this._max = options.max || defaultMax;
+        this._map = new Map();
+        this._list = new List();
+    }
+    get length() {
+        return this._map.size;
+    }
+    set(value, result) {
+        if (value !== null && !supported.has(typeof value))
+            return;
+        const key = value;
+        let node = this._map.get(key);
+        if (node) {
+            node.value = result;
+            this._list.first(node);
+            return;
+        }
+        node = this._list.unshift({ key, value: result, next: null, prev: null });
+        this._map.set(key, node);
+        this._compact();
+    }
+    get(value) {
+        const node = this._map.get(value);
+        if (node) {
+            this._list.first(node);
+            return clone(node.value);
+        }
+    }
+    _compact() {
+        if (this._map.size > this._max) {
+            const node = this._list.pop();
+            this._map.delete(node.key);
+        }
+    }
+}
+export const provider = {
+    provision(options) {
+        return new Cache(options);
+    }
+};

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

@@ -0,0 +1,203 @@
+/**
+ * Derived from the upstream lib/common.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { isArray } from '../utils/index.js';
+import { assert as Assert, definitionException, setMessage } from './assert.js';
+import { Lazy } from './lazy.js';
+let Messages;
+let Schemas;
+const isoDate = /^(?:[-+]\d{2})?(?:\d{4}(?!\d{2}\b))(?:(-?)(?:(?:0[1-9]|1[0-2])(?:\1(?:[12]\d|0[1-9]|3[01]))?|W(?:[0-4]\d|5[0-2])(?:-?[1-7])?|(?:00[1-9]|0[1-9]\d|[12]\d{2}|3(?:[0-5]\d|6[1-6])))(?![T]$|[T][\d]+Z$)(?:[T\s](?:(?:(?:[01]\d|2[0-3])(?:(:?)[0-5]\d)?|24\:?00)(?:[.,]\d+(?!:))?)(?:\2[0-5]\d(?:[.,]\d+)?)?(?:[Z]|(?:[+-])(?:[01]\d|2[0-3])(?::?[0-5]\d)?)?)?)?$/;
+/**
+ * Version of the schema format of the validation engine: schemas of engines with another version are not mixed (bump it
+ * when the schema internals change incompatibly)
+ */
+export const version = '1.0.0';
+export const defaults = {
+    abortEarly: true,
+    allowUnknown: false,
+    artifacts: false,
+    cache: true,
+    context: null,
+    convert: true,
+    dateFormat: 'iso',
+    errors: {
+        escapeHtml: false,
+        label: 'path',
+        language: null,
+        render: true,
+        stack: false,
+        wrap: {
+            label: '"',
+            array: '[]'
+        }
+    },
+    externals: true,
+    messages: {},
+    nonEnumerables: false,
+    noDefaults: false,
+    presence: 'optional',
+    skipFunctions: false,
+    stripUnknown: false,
+    warnings: false
+};
+export const symbols = {
+    //Used to internally identify any-based types (shared with the other copies and versions of the engine)
+    any: Symbol.for('@lakutata/validation/schema'),
+    arraySingle: Symbol('arraySingle'),
+    deepDefault: Symbol('deepDefault'),
+    errors: Symbol('errors'),
+    literal: Symbol('literal'),
+    override: Symbol('override'),
+    parent: Symbol('parent'),
+    prefs: Symbol('prefs'),
+    ref: Symbol('ref'),
+    template: Symbol('template'),
+    values: Symbol('values')
+};
+/**
+ * Read a symbol keyed property of any value
+ * @param value
+ * @param symbol
+ */
+function symbolOf(value, symbol) {
+    return value[symbol];
+}
+//Like upstream, keys may be a single key (then matched as a substring)
+export function assertOptions(options, keys, name = 'Options') {
+    Assert(options && typeof options === 'object' && !isArray(options), 'Options must be of type object');
+    const unknownKeys = Object.keys(options).filter((k) => !keys.includes(k));
+    Assert(unknownKeys.length === 0, `${name} contain unknown keys: ${unknownKeys}`);
+}
+export function checkPreferences(prefs) {
+    Schemas = Schemas || Lazy.schemas();
+    const result = Schemas.preferences.validate(prefs);
+    //The preferences schema has no error override: its errors are validation errors
+    if (result.error)
+        throw definitionException(String([result.error.details[0].message]), checkPreferences);
+}
+/**
+ * Compare two values with an operator (values of any type are compared like JavaScript does)
+ * @param a
+ * @param b
+ * @param operator
+ */
+export function compare(a, b, operator) {
+    const left = a;
+    const right = b;
+    switch (operator) {
+        case '=':
+            return a === b;
+        case '>':
+            return left > right;
+        case '<':
+            return left < right;
+        case '>=':
+            return left >= right;
+        case '<=':
+            return left <= right;
+    }
+}
+/**
+ * The value, or the default value when the value is undefined (upstream: Common.default())
+ * @param value
+ * @param defaultValue
+ */
+export function defaultValue(value, defaultValue) {
+    return value === undefined ? defaultValue : value;
+}
+export function isIsoDate(date) {
+    return isoDate.test(date);
+}
+export function isNumber(value) {
+    return typeof value === 'number' && !isNaN(value);
+}
+/**
+ * Whether the value is a reference or a template
+ * @param obj
+ */
+export function isResolvable(obj) {
+    if (!obj)
+        return false;
+    return !!(symbolOf(obj, symbols.ref) || symbolOf(obj, symbols.template));
+}
+/**
+ * Whether the value is a schema (of this engine version, or of any engine version with the legacy option)
+ * @param schema
+ * @param options
+ */
+export function isSchema(schema, options = {}) {
+    const any = schema ? symbolOf(schema, symbols.any) : undefined;
+    if (!any)
+        return false;
+    Assert(options.legacy || any.version === version, 'Cannot mix different versions of validation schemas');
+    return true;
+}
+export function isValues(obj) {
+    return !!symbolOf(obj, symbols.values);
+}
+export function limit(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+/**
+ * Merge preferences
+ * @param target
+ * @param source
+ */
+export function preferences(target, source) {
+    Messages = Messages || Lazy.messages;
+    const targetPrefs = target || {};
+    const sourcePrefs = source || {};
+    const merged = Object.assign({}, targetPrefs, sourcePrefs);
+    if (sourcePrefs.errors && targetPrefs.errors) {
+        merged.errors = Object.assign({}, targetPrefs.errors, sourcePrefs.errors);
+        merged.errors.wrap = Object.assign({}, targetPrefs.errors.wrap, sourcePrefs.errors.wrap);
+    }
+    if (sourcePrefs.messages)
+        merged.messages = Messages.compile(sourcePrefs.messages, targetPrefs.messages);
+    delete merged[symbols.prefs];
+    return merged;
+}
+/**
+ * Call fn, prefixing the path of a thrown error with the key
+ * @param fn
+ * @param key
+ * @param options
+ */
+export function tryWithPath(fn, key, options = {}) {
+    try {
+        return fn();
+    }
+    catch (err) {
+        const error = err;
+        if (error.path !== undefined) {
+            error.path = key + '.' + error.path;
+        }
+        else {
+            error.path = String(key);
+        }
+        if (options.append)
+            setMessage(error, `${error.message} (${error.path})`);
+        throw err;
+    }
+}
+/**
+ * Validate a method argument, returning the error message of an invalid value
+ * @param value
+ * @param label
+ * @param validation a schema, or a predicate with its error message
+ */
+export function validateArg(value, label, { assert, message }) {
+    if (isSchema(assert)) {
+        const result = assert.validate(value);
+        if (!result.error)
+            return;
+        return result.error.message;
+    }
+    else if (!assert(value)) {
+        return label ? `${label} ${message}` : message;
+    }
+}
+export function verifyFlat(args, method) {
+    for (const arg of args)
+        Assert(!isArray(arg), 'Method no longer accepts array arguments:', method);
+}

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

@@ -0,0 +1,203 @@
+/**
+ * Derived from the upstream lib/compile.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { assert, setMessage } from './assert.js';
+import * as Common from './common.js';
+import * as Ref from './ref.js';
+/**
+ * Compile a schema description (literals, arrays, objects, regular expressions...) into a schema
+ * @param root
+ * @param config
+ * @param options
+ */
+export function schema(root, config, options = {}) {
+    Common.assertOptions(options, ['appendPath', 'override']);
+    try {
+        return compileSchema(root, config, options);
+    }
+    catch (err) {
+        if (options.appendPath && err.path !== undefined)
+            setMessage(err, `${err.message} (${err.path})`);
+        throw err;
+    }
+}
+function compileSchema(root, config, options) {
+    assert(config !== undefined, 'Invalid undefined schema');
+    if (Array.isArray(config)) {
+        assert(config.length, 'Invalid empty array schema');
+        if (config.length === 1)
+            config = config[0];
+    }
+    const valid = (base, ...values) => {
+        if (options.override !== false)
+            return base.valid(root.override, ...values);
+        return base.valid(...values);
+    };
+    if (simple(config))
+        return valid(root, config);
+    if (typeof config === 'function')
+        return root.custom(config);
+    assert(typeof config === 'object', 'Invalid schema content:', typeof config);
+    if (Common.isResolvable(config))
+        return valid(root, config);
+    if (Common.isSchema(config))
+        return config;
+    if (Array.isArray(config)) {
+        for (const item of config) {
+            if (!simple(item))
+                return root.alternatives().try(...config);
+        }
+        return valid(root, ...config);
+    }
+    if (config instanceof RegExp)
+        return root.string().regex(config);
+    if (config instanceof Date)
+        return valid(root.date(), config);
+    assert(Object.getPrototypeOf(config) === Object.getPrototypeOf({}), 'Schema can only contain plain objects');
+    return root.object().keys(config);
+}
+/**
+ * A reference, created from its key unless it is one already
+ * @param id
+ * @param options
+ */
+export function ref(id, options) {
+    return Ref.isRef(id) ? id : Ref.create(id, options);
+}
+/**
+ * Compile a schema, unless it is compiled already (by this version, or by a legacy one when allowed)
+ * @param root
+ * @param schema
+ * @param options
+ */
+export function compile(root, schema, options = {}) {
+    Common.assertOptions(options, ['legacy']);
+    //Compiled by any supported version
+    const any = schema ? schema[Common.symbols.any] : undefined;
+    if (any) {
+        assert(options.legacy || any.version === Common.version, 'Cannot mix different versions of validation schemas:', any.version, Common.version);
+        return schema;
+    }
+    //Uncompiled root
+    //Will error if schema contains other versions
+    if (typeof schema !== 'object' || !options.legacy)
+        return compileRoot(root, schema);
+    //Scan schema for compiled parts
+    const compiler = walk(schema);
+    if (!compiler)
+        return compileRoot(root, schema);
+    return compiler.compile(compiler.root, schema);
+}
+function compileRoot(root, config) {
+    return schema(root, config, { appendPath: true });
+}
+function walk(schema) {
+    if (typeof schema !== 'object')
+        return null;
+    if (Array.isArray(schema)) {
+        for (const item of schema) {
+            const compiler = walk(item);
+            if (compiler)
+                return compiler;
+        }
+        return null;
+    }
+    //Like upstream: null (typeof 'object') throws on the symbol lookup
+    const record = schema;
+    const any = record[Common.symbols.any];
+    if (any)
+        return { root: record[any.root], compile: any.compile };
+    assert(Object.getPrototypeOf(schema) === Object.getPrototypeOf({}), 'Schema can only contain plain objects');
+    for (const key in record) {
+        const compiler = walk(record[key]);
+        if (compiler)
+            return compiler;
+    }
+    return null;
+}
+function simple(value) {
+    return value === null || ['boolean', 'string', 'number'].includes(typeof value);
+}
+/**
+ * Compile when() arguments into a condition or a switch statement
+ * @param schema
+ * @param condition
+ * @param options
+ */
+export function when(schema, condition, options) {
+    if (options === undefined) {
+        assert(condition && typeof condition === 'object', 'Missing options');
+        options = condition;
+        condition = Ref.create('.');
+    }
+    if (Array.isArray(options))
+        options = { switch: options };
+    Common.assertOptions(options, ['is', 'not', 'then', 'otherwise', 'switch', 'break']);
+    //Schema condition
+    if (Common.isSchema(condition)) {
+        assert(options.is === undefined, '"is" can not be used with a schema condition');
+        assert(options.not === undefined, '"not" can not be used with a schema condition');
+        assert(options.switch === undefined, '"switch" can not be used with a schema condition');
+        return conditionOf(schema, { is: condition, then: options.then, otherwise: options.otherwise, break: options.break });
+    }
+    //Single condition
+    assert(Ref.isRef(condition) || typeof condition === 'string', 'Invalid condition:', condition);
+    assert(options.not === undefined || options.is === undefined, 'Cannot combine "is" with "not"');
+    if (options.switch === undefined) {
+        let rule = options;
+        if (options.not !== undefined)
+            rule = { is: options.not, then: options.otherwise, otherwise: options.then, break: options.break };
+        let is = rule.is !== undefined ? schema.$_compile(rule.is) : schema.$_root.invalid(null, false, 0, '').required();
+        assert(rule.then !== undefined || rule.otherwise !== undefined, 'options must have at least one of "then", "otherwise", or "switch"');
+        assert(rule.break === undefined || rule.then === undefined || rule.otherwise === undefined, 'Cannot specify then, otherwise, and break all together');
+        //Only apply required if this wasn't already a schema or a ref
+        if (options.is !== undefined && !Ref.isRef(options.is) && !Common.isSchema(options.is))
+            is = is.required();
+        return conditionOf(schema, { ref: ref(condition), is, then: rule.then, otherwise: rule.otherwise, break: rule.break });
+    }
+    //Switch statement
+    assert(Array.isArray(options.switch), '"switch" must be an array');
+    assert(options.is === undefined, 'Cannot combine "switch" with "is"');
+    assert(options.not === undefined, 'Cannot combine "switch" with "not"');
+    assert(options.then === undefined, 'Cannot combine "switch" with "then"');
+    const rule = {
+        ref: ref(condition),
+        switch: [],
+        break: options.break
+    };
+    for (let i = 0; i < options.switch.length; ++i) {
+        const test = options.switch[i];
+        const last = i === options.switch.length - 1;
+        Common.assertOptions(test, last ? ['is', 'then', 'otherwise'] : ['is', 'then']);
+        assert(test.is !== undefined, 'Switch statement missing "is"');
+        assert(test.then !== undefined, 'Switch statement missing "then"');
+        const item = {
+            is: schema.$_compile(test.is),
+            then: schema.$_compile(test.then)
+        };
+        //Only apply required if this wasn't already a schema or a ref
+        if (!Ref.isRef(test.is) && !Common.isSchema(test.is))
+            item.is = item.is.required();
+        if (last) {
+            assert(options.otherwise === undefined || test.otherwise === undefined, 'Cannot specify "otherwise" inside and outside a "switch"');
+            const otherwise = options.otherwise !== undefined ? options.otherwise : test.otherwise;
+            if (otherwise !== undefined) {
+                assert(rule.break === undefined, 'Cannot specify both otherwise and break');
+                item.otherwise = schema.$_compile(otherwise);
+            }
+        }
+        rule.switch.push(item);
+    }
+    return rule;
+}
+function conditionOf(schema, condition) {
+    for (const key of ['then', 'otherwise']) {
+        if (condition[key] === undefined) {
+            delete condition[key];
+        }
+        else {
+            condition[key] = schema.$_compile(condition[key]);
+        }
+    }
+    return condition;
+}

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

@@ -0,0 +1,189 @@
+/**
+ * Derived from the upstream lib/errors.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { SchemaValidationException } from '../../exceptions/SchemaValidationException.js';
+import * as Common from './common.js';
+import { Template } from './template.js';
+/**
+ * A validation error report, rendered lazily into a message
+ */
+export class Report {
+    constructor(code, value, local, flags, messages, state, prefs) {
+        this.code = code;
+        this.flags = flags;
+        this.messages = messages;
+        this.path = state.path;
+        this.prefs = prefs;
+        this.state = state;
+        this.value = value;
+        this.message = null;
+        this.template = null;
+        this.local = local || {};
+        this.local.label = label(this.flags, this.state, this.prefs, this.messages);
+        if (this.value !== undefined && !Object.prototype.hasOwnProperty.call(this.local, 'value'))
+            this.local.value = this.value;
+        if (this.path.length) {
+            const key = this.path[this.path.length - 1];
+            if (typeof key !== 'object')
+                this.local.key = key;
+        }
+    }
+    _setTemplate(template) {
+        this.template = template;
+        if (!this.flags.label && this.path.length === 0) {
+            const localized = this._template(this.template, 'root');
+            if (localized)
+                this.local.label = localized;
+        }
+    }
+    toString() {
+        if (this.message)
+            return this.message;
+        const code = this.code;
+        if (!this.prefs.errors.render)
+            return this.code;
+        const template = this._template(this.template) ||
+            this._template(this.prefs.messages) ||
+            this._template(this.messages);
+        if (template === undefined)
+            return `Error code "${code}" is not defined, your custom type is missing the correct messages definition`;
+        //Render and cache result
+        this.message = template.render(this.value, this.state, this.prefs, this.local, { errors: this.prefs.errors, messages: [this.prefs.messages, this.messages] });
+        if (!this.prefs.errors.label)
+            this.message = this.message.replace(/^"" /, '').trim();
+        return this.message;
+    }
+    _template(messages, code) {
+        return template(this.value, messages, code || this.code, this.state, this.prefs);
+    }
+}
+/**
+ * Render a path for a label ('a.b[0]')
+ * @param path
+ */
+export function path(path) {
+    let label = '';
+    for (const segment of path) {
+        //Exclude array single path segment
+        if (typeof segment === 'object')
+            continue;
+        if (typeof segment === 'string') {
+            if (label)
+                label += '.';
+            label += segment;
+        }
+        else {
+            label += `[${segment}]`;
+        }
+    }
+    return label;
+}
+/**
+ * Find the message of an error code, in the preferred language first
+ * @param value
+ * @param messages
+ * @param code
+ * @param state
+ * @param prefs
+ */
+export function template(value, messages, code, state, prefs) {
+    if (!messages)
+        return;
+    if (Template.isTemplate(messages))
+        return code !== 'root' ? messages : null;
+    let lang = prefs.errors.language;
+    if (Common.isResolvable(lang))
+        lang = lang.resolve(value, state, prefs, undefined);
+    const byCode = messages;
+    if (lang && byCode[lang]) {
+        const languageMessages = byCode[lang];
+        if (languageMessages[code] !== undefined)
+            return languageMessages[code];
+        if (languageMessages['*'] !== undefined)
+            return languageMessages['*'];
+    }
+    if (!byCode[code])
+        return byCode['*'];
+    return byCode[code];
+}
+/**
+ * The label of a value in error messages
+ * @param flags
+ * @param state
+ * @param prefs
+ * @param messages
+ */
+export function label(flags, state, prefs, messages) {
+    const errorPrefs = prefs.errors;
+    if (!errorPrefs.label)
+        return '';
+    if (flags.label)
+        return flags.label;
+    let labelPath = state.path;
+    if (errorPrefs.label === 'key' && state.path.length > 1)
+        labelPath = state.path.slice(-1);
+    const normalized = path(labelPath);
+    if (normalized)
+        return normalized;
+    return template(null, prefs.messages, 'root', state, prefs) ||
+        messages && template(null, messages, 'root', state, prefs) ||
+        'value';
+}
+/**
+ * The validation error, or the override error, of the errors of a validation
+ * @param errors
+ * @param original
+ * @param prefs
+ */
+export function process(errors, original, prefs) {
+    if (!errors)
+        return null;
+    const { override, message, details } = detailsOf(errors);
+    if (override)
+        return override;
+    //Without override details, as override errors are returned as they are
+    if (prefs.errors.stack)
+        return new SchemaValidationException(message, details, original);
+    const limit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 0;
+    const validationError = new SchemaValidationException(message, details, original);
+    Error.stackTraceLimit = limit;
+    return validationError;
+}
+/**
+ * The message and the details of errors (or the first override error)
+ * @param errors
+ * @param options
+ */
+function detailsOf(errors, options = {}) {
+    let messages = [];
+    const details = [];
+    for (const item of errors) {
+        //Override
+        if (item instanceof Error) {
+            if (options.override !== false)
+                return { override: item };
+            const message = item.toString();
+            messages.push(message);
+            details.push({
+                message,
+                type: 'override',
+                context: { error: item }
+            });
+            continue;
+        }
+        //Report
+        const message = item.toString();
+        messages.push(message);
+        details.push({
+            message,
+            path: item.path.filter((v) => typeof v !== 'object'),
+            type: item.code,
+            context: item.local
+        });
+    }
+    if (messages.length > 1)
+        messages = [...new Set(messages)];
+    return { message: messages.join('. '), details };
+}
+export { detailsOf as details };