@nocobase/plugin-workflow 2.1.0-beta.9 → 2.2.0-beta.1

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

@@ -0,0 +1,271 @@
+'use strict';
+
+const Annotate = require('./annotate');
+const Common = require('./common');
+const Template = require('./template');
+
+
+const internals = {};
+
+
+exports.Report = class {
+
+    constructor(code, value, local, flags, messages, state, prefs) {
+
+        this.code = code;
+        this.flags = flags;
+        this.messages = messages;
+        this.path = state.path;
+        this.prefs = prefs;
+        this.state = state;
+        this.value = value;
+
+        this.message = null;
+        this.template = null;
+
+        this.local = local || {};
+        this.local.label = exports.label(this.flags, this.state, this.prefs, this.messages);
+
+        if (this.value !== undefined &&
+            !this.local.hasOwnProperty('value')) {
+
+            this.local.value = this.value;
+        }
+
+        if (this.path.length) {
+            const key = this.path[this.path.length - 1];
+            if (typeof key !== 'object') {
+                this.local.key = key;
+            }
+        }
+    }
+
+    _setTemplate(template) {
+
+        this.template = template;
+
+        if (!this.flags.label &&
+            this.path.length === 0) {
+
+            const localized = this._template(this.template, 'root');
+            if (localized) {
+                this.local.label = localized;
+            }
+        }
+    }
+
+    toString() {
+
+        if (this.message) {
+            return this.message;
+        }
+
+        const code = this.code;
+
+        if (!this.prefs.errors.render) {
+            return this.code;
+        }
+
+        const template = this._template(this.template) ||
+            this._template(this.prefs.messages) ||
+            this._template(this.messages);
+
+        if (template === undefined) {
+            return `Error code "${code}" is not defined, your custom type is missing the correct messages definition`;
+        }
+
+        // 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();
+        }
+
+        return this.message;
+    }
+
+    _template(messages, code) {
+
+        return exports.template(this.value, messages, code || this.code, this.state, this.prefs);
+    }
+};
+
+
+exports.path = function (path) {
+
+    let label = '';
+    for (const segment of path) {
+        if (typeof segment === 'object') {          // Exclude array single path segment
+            continue;
+        }
+
+        if (typeof segment === 'string') {
+            if (label) {
+                label += '.';
+            }
+
+            label += segment;
+        }
+        else {
+            label += `[${segment}]`;
+        }
+    }
+
+    return label;
+};
+
+
+exports.template = function (value, messages, code, state, prefs) {
+
+    if (!messages) {
+        return;
+    }
+
+    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]) {
+
+        if (messages[lang][code] !== undefined) {
+            return messages[lang][code];
+        }
+
+        if (messages[lang]['*'] !== undefined) {
+            return messages[lang]['*'];
+        }
+    }
+
+    if (!messages[code]) {
+        return messages['*'];
+    }
+
+    return messages[code];
+};
+
+
+exports.label = function (flags, state, prefs, messages) {
+
+    if (!prefs.errors.label) {
+        return '';
+    }
+
+    if (flags.label) {
+        return flags.label;
+    }
+
+    let path = state.path;
+    if (prefs.errors.label === 'key' &&
+        state.path.length > 1) {
+
+        path = state.path.slice(-1);
+    }
+
+    const normalized = exports.path(path);
+    if (normalized) {
+        return normalized;
+    }
+
+    return exports.template(null, prefs.messages, 'root', state, prefs) ||
+        messages && exports.template(null, messages, 'root', state, prefs) ||
+        'value';
+};
+
+
+exports.process = function (errors, original, prefs) {
+
+    if (!errors) {
+        return null;
+    }
+
+    const { override, message, details } = exports.details(errors);
+    if (override) {
+        return override;
+    }
+
+    if (prefs.errors.stack) {
+        return new exports.ValidationError(message, details, original);
+    }
+
+    const limit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 0;
+    const validationError = new exports.ValidationError(message, details, original);
+    Error.stackTraceLimit = limit;
+    return validationError;
+};
+
+
+exports.details = function (errors, options = {}) {
+
+    let messages = [];
+    const details = [];
+
+    for (const item of errors) {
+
+        // Override
+
+        if (item instanceof Error) {
+            if (options.override !== false) {
+                return { override: item };
+            }
+
+            const message = item.toString();
+            messages.push(message);
+
+            details.push({
+                message,
+                type: 'override',
+                context: { error: item }
+            });
+
+            continue;
+        }
+
+        // Report
+
+        const message = item.toString();
+        messages.push(message);
+
+        details.push({
+            message,
+            path: item.path.filter((v) => typeof v !== 'object'),
+            type: item.code,
+            context: item.local
+        });
+    }
+
+    if (messages.length > 1) {
+        messages = [...new Set(messages)];
+    }
+
+    return { message: messages.join('. '), details };
+};
+
+
+exports.ValidationError = class extends Error {
+
+    constructor(message, details, original) {
+
+        super(message);
+        this._original = original;
+        this.details = details;
+    }
+
+    static isError(err) {
+
+        return err instanceof exports.ValidationError;
+    }
+};
+
+
+exports.ValidationError.prototype.isJoi = true;
+
+exports.ValidationError.prototype.name = 'ValidationError';
+
+exports.ValidationError.prototype.annotate = Annotate.error;

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

