@nocobase/plugin-workflow-request-interceptor 2.1.0-beta.8 → 2.2.0-alpha.1

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

@@ -0,0 +1,263 @@
+'use strict';
+
+const Assert = require('@hapi/hoek/lib/assert');
+const DeepEqual = require('@hapi/hoek/lib/deepEqual');
+
+const Common = require('./common');
+
+
+const internals = {};
+
+
+module.exports = internals.Values = class {
+
+    constructor(values, refs) {
+
+        this._values = new Set(values);
+        this._refs = new Set(refs);
+        this._lowercase = internals.lowercases(values);
+
+        this._override = false;
+    }
+
+    get length() {
+
+        return this._values.size + this._refs.size;
+    }
+
+    add(value, refs) {
+
+        // Reference
+
+        if (Common.isResolvable(value)) {
+            if (!this._refs.has(value)) {
+                this._refs.add(value);
+
+                if (refs) {                     // Skipped in a merge
+                    refs.register(value);
+                }
+            }
+
+            return;
+        }
+
+        // Value
+
+        if (!this.has(value, null, null, false)) {
+            this._values.add(value);
+
+            if (typeof value === 'string') {
+                this._lowercase.set(value.toLowerCase(), value);
+            }
+        }
+    }
+
+    static merge(target, source, remove) {
+
+        target = target || new internals.Values();
+
+        if (source) {
+            if (source._override) {
+                return source.clone();
+            }
+
+            for (const item of [...source._values, ...source._refs]) {
+                target.add(item);
+            }
+        }
+
+        if (remove) {
+            for (const item of [...remove._values, ...remove._refs]) {
+                target.remove(item);
+            }
+        }
+
+        return target.length ? target : null;
+    }
+
+    remove(value) {
+
+        // Reference
+
+        if (Common.isResolvable(value)) {
+            this._refs.delete(value);
+            return;
+        }
+
+        // Value
+
+        this._values.delete(value);
+
+        if (typeof value === 'string') {
+            this._lowercase.delete(value.toLowerCase());
+        }
+    }
+
+    has(value, state, prefs, insensitive) {
+
+        return !!this.get(value, state, prefs, insensitive);
+    }
+
+    get(value, state, prefs, insensitive) {
+
+        if (!this.length) {
+            return false;
+        }
+
+        // Simple match
+
+        if (this._values.has(value)) {
+            return { value };
+        }
+
+        // Case insensitive string match
+
+        if (typeof value === 'string' &&
+            value &&
+            insensitive) {
+
+            const found = this._lowercase.get(value.toLowerCase());
+            if (found) {
+                return { value: found };
+            }
+        }
+
+        if (!this._refs.size &&
+            typeof value !== 'object') {
+
+            return false;
+        }
+
+        // Objects
+
+        if (typeof value === 'object') {
+            for (const item of this._values) {
+                if (DeepEqual(item, value)) {
+                    return { value: item };
+                }
+            }
+        }
+
+        // References
+
+        if (state) {
+            for (const ref of this._refs) {
+                const resolved = ref.resolve(value, state, prefs, null, { in: true });
+                if (resolved === undefined) {
+                    continue;
+                }
+
+                const items = !ref.in || typeof resolved !== 'object'
+                    ? [resolved]
+                    : Array.isArray(resolved) ? resolved : Object.keys(resolved);
+
+                for (const item of items) {
+                    if (typeof item !== typeof value) {
+                        continue;
+                    }
+
+                    if (insensitive &&
+                        value &&
+                        typeof value === 'string') {
+
+                        if (item.toLowerCase() === value.toLowerCase()) {
+                            return { value: item, ref };
+                        }
+                    }
+                    else {
+                        if (DeepEqual(item, value)) {
+                            return { value: item, ref };
+                        }
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
+
+    override() {
+
+        this._override = true;
+    }
+
+    values(options) {
+
+        if (options &&
+            options.display) {
+
+            const values = [];
+
+            for (const item of [...this._values, ...this._refs]) {
+                if (item !== undefined) {
+                    values.push(item);
+                }
+            }
+
+            return values;
+        }
+
+        return Array.from([...this._values, ...this._refs]);
+    }
+
+    clone() {
+
+        const set = new internals.Values(this._values, this._refs);
+        set._override = this._override;
+        return set;
+    }
+
+    concat(source) {
+
+        Assert(!source._override, 'Cannot concat override set of values');
+
+        const set = new internals.Values([...this._values, ...source._values], [...this._refs, ...source._refs]);
+        set._override = this._override;
+        return set;
+    }
+
+    describe() {
+
+        const normalized = [];
+
+        if (this._override) {
+            normalized.push({ override: true });
+        }
+
+        for (const value of this._values.values()) {
+            normalized.push(value && typeof value === 'object' ? { value } : value);
+        }
+
+        for (const value of this._refs.values()) {
+            normalized.push(value.describe());
+        }
+
+        return normalized;
+    }
+};
+
+
+internals.Values.prototype[Common.symbols.values] = true;
+
+
+// Aliases
+
+internals.Values.prototype.slice = internals.Values.prototype.clone;
+
+
+// Helpers
+
+internals.lowercases = function (from) {
+
+    const map = new Map();
+
+    if (from) {
+        for (const value of from) {
+            if (typeof value === 'string') {
+                map.set(value.toLowerCase(), value);
+            }
+        }
+    }
+
+    return map;
+};

package/dist/node_modules/joi/node_modules/@hapi/topo/lib/index.d.ts

@@ -0,0 +1,60 @@
+export class Sorter<T> {
+
+    /**
+     * An array of the topologically sorted nodes. This list is renewed upon each call to topo.add().
+     */
+    nodes: T[];
+
+    /**
+     * Adds a node or list of nodes to be added and topologically sorted
+     * 
+     * @param nodes - A mixed value or array of mixed values to be added as nodes to the topologically sorted list.
+     * @param options - Optional sorting information about the nodes.
+     * 
+     * @returns Returns an array of the topologically sorted nodes.
+     */
+    add(nodes: T | T[], options?: Options): T[];
+
+    /**
+     * Merges another Sorter object into the current object.
+     * 
+     * @param others - The other object or array of objects to be merged into the current one.
+     * 
+     * @returns Returns an array of the topologically sorted nodes.
+     */
+    merge(others: Sorter<T> | Sorter<T>[]): T[];
+
+    /**
+     * Sorts the nodes array (only required if the manual option is used when adding items)
+     */
+    sort(): T[];
+}
+
+
+export interface Options {
+
+    /**
+     * The sorting group the added items belong to
+     */
+    readonly group?: string;
+
+    /**
+     * The group or groups the added items must come before
+     */
+    readonly before?: string | string[];
+
+    /**
+     * The group or groups the added items must come after
+     */
+    readonly after?: string | string[];
+
+    /**
+     * A number used to sort items with equal before/after requirements
+     */
+    readonly sort?: number;
+
+    /**
+     * If true, the array is not sorted automatically until sort() is called
+     */
+    readonly manual?: boolean;
+}

package/dist/node_modules/joi/node_modules/@hapi/topo/lib/index.js

@@ -0,0 +1,225 @@
+'use strict';
+
+const Assert = require('@hapi/hoek/lib/assert');
+
+
+const internals = {};
+
+
+exports.Sorter = class {
+
+    constructor() {
+
+        this._items = [];
+        this.nodes = [];
+    }
+
+    add(nodes, options) {
+
+        options = options || {};
+
+        // Validate rules
+
+        const before = [].concat(options.before || []);
+        const after = [].concat(options.after || []);
+        const group = options.group || '?';
+        const sort = options.sort || 0;                   // Used for merging only
+
+        Assert(!before.includes(group), `Item cannot come before itself: ${group}`);
+        Assert(!before.includes('?'), 'Item cannot come before unassociated items');
+        Assert(!after.includes(group), `Item cannot come after itself: ${group}`);
+        Assert(!after.includes('?'), 'Item cannot come after unassociated items');
+
+        if (!Array.isArray(nodes)) {
+            nodes = [nodes];
+        }
+
+        for (const node of nodes) {
+            const item = {
+                seq: this._items.length,
+                sort,
+                before,
+                after,
+                group,
+                node
+            };
+
+            this._items.push(item);
+        }
+
+        // Insert event
+
+        if (!options.manual) {
+            const valid = this._sort();
+            Assert(valid, 'item', group !== '?' ? `added into group ${group}` : '', 'created a dependencies error');
+        }
+
+        return this.nodes;
+    }
+
+    merge(others) {
+
+        if (!Array.isArray(others)) {
+            others = [others];
+        }
+
+        for (const other of others) {
+            if (other) {
+                for (const item of other._items) {
+                    this._items.push(Object.assign({}, item));      // Shallow cloned
+                }
+            }
+        }
+
+        // Sort items
+
+        this._items.sort(internals.mergeSort);
+        for (let i = 0; i < this._items.length; ++i) {
+            this._items[i].seq = i;
+        }
+
+        const valid = this._sort();
+        Assert(valid, 'merge created a dependencies error');
+
+        return this.nodes;
+    }
+
+    sort() {
+
+        const valid = this._sort();
+        Assert(valid, 'sort created a dependencies error');
+
+        return this.nodes;
+    }
+
+    _sort() {
+
+        // Construct graph
+
+        const graph = {};
+        const graphAfters = Object.create(null);            // A prototype can bungle lookups w/ false positives
+        const groups = Object.create(null);
+
+        for (const item of this._items) {
+            const seq = item.seq;                           // Unique across all items
+            const group = item.group;
+
+            // Determine Groups
+
+            groups[group] = groups[group] || [];
+            groups[group].push(seq);
+
+            // Build intermediary graph using 'before'
+
+            graph[seq] = item.before;
+
+            // Build second intermediary graph with 'after'
+
+            for (const after of item.after) {
+                graphAfters[after] = graphAfters[after] || [];
+                graphAfters[after].push(seq);
+            }
+        }
+
+        // Expand intermediary graph
+
+        for (const node in graph) {
+            const expandedGroups = [];
+
+            for (const graphNodeItem in graph[node]) {
+                const group = graph[node][graphNodeItem];
+                groups[group] = groups[group] || [];
+                expandedGroups.push(...groups[group]);
+            }
+
+            graph[node] = expandedGroups;
+        }
+
+        // Merge intermediary graph using graphAfters into final graph
+
+        for (const group in graphAfters) {
+            if (groups[group]) {
+                for (const node of groups[group]) {
+                    graph[node].push(...graphAfters[group]);
+                }
+            }
+        }
+
+        // Compile ancestors
+
+        const ancestors = {};
+        for (const node in graph) {
+            const children = graph[node];
+            for (const child of children) {
+                ancestors[child] = ancestors[child] || [];
+                ancestors[child].push(node);
+            }
+        }
+
+        // Topo sort
+
+        const visited = {};
+        const sorted = [];
+
+        for (let i = 0; i < this._items.length; ++i) {          // Looping through item.seq values out of order
+            let next = i;
+
+            if (ancestors[i]) {
+                next = null;
+                for (let j = 0; j < this._items.length; ++j) {  // As above, these are item.seq values
+                    if (visited[j] === true) {
+                        continue;
+                    }
+
+                    if (!ancestors[j]) {
+                        ancestors[j] = [];
+                    }
+
+                    const shouldSeeCount = ancestors[j].length;
+                    let seenCount = 0;
+                    for (let k = 0; k < shouldSeeCount; ++k) {
+                        if (visited[ancestors[j][k]]) {
+                            ++seenCount;
+                        }
+                    }
+
+                    if (seenCount === shouldSeeCount) {
+                        next = j;
+                        break;
+                    }
+                }
+            }
+
+            if (next !== null) {
+                visited[next] = true;
+                sorted.push(next);
+            }
+        }
+
+        if (sorted.length !== this._items.length) {
+            return false;
+        }
+
+        const seqIndex = {};
+        for (const item of this._items) {
+            seqIndex[item.seq] = item;
+        }
+
+        this._items = [];
+        this.nodes = [];
+
+        for (const value of sorted) {
+            const sortedItem = seqIndex[value];
+            this.nodes.push(sortedItem.node);
+            this._items.push(sortedItem);
+        }
+
+        return true;
+    }
+};
+
+
+internals.mergeSort = (a, b) => {
+
+    return a.sort === b.sort ? 0 : (a.sort < b.sort ? -1 : 1);
+};

package/dist/node_modules/joi/node_modules/@hapi/topo/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@hapi/topo",
+  "description": "Topological sorting with grouping support",
+  "version": "5.1.0",
+  "repository": "git://github.com/hapijs/topo",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib"
+  ],
+  "keywords": [
+    "topological",
+    "sort",
+    "toposort",
+    "topsort"
+  ],
+  "dependencies": {
+    "@hapi/hoek": "^9.0.0"
+  },
+  "devDependencies": {
+    "@hapi/code": "8.x.x",
+    "@hapi/lab": "24.x.x",
+    "typescript": "~4.0.2"
+  },
+  "scripts": {
+    "test": "lab -a @hapi/code -t 100 -L -Y",
+    "test-cov-html": "lab -a @hapi/code -t 100 -L -r html -o coverage.html"
+  },
+  "license": "BSD-3-Clause"
+}

package/dist/node_modules/joi/package.json

@@ -0,0 +1 @@
+{"name":"joi","description":"Object schema validation","version":"17.13.3","repository":"git://github.com/hapijs/joi","main":"lib/index.js","types":"lib/index.d.ts","browser":"dist/joi-browser.min.js","files":["lib/**/*","dist/*"],"keywords":["schema","validation"],"dependencies":{"@hapi/hoek":"^9.3.0","@hapi/topo":"^5.1.0","@sideway/address":"^4.1.5","@sideway/formula":"^3.0.1","@sideway/pinpoint":"^2.0.0"},"devDependencies":{"@hapi/bourne":"2.x.x","@hapi/code":"8.x.x","@hapi/joi-legacy-test":"npm:@hapi/joi@15.x.x","@hapi/lab":"^25.1.3","@types/node":"^14.18.63","typescript":"4.3.x"},"scripts":{"prepublishOnly":"cd browser && npm install && npm run build","test":"lab -t 100 -a @hapi/code -L -Y","test-cov-html":"lab -r html -o coverage.html -a @hapi/code"},"license":"BSD-3-Clause","_lastModified":"2026-06-10T18:13:31.462Z"}

package/dist/server/RequestInterceptionTrigger.d.ts

@@ -6,9 +6,12 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
+import Joi from 'joi';
 import { EventOptions, Trigger, WorkflowModel } from '@nocobase/plugin-workflow';
 export default class RequestInterceptionTrigger extends Trigger {
     static TYPE: string;
+    configSchema: Joi.ObjectSchema<any>;
+    validateConfig(config: Record<string, any>): Record<string, string>;
     sync: boolean;
     middleware: (context: any, next: any) => Promise<any>;
     constructor(workflow: any);

package/dist/server/RequestInterceptionTrigger.js

@@ -40,6 +40,7 @@ __export(RequestInterceptionTrigger_exports, {
 });
 module.exports = __toCommonJS(RequestInterceptionTrigger_exports);
 var import_lodash = require("lodash");
+var import_joi = __toESM(require("joi"));
 var import_plugin_error_handler = __toESM(require("@nocobase/plugin-error-handler"));
 var import_plugin_workflow = require("@nocobase/plugin-workflow");
 var import_data_source_manager = require("@nocobase/data-source-manager");
@@ -54,6 +55,29 @@ class RequestInterceptionError extends Error {
 }
 class RequestInterceptionTrigger extends import_plugin_workflow.Trigger {
   static TYPE = "request-interception";
+  configSchema = import_joi.default.object({
+    collection: import_joi.default.string().required(),
+    global: import_joi.default.boolean().optional(),
+    actions: import_joi.default.when("global", {
+      is: true,
+      then: import_joi.default.array().items(
+        import_joi.default.string().valid(
+          import_constants.INTERCEPTABLE_ACTIONS.CREATE,
+          import_constants.INTERCEPTABLE_ACTIONS.UPDATE,
+          import_constants.INTERCEPTABLE_ACTIONS.UPSERT,
+          import_constants.INTERCEPTABLE_ACTIONS.DESTROY
+        )
+      ).min(1).required().messages({ "array.min": "At least one action is required in global mode" }),
+      otherwise: import_joi.default.array().items(import_joi.default.string()).optional()
+    })
+  });
+  validateConfig(config) {
+    const errors = super.validateConfig(config);
+    if (errors) {
+      return errors;
+    }
+    return (0, import_plugin_workflow.validateCollectionField)(config.collection, this.workflow.app.dataSourceManager);
+  }
   sync = true;
   middleware = async (context, next) => {
     const {
@@ -101,10 +125,19 @@ class RequestInterceptionTrigger extends import_plugin_workflow.Trigger {
       }
       return aIndex - bIndex;
     });
-    for (const workflow of localWorkflows.concat(globalWorkflows)) {
-      if (!workflow.config.global && !triggerWorkflowsMap.has(workflow.key)) {
-        continue;
-      }
+    const syncWorkflows = localWorkflows.filter((workflow) => triggerWorkflowsMap.has(workflow.key)).concat(globalWorkflows);
+    for (const [index, workflow] of syncWorkflows.entries()) {
+      const syncLogMeta = {
+        workflowId: workflow.id,
+        workflowKey: workflow.key,
+        workflowTitle: workflow.title,
+        resourceName,
+        actionName,
+        currentSyncOrder: index + 1,
+        totalSyncWorkflows: syncWorkflows.length,
+        remainingSyncWorkflows: syncWorkflows.length - index - 1
+      };
+      context.logger.debug("[Workflow pre-action]: executing sync workflow", syncLogMeta);
       const processor = await this.workflow.trigger(
         workflow,
         {
@@ -119,25 +152,49 @@ class RequestInterceptionTrigger extends import_plugin_workflow.Trigger {
         { httpContext: context }
       );
       if (!processor) {
-        return context.throw(500);
+        context.logger.error(
+          "[Workflow pre-action]: sync workflow trigger failed before execution created",
+          syncLogMeta
+        );
+        return context.throw(500, "Workflow on your action failed, please contact the administrator");
       }
       const { lastSavedJob, nodesMap } = processor;
       const lastNode = nodesMap.get(lastSavedJob == null ? void 0 : lastSavedJob.nodeId);
       if (processor.execution.status === import_plugin_workflow.EXECUTION_STATUS.RESOLVED) {
         if ((lastNode == null ? void 0 : lastNode.type) === "end") {
+          context.logger.debug("[Workflow pre-action]: sync workflow ended request chain on end node", {
+            ...syncLogMeta,
+            ...(0, import_plugin_workflow.getWorkflowExecutionLogMeta)(workflow, processor)
+          });
           return;
         }
+        context.logger.debug("[Workflow pre-action]: sync workflow finished successfully", {
+          ...syncLogMeta,
+          ...(0, import_plugin_workflow.getWorkflowExecutionLogMeta)(workflow, processor)
+        });
         continue;
       }
       if (processor.execution.status < import_plugin_workflow.EXECUTION_STATUS.STARTED) {
         if ((lastNode == null ? void 0 : lastNode.type) !== "end") {
+          context.logger.error("[Workflow pre-action]: sync workflow failed", {
+            ...syncLogMeta,
+            ...(0, import_plugin_workflow.getWorkflowExecutionLogMeta)(workflow, processor)
+          });
           return context.throw(500, "Workflow on your action failed, please contact the administrator");
         }
+        context.logger.warn("[Workflow pre-action]: sync workflow intercepted request on end node", {
+          ...syncLogMeta,
+          ...(0, import_plugin_workflow.getWorkflowExecutionLogMeta)(workflow, processor)
+        });
         const err = new RequestInterceptionError("Request is intercepted by workflow");
         err.status = 400;
         err.messages = context.state.messages;
         return context.throw(err.status, err);
       }
+      context.logger.error("[Workflow pre-action]: sync workflow is still pending after trigger", {
+        ...syncLogMeta,
+        ...(0, import_plugin_workflow.getWorkflowExecutionLogMeta)(workflow, processor)
+      });
       return context.throw(500, "Workflow on your action hangs, please contact the administrator");
     }
     await next();