@nocobase/plugin-workflow 0.7.0-alpha.9 → 0.7.1-alpha.6

package/lib/collections/workflows.js

@@ -1,65 +1,72 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+function _default() {
+  return {
     name: 'workflows',
-    model: 'WorkflowModel',
-    title: '自动化',
-    fields: [
-        {
-            interface: 'string',
-            type: 'string',
-            name: 'title',
-            title: '自动化名称',
-            required: true
-        },
-        {
-            interface: 'boolean',
-            type: 'boolean',
-            name: 'enabled',
-            title: '启用'
-        },
-        {
-            interface: 'textarea',
-            type: 'text',
-            name: 'description',
-            title: '描述'
-        },
-        {
-            interface: 'select',
-            type: 'string',
-            title: '触发方式',
-            name: 'type',
-            required: true
-        },
-        {
-            interface: 'json',
-            type: 'jsonb',
-            title: '触发配置',
-            name: 'config',
-            required: true,
-            defaultValue: {}
-        },
-        {
-            interface: 'boolean',
-            type: 'boolean',
-            title: '使用事务',
-            name: 'useTransaction',
-            defaultValue: true
-        },
-        {
-            interface: 'linkTo',
-            type: 'hasMany',
-            name: 'nodes',
-            target: 'flow_nodes',
-            title: '流程节点'
-        },
-        {
-            interface: 'linkTo',
-            type: 'hasMany',
-            name: 'executions',
-            target: 'executions',
-            title: '触发执行'
-        }
-    ]
-};
-//# sourceMappingURL=workflows.js.map
+    fields: [{
+      name: 'key',
+      type: 'uid'
+    }, {
+      type: 'string',
+      name: 'title',
+      required: true
+    }, {
+      type: 'boolean',
+      name: 'enabled',
+      defaultValue: false
+    }, {
+      type: 'text',
+      name: 'description'
+    }, {
+      type: 'string',
+      name: 'type',
+      required: true
+    }, {
+      type: 'jsonb',
+      name: 'config',
+      required: true,
+      defaultValue: {}
+    }, {
+      type: 'boolean',
+      name: 'useTransaction',
+      defaultValue: true
+    }, {
+      type: 'hasMany',
+      name: 'nodes',
+      target: 'flow_nodes'
+    }, {
+      type: 'hasMany',
+      name: 'executions'
+    }, {
+      type: 'integer',
+      name: 'executed',
+      defaultValue: 0
+    }, {
+      type: 'integer',
+      name: 'allExecuted',
+      defaultValue: 0
+    }, {
+      type: 'boolean',
+      name: 'current',
+      defaultValue: null
+    }, {
+      type: 'hasMany',
+      name: 'revisions',
+      target: 'workflows',
+      foreignKey: 'key',
+      sourceKey: 'key',
+      // NOTE: no constraints needed here because tricky self-referencing
+      constraints: false
+    }],
+    // NOTE: use unique index for avoiding deadlock in mysql when setCurrent
+    indexes: [{
+      unique: true,
+      fields: ['key', 'current']
+    }]
+  };
+}

package/lib/constants.js

