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

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;

package/lib/server/instructions/condition.js

@@ -3,88 +3,160 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.calculators = void 0;
 
-var _calculators = _interopRequireWildcard(require("../calculators"));
+function _utils() {
+  const data = require("@nocobase/utils");
 
-var _constants = require("../constants");
+  _utils = function _utils() {
+    return data;
+  };
+
+  return data;
+}
+
+function _evaluators() {
+  const data = _interopRequireDefault(require("@nocobase/evaluators"));
 
-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); }
+  _evaluators = function _evaluators() {
+    return data;
+  };
 
-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; }
+  return data;
+}
+
+var _constants = require("../constants");
+
+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: {
-//   not: false,
-//   group: {
-//     type: 'and',
-//     calculations: [
-//       {
-//         calculator: 'time.equal',
-//         operands: [{ value: '{{$context.time}}' }, { value: '{{$fn.now}}' }]
-//       },
-//       {
-//         calculator: 'value.equal',
-//         operands: [{ value: '{{$jobsMapByNodeId.213}}' }, { value: 1 }]
-//       },
-//       {
-//         group: {
-//           type: 'or',
-//           calculations: [
-//             {
-//               calculator: 'value.equal',
-//               operands: [{ value: '{{$jobsMapByNodeId.213}}' }, { value: 1 }]
-//             }
-//           ]
-//         }
-//       }
-//     ]
-//   }
-// }
-function logicCalculate(calculation, input, processor) {
-  if (!calculation) {
-    return true;
-  }
+const calculators = new (_utils().Registry)(); // built-in functions
 
-  const not = calculation.not,
-        group = calculation.group;
-  let result;
+exports.calculators = calculators;
 
-  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));
+function equal(a, b) {
+  return a === b;
+}
 
-    const fn = _calculators.default.get(calculation.calculator);
+function notEqual(a, b) {
+  return a !== b;
+}
 
-    if (!fn) {
-      throw new Error(`no calculator function registered for "${calculation.calculator}"`);
-    }
+function gt(a, b) {
+  return a > b;
+}
+
+function gte(a, b) {
+  return a >= b;
+}
+
+function lt(a, b) {
+  return a < b;
+}
+
+function lte(a, b) {
+  return a <= b;
+}
+
+calculators.register('equal', equal);
+calculators.register('notEqual', notEqual);
+calculators.register('gt', gt);
+calculators.register('gte', gte);
+calculators.register('lt', lt);
+calculators.register('lte', lte);
+calculators.register('===', equal);
+calculators.register('!==', notEqual);
+calculators.register('>', gt);
+calculators.register('>=', gte);
+calculators.register('<', lt);
+calculators.register('<=', lte);
+
+function includes(a, b) {
+  return a.includes(b);
+}
 
-    result = fn(...args);
+function notIncludes(a, b) {
+  return !a.includes(b);
+}
+
+function startsWith(a, b) {
+  return a.startsWith(b);
+}
+
+function notStartsWith(a, b) {
+  return !a.startsWith(b);
+}
+
+function endsWith(a, b) {
+  return a.endsWith(b);
+}
+
+function notEndsWith(a, b) {
+  return !a.endsWith(b);
+}
+
+calculators.register('includes', includes);
+calculators.register('notIncludes', notIncludes);
+calculators.register('startsWith', startsWith);
+calculators.register('notStartsWith', notStartsWith);
+calculators.register('endsWith', endsWith);
+calculators.register('notEndsWith', notEndsWith);
+
+function calculate(calculation = {}) {
+  var _calculation$operands;
+
+  let fn;
+
+  if (!(calculation.calculator && (fn = calculators.get(calculation.calculator)))) {
+    throw new Error(`no calculator function registered for "${calculation.calculator}"`);
+  }
+
+  return Boolean(fn(...((_calculation$operands = calculation.operands) !== null && _calculation$operands !== void 0 ? _calculation$operands : [])));
+}
+
+function logicCalculate(calculation) {
+  if (!calculation) {
+    return true;
+  }
+
+  if (typeof calculation['group'] === 'object') {
+    var _calculation$group$ca;
+
+    const method = calculation['group'].type === 'and' ? 'every' : 'some';
+    return ((_calculation$group$ca = calculation['group'].calculations) !== null && _calculation$group$ca !== void 0 ? _calculation$group$ca : [])[method](item => logicCalculate(item));
   }
 
-  return not ? !result : result;
+  return calculate(calculation);
 }
 
 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 || {},
+            engine = _ref.engine,
             calculation = _ref.calculation,
+            expression = _ref.expression,
             rejectOnFalse = _ref.rejectOnFalse;
 
-      const result = logicCalculate(processor.getParsedValue(calculation), prevJob, processor);
+      const evaluator = _evaluators().default.get(engine);
+
+      let result = true;
+
+      try {
+        result = evaluator ? evaluator(expression, processor.getScope()) : logicCalculate(processor.getParsedValue(calculation));
+      } catch (e) {
+        return {
+          result: e.toString(),
+          status: _constants.JOB_STATUS.ERROR
+        };
+      }
 
       if (!result && rejectOnFalse) {
         return {
-          status: _constants.JOB_STATUS.REJECTED,
+          status: _constants.JOB_STATUS.FAILED,
           result
         };
       }

package/lib/server/instructions/index.js

