@nocobase/plugin-workflow-javascript 2.1.0-alpha.12 → 2.1.0-alpha.14

package/dist/node_modules/joi/lib/validator.js

@@ -0,0 +1,750 @@
+'use strict';
+
+const Assert = require('@hapi/hoek/lib/assert');
+const Clone = require('@hapi/hoek/lib/clone');
+const Ignore = require('@hapi/hoek/lib/ignore');
+const Reach = require('@hapi/hoek/lib/reach');
+
+const Common = require('./common');
+const Errors = require('./errors');
+const State = require('./state');
+
+
+const internals = {
+    result: Symbol('result')
+};
+
+
+exports.entry = function (value, schema, prefs) {
+
+    let settings = Common.defaults;
+    if (prefs) {
+        Assert(prefs.warnings === undefined, 'Cannot override warnings preference in synchronous validation');
+        Assert(prefs.artifacts === undefined, 'Cannot override artifacts preference in synchronous validation');
+        settings = Common.preferences(Common.defaults, prefs);
+    }
+
+    const result = internals.entry(value, schema, settings);
+    Assert(!result.mainstay.externals.length, 'Schema with external rules must use validateAsync()');
+    const outcome = { value: result.value };
+
+    if (result.error) {
+        outcome.error = result.error;
+    }
+
+    if (result.mainstay.warnings.length) {
+        outcome.warning = Errors.details(result.mainstay.warnings);
+    }
+
+    if (result.mainstay.debug) {
+        outcome.debug = result.mainstay.debug;
+    }
+
+    if (result.mainstay.artifacts) {
+        outcome.artifacts = result.mainstay.artifacts;
+    }
+
+    return outcome;
+};
+
+
+exports.entryAsync = async function (value, schema, prefs) {
+
+    let settings = Common.defaults;
+    if (prefs) {
+        settings = Common.preferences(Common.defaults, prefs);
+    }
+
+    const result = internals.entry(value, schema, settings);
+    const mainstay = result.mainstay;
+    if (result.error) {
+        if (mainstay.debug) {
+            result.error.debug = mainstay.debug;
+        }
+
+        throw result.error;
+    }
+
+    if (mainstay.externals.length) {
+        let root = result.value;
+        const errors = [];
+        for (const external of mainstay.externals) {
+            const path = external.state.path;
+            const linked = external.schema.type === 'link' ? mainstay.links.get(external.schema) : null;
+            let node = root;
+            let key;
+            let parent;
+
+            const ancestors = path.length ? [root] : [];
+            const original = path.length ? Reach(value, path) : value;
+
+            if (path.length) {
+                key = path[path.length - 1];
+
+                let current = root;
+                for (const segment of path.slice(0, -1)) {
+                    current = current[segment];
+                    ancestors.unshift(current);
+                }
+
+                parent = ancestors[0];
+                node = parent[key];
+            }
+
+            try {
+                const createError = (code, local) => (linked || external.schema).$_createError(code, node, local, external.state, settings);
+                const output = await external.method(node, {
+                    schema: external.schema,
+                    linked,
+                    state: external.state,
+                    prefs,
+                    original,
+                    error: createError,
+                    errorsArray: internals.errorsArray,
+                    warn: (code, local) => mainstay.warnings.push((linked || external.schema).$_createError(code, node, local, external.state, settings)),
+                    message: (messages, local) => (linked || external.schema).$_createError('external', node, local, external.state, settings, { messages })
+                });
+
+                if (output === undefined ||
+                    output === node) {
+
+                    continue;
+                }
+
+                if (output instanceof Errors.Report) {
+                    mainstay.tracer.log(external.schema, external.state, 'rule', 'external', 'error');
+                    errors.push(output);
+
+                    if (settings.abortEarly) {
+                        break;
+                    }
+
+                    continue;
+                }
+
+                if (Array.isArray(output) &&
+                    output[Common.symbols.errors]) {
+                    mainstay.tracer.log(external.schema, external.state, 'rule', 'external', 'error');
+                    errors.push(...output);
+
+                    if (settings.abortEarly) {
+                        break;
+                    }
+
+                    continue;
+                }
+
+                if (parent) {
+                    mainstay.tracer.value(external.state, 'rule', node, output, 'external');
+                    parent[key] = output;
+                }
+                else {
+                    mainstay.tracer.value(external.state, 'rule', root, output, 'external');
+                    root = output;
+                }
+            }
+            catch (err) {
+                if (settings.errors.label) {
+                    err.message += ` (${(external.label)})`;       // Change message to include path
+                }
+
+                throw err;
+            }
+        }
+
+        result.value = root;
+
+        if (errors.length) {
+            result.error = Errors.process(errors, value, settings);
+
+            if (mainstay.debug) {
+                result.error.debug = mainstay.debug;
+            }
+
+            throw result.error;
+        }
+    }
+
+    if (!settings.warnings &&
+        !settings.debug &&
+        !settings.artifacts) {
+
+        return result.value;
+    }
+
+    const outcome = { value: result.value };
+    if (mainstay.warnings.length) {
+        outcome.warning = Errors.details(mainstay.warnings);
+    }
+
+    if (mainstay.debug) {
+        outcome.debug = mainstay.debug;
+    }
+
+    if (mainstay.artifacts) {
+        outcome.artifacts = mainstay.artifacts;
+    }
+
+    return outcome;
+};
+
+
+internals.Mainstay = class {
+
+    constructor(tracer, debug, links) {
+
+        this.externals = [];
+        this.warnings = [];
+        this.tracer = tracer;
+        this.debug = debug;
+        this.links = links;
+        this.shadow = null;
+        this.artifacts = null;
+
+        this._snapshots = [];
+    }
+
+    snapshot() {
+
+        this._snapshots.push({
+            externals: this.externals.slice(),
+            warnings: this.warnings.slice()
+        });
+    }
+
+    restore() {
+
+        const snapshot = this._snapshots.pop();
+        this.externals = snapshot.externals;
+        this.warnings = snapshot.warnings;
+    }
+
+    commit() {
+
+        this._snapshots.pop();
+    }
+};
+
+
+internals.entry = function (value, schema, prefs) {
+
+    // Prepare state
+
+    const { tracer, cleanup } = internals.tracer(schema, prefs);
+    const debug = prefs.debug ? [] : null;
+    const links = schema._ids._schemaChain ? new Map() : null;
+    const mainstay = new internals.Mainstay(tracer, debug, links);
+    const schemas = schema._ids._schemaChain ? [{ schema }] : null;
+    const state = new State([], [], { mainstay, schemas });
+
+    // Validate value
+
+    const result = exports.validate(value, schema, state, prefs);
+
+    // Process value and errors
+
+    if (cleanup) {
+        schema.$_root.untrace();
+    }
+
+    const error = Errors.process(result.errors, value, prefs);
+    return { value: result.value, error, mainstay };
+};
+
+
+internals.tracer = function (schema, prefs) {
+
+    if (schema.$_root._tracer) {
+        return { tracer: schema.$_root._tracer._register(schema) };
+    }
+
+    if (prefs.debug) {
+        Assert(schema.$_root.trace, 'Debug mode not supported');
+        return { tracer: schema.$_root.trace()._register(schema), cleanup: true };
+    }
+
+    return { tracer: internals.ignore };
+};
+
+
+exports.validate = function (value, schema, state, prefs, overrides = {}) {
+
+    if (schema.$_terms.whens) {
+        schema = schema._generate(value, state, prefs).schema;
+    }
+
+    // Setup state and settings
+
+    if (schema._preferences) {
+        prefs = internals.prefs(schema, prefs);
+    }
+
+    // Cache
+
+    if (schema._cache &&
+        prefs.cache) {
+
+        const result = schema._cache.get(value);
+        state.mainstay.tracer.debug(state, 'validate', 'cached', !!result);
+        if (result) {
+            return result;
+        }
+    }
+
+    // Helpers
+
+    const createError = (code, local, localState) => schema.$_createError(code, value, local, localState || state, prefs);
+    const helpers = {
+        original: value,
+        prefs,
+        schema,
+        state,
+        error: createError,
+        errorsArray: internals.errorsArray,
+        warn: (code, local, localState) => state.mainstay.warnings.push(createError(code, local, localState)),
+        message: (messages, local) => schema.$_createError('custom', value, local, state, prefs, { messages })
+    };
+
+    // Prepare
+
+    state.mainstay.tracer.entry(schema, state);
+
+    const def = schema._definition;
+    if (def.prepare &&
+        value !== undefined &&
+        prefs.convert) {
+
+        const prepared = def.prepare(value, helpers);
+        if (prepared) {
+            state.mainstay.tracer.value(state, 'prepare', value, prepared.value);
+            if (prepared.errors) {
+                return internals.finalize(prepared.value, [].concat(prepared.errors), helpers);         // Prepare error always aborts early
+            }
+
+            value = prepared.value;
+        }
+    }
+
+    // Type coercion
+
+    if (def.coerce &&
+        value !== undefined &&
+        prefs.convert &&
+        (!def.coerce.from || def.coerce.from.includes(typeof value))) {
+
+        const coerced = def.coerce.method(value, helpers);
+        if (coerced) {
+            state.mainstay.tracer.value(state, 'coerced', value, coerced.value);
+            if (coerced.errors) {
+                return internals.finalize(coerced.value, [].concat(coerced.errors), helpers);           // Coerce error always aborts early
+            }
+
+            value = coerced.value;
+        }
+    }
+
+    // Empty value
+
+    const empty = schema._flags.empty;
+    if (empty &&
+        empty.$_match(internals.trim(value, schema), state.nest(empty), Common.defaults)) {
+
+        state.mainstay.tracer.value(state, 'empty', value, undefined);
+        value = undefined;
+    }
+
+    // Presence requirements (required, optional, forbidden)
+
+    const presence = overrides.presence || schema._flags.presence || (schema._flags._endedSwitch ? null : prefs.presence);
+    if (value === undefined) {
+        if (presence === 'forbidden') {
+            return internals.finalize(value, null, helpers);
+        }
+
+        if (presence === 'required') {
+            return internals.finalize(value, [schema.$_createError('any.required', value, null, state, prefs)], helpers);
+        }
+
+        if (presence === 'optional') {
+            if (schema._flags.default !== Common.symbols.deepDefault) {
+                return internals.finalize(value, null, helpers);
+            }
+
+            state.mainstay.tracer.value(state, 'default', value, {});
+            value = {};
+        }
+    }
+    else if (presence === 'forbidden') {
+        return internals.finalize(value, [schema.$_createError('any.unknown', value, null, state, prefs)], helpers);
+    }
+
+    // Allowed values
+
+    const errors = [];
+
+    if (schema._valids) {
+        const match = schema._valids.get(value, state, prefs, schema._flags.insensitive);
+        if (match) {
+            if (prefs.convert) {
+                state.mainstay.tracer.value(state, 'valids', value, match.value);
+                value = match.value;
+            }
+
+            state.mainstay.tracer.filter(schema, state, 'valid', match);
+            return internals.finalize(value, null, helpers);
+        }
+
+        if (schema._flags.only) {
+            const report = schema.$_createError('any.only', value, { valids: schema._valids.values({ display: true }) }, state, prefs);
+            if (prefs.abortEarly) {
+                return internals.finalize(value, [report], helpers);
+            }
+
+            errors.push(report);
+        }
+    }
+
+    // Denied values
+
+    if (schema._invalids) {
+        const match = schema._invalids.get(value, state, prefs, schema._flags.insensitive);
+        if (match) {
+            state.mainstay.tracer.filter(schema, state, 'invalid', match);
+            const report = schema.$_createError('any.invalid', value, { invalids: schema._invalids.values({ display: true }) }, state, prefs);
+            if (prefs.abortEarly) {
+                return internals.finalize(value, [report], helpers);
+            }
+
+            errors.push(report);
+        }
+    }
+
+    // Base type
+
+    if (def.validate) {
+        const base = def.validate(value, helpers);
+        if (base) {
+            state.mainstay.tracer.value(state, 'base', value, base.value);
+            value = base.value;
+
+            if (base.errors) {
+                if (!Array.isArray(base.errors)) {
+                    errors.push(base.errors);
+                    return internals.finalize(value, errors, helpers);          // Base error always aborts early
+                }
+
+                if (base.errors.length) {
+                    errors.push(...base.errors);
+                    return internals.finalize(value, errors, helpers);          // Base error always aborts early
+                }
+            }
+        }
+    }
+
+    // Validate tests
+
+    if (!schema._rules.length) {
+        return internals.finalize(value, errors, helpers);
+    }
+
+    return internals.rules(value, errors, helpers);
+};
+
+
+internals.rules = function (value, errors, helpers) {
+
+    const { schema, state, prefs } = helpers;
+
+    for (const rule of schema._rules) {
+        const definition = schema._definition.rules[rule.method];
+
+        // Skip rules that are also applied in coerce step
+
+        if (definition.convert &&
+            prefs.convert) {
+
+            state.mainstay.tracer.log(schema, state, 'rule', rule.name, 'full');
+            continue;
+        }
+
+        // Resolve references
+
+        let ret;
+        let args = rule.args;
+        if (rule._resolve.length) {
+            args = Object.assign({}, args);                                     // Shallow copy
+            for (const key of rule._resolve) {
+                const resolver = definition.argsByName.get(key);
+
+                const resolved = args[key].resolve(value, state, prefs);
+                const normalized = resolver.normalize ? resolver.normalize(resolved) : resolved;
+
+                const invalid = Common.validateArg(normalized, null, resolver);
+                if (invalid) {
+                    ret = schema.$_createError('any.ref', resolved, { arg: key, ref: args[key], reason: invalid }, state, prefs);
+                    break;
+                }
+
+                args[key] = normalized;
+            }
+        }
+
+        // Test rule
+
+        ret = ret || definition.validate(value, helpers, args, rule);           // Use ret if already set to reference error
+
+        const result = internals.rule(ret, rule);
+        if (result.errors) {
+            state.mainstay.tracer.log(schema, state, 'rule', rule.name, 'error');
+
+            if (rule.warn) {
+                state.mainstay.warnings.push(...result.errors);
+                continue;
+            }
+
+            if (prefs.abortEarly) {
+                return internals.finalize(value, result.errors, helpers);
+            }
+
+            errors.push(...result.errors);
+        }
+        else {
+            state.mainstay.tracer.log(schema, state, 'rule', rule.name, 'pass');
+            state.mainstay.tracer.value(state, 'rule', value, result.value, rule.name);
+            value = result.value;
+        }
+    }
+
+    return internals.finalize(value, errors, helpers);
+};
+
+
+internals.rule = function (ret, rule) {
+
+    if (ret instanceof Errors.Report) {
+        internals.error(ret, rule);
+        return { errors: [ret], value: null };
+    }
+
+    if (Array.isArray(ret) &&
+        ret[Common.symbols.errors]) {
+
+        ret.forEach((report) => internals.error(report, rule));
+        return { errors: ret, value: null };
+    }
+
+    return { errors: null, value: ret };
+};
+
+
+internals.error = function (report, rule) {
+
+    if (rule.message) {
+        report._setTemplate(rule.message);
+    }
+
+    return report;
+};
+
+
+internals.finalize = function (value, errors, helpers) {
+
+    errors = errors || [];
+    const { schema, state, prefs } = helpers;
+
+    // Failover value
+
+    if (errors.length) {
+        const failover = internals.default('failover', undefined, errors, helpers);
+        if (failover !== undefined) {
+            state.mainstay.tracer.value(state, 'failover', value, failover);
+            value = failover;
+            errors = [];
+        }
+    }
+
+    // Error override
+
+    if (errors.length &&
+        schema._flags.error) {
+
+        if (typeof schema._flags.error === 'function') {
+            errors = schema._flags.error(errors);
+            if (!Array.isArray(errors)) {
+                errors = [errors];
+            }
+
+            for (const error of errors) {
+                Assert(error instanceof Error || error instanceof Errors.Report, 'error() must return an Error object');
+            }
+        }
+        else {
+            errors = [schema._flags.error];
+        }
+    }
+
+    // Default
+
+    if (value === undefined) {
+        const defaulted = internals.default('default', value, errors, helpers);
+        state.mainstay.tracer.value(state, 'default', value, defaulted);
+        value = defaulted;
+    }
+
+    // Cast
+
+    if (schema._flags.cast &&
+        value !== undefined) {
+
+        const caster = schema._definition.cast[schema._flags.cast];
+        if (caster.from(value)) {
+            const casted = caster.to(value, helpers);
+            state.mainstay.tracer.value(state, 'cast', value, casted, schema._flags.cast);
+            value = casted;
+        }
+    }
+
+    // Externals
+
+    if (schema.$_terms.externals &&
+        prefs.externals &&
+        prefs._externals !== false) {                       // Disabled for matching
+
+        for (const { method } of schema.$_terms.externals) {
+            state.mainstay.externals.push({ method, schema, state, label: Errors.label(schema._flags, state, prefs) });
+        }
+    }
+
+    // Result
+
+    const result = { value, errors: errors.length ? errors : null };
+
+    if (schema._flags.result) {
+        result.value = schema._flags.result === 'strip' ? undefined : /* raw */ helpers.original;
+        state.mainstay.tracer.value(state, schema._flags.result, value, result.value);
+        state.shadow(value, schema._flags.result);
+    }
+
+    // Cache
+
+    if (schema._cache &&
+        prefs.cache !== false &&
+        !schema._refs.length) {
+
+        schema._cache.set(helpers.original, result);
+    }
+
+    // Artifacts
+
+    if (value !== undefined &&
+        !result.errors &&
+        schema._flags.artifact !== undefined) {
+
+        state.mainstay.artifacts = state.mainstay.artifacts || new Map();
+        if (!state.mainstay.artifacts.has(schema._flags.artifact)) {
+            state.mainstay.artifacts.set(schema._flags.artifact, []);
+        }
+
+        state.mainstay.artifacts.get(schema._flags.artifact).push(state.path);
+    }
+
+    return result;
+};
+
+
+internals.prefs = function (schema, prefs) {
+
+    const isDefaultOptions = prefs === Common.defaults;
+    if (isDefaultOptions &&
+        schema._preferences[Common.symbols.prefs]) {
+
+        return schema._preferences[Common.symbols.prefs];
+    }
+
+    prefs = Common.preferences(prefs, schema._preferences);
+    if (isDefaultOptions) {
+        schema._preferences[Common.symbols.prefs] = prefs;
+    }
+
+    return prefs;
+};
+
+
+internals.default = function (flag, value, errors, helpers) {
+
+    const { schema, state, prefs } = helpers;
+    const source = schema._flags[flag];
+    if (prefs.noDefaults ||
+        source === undefined) {
+
+        return value;
+    }
+
+    state.mainstay.tracer.log(schema, state, 'rule', flag, 'full');
+
+    if (!source) {
+        return source;
+    }
+
+    if (typeof source === 'function') {
+        const args = source.length ? [Clone(state.ancestors[0]), helpers] : [];
+
+        try {
+            return source(...args);
+        }
+        catch (err) {
+            errors.push(schema.$_createError(`any.${flag}`, null, { error: err }, state, prefs));
+            return;
+        }
+    }
+
+    if (typeof source !== 'object') {
+        return source;
+    }
+
+    if (source[Common.symbols.literal]) {
+        return source.literal;
+    }
+
+    if (Common.isResolvable(source)) {
+        return source.resolve(value, state, prefs);
+    }
+
+    return Clone(source);
+};
+
+
+internals.trim = function (value, schema) {
+
+    if (typeof value !== 'string') {
+        return value;
+    }
+
+    const trim = schema.$_getRule('trim');
+    if (!trim ||
+        !trim.args.enabled) {
+
+        return value;
+    }
+
+    return value.trim();
+};
+
+
+internals.ignore = {
+    active: false,
+    debug: Ignore,
+    entry: Ignore,
+    filter: Ignore,
+    log: Ignore,
+    resolve: Ignore,
+    value: Ignore
+};
+
+
+internals.errorsArray = function () {
+
+    const errors = [];
+    errors[Common.symbols.errors] = true;
+    return errors;
+};