@nocobase/plugin-workflow 0.9.0-alpha.2 → 0.9.1-alpha.2

package/lib/server/actions/workflows.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.destroy = destroy;
 exports.revision = revision;
 exports.update = update;
 
@@ -16,6 +17,16 @@ function _actions() {
   return data;
 }
 
+function _database() {
+  const data = require("@nocobase/database");
+
+  _database = function _database() {
+    return data;
+  };
+
+  return data;
+}
+
 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; }
@@ -56,13 +67,16 @@ function _update() {
 
     const _context$action$param = context.action.params,
           filterByTk = _context$action$param.filterByTk,
-          values = _context$action$param.values; // only enable/disable
+          values = _context$action$param.values;
+    context.action.mergeParams({
+      whitelist: ['title', 'description', 'enabled', 'config']
+    }); // only enable/disable
 
-    if (Object.keys(values).sort().join() !== 'enabled,key') {
+    if (Object.keys(values).includes('config')) {
       const workflow = yield repository.findById(filterByTk);
 
       if (workflow.get('executed')) {
-        return context.throw(400, 'executed workflow can not be updated');
+        return context.throw(400, 'config of executed workflow can not be updated');
       }
     }
 
@@ -71,6 +85,54 @@ function _update() {
   return _update.apply(this, arguments);
 }
 
+function destroy(_x3, _x4) {
+  return _destroy.apply(this, arguments);
+}
+
+function _destroy() {
+  _destroy = _asyncToGenerator(function* (context, next) {
+    const repository = _actions().utils.getRepositoryFromParams(context);
+
+    const _context$action$param2 = context.action.params,
+          filterByTk = _context$action$param2.filterByTk,
+          filter = _context$action$param2.filter;
+    yield context.db.sequelize.transaction( /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator(function* (transaction) {
+        const items = yield repository.find({
+          filterByTk,
+          filter,
+          fields: ['id', 'key', 'current'],
+          transaction
+        });
+        const ids = new Set(items.map(item => item.id));
+        const keysSet = new Set(items.filter(item => item.current).map(item => item.key));
+        const revisions = yield repository.find({
+          filter: {
+            key: Array.from(keysSet),
+            current: {
+              [_database().Op.not]: true
+            }
+          },
+          fields: ['id'],
+          transaction
+        });
+        revisions.forEach(item => ids.add(item.id));
+        context.body = yield repository.destroy({
+          filterByTk: Array.from(ids),
+          individualHooks: true,
+          transaction
+        });
+      });
+
+      return function (_x7) {
+        return _ref.apply(this, arguments);
+      };
+    }());
+    next();
+  });
+  return _destroy.apply(this, arguments);
+}
+
 function typeOf(value) {
   if (Array.isArray(value)) {
     return 'array';
@@ -105,20 +167,15 @@ function migrateConfig(config, oldToNew) {
         return value.map(item => migrate(item));
 
       case 'string':
-        const matcher = value.match(/(\{\{\$jobsMapByNodeId\.)([\w-]+)/);
+        return value.replace(/(\{\{\$jobsMapByNodeId\.)([\w-]+)/g, (_, jobVar, oldNodeId) => {
+          const newNode = oldToNew.get(Number.parseInt(oldNodeId, 10));
 
-        if (!matcher) {
-          return value;
-        }
-
-        const oldNodeId = Number.parseInt(matcher[2], 10);
-        const newNode = oldToNew.get(oldNodeId);
-
-        if (!newNode) {
-          throw new Error('node configurated for result is not existed');
-        }
+          if (!newNode) {
+            throw new Error('node configurated for result is not existed');
+          }
 
-        return value.replace(matcher[0], `{{$jobsMapByNodeId.${newNode.id}`);
+          return `{{$jobsMapByNodeId.${newNode.id}`;
+        });
 
       default:
         return value;
@@ -128,7 +185,7 @@ function migrateConfig(config, oldToNew) {
   return migrate(config);
 }
 
-function revision(_x3, _x4) {
+function revision(_x5, _x6) {
   return _revision.apply(this, arguments);
 }
 
@@ -138,12 +195,12 @@ function _revision() {
 
     const repository = _actions().utils.getRepositoryFromParams(context);
 
-    const _context$action$param2 = context.action.params,
-          filterByTk = _context$action$param2.filterByTk,
-          _context$action$param3 = _context$action$param2.filter,
-          filter = _context$action$param3 === void 0 ? {} : _context$action$param3;
+    const _context$action$param3 = context.action.params,
+          filterByTk = _context$action$param3.filterByTk,
+          _context$action$param4 = _context$action$param3.filter,
+          filter = _context$action$param4 === void 0 ? {} : _context$action$param4;
     context.body = yield db.sequelize.transaction( /*#__PURE__*/function () {
-      var _ref = _asyncToGenerator(function* (transaction) {
+      var _ref2 = _asyncToGenerator(function* (transaction) {
         const origin = yield repository.findOne({
           filterByTk,
           filter,
@@ -256,8 +313,8 @@ function _revision() {
         return instance;
       });
 
-      return function (_x5) {
-        return _ref.apply(this, arguments);
+      return function (_x8) {
+        return _ref2.apply(this, arguments);
       };
     }());
     yield next();

package/lib/server/collections/executions.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _default = {
+  namespace: 'workflow',
+  duplicator: 'optional',
   name: 'executions',
   fields: [{
     type: 'belongsTo',
@@ -16,16 +18,12 @@ var _default = {
     type: 'boolean',
     name: 'useTransaction',
     defaultValue: false
-  }, // @deprecated
-  {
-    type: 'uuid',
-    name: 'transaction',
-    defaultValue: null
   }, {
     type: 'hasMany',
-    name: 'jobs'
+    name: 'jobs',
+    onDelete: 'CASCADE'
   }, {
-    type: 'jsonb',
+    type: 'json',
     name: 'context'
   }, {
     type: 'integer',

package/lib/server/collections/flow_nodes.js

@@ -5,26 +5,21 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _default = {
+  namespace: 'workflow',
+  duplicator: 'required',
   name: 'flow_nodes',
-  // model: 'FlowNodeModel',
-  title: 'Workflow Nodes',
   fields: [{
-    interface: 'string',
     type: 'string',
-    name: 'title',
-    title: '名称'
+    name: 'title'
   }, // which workflow belongs to
   {
-    interface: 'linkTo',
     name: 'workflow',
     type: 'belongsTo'
   }, {
-    interface: 'linkTo',
     name: 'upstream',
     type: 'belongsTo',
     target: 'flow_nodes'
   }, {
-    interface: 'linkTo',
     name: 'branches',
     type: 'hasMany',
     target: 'flow_nodes',
@@ -34,28 +29,21 @@ var _default = {
   // put here because the design of flow-links model is not really necessary for now.
   // or it should be put into flow-links model.
   {
-    interface: 'select',
     name: 'branchIndex',
-    type: 'integer',
-    title: 'branch index'
+    type: 'integer'
   }, // Note: for reasons:
   // 1. redirect type node to solve cycle flow.
   // 2. recognize as real next node after branches.
   {
-    interface: 'linkTo',
     name: 'downstream',
     type: 'belongsTo',
     target: 'flow_nodes'
   }, {
-    interface: 'select',
     type: 'string',
-    name: 'type',
-    title: '类型'
+    name: 'type'
   }, {
-    interface: 'json',
-    type: 'jsonb',
+    type: 'json',
     name: 'config',
-    title: '配置',
     defaultValue: {}
   }]
 };

package/lib/server/collections/jobs.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _default = {
+  namespace: 'workflow',
+  duplicator: 'optional',
   name: 'jobs',
   fields: [{
     type: 'belongsTo',
@@ -21,7 +23,7 @@ var _default = {
     type: 'integer',
     name: 'status'
   }, {
-    type: 'jsonb',
+    type: 'json',
     name: 'result'
   }]
 };

package/lib/server/collections/workflows.js

@@ -7,6 +7,8 @@ exports.default = _default;
 
 function _default() {
   return {
+    namespace: 'workflow',
+    duplicator: 'required',
     name: 'workflows',
     fields: [{
       name: 'key',
@@ -27,7 +29,7 @@ function _default() {
       name: 'type',
       required: true
     }, {
-      type: 'jsonb',
+      type: 'json',
       name: 'config',
       required: true,
       defaultValue: {}
@@ -38,10 +40,12 @@ function _default() {
     }, {
       type: 'hasMany',
       name: 'nodes',
-      target: 'flow_nodes'
+      target: 'flow_nodes',
+      onDelete: 'CASCADE'
     }, {
       type: 'hasMany',
-      name: 'executions'
+      name: 'executions',
+      onDelete: 'CASCADE'
     }, {
       type: 'integer',
       name: 'executed',
@@ -53,7 +57,7 @@ function _default() {
     }, {
       type: 'boolean',
       name: 'current',
-      defaultValue: null
+      defaultValue: false
     }, {
       type: 'hasMany',
       name: 'revisions',

package/lib/server/constants.d.ts

@@ -1,15 +1,21 @@
 export declare const EXECUTION_STATUS: {
-    CREATED: any;
+    QUEUEING: any;
     STARTED: number;
     RESOLVED: number;
-    REJECTED: number;
+    FAILED: number;
+    ERROR: number;
+    ABORTED: number;
     CANCELED: number;
+    REJECTED: number;
 };
 export declare const JOB_STATUS: {
     PENDING: number;
     RESOLVED: number;
-    REJECTED: number;
+    FAILED: number;
+    ERROR: number;
+    ABORTED: number;
     CANCELED: number;
+    REJECTED: number;
 };
 export declare const BRANCH_INDEX: {
     DEFAULT: any;

package/lib/server/constants.js

@@ -5,18 +5,24 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.JOB_STATUS = exports.EXECUTION_STATUS = exports.BRANCH_INDEX = void 0;
 const EXECUTION_STATUS = {
-  CREATED: null,
+  QUEUEING: null,
   STARTED: 0,
   RESOLVED: 1,
-  REJECTED: -1,
-  CANCELED: -2
+  FAILED: -1,
+  ERROR: -2,
+  ABORTED: -3,
+  CANCELED: -4,
+  REJECTED: -5
 };
 exports.EXECUTION_STATUS = EXECUTION_STATUS;
 const JOB_STATUS = {
   PENDING: 0,
   RESOLVED: 1,
-  REJECTED: -1,
-  CANCELED: -2
+  FAILED: -1,
+  ERROR: -2,
+  ABORTED: -3,
+  CANCELED: -4,
+  REJECTED: -5
 };
 exports.JOB_STATUS = JOB_STATUS;
 const BRANCH_INDEX = {

package/lib/server/functions/index.d.ts

@@ -0,0 +1,4 @@
+import Plugin from "..";
+export default function ({ functions }: Plugin, more?: {
+    [key: string]: Function;
+}): void;

package/lib/server/functions/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function now() {
+  return new Date();
+}
+
+function _default({
+  functions
+}, more = {}) {
+  functions.register('now', now);
+
+  for (var _i = 0, _Object$entries = Object.entries(more); _i < _Object$entries.length; _i++) {
+    const _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+          name = _Object$entries$_i[0],
+          fn = _Object$entries$_i[1];
+
+    functions.register(name, fn);
+  }
+}
+
+;

package/lib/server/index.d.ts

@@ -1,5 +1,4 @@
 export * from './constants';
-export * from './calculators';
 export { Trigger } from './triggers';
 export { default as Processor } from './Processor';
 export { default } from './Plugin';

package/lib/server/index.js

@@ -40,20 +40,6 @@ Object.keys(_constants).forEach(function (key) {
   });
 });
 
-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 _triggers = require("./triggers");
 
 var _Processor = _interopRequireDefault(require("./Processor"));

package/lib/server/instructions/calculation.d.ts

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

package/lib/server/instructions/calculation.js

@@ -5,54 +5,49 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+function _evaluators() {
+  const data = _interopRequireDefault(require("@nocobase/evaluators"));
+
+  _evaluators = function _evaluators() {
+    return data;
+  };
+
+  return data;
+}
+
 var _constants = require("../constants");
 
-var _calculators = require("../calculators");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 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: [
-//     {
-//       type: 'calculation',
-//       options: {
-//         calculator: 'add',
-//         operands: [{ value: 1 }, { value: 2 }]
-//       }
-//     },
-//     {
-//       type: 'constant',
-//       value: '{{$context.data.title}}'
-//     },
-//     {
-//       type: 'context',
-//       options: {
-//         path: 'data.title'
-//       }
-//     },
-//     {
-//       type: 'constant',
-//       value: 1
-//     }
-//   ]
-// }
 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
-      };
+            _ref$engine = _ref.engine,
+            engine = _ref$engine === void 0 ? 'math.js' : _ref$engine,
+            _ref$expression = _ref.expression,
+            expression = _ref$expression === void 0 ? '' : _ref$expression;
+
+      const evaluator = _evaluators().default.get(engine);
+
+      const scope = processor.getScope();
+
+      try {
+        const result = evaluator && expression ? evaluator(expression, scope) : null;
+        return {
+          result,
+          status: _constants.JOB_STATUS.RESOLVED
+        };
+      } catch (e) {
+        return {
+          result: e.toString(),
+          status: _constants.JOB_STATUS.ERROR
+        };
+      }
     })();
   }
 

package/lib/server/instructions/condition.d.ts

@@ -1,5 +1,5 @@
-declare const _default: {
-    run(node: any, prevJob: any, processor: any): Promise<any>;
-    resume(node: any, branchJob: any, processor: any): Promise<any>;
-};
+import { Registry } from "@nocobase/utils";
+import { Instruction } from ".";
+export declare const calculators: Registry<Function>;
+declare const _default: Instruction;
 export default _default;