@@ -47,7 +47,7 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
 
 function _default(plugin, more = {}) {
   const instructions = plugin.instructions;
-  const natives = ['calculation', 'condition', 'parallel', 'delay', 'prompt', 'query', 'create', 'update', 'destroy', 'request'].reduce((result, key) => Object.assign(result, {
+  const natives = ['calculation', 'condition', 'parallel', 'delay', 'manual', 'query', 'create', 'update', 'destroy', 'request'].reduce((result, key) => Object.assign(result, {
     [key]: (0, _utils().requireModule)(_path().default.isAbsolute(key) ? key : _path().default.join(__dirname, key))
   }), {});
 

package/lib/server/instructions/manual/actions.js

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.submit = submit;
+
+function _actions() {
+  const data = require("@nocobase/actions");
+
+  _actions = function _actions() {
+    return data;
+  };
+
+  return data;
+}
+
+var _constants = require("../../constants");
+
+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); }); }; }
+
+function submit(_x, _x2) {
+  return _submit.apply(this, arguments);
+}
+
+function _submit() {
+  _submit = _asyncToGenerator(function* (context, next) {
+    const repository = _actions().utils.getRepositoryFromParams(context);
+
+    const _context$action$param = context.action.params,
+          filterByTk = _context$action$param.filterByTk,
+          values = _context$action$param.values;
+    const currentUser = context.state.currentUser;
+
+    if (!currentUser) {
+      return context.throw(401);
+    }
+
+    const plugin = context.app.pm.get('workflow');
+    const userJob = yield context.db.sequelize.transaction( /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator(function* (transaction) {
+        var _instance$node$config2;
+
+        const instance = yield repository.findOne({
+          filterByTk,
+          // filter: {
+          //   userId: currentUser?.id
+          // },
+          appends: ['job', 'node', 'execution', 'workflow'],
+          context,
+          transaction
+        });
+
+        if (!instance) {
+          return context.throw(404);
+        }
+
+        const _instance$node$config = instance.node.config.actions,
+              actions = _instance$node$config === void 0 ? [] : _instance$node$config; // NOTE: validate status
+
+        if (instance.status !== _constants.JOB_STATUS.PENDING || instance.job.status !== _constants.JOB_STATUS.PENDING || instance.execution.status !== _constants.EXECUTION_STATUS.STARTED || !instance.workflow.enabled || !actions.includes(values.status)) {
+          return context.throw(400);
+        }
+
+        instance.execution.workflow = instance.workflow;
+        const processor = plugin.createProcessor(instance.execution, {
+          transaction
+        });
+        yield processor.prepare();
+        const assignees = processor.getParsedValue((_instance$node$config2 = instance.node.config.assignees) !== null && _instance$node$config2 !== void 0 ? _instance$node$config2 : []);
+
+        if (!assignees.includes(currentUser.id) || instance.userId !== currentUser.id) {
+          return context.throw(403);
+        } // NOTE: validate assignee
+
+
+        yield instance.update({
+          status: values.status,
+          result: values.result
+        }, {
+          transaction
+        });
+        return instance;
+      });
+
+      return function (_x3) {
+        return _ref.apply(this, arguments);
+      };
+    }()); // await transaction.commit();
+
+    context.body = userJob;
+    context.status = 202;
+    yield next();
+    userJob.job.latestUserJob = userJob; // NOTE: resume the process and no `await` for quick returning
+
+    plugin.resume(userJob.job);
+  });
+  return _submit.apply(this, arguments);
+}

package/lib/server/{extensions/assignees/collections → instructions/manual/collecions}/jobs.d.ts

@@ -6,11 +6,13 @@ declare const _default: {
         through: string;
         target?: undefined;
         foreignKey?: undefined;
+        onDelete?: undefined;
     } | {
         type: string;
         name: string;
         target: string;
         foreignKey: string;
+        onDelete: string;
         through?: undefined;
     })[];
 };

package/lib/server/{extensions/assignees/collections → instructions/manual/collecions}/jobs.js

@@ -14,7 +14,8 @@ var _default = {
     type: 'hasMany',
     name: 'usersJobs',
     target: 'users_jobs',
-    foreignKey: 'jobId'
+    foreignKey: 'jobId',
+    onDelete: 'CASCADE'
   }]
 };
 exports.default = _default;

package/lib/server/{extensions/assignees/collections → instructions/manual/collecions}/users_jobs.js

@@ -5,26 +5,26 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _default = {
+  namespace: 'workflow',
   name: 'users_jobs',
+  duplicator: 'optional',
   fields: [{
     type: 'bigInt',
     name: 'id',
     primaryKey: true,
     autoIncrement: true
-  }, {
-    type: 'bigInt',
-    name: 'userId',
-    primaryKey: false
-  }, {
-    type: 'bigInt',
-    name: 'jobId',
-    primaryKey: false
   }, {
     type: 'belongsTo',
-    name: 'job'
+    name: 'job',
+    target: 'jobs',
+    foreignKey: 'jobId',
+    primaryKey: false
   }, {
     type: 'belongsTo',
-    name: 'user'
+    name: 'user',
+    target: 'users',
+    foreignKey: 'userId',
+    primaryKey: false
   }, {
     type: 'belongsTo',
     name: 'execution'

package/lib/server/instructions/manual/index.d.ts

@@ -0,0 +1,25 @@
+import Plugin from '../..';
+import { Instruction } from '..';
+export interface ManualConfig {
+    schema: {
+        collection: {
+            name: string;
+            fields: any[];
+        };
+        blocks: {
+            [key: string]: any;
+        };
+        actions: {
+            [key: string]: any;
+        };
+    };
+    actions: number[];
+    assignees?: number[];
+    mode?: number;
+}
+export default class implements Instruction {
+    protected plugin: Plugin;
+    constructor(plugin: Plugin);
+    run(node: any, prevJob: any, processor: any): Promise<any>;
+    resume(node: any, job: any, processor: any): Promise<any>;
+}