@lakutata/core 1.0.59 → 3.0.0-beta.0

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

@@ -0,0 +1,102 @@
+/**
+ * Not from upstream: the string formats of JSON Schema (lakutata's own), validated like the full formats of
+ * ajv-formats, the reference of the JSON Schema tooling: RFC 3339 dates and times, RFC 5321 email addresses without
+ * the list of top level domains, RFC 1123 host names, IP addresses, RFC 3986 URIs, UUIDs, ECMA-262 regular expressions,
+ * JSON pointers, URI templates and base64 bytes.
+ */
+import { isEmailValid, ipRegex, uriRegex } from '../address/index.js';
+const DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+const DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
+const DURATION = /^P(?!$)((\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?|(\d+W)?)$/;
+const HOSTNAME = /^(?=.{1,253}\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\.?$/i;
+const IPV4 = /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/;
+const IPV6 = ipRegex({ version: ['ipv6'], cidr: 'forbidden' }).regex;
+const URI = uriRegex().regex;
+const URI_REFERENCE = uriRegex({ allowRelative: true }).regex;
+const UUID = /^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i;
+const JSON_POINTER = /^(?:\/(?:[^~/]|~0|~1)*)*$/;
+const RELATIVE_JSON_POINTER = /^(?:0|[1-9][0-9]*)(?:#|(?:\/(?:[^~/]|~0|~1)*)*)$/;
+const URI_TEMPLATE = /^(?:[^\x00-\x20"'<>%\\^`{|}]|%[0-9a-f]{2}|\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\*)?)*\})*$/i;
+const BYTE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+/**
+ * Whether a year is a leap year
+ * @param year
+ */
+function isLeapYear(year) {
+    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+/**
+ * An RFC 3339 full-date
+ * @param value
+ */
+function isDate(value) {
+    const matches = DATE.exec(value);
+    if (!matches)
+        return false;
+    const year = +matches[1];
+    const month = +matches[2];
+    const day = +matches[3];
+    return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month]);
+}
+/**
+ * An RFC 3339 full-time (a leap second is only valid at 23:59:60 UTC)
+ * @param value
+ */
+function isTime(value) {
+    const matches = TIME.exec(value);
+    if (!matches)
+        return false;
+    const hour = +matches[1];
+    const minute = +matches[2];
+    const second = +matches[3];
+    const zone = matches[4];
+    //The time zone is required
+    if (!zone)
+        return false;
+    const sign = matches[5] === '-' ? -1 : 1;
+    const zoneHour = +(matches[6] || 0);
+    const zoneMinute = +(matches[7] || 0);
+    if (zoneHour > 23 || zoneMinute > 59)
+        return false;
+    if (hour <= 23 && minute <= 59 && second < 60)
+        return true;
+    //Leap second
+    const utcMinute = minute - zoneMinute * sign;
+    const utcHour = hour - zoneHour * sign - (utcMinute < 0 ? 1 : 0);
+    return (utcHour === 23 || utcHour === -1) && (utcMinute === 59 || utcMinute === -1) && second < 61;
+}
+/**
+ * The format validators, by name
+ */
+export const formats = Object.freeze({
+    'date': isDate,
+    'time': isTime,
+    'date-time': (value) => {
+        const parts = value.split(/t|\s/i);
+        return parts.length === 2 && isDate(parts[0]) && isTime(parts[1]);
+    },
+    'duration': (value) => DURATION.test(value),
+    'email': (value) => isEmailValid(value, { allowUnicode: false }),
+    'idn-email': (value) => isEmailValid(value),
+    'hostname': (value) => HOSTNAME.test(value),
+    'ipv4': (value) => IPV4.test(value),
+    'ipv6': (value) => IPV6.test(value),
+    'uri': (value) => URI.test(value),
+    //The empty string is a relative reference
+    'uri-reference': (value) => value === '' || URI_REFERENCE.test(value),
+    'uri-template': (value) => URI_TEMPLATE.test(value),
+    'uuid': (value) => UUID.test(value),
+    'regex': (value) => {
+        try {
+            new RegExp(value, 'u');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    'json-pointer': (value) => JSON_POINTER.test(value),
+    'relative-json-pointer': (value) => RELATIVE_JSON_POINTER.test(value),
+    'byte': (value) => BYTE.test(value)
+});

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

@@ -0,0 +1,199 @@
+/**
+ * Derived from the upstream lib/index.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { clone } from '../utils/index.js';
+import { assert, setMessage } from './assert.js';
+import { SchemaValidationException } from '../../exceptions/SchemaValidationException.js';
+import * as Cache from './cache.js';
+import * as Common from './common.js';
+import * as Compile from './compile.js';
+import * as Extend from './extend.js';
+import * as Manifest from './manifest.js';
+import * as Ref from './ref.js';
+import { Template } from './template.js';
+import * as Trace from './trace.js';
+import Alternatives from './types/alternatives.js';
+import Any from './types/any.js';
+import ArrayType from './types/array.js';
+import BooleanType from './types/boolean.js';
+import DateType from './types/date.js';
+import FunctionType from './types/function.js';
+import Link from './types/link.js';
+import NumberType from './types/number.js';
+import ObjectType from './types/object.js';
+import StringType from './types/string.js';
+import SymbolType from './types/symbol.js';
+import BinaryType from './types/binary.js';
+import getSchemas from './schemas.js';
+let Schemas;
+const types = {
+    alternatives: Alternatives,
+    any: Any,
+    array: ArrayType,
+    boolean: BooleanType,
+    date: DateType,
+    function: FunctionType,
+    link: Link,
+    number: NumberType,
+    object: ObjectType,
+    string: StringType,
+    symbol: SymbolType
+};
+const aliases = {
+    alt: 'alternatives',
+    bool: 'boolean',
+    func: 'function'
+};
+if (Buffer)
+    types.binary = BinaryType;
+function createRoot() {
+    const root = {
+        _types: new Set(Object.keys(types))
+    };
+    //Types
+    for (const type of root._types) {
+        root[type] = function (...args) {
+            assert(!args.length || ['alternatives', 'link', 'object'].includes(type), 'The', type, 'type does not allow arguments');
+            return generate(this, types[type], args);
+        };
+    }
+    //Shortcuts
+    for (const method of ['allow', 'custom', 'disallow', 'equal', 'exist', 'forbidden', 'invalid', 'not', 'only', 'optional', 'options', 'prefs', 'preferences', 'required', 'strip', 'valid', 'when']) {
+        root[method] = function (...args) {
+            const schema = this.any();
+            return (schema[method]).call(schema, ...args);
+        };
+    }
+    //Methods
+    Object.assign(root, methods);
+    //Aliases
+    for (const alias in aliases) {
+        const target = aliases[alias];
+        root[alias] = root[target];
+    }
+    root.x = root.expression;
+    //Trace
+    if (Trace.setup)
+        Trace.setup(root);
+    return root;
+}
+const methods = {
+    ValidationError: SchemaValidationException,
+    version: Common.version,
+    cache: Cache.provider,
+    assert(value, schema, ...args) {
+        //[message], [options]
+        assertValue(value, schema, true, args);
+    },
+    attempt(value, schema, ...args) {
+        //[message], [options]
+        return assertValue(value, schema, false, args);
+    },
+    build(desc) {
+        assert(typeof Manifest.build === 'function', 'Manifest functionality disabled');
+        return Manifest.build(this, desc);
+    },
+    checkPreferences(prefs) {
+        Common.checkPreferences(prefs);
+    },
+    compile(schema, options) {
+        return Compile.compile(this, schema, options);
+    },
+    defaults(modifier) {
+        assert(typeof modifier === 'function', 'modifier must be a function');
+        const engine = Object.assign({}, this);
+        for (const type of engine._types) {
+            const schema = modifier(engine[type].call(engine));
+            assert(Common.isSchema(schema), 'modifier must return a valid schema object');
+            engine[type] = function (...args) {
+                return generate(this, schema, args);
+            };
+        }
+        return engine;
+    },
+    expression(source, options) {
+        return new Template(source, options);
+    },
+    extend(...extensions) {
+        Common.verifyFlat(extensions, 'extend');
+        Schemas = Schemas || getSchemas();
+        assert(extensions.length, 'You need to provide at least one extension');
+        this.assert(extensions, Schemas.extensions);
+        const engine = Object.assign({}, this);
+        engine._types = new Set(engine._types);
+        for (let extension of extensions) {
+            if (typeof extension === 'function')
+                extension = extension(engine);
+            this.assert(extension, Schemas.extension);
+            const expanded = expandExtension(extension, engine);
+            for (const item of expanded) {
+                assert(engine[item.type] === undefined || engine._types.has(item.type), 'Cannot override name', item.type);
+                const base = item.base || this.any();
+                const schema = Extend.type(base, item);
+                engine._types.add(item.type);
+                engine[item.type] = function (...args) {
+                    return generate(this, schema, args);
+                };
+            }
+        }
+        return engine;
+    },
+    isError: SchemaValidationException.isError,
+    isExpression: Template.isTemplate,
+    isRef: Ref.isRef,
+    isSchema: Common.isSchema,
+    in(key, options) {
+        return Ref.in(key, options);
+    },
+    override: Common.symbols.override,
+    ref(key, options) {
+        return Ref.create(key, options);
+    },
+    types() {
+        const result = {};
+        for (const type of this._types)
+            result[type] = this[type].call(this);
+        for (const target in aliases)
+            result[target] = this[target].call(this);
+        return result;
+    }
+};
+function assertValue(value, schema, annotate, args) {
+    //[message], [options]
+    const message = args[0] instanceof Error || typeof args[0] === 'string' ? args[0] : null;
+    const options = message !== null ? args[1] : args[0];
+    const result = schema.validate(value, Common.preferences({ errors: { stack: true } }, options || {}));
+    let error = result.error;
+    if (!error)
+        return result.value;
+    if (message instanceof Error)
+        throw message;
+    const display = annotate && typeof error.annotate === 'function' ? error.annotate() : error.message;
+    if (error instanceof SchemaValidationException === false)
+        error = clone(error);
+    setMessage(error, message ? `${message} ${display}` : display);
+    throw error;
+}
+function generate(root, schema, args) {
+    assert(root, 'Must be invoked on a validation root.');
+    schema.$_root = root;
+    if (!schema._definition.args || !args.length)
+        return schema;
+    return schema._definition.args(schema, ...args);
+}
+function expandExtension(extension, engine) {
+    if (typeof extension.type === 'string')
+        return [extension];
+    const extended = [];
+    for (const type of engine._types) {
+        if (extension.type.test(type)) {
+            const item = Object.assign({}, extension);
+            item.type = type;
+            item.base = engine[type].call(engine);
+            extended.push(item);
+        }
+    }
+    return extended;
+}
+const Engine = createRoot();
+export default Engine;

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

@@ -0,0 +1,5 @@
+export const Lazy = {
+    messages: undefined,
+    template: undefined,
+    schemas: undefined
+};

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

@@ -0,0 +1,325 @@
+/**
+ * Derived from the upstream lib/manifest.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';
+import { Lazy } from './lazy.js';
+import * as Messages from './messages.js';
+import * as Ref from './ref.js';
+import { Template } from './template.js';
+let Schemas;
+/**
+ * Describe a schema
+ * @param schema
+ */
+export function describe(schema) {
+    const def = schema._definition;
+    //Type
+    const desc = {
+        type: schema.type,
+        flags: {},
+        rules: []
+    };
+    const flags = desc.flags;
+    const rules = desc.rules;
+    //Flags
+    for (const flag in schema._flags) {
+        if (flag[0] !== '_')
+            flags[flag] = describeItem(schema._flags[flag]);
+    }
+    if (!Object.keys(flags).length)
+        delete desc.flags;
+    //Preferences
+    if (schema._preferences) {
+        //The preferences may hold their merge with the default preferences (symbols.prefs)
+        const preferences = clone(schema._preferences, { shallow: ['messages'] });
+        desc.preferences = preferences;
+        delete preferences[Common.symbols.prefs];
+        if (preferences.messages)
+            preferences.messages = Messages.decompile(preferences.messages);
+    }
+    //Allow / Invalid
+    if (schema._valids)
+        desc.allow = schema._valids.describe();
+    if (schema._invalids)
+        desc.invalid = schema._invalids.describe();
+    //Rules
+    for (const rule of schema._rules) {
+        const ruleDef = def.rules[rule.name];
+        //Defaults to true
+        if (ruleDef.manifest === false)
+            continue;
+        const item = { name: rule.name };
+        for (const custom in def.modifiers) {
+            if (rule[custom] !== undefined)
+                item[custom] = describeItem(rule[custom]);
+        }
+        if (rule.args) {
+            const args = {};
+            item.args = args;
+            for (const key in rule.args) {
+                const arg = rule.args[key];
+                if (key === 'options' && !Object.keys(arg).length)
+                    continue;
+                args[key] = describeItem(arg, { assign: key });
+            }
+            if (!Object.keys(args).length)
+                delete item.args;
+        }
+        rules.push(item);
+    }
+    if (!rules.length)
+        delete desc.rules;
+    //Terms (must be last to verify no name conflicts)
+    for (const term in schema.$_terms) {
+        if (term[0] === '_')
+            continue;
+        assert(!desc[term], 'Cannot describe schema due to internal name conflict with', term);
+        const items = schema.$_terms[term];
+        if (!items)
+            continue;
+        if (items instanceof Map) {
+            if (items.size)
+                desc[term] = [...items.entries()];
+            continue;
+        }
+        if (Common.isValues(items)) {
+            desc[term] = items.describe();
+            continue;
+        }
+        assert(def.terms[term], 'Term', term, 'missing configuration');
+        const manifest = def.terms[term].manifest;
+        const mapped = typeof manifest === 'object';
+        const list = items;
+        if (!list.length && !mapped)
+            continue;
+        const normalized = [];
+        for (const item of list)
+            normalized.push(describeItem(item));
+        //Mapped
+        if (mapped) {
+            const { from, to } = manifest.mapped;
+            const described = {};
+            desc[term] = described;
+            for (const item of normalized)
+                described[item[to]] = item[from];
+            continue;
+        }
+        //Single
+        if (manifest === 'single') {
+            assert(normalized.length === 1, 'Term', term, 'contains more than one item');
+            desc[term] = normalized[0];
+            continue;
+        }
+        //Array
+        desc[term] = normalized;
+    }
+    validate(schema.$_root, desc);
+    return desc;
+}
+function describeItem(item, options = {}) {
+    //Like upstream (item.map(describe)), without options
+    if (Array.isArray(item))
+        return item.map((entry) => describeItem(entry));
+    if (item === Common.symbols.deepDefault)
+        return { special: 'deep' };
+    if (typeof item !== 'object' || item === null)
+        return item;
+    if (options.assign === 'options')
+        return clone(item);
+    if (Buffer && Buffer.isBuffer(item))
+        return { buffer: item.toString('binary') };
+    if (item instanceof Date)
+        return item.toISOString();
+    if (item instanceof Error)
+        return item;
+    if (item instanceof RegExp) {
+        if (options.assign === 'regex')
+            return item.toString();
+        return { regex: item.toString() };
+    }
+    const record = item;
+    if (record[Common.symbols.literal])
+        return { function: record.literal };
+    if (typeof record.describe === 'function') {
+        const describer = record.describe;
+        if (options.assign === 'ref')
+            return describer.call(item).ref;
+        return describer.call(item);
+    }
+    const normalized = {};
+    for (const key in record) {
+        const value = record[key];
+        if (value === undefined)
+            continue;
+        normalized[key] = describeItem(value, { assign: key });
+    }
+    return normalized;
+}
+/**
+ * Build a schema from its description
+ * @param engine
+ * @param desc
+ */
+export function build(engine, desc) {
+    const builder = new Builder(engine);
+    return builder.parse(desc);
+}
+/**
+ * Builds schemas and values from their descriptions
+ */
+export class Builder {
+    constructor(engine) {
+        this.engine = engine;
+    }
+    parse(desc) {
+        validate(this.engine, desc);
+        //Type
+        let schema = this.engine[desc.type].call(this.engine)._bare();
+        const def = schema._definition;
+        //Flags
+        if (desc.flags) {
+            for (const flag in desc.flags) {
+                const setter = def.flags[flag] && def.flags[flag].setter || flag;
+                assert(typeof schema[setter] === 'function', 'Invalid flag', flag, 'for type', desc.type);
+                schema = call(schema, setter, this.build(desc.flags[flag]));
+            }
+        }
+        //Preferences
+        if (desc.preferences)
+            schema = schema.preferences(this.build(desc.preferences));
+        //Allow / Invalid
+        if (desc.allow)
+            schema = schema.allow(...this.build(desc.allow));
+        if (desc.invalid)
+            schema = schema.invalid(...this.build(desc.invalid));
+        //Rules
+        if (desc.rules) {
+            for (const rule of desc.rules) {
+                assert(typeof schema[rule.name] === 'function', 'Invalid rule', rule.name, 'for type', desc.type);
+                const args = [];
+                if (rule.args) {
+                    const built = {};
+                    for (const key in rule.args)
+                        built[key] = this.build(rule.args[key], { assign: key });
+                    const keys = Object.keys(built);
+                    const definition = def.rules[rule.name].args;
+                    if (definition) {
+                        assert(keys.length <= definition.length, 'Invalid number of arguments for', desc.type, rule.name, '(expected up to', definition.length, ', found', keys.length, ')');
+                        for (const { name } of definition)
+                            args.push(built[name]);
+                    }
+                    else {
+                        assert(keys.length === 1, 'Invalid number of arguments for', desc.type, rule.name, '(expected up to 1, found', keys.length, ')');
+                        args.push(built[keys[0]]);
+                    }
+                }
+                //Apply
+                schema = call(schema, rule.name, ...args);
+                //Ruleset
+                const options = {};
+                for (const custom in def.modifiers) {
+                    if (rule[custom] !== undefined)
+                        options[custom] = this.build(rule[custom]);
+                }
+                if (Object.keys(options).length)
+                    schema = schema.rule(options);
+            }
+        }
+        //Terms
+        const terms = {};
+        for (const key in desc) {
+            if (['allow', 'flags', 'invalid', 'whens', 'preferences', 'rules', 'type'].includes(key))
+                continue;
+            assert(def.terms[key], 'Term', key, 'missing configuration');
+            const manifest = def.terms[key].manifest;
+            if (manifest === 'schema') {
+                terms[key] = desc[key].map((item) => this.parse(item));
+                continue;
+            }
+            if (manifest === 'values') {
+                terms[key] = desc[key].map((item) => this.build(item));
+                continue;
+            }
+            if (manifest === 'single') {
+                terms[key] = this.build(desc[key]);
+                continue;
+            }
+            if (typeof manifest === 'object') {
+                const mapped = {};
+                terms[key] = mapped;
+                const described = desc[key];
+                for (const name in described) {
+                    const value = described[name];
+                    mapped[name] = this.parse(value);
+                }
+                continue;
+            }
+            terms[key] = this.build(desc[key]);
+        }
+        if (desc.whens)
+            terms.whens = desc.whens.map((when) => this.build(when));
+        schema = def.manifest.build(schema, terms);
+        schema.$_temp.ruleset = false;
+        return schema;
+    }
+    build(desc, options = {}) {
+        if (desc === null)
+            return null;
+        if (Array.isArray(desc))
+            return desc.map((item) => this.build(item));
+        if (desc instanceof Error)
+            return desc;
+        if (options.assign === 'options')
+            return clone(desc);
+        if (options.assign === 'regex')
+            return regex(desc);
+        if (options.assign === 'ref')
+            return Ref.build(desc);
+        if (typeof desc !== 'object')
+            return desc;
+        const record = desc;
+        if (Object.keys(record).length === 1) {
+            if (record.buffer) {
+                assert(Buffer, 'Buffers are not supported');
+                return Buffer && Buffer.from(record.buffer, 'binary');
+            }
+            if (record.function)
+                return { [Common.symbols.literal]: true, literal: record.function };
+            if (record.override)
+                return Common.symbols.override;
+            if (record.ref)
+                return Ref.build(record.ref);
+            if (record.regex)
+                return regex(record.regex);
+            if (record.special) {
+                assert(['deep'].includes(record.special), 'Unknown special value', record.special);
+                return Common.symbols.deepDefault;
+            }
+            if (record.value)
+                return clone(record.value);
+        }
+        if (record.type)
+            return this.parse(record);
+        if (record.template)
+            return Template.build(record);
+        const normalized = {};
+        for (const key in record)
+            normalized[key] = this.build(record[key], { assign: key });
+        return normalized;
+    }
+}
+function call(schema, name, ...args) {
+    return schema[name].call(schema, ...args);
+}
+function regex(string) {
+    const end = string.lastIndexOf('/');
+    const exp = string.slice(1, end);
+    const flags = string.slice(end + 1);
+    return new RegExp(exp, flags);
+}
+function validate(engine, desc) {
+    Schemas = Schemas || Lazy.schemas();
+    engine.assert(desc, Schemas.description);
+}