@lakutata/core 1.0.59 → 3.0.0-beta.0

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

@@ -0,0 +1,199 @@
+/**
+ * Derived from the upstream lib/extend.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 * as Messages from './messages.js';
+/**
+ * A new type (a schema with its own prototype), extending the type of a schema
+ * @param from
+ * @param options
+ */
+export function type(from, options) {
+    const base = Object.getPrototypeOf(from);
+    const prototype = clone(base);
+    const schema = from._assign(Object.create(prototype));
+    //Shallow cloned
+    const def = Object.assign({}, options);
+    delete def.base;
+    //Normalized in place below, like upstream
+    const extended = def;
+    prototype._definition = extended;
+    const parent = base._definition || {};
+    extended.messages = Messages.merge(parent.messages, def.messages);
+    extended.properties = Object.assign({}, parent.properties, def.properties);
+    //Type
+    schema.type = def.type;
+    //Flags
+    extended.flags = Object.assign({}, parent.flags, def.flags);
+    //Terms
+    const terms = Object.assign({}, parent.terms);
+    if (def.terms) {
+        //Only apply own terms
+        for (const name in def.terms) {
+            const term = def.terms[name];
+            assert(schema.$_terms[name] === undefined, 'Invalid term override for', def.type, name);
+            schema.$_terms[name] = term.init;
+            terms[name] = term;
+        }
+    }
+    extended.terms = terms;
+    //Constructor arguments
+    if (!def.args)
+        extended.args = parent.args;
+    //Prepare
+    extended.prepare = prepare(def.prepare, parent.prepare);
+    //Coerce
+    if (def.coerce) {
+        if (typeof def.coerce === 'function')
+            def.coerce = { method: def.coerce };
+        if (def.coerce.from && !Array.isArray(def.coerce.from))
+            def.coerce = { method: def.coerce.method, from: [].concat(def.coerce.from) };
+    }
+    extended.coerce = coerce(def.coerce, parent.coerce);
+    //Validate
+    extended.validate = validate(def.validate, parent.validate);
+    //Rules
+    const rules = Object.assign({}, parent.rules);
+    if (def.rules) {
+        for (const name in def.rules) {
+            const rule = def.rules[name];
+            assert(typeof rule === 'object', 'Invalid rule definition for', def.type, name);
+            let method = rule.method;
+            if (method === undefined) {
+                method = function () {
+                    return this.$_addRule(name);
+                };
+            }
+            if (method) {
+                assert(!prototype[name], 'Rule conflict in', def.type, name);
+                prototype[name] = method;
+            }
+            assert(!rules[name], 'Rule conflict in', def.type, name);
+            rules[name] = rule;
+            if (rule.alias) {
+                const aliases = [].concat(rule.alias);
+                for (const alias of aliases)
+                    prototype[alias] = rule.method;
+            }
+            if (rule.args) {
+                const argsByName = new Map();
+                rule.argsByName = argsByName;
+                rule.args = rule.args.map((arg) => {
+                    if (typeof arg === 'string')
+                        arg = { name: arg };
+                    assert(!argsByName.has(arg.name), 'Duplicated argument name', arg.name);
+                    if (Common.isSchema(arg.assert))
+                        arg.assert = arg.assert.strict().label(arg.name);
+                    argsByName.set(arg.name, arg);
+                    return arg;
+                });
+            }
+        }
+    }
+    extended.rules = rules;
+    //Modifiers
+    const modifiers = Object.assign({}, parent.modifiers);
+    if (def.modifiers) {
+        for (const name in def.modifiers) {
+            assert(!prototype[name], 'Rule conflict in', def.type, name);
+            const modifier = def.modifiers[name];
+            assert(typeof modifier === 'function', 'Invalid modifier definition for', def.type, name);
+            const method = function (arg) {
+                return this.rule({ [name]: arg });
+            };
+            prototype[name] = method;
+            modifiers[name] = modifier;
+        }
+    }
+    extended.modifiers = modifiers;
+    //Overrides
+    if (def.overrides) {
+        prototype._super = base;
+        //Backwards compatibility
+        schema.$_super = {};
+        for (const override in def.overrides) {
+            const overridden = base[override];
+            assert(overridden, 'Cannot override missing', override);
+            def.overrides[override][Common.symbols.parent] = overridden;
+            //Backwards compatibility
+            schema.$_super[override] = overridden.bind(schema);
+        }
+        Object.assign(prototype, def.overrides);
+    }
+    //Casts
+    extended.cast = Object.assign({}, parent.cast, def.cast);
+    //Manifest
+    const manifest = Object.assign({}, parent.manifest, def.manifest);
+    manifest.build = build(def.manifest && def.manifest.build, parent.manifest && parent.manifest.build);
+    extended.manifest = manifest;
+    //Rebuild
+    extended.rebuild = rebuild(def.rebuild, parent.rebuild);
+    return schema;
+}
+function build(child, parent) {
+    if (!child || !parent)
+        return child || parent;
+    return function (obj, desc) {
+        return parent(child(obj, desc), desc);
+    };
+}
+function coerce(child, parent) {
+    if (!child || !parent)
+        return child || parent;
+    return {
+        from: child.from && parent.from ? [...new Set([...child.from, ...parent.from])] : null,
+        method(value, helpers) {
+            let coerced;
+            if (!parent.from || parent.from.includes(typeof value)) {
+                coerced = parent.method(value, helpers);
+                if (coerced) {
+                    if (coerced.errors || coerced.value === undefined)
+                        return coerced;
+                    value = coerced.value;
+                }
+            }
+            if (!child.from || child.from.includes(typeof value)) {
+                const own = child.method(value, helpers);
+                if (own)
+                    return own;
+            }
+            return coerced;
+        }
+    };
+}
+function prepare(child, parent) {
+    if (!child || !parent)
+        return child || parent;
+    return function (value, helpers) {
+        const prepared = child(value, helpers);
+        if (prepared) {
+            if (prepared.errors || prepared.value === undefined)
+                return prepared;
+            value = prepared.value;
+        }
+        return parent(value, helpers) || prepared;
+    };
+}
+function rebuild(child, parent) {
+    if (!child || !parent)
+        return child || parent;
+    return function (schema) {
+        parent(schema);
+        child(schema);
+    };
+}
+function validate(child, parent) {
+    if (!child || !parent)
+        return child || parent;
+    return function (value, helpers) {
+        const result = parent(value, helpers);
+        if (result) {
+            if (result.errors && (!Array.isArray(result.errors) || result.errors.length))
+                return result;
+            value = result.value;
+        }
+        return child(value, helpers) || result;
+    };
+}