@@ -1,21 +1,26 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BRANCH_INDEX = exports.JOB_STATUS = exports.EXECUTION_STATUS = void 0;
-exports.EXECUTION_STATUS = {
-    STARTED: 0,
-    RESOLVED: 1,
-    REJECTED: -1,
-    CANCELLED: -2
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.JOB_STATUS = exports.EXECUTION_STATUS = exports.BRANCH_INDEX = void 0;
+const EXECUTION_STATUS = {
+  STARTED: 0,
+  RESOLVED: 1,
+  REJECTED: -1,
+  CANCELLED: -2
 };
-exports.JOB_STATUS = {
-    PENDING: 0,
-    RESOLVED: 1,
-    REJECTED: -1,
-    CANCELLED: -2
+exports.EXECUTION_STATUS = EXECUTION_STATUS;
+const JOB_STATUS = {
+  PENDING: 0,
+  RESOLVED: 1,
+  REJECTED: -1,
+  CANCELLED: -2
 };
-exports.BRANCH_INDEX = {
-    DEFAULT: null,
-    ON_TRUE: 1,
-    ON_FALSE: 0
+exports.JOB_STATUS = JOB_STATUS;
+const BRANCH_INDEX = {
+  DEFAULT: null,
+  ON_TRUE: 1,
+  ON_FALSE: 0
 };
-//# sourceMappingURL=constants.js.map
+exports.BRANCH_INDEX = BRANCH_INDEX;

package/lib/index.d.ts

@@ -1,5 +1,6 @@
-export * from './constants';
 export * from './calculators';
-export * from './triggers';
+export * from './constants';
 export * from './instructions';
-export { default } from './server';
+export * from './triggers';
+export * from './Processor';
+export { default } from './Plugin';

package/lib/index.js

@@ -1,23 +1,86 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = void 0;
-__exportStar(require("./constants"), exports);
-__exportStar(require("./calculators"), exports);
-__exportStar(require("./triggers"), exports);
-__exportStar(require("./instructions"), exports);
-var server_1 = require("./server");
-Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(server_1).default; } });
-//# sourceMappingURL=index.js.map
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {};
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function get() {
+    return _Plugin.default;
+  }
+});
+
+var _calculators = require("./calculators");
+
+Object.keys(_calculators).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _calculators[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _calculators[key];
+    }
+  });
+});
+
+var _constants = require("./constants");
+
+Object.keys(_constants).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _constants[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _constants[key];
+    }
+  });
+});
+
+var _instructions = require("./instructions");
+
+Object.keys(_instructions).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _instructions[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _instructions[key];
+    }
+  });
+});
+
+var _triggers = require("./triggers");
+
+Object.keys(_triggers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _triggers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _triggers[key];
+    }
+  });
+});
+
+var _Processor = require("./Processor");
+
+Object.keys(_Processor).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _Processor[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _Processor[key];
+    }
+  });
+});
+
+var _Plugin = _interopRequireDefault(require("./Plugin"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/lib/instructions/calculation.d.ts

@@ -1,6 +1,6 @@
 import FlowNodeModel from "../models/FlowNode";
 declare const _default: {
-    run(this: FlowNodeModel, prevJob: any, execution: any): Promise<{
+    run(node: FlowNodeModel, prevJob: any, processor: any): Promise<{
         result: any;
         status: number;
     }>;

package/lib/instructions/calculation.js

@@ -1,16 +1,18 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("../constants");
-const calculators_1 = require("../calculators");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _constants = require("../constants");
+
+var _calculators = require("../calculators");
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
 // @calculation: {
 //   calculator: 'concat',
 //   operands: [
@@ -37,21 +39,22 @@ const calculators_1 = require("../calculators");
 //     }
 //   ]
 // }
-exports.default = {
-    run(prevJob, execution) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { calculation } = this.config || {};
-            const result = calculation
-                ? (0, calculators_1.calculate)({
-                    type: '$calculation',
-                    options: execution.getParsedValue(calculation)
-                }, prevJob, execution)
-                : null;
-            return {
-                result,
-                status: constants_1.JOB_STATUS.RESOLVED
-            };
-        });
-    }
+var _default = {
+  run(node, prevJob, processor) {
+    return _asyncToGenerator(function* () {
+      const _ref = node.config || {},
+            calculation = _ref.calculation;
+
+      const result = calculation ? (0, _calculators.calculate)({
+        type: '$calculation',
+        options: processor.getParsedValue(calculation)
+      }, prevJob, processor) : null;
+      return {
+        result,
+        status: _constants.JOB_STATUS.RESOLVED
+      };
+    })();
+  }
+
 };
-//# sourceMappingURL=calculation.js.map
+exports.default = _default;

package/lib/instructions/condition.d.ts

@@ -1,5 +1,5 @@
 declare const _default: {
-    run(this: any, prevJob: any, execution: any): Promise<any>;
-    resume(this: any, branchJob: any, execution: any): Promise<any>;
+    run(node: any, prevJob: any, processor: any): Promise<any>;
+    resume(node: any, branchJob: any, processor: any): Promise<any>;
 };
 export default _default;

package/lib/instructions/condition.js

@@ -1,35 +1,22 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const calculators_1 = __importStar(require("../calculators"));
-const constants_1 = require("../constants");
+exports.default = void 0;
+
+var _calculators = _interopRequireWildcard(require("../calculators"));
+
+var _constants = require("../constants");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
 // @calculation: {
 //   not: false,
 //   group: {
@@ -57,64 +44,80 @@ const constants_1 = require("../constants");
 //     ]
 //   }
 // }
-function logicCalculate(calculation, input, execution) {
-    if (!calculation) {
-        return true;
-    }
-    const { not, group } = calculation;
-    let result;
-    if (group) {
-        const method = group.type === 'and' ? 'every' : 'some';
-        result = group.calculations[method](item => logicCalculate(item, input, execution));
+function logicCalculate(calculation, input, processor) {
+  if (!calculation) {
+    return true;
+  }
+
+  const not = calculation.not,
+        group = calculation.group;
+  let result;
+
+  if (group) {
+    const method = group.type === 'and' ? 'every' : 'some';
+    result = group.calculations[method](item => logicCalculate(item, input, processor));
+  } else {
+    const args = calculation.operands.map(operand => (0, _calculators.calculate)(operand, input, processor));
+
+    const fn = _calculators.default.get(calculation.calculator);
+
+    if (!fn) {
+      throw new Error(`no calculator function registered for "${calculation.calculator}"`);
     }
-    else {
-        const args = calculation.operands.map(operand => (0, calculators_1.calculate)(operand, input, execution));
-        const fn = calculators_1.default.get(calculation.calculator);
-        if (!fn) {
-            throw new Error(`no calculator function registered for "${calculation.calculator}"`);
-        }
-        result = fn(...args);
-    }
-    return not ? !result : result;
+
+    result = fn(...args);
+  }
+
+  return not ? !result : result;
 }
-exports.default = {
-    run(prevJob, execution) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // TODO(optimize): loading of jobs could be reduced and turned into incrementally in execution
-            // const jobs = await execution.getJobs();
-            const { calculation, rejectOnFalse } = this.config || {};
-            const result = logicCalculate(calculation, prevJob, execution);
-            if (!result && rejectOnFalse) {
-                return {
-                    status: constants_1.JOB_STATUS.REJECTED,
-                    result
-                };
-            }
-            const job = {
-                status: constants_1.JOB_STATUS.RESOLVED,
-                result,
-                // TODO(optimize): try unify the building of job
-                nodeId: this.id,
-                upstreamId: prevJob && prevJob.id || null
-            };
-            const branchNode = execution.nodes
-                .find(item => item.upstream === this && Boolean(item.branchIndex) === result);
-            if (!branchNode) {
-                return job;
-            }
-            const savedJob = yield execution.saveJob(job);
-            return execution.run(branchNode, savedJob);
-        });
-    },
-    resume(branchJob, execution) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (branchJob.status === constants_1.JOB_STATUS.RESOLVED) {
-                // return to continue this.downstream
-                return branchJob;
-            }
-            // pass control to upper scope by ending current scope
-            return execution.end(this, branchJob);
-        });
-    }
+
+var _default = {
+  run(node, prevJob, processor) {
+    return _asyncToGenerator(function* () {
+      // TODO(optimize): loading of jobs could be reduced and turned into incrementally in processor
+      // const jobs = await processor.getJobs();
+      const _ref = node.config || {},
+            calculation = _ref.calculation,
+            rejectOnFalse = _ref.rejectOnFalse;
+
+      const result = logicCalculate(calculation, prevJob, processor);
+
+      if (!result && rejectOnFalse) {
+        return {
+          status: _constants.JOB_STATUS.REJECTED,
+          result
+        };
+      }
+
+      const job = {
+        status: _constants.JOB_STATUS.RESOLVED,
+        result,
+        // TODO(optimize): try unify the building of job
+        nodeId: node.id,
+        upstreamId: prevJob && prevJob.id || null
+      };
+      const branchNode = processor.nodes.find(item => item.upstream === node && Boolean(item.branchIndex) === result);
+
+      if (!branchNode) {
+        return job;
+      }
+
+      const savedJob = yield processor.saveJob(job);
+      return processor.run(branchNode, savedJob);
+    })();
+  },
+
+  resume(node, branchJob, processor) {
+    return _asyncToGenerator(function* () {
+      if (branchJob.status === _constants.JOB_STATUS.RESOLVED) {
+        // return to continue node.downstream
+        return branchJob;
+      } // pass control to upper scope by ending current scope
+
+
+      return processor.end(node, branchJob);
+    })();
+  }
+
 };
-//# sourceMappingURL=condition.js.map
+exports.default = _default;

package/lib/instructions/create.d.ts

@@ -1,7 +1,7 @@
 import FlowNodeModel from "../models/FlowNode";
 declare const _default: {
-    run(this: FlowNodeModel, input: any, execution: any): Promise<{
-        result: import("@nocobase/database").Model<any, any>;
+    run(node: FlowNodeModel, input: any, processor: any): Promise<{
+        result: any;
         status: number;
     }>;
 };