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

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

@@ -0,0 +1,346 @@
+'use strict';
+
+const DeepEqual = require('@hapi/hoek/lib/deepEqual');
+const Pinpoint = require('@sideway/pinpoint');
+
+const Errors = require('./errors');
+
+
+const internals = {
+    codes: {
+        error: 1,
+        pass: 2,
+        full: 3
+    },
+    labels: {
+        0: 'never used',
+        1: 'always error',
+        2: 'always pass'
+    }
+};
+
+
+exports.setup = function (root) {
+
+    const trace = function () {
+
+        root._tracer = root._tracer || new internals.Tracer();
+        return root._tracer;
+    };
+
+    root.trace = trace;
+    root[Symbol.for('@hapi/lab/coverage/initialize')] = trace;
+
+    root.untrace = () => {
+
+        root._tracer = null;
+    };
+};
+
+
+exports.location = function (schema) {
+
+    return schema.$_setFlag('_tracerLocation', Pinpoint.location(2));                       // base.tracer(), caller
+};
+
+
+internals.Tracer = class {
+
+    constructor() {
+
+        this.name = 'Joi';
+        this._schemas = new Map();
+    }
+
+    _register(schema) {
+
+        const existing = this._schemas.get(schema);
+        if (existing) {
+            return existing.store;
+        }
+
+        const store = new internals.Store(schema);
+        const { filename, line } = schema._flags._tracerLocation || Pinpoint.location(5);   // internals.tracer(), internals.entry(), exports.entry(), validate(), caller
+        this._schemas.set(schema, { filename, line, store });
+        return store;
+    }
+
+    _combine(merged, sources) {
+
+        for (const { store } of this._schemas.values()) {
+            store._combine(merged, sources);
+        }
+    }
+
+    report(file) {
+
+        const coverage = [];
+
+        // Process each registered schema
+
+        for (const { filename, line, store } of this._schemas.values()) {
+            if (file &&
+                file !== filename) {
+
+                continue;
+            }
+
+            // Process sub schemas of the registered root
+
+            const missing = [];
+            const skipped = [];
+
+            for (const [schema, log] of store._sources.entries()) {
+
+                // Check if sub schema parent skipped
+
+                if (internals.sub(log.paths, skipped)) {
+                    continue;
+                }
+
+                // Check if sub schema reached
+
+                if (!log.entry) {
+                    missing.push({
+                        status: 'never reached',
+                        paths: [...log.paths]
+                    });
+
+                    skipped.push(...log.paths);
+                    continue;
+                }
+
+                // Check values
+
+                for (const type of ['valid', 'invalid']) {
+                    const set = schema[`_${type}s`];
+                    if (!set) {
+                        continue;
+                    }
+
+                    const values = new Set(set._values);
+                    const refs = new Set(set._refs);
+                    for (const { value, ref } of log[type]) {
+                        values.delete(value);
+                        refs.delete(ref);
+                    }
+
+                    if (values.size ||
+                        refs.size) {
+
+                        missing.push({
+                            status: [...values, ...[...refs].map((ref) => ref.display)],
+                            rule: `${type}s`
+                        });
+                    }
+                }
+
+                // Check rules status
+
+                const rules = schema._rules.map((rule) => rule.name);
+                for (const type of ['default', 'failover']) {
+                    if (schema._flags[type] !== undefined) {
+                        rules.push(type);
+                    }
+                }
+
+                for (const name of rules) {
+                    const status = internals.labels[log.rule[name] || 0];
+                    if (status) {
+                        const report = { rule: name, status };
+                        if (log.paths.size) {
+                            report.paths = [...log.paths];
+                        }
+
+                        missing.push(report);
+                    }
+                }
+            }
+
+            if (missing.length) {
+                coverage.push({
+                    filename,
+                    line,
+                    missing,
+                    severity: 'error',
+                    message: `Schema missing tests for ${missing.map(internals.message).join(', ')}`
+                });
+            }
+        }
+
+        return coverage.length ? coverage : null;
+    }
+};
+
+
+internals.Store = class {
+
+    constructor(schema) {
+
+        this.active = true;
+        this._sources = new Map();          // schema -> { paths, entry, rule, valid, invalid }
+        this._combos = new Map();           // merged -> [sources]
+        this._scan(schema);
+    }
+
+    debug(state, source, name, result) {
+
+        state.mainstay.debug && state.mainstay.debug.push({ type: source, name, result, path: state.path });
+    }
+
+    entry(schema, state) {
+
+        internals.debug(state, { type: 'entry' });
+
+        this._record(schema, (log) => {
+
+            log.entry = true;
+        });
+    }
+
+    filter(schema, state, source, value) {
+
+        internals.debug(state, { type: source, ...value });
+
+        this._record(schema, (log) => {
+
+            log[source].add(value);
+        });
+    }
+
+    log(schema, state, source, name, result) {
+
+        internals.debug(state, { type: source, name, result: result === 'full' ? 'pass' : result });
+
+        this._record(schema, (log) => {
+
+            log[source][name] = log[source][name] || 0;
+            log[source][name] |= internals.codes[result];
+        });
+    }
+
+    resolve(state, ref, to) {
+
+        if (!state.mainstay.debug) {
+            return;
+        }
+
+        const log = { type: 'resolve', ref: ref.display, to, path: state.path };
+        state.mainstay.debug.push(log);
+    }
+
+    value(state, by, from, to, name) {
+
+        if (!state.mainstay.debug ||
+            DeepEqual(from, to)) {
+
+            return;
+        }
+
+        const log = { type: 'value', by, from, to, path: state.path };
+        if (name) {
+            log.name = name;
+        }
+
+        state.mainstay.debug.push(log);
+    }
+
+    _record(schema, each) {
+
+        const log = this._sources.get(schema);
+        if (log) {
+            each(log);
+            return;
+        }
+
+        const sources = this._combos.get(schema);
+        for (const source of sources) {
+            this._record(source, each);
+        }
+    }
+
+    _scan(schema, _path) {
+
+        const path = _path || [];
+
+        let log = this._sources.get(schema);
+        if (!log) {
+            log = {
+                paths: new Set(),
+                entry: false,
+                rule: {},
+                valid: new Set(),
+                invalid: new Set()
+            };
+
+            this._sources.set(schema, log);
+        }
+
+        if (path.length) {
+            log.paths.add(path);
+        }
+
+        const each = (sub, source) => {
+
+            const subId = internals.id(sub, source);
+            this._scan(sub, path.concat(subId));
+        };
+
+        schema.$_modify({ each, ref: false });
+    }
+
+    _combine(merged, sources) {
+
+        this._combos.set(merged, sources);
+    }
+};
+
+
+internals.message = function (item) {
+
+    const path = item.paths ? Errors.path(item.paths[0]) + (item.rule ? ':' : '') : '';
+    return `${path}${item.rule || ''} (${item.status})`;
+};
+
+
+internals.id = function (schema, { source, name, path, key }) {
+
+    if (schema._flags.id) {
+        return schema._flags.id;
+    }
+
+    if (key) {
+        return key;
+    }
+
+    name = `@${name}`;
+
+    if (source === 'terms') {
+        return [name, path[Math.min(path.length - 1, 1)]];
+    }
+
+    return name;
+};
+
+
+internals.sub = function (paths, skipped) {
+
+    for (const path of paths) {
+        for (const skip of skipped) {
+            if (DeepEqual(path.slice(0, skip.length), skip)) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+};
+
+
+internals.debug = function (state, event) {
+
+    if (state.mainstay.debug) {
+        event.path = state.debug ? [...state.path, state.debug] : state.path;
+        state.mainstay.debug.push(event);
+    }
+};

package/dist/node_modules/joi/lib/types/alternatives.js

@@ -0,0 +1,364 @@
+'use strict';
+
+const Assert = require('@hapi/hoek/lib/assert');
+const Merge = require('@hapi/hoek/lib/merge');
+
+const Any = require('./any');
+const Common = require('../common');
+const Compile = require('../compile');
+const Errors = require('../errors');
+const Ref = require('../ref');
+
+
+const internals = {};
+
+
+module.exports = Any.extend({
+
+    type: 'alternatives',
+
+    flags: {
+
+        match: { default: 'any' }                 // 'any', 'one', 'all'
+    },
+
+    terms: {
+
+        matches: { init: [], register: Ref.toSibling }
+    },
+
+    args(schema, ...schemas) {
+
+        if (schemas.length === 1) {
+            if (Array.isArray(schemas[0])) {
+                return schema.try(...schemas[0]);
+            }
+        }
+
+        return schema.try(...schemas);
+    },
+
+    validate(value, helpers) {
+
+        const { schema, error, state, prefs } = helpers;
+
+        // Match all or one
+
+        if (schema._flags.match) {
+            const matched = [];
+            const failed = [];
+
+            for (let i = 0; i < schema.$_terms.matches.length; ++i) {
+                const item = schema.$_terms.matches[i];
+                const localState = state.nest(item.schema, `match.${i}`);
+                localState.snapshot();
+
+                const result = item.schema.$_validate(value, localState, prefs);
+                if (!result.errors) {
+                    matched.push(result.value);
+                    localState.commit();
+                }
+                else {
+                    failed.push(result.errors);
+                    localState.restore();
+                }
+            }
+
+            if (matched.length === 0) {
+                const context = {
+                    details: failed.map((f) => Errors.details(f, { override: false }))
+                };
+
+                return { errors: error('alternatives.any', context) };
+            }
+
+            // Match one
+
+            if (schema._flags.match === 'one') {
+                return matched.length === 1 ? { value: matched[0] } : { errors: error('alternatives.one') };
+            }
+
+            // Match all
+
+            if (matched.length !== schema.$_terms.matches.length) {
+                const context = {
+                    details: failed.map((f) => Errors.details(f, { override: false }))
+                };
+
+                return { errors: error('alternatives.all', context) };
+            }
+
+            const isAnyObj = (alternative) => {
+
+                return alternative.$_terms.matches.some((v) => {
+
+                    return v.schema.type === 'object' ||
+                        (v.schema.type === 'alternatives' && isAnyObj(v.schema));
+                });
+            };
+
+            return isAnyObj(schema) ? { value: matched.reduce((acc, v) => Merge(acc, v, { mergeArrays: false })) } : { value: matched[matched.length - 1] };
+        }
+
+        // Match any
+
+        const errors = [];
+        for (let i = 0; i < schema.$_terms.matches.length; ++i) {
+            const item = schema.$_terms.matches[i];
+
+            // Try
+
+            if (item.schema) {
+                const localState = state.nest(item.schema, `match.${i}`);
+                localState.snapshot();
+
+                const result = item.schema.$_validate(value, localState, prefs);
+                if (!result.errors) {
+                    localState.commit();
+                    return result;
+                }
+
+                localState.restore();
+                errors.push({ schema: item.schema, reports: result.errors });
+                continue;
+            }
+
+            // Conditional
+
+            const input = item.ref ? item.ref.resolve(value, state, prefs) : value;
+            const tests = item.is ? [item] : item.switch;
+
+            for (let j = 0; j < tests.length; ++j) {
+                const test = tests[j];
+                const { is, then, otherwise } = test;
+
+                const id = `match.${i}${item.switch ? '.' + j : ''}`;
+                if (!is.$_match(input, state.nest(is, `${id}.is`), prefs)) {
+                    if (otherwise) {
+                        return otherwise.$_validate(value, state.nest(otherwise, `${id}.otherwise`), prefs);
+                    }
+                }
+                else if (then) {
+                    return then.$_validate(value, state.nest(then, `${id}.then`), prefs);
+                }
+            }
+        }
+
+        return internals.errors(errors, helpers);
+    },
+
+    rules: {
+
+        conditional: {
+            method(condition, options) {
+
+                Assert(!this._flags._endedSwitch, 'Unreachable condition');
+                Assert(!this._flags.match, 'Cannot combine match mode', this._flags.match, 'with conditional rule');
+                Assert(options.break === undefined, 'Cannot use break option with alternatives conditional');
+
+                const obj = this.clone();
+
+                const match = Compile.when(obj, condition, options);
+                const conditions = match.is ? [match] : match.switch;
+                for (const item of conditions) {
+                    if (item.then &&
+                        item.otherwise) {
+
+                        obj.$_setFlag('_endedSwitch', true, { clone: false });
+                        break;
+                    }
+                }
+
+                obj.$_terms.matches.push(match);
+                return obj.$_mutateRebuild();
+            }
+        },
+
+        match: {
+            method(mode) {
+
+                Assert(['any', 'one', 'all'].includes(mode), 'Invalid alternatives match mode', mode);
+
+                if (mode !== 'any') {
+                    for (const match of this.$_terms.matches) {
+                        Assert(match.schema, 'Cannot combine match mode', mode, 'with conditional rules');
+                    }
+                }
+
+                return this.$_setFlag('match', mode);
+            }
+        },
+
+        try: {
+            method(...schemas) {
+
+                Assert(schemas.length, 'Missing alternative schemas');
+                Common.verifyFlat(schemas, 'try');
+
+                Assert(!this._flags._endedSwitch, 'Unreachable condition');
+
+                const obj = this.clone();
+                for (const schema of schemas) {
+                    obj.$_terms.matches.push({ schema: obj.$_compile(schema) });
+                }
+
+                return obj.$_mutateRebuild();
+            }
+        }
+    },
+
+    overrides: {
+
+        label(name) {
+
+            const obj = this.$_parent('label', name);
+            const each = (item, source) => {
+
+                return source.path[0] !== 'is' && typeof item._flags.label !== 'string' ? item.label(name) : undefined;
+            };
+
+            return obj.$_modify({ each, ref: false });
+        }
+    },
+
+    rebuild(schema) {
+
+        // Flag when an alternative type is an array
+
+        const each = (item) => {
+
+            if (Common.isSchema(item) &&
+                item.type === 'array') {
+
+                schema.$_setFlag('_arrayItems', true, { clone: false });
+            }
+        };
+
+        schema.$_modify({ each });
+    },
+
+    manifest: {
+
+        build(obj, desc) {
+
+            if (desc.matches) {
+                for (const match of desc.matches) {
+                    const { schema, ref, is, not, then, otherwise } = match;
+                    if (schema) {
+                        obj = obj.try(schema);
+                    }
+                    else if (ref) {
+                        obj = obj.conditional(ref, { is, then, not, otherwise, switch: match.switch });
+                    }
+                    else {
+                        obj = obj.conditional(is, { then, otherwise });
+                    }
+                }
+            }
+
+            return obj;
+        }
+    },
+
+    messages: {
+        'alternatives.all': '{{#label}} does not match all of the required types',
+        'alternatives.any': '{{#label}} does not match any of the allowed types',
+        'alternatives.match': '{{#label}} does not match any of the allowed types',
+        'alternatives.one': '{{#label}} matches more than one allowed type',
+        'alternatives.types': '{{#label}} must be one of {{#types}}'
+    }
+});
+
+
+// Helpers
+
+internals.errors = function (failures, { error, state }) {
+
+    // Nothing matched due to type criteria rules
+
+    if (!failures.length) {
+        return { errors: error('alternatives.any') };
+    }
+
+    // Single error
+
+    if (failures.length === 1) {
+        return { errors: failures[0].reports };
+    }
+
+    // Analyze reasons
+
+    const valids = new Set();
+    const complex = [];
+
+    for (const { reports, schema } of failures) {
+
+        // Multiple errors (!abortEarly)
+
+        if (reports.length > 1) {
+            return internals.unmatched(failures, error);
+        }
+
+        // Custom error
+
+        const report = reports[0];
+        if (report instanceof Errors.Report === false) {
+            return internals.unmatched(failures, error);
+        }
+
+        // Internal object or array error
+
+        if (report.state.path.length !== state.path.length) {
+            complex.push({ type: schema.type, report });
+            continue;
+        }
+
+        // Valids
+
+        if (report.code === 'any.only') {
+            for (const valid of report.local.valids) {
+                valids.add(valid);
+            }
+
+            continue;
+        }
+
+        // Base type
+
+        const [type, code] = report.code.split('.');
+        if (code !== 'base') {
+            complex.push({ type: schema.type, report });
+        }
+        else if (report.code === 'object.base') {
+            valids.add(report.local.type);
+        }
+        else {
+            valids.add(type);
+        }
+    }
+
+    // All errors are base types or valids
+
+    if (!complex.length) {
+        return { errors: error('alternatives.types', { types: [...valids] }) };
+    }
+
+    // Single complex error
+
+    if (complex.length === 1) {
+        return { errors: complex[0].report };
+    }
+
+    return internals.unmatched(failures, error);
+};
+
+
+internals.unmatched = function (failures, error) {
+
+    const errors = [];
+    for (const failure of failures) {
+        errors.push(...failure.reports);
+    }
+
+    return { errors: error('alternatives.match', Errors.details(errors, { override: false })) };
+};