package/dist/esm/lib/validation/engine/schema/extensions/bigint.js

@@ -0,0 +1,170 @@
+const isBigint = (value) => typeof value === 'bigint';
+/**
+ * The bigint extension of the root object
+ * @param _engine the root object (extend() requires the factories of the extensions to take it)
+ */
+export const bigintExtension = (_engine) => ({
+    type: 'bigint',
+    messages: {
+        'bigint.base': '{{#label}} must be a bigint',
+        'bigint.greater': '{{#label}} must be greater than {{#limit}}',
+        'bigint.less': '{{#label}} must be less than {{#limit}}',
+        'bigint.max': '{{#label}} must be less than or equal to {{#limit}}',
+        'bigint.min': '{{#label}} must be greater than or equal to {{#limit}}',
+        'bigint.multiple': '{{#label}} must be a multiple of {{#base}}',
+        'bigint.negative': '{{#label}} must be a negative number',
+        'bigint.port': '{{#label}} must be a valid port',
+        'bigint.positive': '{{#label}} must be a positive number'
+    },
+    coerce(value) {
+        if (typeof value === 'string' || (typeof value === 'number' && Number.isInteger(value))) {
+            try {
+                return { value: BigInt(value) };
+            }
+            catch {
+                //Not convertible: validate() reports it
+            }
+        }
+        return { value };
+    },
+    validate(value, helpers) {
+        if (!isBigint(value))
+            return { value, errors: helpers.error('bigint.base') };
+    },
+    rules: {
+        greater: {
+            method(limit) {
+                return this.$_addRule({ name: 'greater', args: { limit } });
+            },
+            validate(value, helpers, { limit }) {
+                return value > limit ? value : helpers.error('bigint.greater', { limit: limit.toString() });
+            },
+            args: [
+                {
+                    name: 'limit',
+                    ref: true,
+                    assert: isBigint,
+                    message: 'must be a bigint'
+                }
+            ]
+        },
+        less: {
+            method(limit) {
+                return this.$_addRule({ name: 'less', args: { limit } });
+            },
+            validate(value, helpers, { limit }) {
+                return value < limit ? value : helpers.error('bigint.less', { limit: limit.toString() });
+            },
+            args: [
+                {
+                    name: 'limit',
+                    ref: true,
+                    assert: isBigint,
+                    message: 'must be a bigint'
+                }
+            ]
+        },
+        max: {
+            method(limit) {
+                return this.$_addRule({ name: 'max', args: { limit } });
+            },
+            validate(value, helpers, { limit }) {
+                return value <= limit ? value : helpers.error('bigint.max', { limit: limit.toString() });
+            },
+            args: [
+                {
+                    name: 'limit',
+                    ref: true,
+                    assert: isBigint,
+                    message: 'must be a bigint'
+                }
+            ]
+        },
+        min: {
+            method(limit) {
+                return this.$_addRule({ name: 'min', args: { limit } });
+            },
+            validate(value, helpers, { limit }) {
+                return value >= limit ? value : helpers.error('bigint.min', { limit: limit.toString() });
+            },
+            args: [
+                {
+                    name: 'limit',
+                    ref: true,
+                    assert: isBigint,
+                    message: 'must be a bigint'
+                }
+            ]
+        },
+        multiple: {
+            method(base) {
+                return this.$_addRule({ name: 'multiple', args: { base } });
+            },
+            validate(value, helpers, { base }) {
+                //A multiple of the base: 0 and the negative multiples included, as the numbers (upstream refused the
+                //values lower than the base)
+                return value % base === 0n
+                    ? value
+                    : helpers.error('bigint.multiple', { base: base.toString() });
+            },
+            args: [
+                {
+                    name: 'base',
+                    ref: true,
+                    assert: (base) => isBigint(base) && base > 0n,
+                    message: 'must be a positive bigint'
+                }
+            ],
+            multi: true
+        },
+        negative: {
+            method() {
+                return this.$_addRule({ name: 'negative' });
+            },
+            validate(value, helpers) {
+                return value < 0n ? value : helpers.error('bigint.negative');
+            }
+        },
+        port: {
+            method() {
+                return this.$_addRule({ name: 'port' });
+            },
+            validate(value, helpers) {
+                return value >= 0n && value <= 65535n ? value : helpers.error('bigint.port');
+            }
+        },
+        positive: {
+            method() {
+                return this.$_addRule({ name: 'positive' });
+            },
+            validate(value, helpers) {
+                return value > 0n ? value : helpers.error('bigint.positive');
+            }
+        },
+        sign: {
+            method(sign) {
+                return this.$_addRule({ name: 'sign', args: { sign } });
+            },
+            validate(value, helpers, { sign }) {
+                return (sign === 'negative' && value < 0n) || (sign === 'positive' && value > 0n)
+                    ? value
+                    : helpers.error(`bigint.${sign}`);
+            },
+            args: [
+                {
+                    name: 'sign',
+                    assert: (value) => ['negative', 'positive'].includes(value),
+                    message: 'must be "negative" or "positive"'
+                }
+            ]
+        }
+    }
+});
+/**
+ * A root object with the bigint type
+ * @param baseEngine
+ */
+export const extendBigInt = (baseEngine) => {
+    //The extension is typed with its own schema type, the root accepts the extensions of any schema type
+    return baseEngine.extend(bigintExtension);
+};