@lakutata/core 1.0.60 → 3.0.0-beta.0

package/dist/esm/lib/validation/engine/schema/types/binary.js

@@ -0,0 +1,78 @@
+/**
+ * Derived from the upstream lib/types/binary.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { assert } from '../assert.js';
+import Any from './any.js';
+import * as Common from '../common.js';
+const BinaryType = Any.extend({
+    type: 'binary',
+    coerce: {
+        from: ['string', 'object'],
+        method(value, { schema }) {
+            if (typeof value === 'string' || (value !== null && value.type === 'Buffer')) {
+                try {
+                    //A serialized buffer ({type: 'Buffer', data: [...]}) is accepted by Buffer.from() too
+                    return { value: Buffer.from(value, schema._flags.encoding) };
+                }
+                catch {
+                    //Not a value of the encoding: the value is validated as it is
+                }
+            }
+        }
+    },
+    validate(value, { error }) {
+        if (!Buffer.isBuffer(value))
+            return { value, errors: error('binary.base') };
+    },
+    rules: {
+        encoding: {
+            method(encoding) {
+                assert(Buffer.isEncoding(encoding), 'Invalid encoding:', encoding);
+                return this.$_setFlag('encoding', encoding);
+            }
+        },
+        length: {
+            method(limit) {
+                return this.$_addRule({ name: 'length', method: 'length', args: { limit }, operator: '=' });
+            },
+            validate(value, helpers, { limit }, { name, operator, args }) {
+                if (Common.compare(value.length, limit, operator))
+                    return value;
+                return helpers.error('binary.' + name, { limit: args.limit, value });
+            },
+            args: [
+                {
+                    name: 'limit',
+                    ref: true,
+                    assert: Common.limit,
+                    message: 'must be a positive integer'
+                }
+            ]
+        },
+        max: {
+            method(limit) {
+                return this.$_addRule({ name: 'max', method: 'length', args: { limit }, operator: '<=' });
+            }
+        },
+        min: {
+            method(limit) {
+                return this.$_addRule({ name: 'min', method: 'length', args: { limit }, operator: '>=' });
+            }
+        }
+    },
+    cast: {
+        string: {
+            from: (value) => Buffer.isBuffer(value),
+            to(value) {
+                return value.toString();
+            }
+        }
+    },
+    messages: {
+        'binary.base': '{{#label}} must be a buffer or a string',
+        'binary.length': '{{#label}} must be {{#limit}} bytes',
+        'binary.max': '{{#label}} must be less than or equal to {{#limit}} bytes',
+        'binary.min': '{{#label}} must be at least {{#limit}} bytes'
+    }
+});
+export default BinaryType;

package/dist/esm/lib/validation/engine/schema/types/boolean.js

@@ -0,0 +1,104 @@
+/**
+ * Derived from the upstream lib/types/boolean.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { assert } from '../assert.js';
+import Any from './any.js';
+import * as Common from '../common.js';
+import { Values } from '../values.js';
+function isBool(value) {
+    return typeof value === 'boolean';
+}
+const BooleanType = Any.extend({
+    type: 'boolean',
+    flags: {
+        sensitive: { default: false }
+    },
+    terms: {
+        falsy: {
+            init: null,
+            manifest: 'values'
+        },
+        truthy: {
+            init: null,
+            manifest: 'values'
+        }
+    },
+    coerce(value, { schema }) {
+        if (typeof value === 'boolean')
+            return;
+        if (typeof value === 'string') {
+            const trimmedValue = value.trim();
+            const normalized = schema._flags.sensitive ? trimmedValue : trimmedValue.toLowerCase();
+            value = normalized === 'true' ? true : (normalized === 'false' ? false : value);
+        }
+        if (typeof value !== 'boolean') {
+            value = schema.$_terms.truthy && schema.$_terms.truthy.has(value, null, null, !schema._flags.sensitive) ||
+                (schema.$_terms.falsy && schema.$_terms.falsy.has(value, null, null, !schema._flags.sensitive) ? false : value);
+        }
+        return { value };
+    },
+    validate(value, { error }) {
+        if (typeof value !== 'boolean')
+            return { value, errors: error('boolean.base') };
+    },
+    rules: {
+        truthy: {
+            method(...values) {
+                Common.verifyFlat(values, 'truthy');
+                const obj = this.clone();
+                obj.$_terms.truthy = obj.$_terms.truthy || new Values();
+                for (let i = 0; i < values.length; ++i) {
+                    const value = values[i];
+                    assert(value !== undefined, 'Cannot call truthy with undefined');
+                    obj.$_terms.truthy.add(value);
+                }
+                return obj;
+            }
+        },
+        falsy: {
+            method(...values) {
+                Common.verifyFlat(values, 'falsy');
+                const obj = this.clone();
+                obj.$_terms.falsy = obj.$_terms.falsy || new Values();
+                for (let i = 0; i < values.length; ++i) {
+                    const value = values[i];
+                    assert(value !== undefined, 'Cannot call falsy with undefined');
+                    obj.$_terms.falsy.add(value);
+                }
+                return obj;
+            }
+        },
+        sensitive: {
+            method(enabled = true) {
+                return this.$_setFlag('sensitive', enabled);
+            }
+        }
+    },
+    cast: {
+        number: {
+            from: isBool,
+            to(value) {
+                return value ? 1 : 0;
+            }
+        },
+        string: {
+            from: isBool,
+            to(value) {
+                return value ? 'true' : 'false';
+            }
+        }
+    },
+    manifest: {
+        build(obj, desc) {
+            if (desc.truthy)
+                obj = obj.truthy(...desc.truthy);
+            if (desc.falsy)
+                obj = obj.falsy(...desc.falsy);
+            return obj;
+        }
+    },
+    messages: {
+        'boolean.base': '{{#label}} must be a boolean'
+    }
+});
+export default BooleanType;

package/dist/esm/lib/validation/engine/schema/types/date.js

@@ -0,0 +1,159 @@
+/**
+ * Derived from the upstream lib/types/date.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { assert } from '../assert.js';
+import Any from './any.js';
+import * as Common from '../common.js';
+import { Template } from '../template.js';
+function isDate(value) {
+    return value instanceof Date;
+}
+const DateType = Any.extend({
+    type: 'date',
+    coerce: {
+        from: ['number', 'string'],
+        method(value, { schema }) {
+            return { value: parse(value, schema._flags.format) || value };
+        }
+    },
+    validate(value, { schema, error, prefs }) {
+        if (value instanceof Date &&
+            !isNaN(value.getTime())) {
+            return;
+        }
+        const format = schema._flags.format;
+        if (!prefs.convert ||
+            !format ||
+            typeof value !== 'string') {
+            return { value, errors: error('date.base') };
+        }
+        return { value, errors: error('date.format', { format }) };
+    },
+    rules: {
+        compare: {
+            method: false,
+            validate(value, helpers, { date }, { name, operator, args }) {
+                const to = date === 'now' ? Date.now() : date.getTime();
+                if (Common.compare(value.getTime(), to, operator))
+                    return value;
+                return helpers.error('date.' + name, { limit: args.date, value });
+            },
+            args: [
+                {
+                    name: 'date',
+                    ref: true,
+                    normalize: (date) => {
+                        return date === 'now' ? date : parse(date);
+                    },
+                    assert: (date) => date !== null,
+                    message: 'must have a valid date format'
+                }
+            ]
+        },
+        format: {
+            method(format) {
+                assert(['iso', 'javascript', 'unix'].includes(format), 'Unknown date format', format);
+                return this.$_setFlag('format', format);
+            }
+        },
+        greater: {
+            method(date) {
+                return this.$_addRule({ name: 'greater', method: 'compare', args: { date }, operator: '>' });
+            }
+        },
+        iso: {
+            method() {
+                return this.format('iso');
+            }
+        },
+        less: {
+            method(date) {
+                return this.$_addRule({ name: 'less', method: 'compare', args: { date }, operator: '<' });
+            }
+        },
+        max: {
+            method(date) {
+                return this.$_addRule({ name: 'max', method: 'compare', args: { date }, operator: '<=' });
+            }
+        },
+        min: {
+            method(date) {
+                return this.$_addRule({ name: 'min', method: 'compare', args: { date }, operator: '>=' });
+            }
+        },
+        timestamp: {
+            method(type = 'javascript') {
+                assert(['javascript', 'unix'].includes(type), '"type" must be one of "javascript, unix"');
+                return this.format(type);
+            }
+        }
+    },
+    cast: {
+        number: {
+            from: isDate,
+            to(value) {
+                return value.getTime();
+            }
+        },
+        string: {
+            from: isDate,
+            to(value, { prefs }) {
+                return Template.date(value, prefs);
+            }
+        }
+    },
+    messages: {
+        'date.base': '{{#label}} must be a valid date',
+        'date.format': '{{#label}} must be in {msg("date.format." + #format) || #format} format',
+        'date.greater': '{{#label}} must be greater than {{:#limit}}',
+        'date.less': '{{#label}} must be less than {{:#limit}}',
+        'date.max': '{{#label}} must be less than or equal to {{:#limit}}',
+        'date.min': '{{#label}} must be greater than or equal to {{:#limit}}',
+        //Messages used in date.format
+        'date.format.iso': 'ISO 8601 date',
+        'date.format.javascript': 'timestamp or number of milliseconds',
+        'date.format.unix': 'timestamp or number of seconds'
+    }
+});
+export default DateType;
+//Helpers
+function parse(value, format) {
+    if (value instanceof Date)
+        return value;
+    if (typeof value !== 'string' &&
+        (isNaN(value) || !isFinite(value))) {
+        return null;
+    }
+    if (/^\s*$/.test(value))
+        return null;
+    //ISO
+    if (format === 'iso') {
+        if (!Common.isIsoDate(value))
+            return null;
+        return date(value.toString());
+    }
+    //Normalize number string
+    const original = value;
+    if (typeof value === 'string' &&
+        /^[+-]?\d+(\.\d+)?$/.test(value)) {
+        value = parseFloat(value);
+    }
+    //Timestamp
+    if (format) {
+        //Casting to number
+        if (format === 'javascript')
+            return date(1 * value);
+        if (format === 'unix')
+            return date(1000 * value);
+        if (typeof original === 'string')
+            return null;
+    }
+    //Plain
+    return date(value);
+}
+function date(value) {
+    const date = new Date(value);
+    if (!isNaN(date.getTime()))
+        return date;
+    return null;
+}

package/dist/esm/lib/validation/engine/schema/types/function.js

@@ -0,0 +1,63 @@
+/**
+ * Derived from the upstream lib/types/function.js (see UPSTREAM.md; BSD-3-Clause, see THIRD_PARTY_NOTICES.md)
+ */
+import { assert } from '../assert.js';
+import Keys from './keys.js';
+const FunctionType = Keys.extend({
+    type: 'function',
+    properties: {
+        typeof: 'function'
+    },
+    rules: {
+        arity: {
+            method(n) {
+                assert(Number.isSafeInteger(n) && n >= 0, 'n must be a positive integer');
+                return this.$_addRule({ name: 'arity', args: { n } });
+            },
+            validate(value, helpers, { n }) {
+                if (value.length === n)
+                    return value;
+                return helpers.error('function.arity', { n });
+            }
+        },
+        class: {
+            method() {
+                return this.$_addRule('class');
+            },
+            validate(value, helpers) {
+                if ((/^\s*class\s/).test(value.toString()))
+                    return value;
+                return helpers.error('function.class', { value });
+            }
+        },
+        minArity: {
+            method(n) {
+                assert(Number.isSafeInteger(n) && n > 0, 'n must be a strict positive integer');
+                return this.$_addRule({ name: 'minArity', args: { n } });
+            },
+            validate(value, helpers, { n }) {
+                if (value.length >= n)
+                    return value;
+                return helpers.error('function.minArity', { n });
+            }
+        },
+        maxArity: {
+            method(n) {
+                assert(Number.isSafeInteger(n) && n >= 0, 'n must be a positive integer');
+                return this.$_addRule({ name: 'maxArity', args: { n } });
+            },
+            validate(value, helpers, { n }) {
+                if (value.length <= n)
+                    return value;
+                return helpers.error('function.maxArity', { n });
+            }
+        }
+    },
+    messages: {
+        'function.arity': '{{#label}} must have an arity of {{#n}}',
+        'function.class': '{{#label}} must be a class',
+        'function.maxArity': '{{#label}} must have an arity lesser or equal to {{#n}}',
+        'function.minArity': '{{#label}} must have an arity greater or equal to {{#n}}'
+    }
+});
+export default FunctionType;