@@ -0,0 +1,312 @@
+'use strict';
+
+const Assert = require('@hapi/hoek/lib/assert');
+const Clone = require('@hapi/hoek/lib/clone');
+
+const Common = require('./common');
+const Messages = require('./messages');
+
+
+const internals = {};
+
+
+exports.type = function (from, options) {
+
+    const base = Object.getPrototypeOf(from);
+    const prototype = Clone(base);
+    const schema = from._assign(Object.create(prototype));
+    const def = Object.assign({}, options);                                 // Shallow cloned
+    delete def.base;
+
+    prototype._definition = def;
+
+    const parent = base._definition || {};
+    def.messages = Messages.merge(parent.messages, def.messages);
+    def.properties = Object.assign({}, parent.properties, def.properties);
+
+    // Type
+
+    schema.type = def.type;
+
+    // Flags
+
+    def.flags = Object.assign({}, parent.flags, def.flags);
+
+    // Terms
+
+    const terms = Object.assign({}, parent.terms);
+    if (def.terms) {
+        for (const name in def.terms) {                                     // Only apply own terms
+            const term = def.terms[name];
+            Assert(schema.$_terms[name] === undefined, 'Invalid term override for', def.type, name);
+            schema.$_terms[name] = term.init;
+            terms[name] = term;
+        }
+    }
+
+    def.terms = terms;
+
+    // Constructor arguments
+
+    if (!def.args) {
+        def.args = parent.args;
+    }
+
+    // Prepare
+
+    def.prepare = internals.prepare(def.prepare, parent.prepare);
+
+    // Coerce
+
+    if (def.coerce) {
+        if (typeof def.coerce === 'function') {
+            def.coerce = { method: def.coerce };
+        }
+
+        if (def.coerce.from &&
+            !Array.isArray(def.coerce.from)) {
+
+            def.coerce = { method: def.coerce.method, from: [].concat(def.coerce.from) };
+        }
+    }
+
+    def.coerce = internals.coerce(def.coerce, parent.coerce);
+
+    // Validate
+
+    def.validate = internals.validate(def.validate, parent.validate);
+
+    // Rules
+
+    const rules = Object.assign({}, parent.rules);
+    if (def.rules) {
+        for (const name in def.rules) {
+            const rule = def.rules[name];
+            Assert(typeof rule === 'object', 'Invalid rule definition for', def.type, name);
+
+            let method = rule.method;
+            if (method === undefined) {
+                method = function () {
+
+                    return this.$_addRule(name);
+                };
+            }
+
+            if (method) {
+                Assert(!prototype[name], 'Rule conflict in', def.type, name);
+                prototype[name] = method;
+            }
+
+            Assert(!rules[name], 'Rule conflict in', def.type, name);
+            rules[name] = rule;
+
+            if (rule.alias) {
+                const aliases = [].concat(rule.alias);
+                for (const alias of aliases) {
+                    prototype[alias] = rule.method;
+                }
+            }
+
+            if (rule.args) {
+                rule.argsByName = new Map();
+                rule.args = rule.args.map((arg) => {
+
+                    if (typeof arg === 'string') {
+                        arg = { name: arg };
+                    }
+
+                    Assert(!rule.argsByName.has(arg.name), 'Duplicated argument name', arg.name);
+
+                    if (Common.isSchema(arg.assert)) {
+                        arg.assert = arg.assert.strict().label(arg.name);
+                    }
+
+                    rule.argsByName.set(arg.name, arg);
+                    return arg;
+                });
+            }
+        }
+    }
+
+    def.rules = rules;
+
+    // Modifiers
+
+    const modifiers = Object.assign({}, parent.modifiers);
+    if (def.modifiers) {
+        for (const name in def.modifiers) {
+            Assert(!prototype[name], 'Rule conflict in', def.type, name);
+
+            const modifier = def.modifiers[name];
+            Assert(typeof modifier === 'function', 'Invalid modifier definition for', def.type, name);
+
+            const method = function (arg) {
+
+                return this.rule({ [name]: arg });
+            };
+
+            prototype[name] = method;
+            modifiers[name] = modifier;
+        }
+    }
+
+    def.modifiers = modifiers;
+
+    // Overrides
+
+    if (def.overrides) {
+        prototype._super = base;
+        schema.$_super = {};                                                            // Backwards compatibility
+        for (const override in def.overrides) {
+            Assert(base[override], 'Cannot override missing', override);
+            def.overrides[override][Common.symbols.parent] = base[override];
+            schema.$_super[override] = base[override].bind(schema);                     // Backwards compatibility
+        }
+
+        Object.assign(prototype, def.overrides);
+    }
+
+    // Casts
+
+    def.cast = Object.assign({}, parent.cast, def.cast);
+
+    // Manifest
+
+    const manifest = Object.assign({}, parent.manifest, def.manifest);
+    manifest.build = internals.build(def.manifest && def.manifest.build, parent.manifest && parent.manifest.build);
+    def.manifest = manifest;
+
+    // Rebuild
+
+    def.rebuild = internals.rebuild(def.rebuild, parent.rebuild);
+
+    return schema;
+};
+
+
+// Helpers
+
+internals.build = function (child, parent) {
+
+    if (!child ||
+        !parent) {
+
+        return child || parent;
+    }
+
+    return function (obj, desc) {
+
+        return parent(child(obj, desc), desc);
+    };
+};
+
+
+internals.coerce = function (child, parent) {
+
+    if (!child ||
+        !parent) {
+
+        return child || parent;
+    }
+
+    return {
+        from: child.from && parent.from ? [...new Set([...child.from, ...parent.from])] : null,
+        method(value, helpers) {
+
+            let coerced;
+            if (!parent.from ||
+                parent.from.includes(typeof value)) {
+
+                coerced = parent.method(value, helpers);
+                if (coerced) {
+                    if (coerced.errors ||
+                        coerced.value === undefined) {
+
+                        return coerced;
+                    }
+
+                    value = coerced.value;
+                }
+            }
+
+            if (!child.from ||
+                child.from.includes(typeof value)) {
+
+                const own = child.method(value, helpers);
+                if (own) {
+                    return own;
+                }
+            }
+
+            return coerced;
+        }
+    };
+};
+
+
+internals.prepare = function (child, parent) {
+
+    if (!child ||
+        !parent) {
+
+        return child || parent;
+    }
+
+    return function (value, helpers) {
+
+        const prepared = child(value, helpers);
+        if (prepared) {
+            if (prepared.errors ||
+                prepared.value === undefined) {
+
+                return prepared;
+            }
+
+            value = prepared.value;
+        }
+
+        return parent(value, helpers) || prepared;
+    };
+};
+
+
+internals.rebuild = function (child, parent) {
+
+    if (!child ||
+        !parent) {
+
+        return child || parent;
+    }
+
+    return function (schema) {
+
+        parent(schema);
+        child(schema);
+    };
+};
+
+
+internals.validate = function (child, parent) {
+
+    if (!child ||
+        !parent) {
+
+        return child || parent;
+    }
+
+    return function (value, helpers) {
+
+        const result = parent(value, helpers);
+        if (result) {
+            if (result.errors &&
+                (!Array.isArray(result.errors) || result.errors.length)) {
+
+                return result;
+            }
+
+            value = result.value;
+        }
+
+        return child(value, helpers) || result;
+    };
+};