@lakutata/core 1.0.60 → 3.0.0-beta.0

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

@@ -0,0 +1,364 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Builder = void 0;
+exports.describe = describe;
+exports.build = build;
+/**
+ * Derived from the upstream lib/manifest.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+const index_js_1 = require("../utils/index.js");
+const assert_js_1 = require("./assert.js");
+const Common = __importStar(require("./common.js"));
+const lazy_js_1 = require("./lazy.js");
+const Messages = __importStar(require("./messages.js"));
+const Ref = __importStar(require("./ref.js"));
+const template_js_1 = require("./template.js");
+let Schemas;
+/**
+ * Describe a schema
+ * @param schema
+ */
+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 = (0, index_js_1.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;
+        (0, assert_js_1.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;
+        }
+        (0, assert_js_1.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') {
+            (0, assert_js_1.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 (0, index_js_1.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
+ */
+function build(engine, desc) {
+    const builder = new Builder(engine);
+    return builder.parse(desc);
+}
+/**
+ * Builds schemas and values from their descriptions
+ */
+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;
+                (0, assert_js_1.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) {
+                (0, assert_js_1.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) {
+                        (0, assert_js_1.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 {
+                        (0, assert_js_1.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;
+            (0, assert_js_1.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 (0, index_js_1.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) {
+                (0, assert_js_1.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) {
+                (0, assert_js_1.assert)(['deep'].includes(record.special), 'Unknown special value', record.special);
+                return Common.symbols.deepDefault;
+            }
+            if (record.value)
+                return (0, index_js_1.clone)(record.value);
+        }
+        if (record.type)
+            return this.parse(record);
+        if (record.template)
+            return template_js_1.Template.build(record);
+        const normalized = {};
+        for (const key in record)
+            normalized[key] = this.build(record[key], { assign: key });
+        return normalized;
+    }
+}
+exports.Builder = Builder;
+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_js_1.Lazy.schemas();
+    engine.assert(desc, Schemas.description);
+}

package/dist/cjs/lib/validation/engine/schema/messages.d.ts

@@ -0,0 +1,37 @@
+import { Template } from './template.js';
+/**
+ * A message: a template, or a string (only the 'root' label is kept as a string)
+ */
+export type Message = Template | string;
+/**
+ * Compiled messages of one language, by error code
+ */
+export type LanguageMessages = Record<string, Message>;
+/**
+ * Compiled messages: a single template, or messages by error code and by language
+ */
+export type Messages = Template | Record<string, Message | LanguageMessages>;
+/**
+ * Messages as provided in options: strings or templates, by error code and by language
+ */
+export type MessagesInput = string | Template | Record<string, string | Template | Record<string, string | Template>>;
+export type MessagesDescription = Record<string, unknown>;
+type MessagesRecord = Record<string, Message | LanguageMessages>;
+/**
+ * Compile messages into templates, merged into a copy of target
+ * @param messages
+ * @param target
+ */
+export declare function compile(messages: MessagesInput, target?: Messages | null): Messages;
+/**
+ * Describe compiled messages
+ * @param messages
+ */
+export declare function decompile(messages: MessagesRecord): MessagesDescription;
+/**
+ * Merge extended messages into (a copy of) base messages
+ * @param base
+ * @param extended
+ */
+export declare function merge(base: Messages | null | undefined, extended: MessagesInput | null | undefined): Messages | null | undefined;
+export {};

package/dist/cjs/lib/validation/engine/schema/messages.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = compile;
+exports.decompile = decompile;
+exports.merge = merge;
+/**
+ * Derived from the upstream lib/messages.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+const index_js_1 = require("../utils/index.js");
+const assert_js_1 = require("./assert.js");
+const lazy_js_1 = require("./lazy.js");
+const template_js_1 = require("./template.js");
+/**
+ * Compile messages into templates, merged into a copy of target
+ * @param messages
+ * @param target
+ */
+function compile(messages, target) {
+    //Single value string ('plain error message', 'template {error} message')
+    if (typeof messages === 'string') {
+        (0, assert_js_1.assert)(!target, 'Cannot set single message string');
+        return new template_js_1.Template(messages);
+    }
+    //Single value template
+    if (template_js_1.Template.isTemplate(messages)) {
+        (0, assert_js_1.assert)(!target, 'Cannot set single message template');
+        return messages;
+    }
+    //By error code { 'number.min': <string | template> }
+    (0, assert_js_1.assert)(typeof messages === 'object' && !(0, index_js_1.isArray)(messages), 'Invalid message options');
+    const compiled = target ? (0, index_js_1.clone)(target) : {};
+    for (const code in messages) {
+        const message = messages[code];
+        if (code === 'root' || template_js_1.Template.isTemplate(message)) {
+            compiled[code] = message;
+            continue;
+        }
+        if (typeof message === 'string') {
+            compiled[code] = new template_js_1.Template(message);
+            continue;
+        }
+        //By language { english: { 'number.min': <string | template> } }
+        (0, assert_js_1.assert)(typeof message === 'object' && !(0, index_js_1.isArray)(message), 'Invalid message for', code);
+        const language = code;
+        compiled[language] = compiled[language] || {};
+        const languageMessages = compiled[language];
+        for (const languageCode in message) {
+            const localized = message[languageCode];
+            if (languageCode === 'root' || template_js_1.Template.isTemplate(localized)) {
+                languageMessages[languageCode] = localized;
+                continue;
+            }
+            (0, assert_js_1.assert)(typeof localized === 'string', 'Invalid message for', languageCode, 'in', language);
+            languageMessages[languageCode] = new template_js_1.Template(localized);
+        }
+    }
+    return compiled;
+}
+/**
+ * Describe compiled messages
+ * @param messages
+ */
+function decompile(messages) {
+    //By error code { 'number.min': <string | template> }
+    const target = {};
+    for (const code in messages) {
+        const message = messages[code];
+        if (code === 'root') {
+            target.root = message;
+            continue;
+        }
+        if (template_js_1.Template.isTemplate(message)) {
+            target[code] = message.describe({ compact: true });
+            continue;
+        }
+        //By language { english: { 'number.min': <string | template> } }
+        const language = code;
+        const described = {};
+        target[language] = described;
+        for (const languageCode in message) {
+            const localized = message[languageCode];
+            if (languageCode === 'root') {
+                described.root = localized;
+                continue;
+            }
+            described[languageCode] = localized.describe({ compact: true });
+        }
+    }
+    return target;
+}
+/**
+ * Merge extended messages into (a copy of) base messages
+ * @param base
+ * @param extended
+ */
+function merge(base, extended) {
+    if (!base)
+        return compile(extended);
+    if (!extended)
+        return base;
+    //Single value string
+    if (typeof extended === 'string')
+        return new template_js_1.Template(extended);
+    //Single value template
+    if (template_js_1.Template.isTemplate(extended))
+        return extended;
+    //By error code { 'number.min': <string | template> }
+    const target = (0, index_js_1.clone)(base);
+    for (const code in extended) {
+        const message = extended[code];
+        if (code === 'root' || template_js_1.Template.isTemplate(message)) {
+            target[code] = message;
+            continue;
+        }
+        if (typeof message === 'string') {
+            target[code] = new template_js_1.Template(message);
+            continue;
+        }
+        //By language { english: { 'number.min': <string | template> } }
+        (0, assert_js_1.assert)(typeof message === 'object' && !(0, index_js_1.isArray)(message), 'Invalid message for', code);
+        const language = code;
+        target[language] = target[language] || {};
+        const languageMessages = target[language];
+        for (const languageCode in message) {
+            const localized = message[languageCode];
+            if (languageCode === 'root' || template_js_1.Template.isTemplate(localized)) {
+                languageMessages[languageCode] = localized;
+                continue;
+            }
+            (0, assert_js_1.assert)(typeof localized === 'string', 'Invalid message for', languageCode, 'in', language);
+            languageMessages[languageCode] = new template_js_1.Template(localized);
+        }
+    }
+    return target;
+}
+lazy_js_1.Lazy.messages = { compile: (messages, target) => compile(messages, target) };