@depup/joi 18.1.1-depup.0

package/lib/types/binary.js

@@ -0,0 +1,124 @@
+'use strict';
+
+const { assert } = require('@hapi/hoek');
+
+const Any = require('./any');
+const Common = require('../common');
+
+
+const internals = {};
+
+
+module.exports = Any.extend({
+
+    type: 'binary',
+
+    coerce: {
+        from: ['string', 'object'],
+        method(value, { schema }) {
+
+            if (typeof value === 'string' || (value !== null && value.type === 'Buffer')) {
+                try {
+                    return { value: Buffer.from(value, schema._flags.encoding) };
+                }
+                catch { }
+            }
+        }
+    },
+
+    validate(value, { error }) {
+
+        if (!Buffer.isBuffer(value)) {
+            return { value, errors: error('binary.base') };
+        }
+    },
+
+    jsonSchema(schema, res, mode, options) {
+
+        res.type = 'string';
+        res.format = 'binary';
+
+        return res;
+    },
+
+    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 });
+            },
+            jsonSchema(rule, res) {
+
+                res.minLength = rule.args.limit;
+                res.maxLength = rule.args.limit;
+                return res;
+            },
+            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: '<=' });
+            },
+            jsonSchema(rule, res) {
+
+                res.maxLength = rule.args.limit;
+                return res;
+            }
+        },
+
+        min: {
+            method(limit) {
+
+                return this.$_addRule({ name: 'min', method: 'length', args: { limit }, operator: '>=' });
+            },
+            jsonSchema(rule, res) {
+
+                res.minLength = rule.args.limit;
+                return res;
+            }
+        }
+    },
+
+    cast: {
+        string: {
+            from: (value) => Buffer.isBuffer(value),
+            to(value, helpers) {
+
+                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'
+    }
+});

package/lib/types/boolean.js

@@ -0,0 +1,151 @@
+'use strict';
+
+const { assert } = require('@hapi/hoek');
+
+const Any = require('./any');
+const Common = require('../common');
+const Values = require('../values');
+
+
+const internals = {};
+
+
+internals.isBool = function (value) {
+
+    return typeof value === 'boolean';
+};
+
+
+module.exports = 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: internals.isBool,
+            to(value, helpers) {
+
+                return value ? 1 : 0;
+            }
+        },
+        string: {
+            from: internals.isBool,
+            to(value, helpers) {
+
+                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'
+    }
+});

package/lib/types/date.js

@@ -0,0 +1,279 @@
+'use strict';
+
+const { assert } = require('@hapi/hoek');
+
+const Any = require('./any');
+const Common = require('../common');
+const Template = require('../template');
+
+
+const internals = {
+    formats: ['iso', 'javascript', 'unix']
+};
+
+
+internals.isDate = function (value) {
+
+    return value instanceof Date;
+};
+
+
+module.exports = Any.extend({
+
+    type: 'date',
+
+    coerce: {
+        from: ['number', 'string'],
+        method(value, { schema }) {
+
+            return { value: internals.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 }) };
+    },
+
+    jsonSchema(schema, res, mode, options) {
+
+        res.type = 'string';
+        res.format = 'date-time';
+
+        return res;
+    },
+
+    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 : internals.parse(date);
+                    },
+                    assert: (date) => date !== null,
+                    message: 'must have a valid date format'
+                }
+            ]
+        },
+
+        format: {
+            method(format) {
+
+                assert(internals.formats.includes(format), 'Unknown date format', format);
+
+                return this.$_setFlag('format', format);
+            }
+        },
+
+        greater: {
+            method(date) {
+
+                return this.$_addRule({ name: 'greater', method: 'compare', args: { date }, operator: '>' });
+            },
+            jsonSchema(rule, res) {
+
+                const date = rule.args.date;
+                if (date instanceof Date) {
+                    res['x-constraint'] = { ...res['x-constraint'], greater: date.toISOString() };
+                }
+
+                return res;
+            }
+        },
+
+        iso: {
+            method() {
+
+                return this.format('iso');
+            }
+        },
+
+        less: {
+            method(date) {
+
+                return this.$_addRule({ name: 'less', method: 'compare', args: { date }, operator: '<' });
+            },
+            jsonSchema(rule, res) {
+
+                const date = rule.args.date;
+                if (date instanceof Date) {
+                    res['x-constraint'] = { ...res['x-constraint'], less: date.toISOString() };
+                }
+
+                return res;
+            }
+        },
+
+        max: {
+            method(date) {
+
+                return this.$_addRule({ name: 'max', method: 'compare', args: { date }, operator: '<=' });
+            },
+            jsonSchema(rule, res) {
+
+                const date = rule.args.date;
+                if (date instanceof Date) {
+                    res['x-constraint'] = { ...res['x-constraint'], max: date.toISOString() };
+                }
+
+                return res;
+            }
+        },
+
+        min: {
+            method(date) {
+
+                return this.$_addRule({ name: 'min', method: 'compare', args: { date }, operator: '>=' });
+            },
+            jsonSchema(rule, res) {
+
+                const date = rule.args.date;
+                if (date instanceof Date) {
+                    res['x-constraint'] = { ...res['x-constraint'], min: date.toISOString() };
+                }
+
+                return res;
+            }
+        },
+
+        timestamp: {
+            method(type = 'javascript') {
+
+                assert(['javascript', 'unix'].includes(type), '"type" must be one of "javascript, unix"');
+
+                return this.format(type);
+            }
+        }
+    },
+
+    cast: {
+        number: {
+            from: internals.isDate,
+            to(value, helpers) {
+
+                return value.getTime();
+            }
+        },
+        string: {
+            from: internals.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'
+    }
+});
+
+
+// Helpers
+
+internals.parse = function (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 internals.date(value.toString());
+    }
+
+    // Normalize number string
+
+    const original = value;
+    if (typeof value === 'string' &&
+        /^[+-]?\d+(\.\d+)?$/.test(value)) {
+
+        value = parseFloat(value);
+    }
+
+    // Timestamp
+
+    if (format) {
+        if (format === 'javascript') {
+            return internals.date(1 * value);        // Casting to number
+        }
+
+        if (format === 'unix') {
+            return internals.date(1000 * value);
+        }
+
+        if (typeof original === 'string') {
+            return null;
+        }
+    }
+
+    // Plain
+
+    return internals.date(value);
+};
+
+
+internals.date = function (value) {
+
+    const date = new Date(value);
+    if (!isNaN(date.getTime())) {
+        return date;
+    }
+
+    return null;
+};

package/lib/types/function.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const { assert } = require('@hapi/hoek');
+
+const Keys = require('./keys');
+
+
+const internals = {};
+
+
+module.exports = 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}}'
+    }
+});