joi 14.2.0 → 17.2.0

package/lib/errors.js

@@ -1,74 +1,56 @@
 'use strict';
 
-// Load modules
+const Annotate = require('./annotate');
+const Common = require('./common');
+const Template = require('./template');
 
-const Hoek = require('hoek');
-const Language = require('./language');
 
+const internals = {};
 
-// Declare internals
 
-const internals = {
-    annotations: Symbol('joi-annotations')
-};
+exports.Report = class {
 
-internals.stringify = function (value, wrapArrays) {
+    constructor(code, value, local, flags, messages, state, prefs) {
 
-    const type = typeof value;
+        this.code = code;
+        this.flags = flags;
+        this.messages = messages;
+        this.path = state.path;
+        this.prefs = prefs;
+        this.state = state;
+        this.value = value;
 
-    if (value === null) {
-        return 'null';
-    }
+        this.message = null;
+        this.template = null;
 
-    if (type === 'string') {
-        return value;
-    }
+        this.local = local || {};
+        this.local.label = exports.label(this.flags, this.state, this.prefs, this.messages);
 
-    if (value instanceof exports.Err || type === 'function' || type === 'symbol') {
-        return value.toString();
-    }
+        if (this.value !== undefined &&
+            !this.local.hasOwnProperty('value')) {
 
-    if (type === 'object') {
-        if (Array.isArray(value)) {
-            let partial = '';
+            this.local.value = this.value;
+        }
 
-            for (let i = 0; i < value.length; ++i) {
-                partial = partial + (partial.length ? ', ' : '') + internals.stringify(value[i], wrapArrays);
+        if (this.path.length) {
+            const key = this.path[this.path.length - 1];
+            if (typeof key !== 'object') {
+                this.local.key = key;
             }
-
-            return wrapArrays ? '[' + partial + ']' : partial;
         }
-
-        return value.toString();
     }
 
-    return JSON.stringify(value);
-};
-
-exports.Err = class {
+    _setTemplate(template) {
 
-    constructor(type, context, state, options, flags, message, template) {
-
-        this.isJoi = true;
-        this.type = type;
-        this.context = context || {};
-        this.context.key = state.path[state.path.length - 1];
-        this.context.label = state.key;
-        this.path = state.path;
-        this.options = options;
-        this.flags = flags;
-        this.message = message;
         this.template = template;
 
-        const localized = this.options.language;
+        if (!this.flags.label &&
+            this.path.length === 0) {
 
-        if (this.flags.label) {
-            this.context.label = this.flags.label;
-        }
-        else if (localized &&                   // language can be null for arrays exclusion check
-            (this.context.label === '' ||
-            this.context.label === null)) {
-            this.context.label = localized.root || Language.errors.root;
+            const localized = this._template(this.template, 'root');
+            if (localized) {
+                this.local.label = localized;
+            }
         }
     }
 
@@ -78,294 +60,203 @@ exports.Err = class {
             return this.message;
         }
 
-        let format;
+        const code = this.code;
 
-        if (this.template) {
-            format = this.template;
+        if (!this.prefs.errors.render) {
+            return this.code;
         }
 
-        const localized = this.options.language;
+        const template = this._template(this.template) ||
+            this._template(this.prefs.messages) ||
+            this._template(this.messages);
 
-        format = format || Hoek.reach(localized, this.type) || Hoek.reach(Language.errors, this.type);
-
-        if (format === undefined) {
-            return `Error code "${this.type}" is not defined, your custom type is missing the correct language definition`;
+        if (template === undefined) {
+            return `Error code "${code}" is not defined, your custom type is missing the correct messages definition`;
         }
 
-        let wrapArrays = Hoek.reach(localized, 'messages.wrapArrays');
-        if (typeof wrapArrays !== 'boolean') {
-            wrapArrays = Language.errors.messages.wrapArrays;
+        // Render and cache result
+
+        this.message = template.render(this.value, this.state, this.prefs, this.local, { errors: this.prefs.errors, messages: [this.prefs.messages, this.messages] });
+        if (!this.prefs.errors.label) {
+            this.message = this.message.replace(/^"" /, '').trim();
         }
 
-        if (format === null) {
-            const childrenString = internals.stringify(this.context.reason, wrapArrays);
-            if (wrapArrays) {
-                return childrenString.slice(1, -1);
-            }
+        return this.message;
+    }
 
-            return childrenString;
-        }
+    _template(messages, code) {
+
+        return exports.template(this.value, messages, code || this.code, this.state, this.prefs);
+    }
+};
 
-        const hasKey = /{{!?label}}/.test(format);
-        const skipKey = format.length > 2 && format[0] === '!' && format[1] === '!';
 
-        if (skipKey) {
-            format = format.slice(2);
+exports.path = function (path) {
+
+    let label = '';
+    for (const segment of path) {
+        if (typeof segment === 'object') {          // Exclude array single path segment
+            continue;
         }
 
-        if (!hasKey && !skipKey) {
-            const localizedKey = Hoek.reach(localized, 'key');
-            if (typeof localizedKey === 'string') {
-                format = localizedKey + format;
-            }
-            else {
-                format = Hoek.reach(Language.errors, 'key') + format;
+        if (typeof segment === 'string') {
+            if (label) {
+                label += '.';
             }
+
+            label += segment;
+        }
+        else {
+            label += `[${segment}]`;
         }
+    }
+
+    return label;
+};
 
-        const message =  format.replace(/{{(!?)([^}]+)}}/g, ($0, isSecure, name) => {
 
-            const value = Hoek.reach(this.context, name);
-            const normalized = internals.stringify(value, wrapArrays);
-            return (isSecure && this.options.escapeHtml ? Hoek.escapeHtml(normalized) : normalized);
-        });
+exports.template = function (value, messages, code, state, prefs) {
 
-        this.toString = () => message;  // Persist result of last toString call, it won't change
+    if (!messages) {
+        return;
+    }
 
-        return message;
+    if (Template.isTemplate(messages)) {
+        return code !== 'root' ? messages : null;
     }
 
-};
+    let lang = prefs.errors.language;
+    if (Common.isResolvable(lang)) {
+        lang = lang.resolve(value, state, prefs);
+    }
 
+    if (lang &&
+        messages[lang] &&
+        messages[lang][code] !== undefined) {
 
-exports.create = function (type, context, state, options, flags, message, template) {
+        return messages[lang][code];
+    }
 
-    return new exports.Err(type, context, state, options, flags, message, template);
+    return messages[code];
 };
 
 
-exports.process = function (errors, object) {
+exports.label = function (flags, state, prefs, messages) {
 
-    if (!errors) {
-        return null;
+    if (flags.label) {
+        return flags.label;
     }
 
-    // Construct error
-
-    let message = '';
-    const details = [];
+    if (!prefs.errors.label) {
+        return '';
+    }
 
-    const processErrors = function (localErrors, parent, overrideMessage) {
+    let path = state.path;
+    if (prefs.errors.label === 'key' &&
+        state.path.length > 1) {
 
-        for (let i = 0; i < localErrors.length; ++i) {
-            const item = localErrors[i];
+        path = state.path.slice(-1);
+    }
 
-            if (item instanceof Error) {
-                return item;
-            }
+    const normalized = exports.path(path);
+    if (normalized) {
+        return normalized;
+    }
 
-            if (item.flags.error && typeof item.flags.error !== 'function') {
-                if (!item.flags.selfError || !item.context.reason) {
-                    return item.flags.error;
-                }
-            }
+    return exports.template(null, prefs.messages, 'root', state, prefs) ||
+        messages && exports.template(null, messages, 'root', state, prefs) ||
+        'value';
+};
 
-            let itemMessage;
-            if (parent === undefined) {
-                itemMessage = item.toString();
-                message = message + (message ? '. ' : '') + itemMessage;
-            }
 
-            // Do not push intermediate errors, we're only interested in leafs
+exports.process = function (errors, original, prefs) {
 
-            if (item.context.reason) {
-                const override = processErrors(item.context.reason, item.path, item.type === 'override' ? item.message : null);
-                if (override) {
-                    return override;
-                }
-            }
-            else {
-                details.push({
-                    message: overrideMessage || itemMessage || item.toString(),
-                    path: item.path,
-                    type: item.type,
-                    context: item.context
-                });
-            }
-        }
-    };
+    if (!errors) {
+        return null;
+    }
 
-    const override = processErrors(errors);
+    const { override, message, details } = exports.details(errors);
     if (override) {
         return override;
     }
 
-    const error = new Error(message);
-    error.isJoi = true;
-    error.name = 'ValidationError';
-    error.details = details;
-    error._object = object;
-    error.annotate = internals.annotate;
-    return error;
-};
-
-
-// Inspired by json-stringify-safe
-internals.safeStringify = function (obj, spaces) {
+    if (prefs.errors.stack) {
+        return new exports.ValidationError(message, details, original);
+    }
 
-    return JSON.stringify(obj, internals.serializer(), spaces);
+    const limit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 0;
+    const validationError = new exports.ValidationError(message, details, original);
+    Error.stackTraceLimit = limit;
+    return validationError;
 };
 
-internals.serializer = function () {
-
-    const keys = [];
-    const stack = [];
 
-    const cycleReplacer = (key, value) => {
+exports.details = function (errors, options = {}) {
 
-        if (stack[0] === value) {
-            return '[Circular ~]';
-        }
+    let messages = [];
+    const details = [];
 
-        return '[Circular ~.' + keys.slice(0, stack.indexOf(value)).join('.') + ']';
-    };
+    for (const item of errors) {
 
-    return function (key, value) {
+        // Override
 
-        if (stack.length > 0) {
-            const thisPos = stack.indexOf(this);
-            if (~thisPos) {
-                stack.length = thisPos + 1;
-                keys.length = thisPos + 1;
-                keys[thisPos] = key;
-            }
-            else {
-                stack.push(this);
-                keys.push(key);
+        if (item instanceof Error) {
+            if (options.override !== false) {
+                return { override: item };
             }
 
-            if (~stack.indexOf(value)) {
-                value = cycleReplacer.call(this, key, value);
-            }
-        }
-        else {
-            stack.push(value);
-        }
+            const message = item.toString();
+            messages.push(message);
 
-        if (value) {
-            const annotations = value[internals.annotations];
-            if (annotations) {
-                if (Array.isArray(value)) {
-                    const annotated = [];
-
-                    for (let i = 0; i < value.length; ++i) {
-                        if (annotations.errors[i]) {
-                            annotated.push(`_$idx$_${annotations.errors[i].sort().join(', ')}_$end$_`);
-                        }
-
-                        annotated.push(value[i]);
-                    }
-
-                    value = annotated;
-                }
-                else {
-                    const errorKeys = Object.keys(annotations.errors);
-                    for (let i = 0; i < errorKeys.length; ++i) {
-                        const errorKey = errorKeys[i];
-                        value[`${errorKey}_$key$_${annotations.errors[errorKey].sort().join(', ')}_$end$_`] = value[errorKey];
-                        value[errorKey] = undefined;
-                    }
-
-                    const missingKeys = Object.keys(annotations.missing);
-                    for (let i = 0; i < missingKeys.length; ++i) {
-                        const missingKey = missingKeys[i];
-                        value[`_$miss$_${missingKey}|${annotations.missing[missingKey]}_$end$_`] = '__missing__';
-                    }
-                }
-
-                return value;
-            }
-        }
+            details.push({
+                message,
+                type: 'override',
+                context: { error: item }
+            });
 
-        if (value === Infinity || value === -Infinity || Number.isNaN(value) ||
-            typeof value === 'function' || typeof value === 'symbol') {
-            return '[' + value.toString() + ']';
+            continue;
         }
 
-        return value;
-    };
-};
+        // Report
 
+        const message = item.toString();
+        messages.push(message);
 
-internals.annotate = function (stripColorCodes) {
-
-    const redFgEscape = stripColorCodes ? '' : '\u001b[31m';
-    const redBgEscape = stripColorCodes ? '' : '\u001b[41m';
-    const endColor = stripColorCodes ? '' : '\u001b[0m';
+        details.push({
+            message,
+            path: item.path.filter((v) => typeof v !== 'object'),
+            type: item.code,
+            context: item.local
+        });
+    }
 
-    if (typeof this._object !== 'object') {
-        return this.details[0].message;
+    if (messages.length > 1) {
+        messages = [...new Set(messages)];
     }
 
-    const obj = Hoek.clone(this._object || {});
+    return { message: messages.join('. '), details };
+};
 
-    for (let i = this.details.length - 1; i >= 0; --i) {        // Reverse order to process deepest child first
-        const pos = i + 1;
-        const error = this.details[i];
-        const path = error.path;
-        let ref = obj;
-        for (let j = 0; ; ++j) {
-            const seg = path[j];
 
-            if (ref.isImmutable) {
-                ref = ref.clone();                              // joi schemas are not cloned by hoek, we have to take this extra step
-            }
+exports.ValidationError = class extends Error {
 
-            if (j + 1 < path.length &&
-                ref[seg] &&
-                typeof ref[seg] !== 'string') {
+    constructor(message, details, original) {
 
-                ref = ref[seg];
-            }
-            else {
-                const refAnnotations = ref[internals.annotations] = ref[internals.annotations] || { errors: {}, missing: {} };
-                const value = ref[seg];
-                const cacheKey = seg || error.context.label;
-
-                if (value !== undefined) {
-                    refAnnotations.errors[cacheKey] = refAnnotations.errors[cacheKey] || [];
-                    refAnnotations.errors[cacheKey].push(pos);
-                }
-                else {
-                    refAnnotations.missing[cacheKey] = pos;
-                }
-
-                break;
-            }
-        }
+        super(message);
+        this._original = original;
+        this.details = details;
     }
 
-    const replacers = {
-        key: /_\$key\$_([, \d]+)_\$end\$_"/g,
-        missing: /"_\$miss\$_([^|]+)\|(\d+)_\$end\$_": "__missing__"/g,
-        arrayIndex: /\s*"_\$idx\$_([, \d]+)_\$end\$_",?\n(.*)/g,
-        specials: /"\[(NaN|Symbol.*|-?Infinity|function.*|\(.*)]"/g
-    };
+    static isError(err) {
 
-    let message = internals.safeStringify(obj, 2)
-        .replace(replacers.key, ($0, $1) => `" ${redFgEscape}[${$1}]${endColor}`)
-        .replace(replacers.missing, ($0, $1, $2) => `${redBgEscape}"${$1}"${endColor}${redFgEscape} [${$2}]: -- missing --${endColor}`)
-        .replace(replacers.arrayIndex, ($0, $1, $2) => `\n${$2} ${redFgEscape}[${$1}]${endColor}`)
-        .replace(replacers.specials, ($0, $1) => $1);
+        return err instanceof exports.ValidationError;
+    }
+};
 
-    message = `${message}\n${redFgEscape}`;
 
-    for (let i = 0; i < this.details.length; ++i) {
-        const pos = i + 1;
-        message = `${message}\n[${pos}] ${this.details[i].message}`;
-    }
+exports.ValidationError.prototype.isJoi = true;
 
-    message = message + endColor;
+exports.ValidationError.prototype.name = 'ValidationError';
 
-    return message;
-};
+exports.ValidationError.prototype.annotate = Annotate.error;