@nocobase/plugin-workflow 0.7.3-alpha.1 → 0.7.4-alpha.1

package/lib/server/Plugin.d.ts

@@ -9,10 +9,12 @@ import ExecutionModel from './models/Execution';
 export default class WorkflowPlugin extends Plugin {
     instructions: Registry<Instruction>;
     triggers: Registry<Trigger>;
+    calculators: Registry<Function>;
+    extensions: typeof import("./extensions/assignees").default[];
     onBeforeSave: (instance: WorkflowModel, options: any) => Promise<void>;
     getName(): string;
     load(): Promise<void>;
     toggle(workflow: WorkflowModel, enable?: boolean): void;
-    trigger(workflow: any, context: Object, options?: Transactionable): Promise<any>;
+    trigger(workflow: WorkflowModel, context: Object, options?: Transactionable): Promise<ExecutionModel | null>;
     createProcessor(execution: ExecutionModel, options?: {}): Processor;
 }

package/lib/server/Plugin.js

@@ -53,6 +53,10 @@ var _instructions = _interopRequireDefault(require("./instructions"));
 
 var _Processor = _interopRequireDefault(require("./Processor"));
 
+var _calculators = _interopRequireDefault(require("./calculators"));
+
+var _extensions = _interopRequireDefault(require("./extensions"));
+
 var _constants = require("./constants");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -75,6 +79,8 @@ class WorkflowPlugin extends _server().Plugin {
     _this = this;
     this.instructions = new (_utils().Registry)();
     this.triggers = new (_utils().Registry)();
+    this.calculators = _calculators.default;
+    this.extensions = _extensions.default;
 
     this.onBeforeSave = /*#__PURE__*/function () {
       var _ref = _asyncToGenerator(function* (instance, options) {
@@ -148,11 +154,16 @@ class WorkflowPlugin extends _server().Plugin {
       (0, _instructions.default)(_this2, options.instructions);
       db.on('workflows.beforeSave', _this2.onBeforeSave);
       db.on('workflows.afterSave', model => _this2.toggle(model));
-      db.on('workflows.afterDestroy', model => _this2.toggle(model, false)); // [Life Cycle]:
+      db.on('workflows.afterDestroy', model => _this2.toggle(model, false));
+
+      _this2.app.on('afterLoadAll', /*#__PURE__*/_asyncToGenerator(function* () {
+        return _this2.extensions.reduce((promise, extend) => promise.then(() => extend(_this2)), Promise.resolve());
+      })); // [Life Cycle]:
       //   * load all workflows in db
       //   * add all hooks for enabled workflows
       //   * add hooks for create/update[enabled]/delete workflow to add/remove specific hooks
 
+
       _this2.app.on('beforeStart', /*#__PURE__*/_asyncToGenerator(function* () {
         const collection = db.getCollection('workflows');
         const workflows = yield collection.repository.find({
@@ -203,7 +214,7 @@ class WorkflowPlugin extends _server().Plugin {
     return _asyncToGenerator(function* () {
       // `null` means not to trigger
       if (context === null) {
-        return;
+        return null;
       }
 
       let transaction = null;
@@ -220,7 +231,7 @@ class WorkflowPlugin extends _server().Plugin {
 
         if (existed) {
           console.warn(`workflow ${workflow.id} has already been triggered in same execution (${transaction.id}), and newly triggering will be skipped.`);
-          return;
+          return null;
         }
       }
 

package/lib/server/Processor.js

@@ -237,8 +237,7 @@ class Processor {
         }
       }
 
-      let savedJob; // TODO(optimize): many checking of resuming or new could be improved
-      // could be implemented separately in exec() / resume()
+      let savedJob;
 
       if (job instanceof _database().Model) {
         savedJob = yield job.save({
@@ -452,5 +451,5 @@ Processor.StatusMap = {
   [_constants.JOB_STATUS.PENDING]: _constants.EXECUTION_STATUS.STARTED,
   [_constants.JOB_STATUS.RESOLVED]: _constants.EXECUTION_STATUS.RESOLVED,
   [_constants.JOB_STATUS.REJECTED]: _constants.EXECUTION_STATUS.REJECTED,
-  [_constants.JOB_STATUS.CANCELLED]: _constants.EXECUTION_STATUS.CANCELLED
+  [_constants.JOB_STATUS.CANCELED]: _constants.EXECUTION_STATUS.CANCELED
 };

package/lib/server/actions/index.js

@@ -9,6 +9,8 @@ var workflows = _interopRequireWildcard(require("./workflows"));
 
 var nodes = _interopRequireWildcard(require("./nodes"));
 
+var jobs = _interopRequireWildcard(require("./jobs"));
+
 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; }
@@ -28,10 +30,10 @@ function make(name, mod) {
 function _default({
   app
 }) {
-  app.actions(_objectSpread(_objectSpread(_objectSpread({}, make('workflows', workflows)), make('workflows.nodes', {
+  app.actions(_objectSpread(_objectSpread(_objectSpread(_objectSpread({}, make('workflows', workflows)), make('workflows.nodes', {
     create: nodes.create,
     destroy: nodes.destroy
   })), make('flow_nodes', {
     update: nodes.update
-  })));
+  })), make('jobs', jobs)));
 }

package/lib/server/actions/jobs.d.ts

@@ -0,0 +1,2 @@
+import { Context } from '@nocobase/actions';
+export declare function submit(context: Context, next: any): Promise<never>;

package/lib/server/actions/jobs.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.submit = submit;
+
+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 values = context.action.params.values;
+    const instance = context.body; // NOTE: validate status
+
+    if (instance.status !== _constants.JOB_STATUS.PENDING) {
+      return context.throw(400);
+    } // NOTE: validate assignee
+
+
+    instance.set({
+      status: values.status,
+      result: values.result
+    });
+    context.status = 202;
+    yield next();
+    const plugin = context.app.pm.get('@nocobase/plugin-workflow');
+    const processor = plugin.createProcessor(instance.execution); // NOTE: resume the process and no `await` for quick returning
+
+    processor.resume(instance);
+  });
+  return _submit.apply(this, arguments);
+}

package/lib/server/actions/workflows.js

@@ -75,7 +75,7 @@ function migrateConfig(config, oldToNew) {
         return value.map(item => migrate(item));
 
       case 'string':
-        return value.replace(/(\{\{\$jobsMapByNodeId\.)(\d+)/, (_, prefix, id) => `${prefix}${oldToNew.get(Number.parseInt(id, 10)).id}`);
+        return value.replace(/(\{\{\$jobsMapByNodeId\.)([\w-]+)/, (_, prefix, id) => `${prefix}${oldToNew.get(Number.parseInt(id, 10)).id}`);
 
       default:
         return value;

package/lib/server/calculators/index.js

@@ -116,23 +116,23 @@ calculators.register('<', lt);
 calculators.register('<=', lte);
 
 function add(...args) {
-  return args.reduce((sum, a) => sum + a, 0);
+  return args.reduce((sum, a) => sum + (0, _lodash().toNumber)(a), 0);
 }
 
 function minus(a, b) {
-  return a - b;
+  return (0, _lodash().toNumber)(a) - (0, _lodash().toNumber)(b);
 }
 
 function multiple(...args) {
-  return args.reduce((result, a) => result * a, 1);
+  return args.reduce((result, a) => result * (0, _lodash().toNumber)(a), 1);
 }
 
 function divide(a, b) {
-  return a / b;
+  return (0, _lodash().toNumber)(a) / (0, _lodash().toNumber)(b);
 }
 
 function mod(a, b) {
-  return a % b;
+  return (0, _lodash().toNumber)(a) % (0, _lodash().toNumber)(b);
 }
 
 calculators.register('add', add);

package/lib/server/constants.d.ts

@@ -2,13 +2,13 @@ export declare const EXECUTION_STATUS: {
     STARTED: number;
     RESOLVED: number;
     REJECTED: number;
-    CANCELLED: number;
+    CANCELED: number;
 };
 export declare const JOB_STATUS: {
     PENDING: number;
     RESOLVED: number;
     REJECTED: number;
-    CANCELLED: number;
+    CANCELED: number;
 };
 export declare const BRANCH_INDEX: {
     DEFAULT: any;

package/lib/server/constants.js

@@ -8,14 +8,14 @@ const EXECUTION_STATUS = {
   STARTED: 0,
   RESOLVED: 1,
   REJECTED: -1,
-  CANCELLED: -2
+  CANCELED: -2
 };
 exports.EXECUTION_STATUS = EXECUTION_STATUS;
 const JOB_STATUS = {
   PENDING: 0,
   RESOLVED: 1,
   REJECTED: -1,
-  CANCELLED: -2
+  CANCELED: -2
 };
 exports.JOB_STATUS = JOB_STATUS;
 const BRANCH_INDEX = {

package/lib/server/extensions/assignees/actions.d.ts

@@ -0,0 +1,2 @@
+import { Context } from '@nocobase/actions';
+export declare function submit(context: Context, next: any): Promise<never>;

package/lib/server/extensions/assignees/actions.js

@@ -0,0 +1,76 @@
+"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 instance = yield repository.findOne({
+      filterByTk,
+      // filter: {
+      //   userId: currentUser?.id
+      // },
+      appends: ['job', 'node', 'execution'],
+      context
+    });
+    const _instance$node$config = instance.node.config,
+          actions = _instance$node$config.actions,
+          assignees = _instance$node$config.assignees; // NOTE: validate status
+
+    if (instance.status !== _constants.JOB_STATUS.PENDING || instance.job.status !== _constants.JOB_STATUS.PENDING || instance.execution.status !== _constants.EXECUTION_STATUS.STARTED || actions && !actions[values.status]) {
+      context.throw(400);
+    }
+
+    if (!assignees.includes(currentUser.id) || instance.userId !== currentUser.id) {
+      return context.throw(404);
+    } // NOTE: validate assignee
+
+
+    yield instance.update({
+      status: values.status,
+      result: values.result
+    });
+    context.body = instance;
+    context.status = 202;
+    yield next();
+    instance.job.latestUserJob = instance;
+    const plugin = context.app.pm.get('@nocobase/plugin-workflow');
+    const processor = plugin.createProcessor(instance.execution); // NOTE: resume the process and no `await` for quick returning
+
+    processor.resume(instance.job);
+  });
+  return _submit.apply(this, arguments);
+}

package/lib/server/extensions/assignees/collections/jobs.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    collectionOptions: import("@nocobase/database").CollectionOptions;
+    mergeOptions: import("@nocobase/database").MergeOptions;
+    extend: boolean;
+};
+export default _default;

package/lib/server/extensions/assignees/collections/jobs.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _database() {
+  const data = require("@nocobase/database");
+
+  _database = function _database() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _database().extend)({
+  name: 'jobs',
+  fields: [{
+    type: 'belongsToMany',
+    name: 'users',
+    through: 'users_jobs'
+  }, {
+    type: 'hasMany',
+    name: 'usersJobs',
+    target: 'users_jobs',
+    foreignKey: 'jobId'
+  }]
+});
+
+exports.default = _default;

package/lib/server/extensions/assignees/collections/users.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    collectionOptions: import("@nocobase/database").CollectionOptions;
+    mergeOptions: import("@nocobase/database").MergeOptions;
+    extend: boolean;
+};
+export default _default;

package/lib/server/extensions/assignees/collections/users.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _database() {
+  const data = require("@nocobase/database");
+
+  _database = function _database() {
+    return data;
+  };
+
+  return data;
+}
+
+var _default = (0, _database().extend)({
+  name: 'users',
+  fields: [{
+    type: 'belongsToMany',
+    name: 'jobs',
+    through: 'users_jobs'
+  }, {
+    type: 'hasMany',
+    name: 'usersJobs',
+    target: 'users_jobs'
+  }]
+});
+
+exports.default = _default;

package/lib/server/extensions/assignees/collections/users_jobs.d.ts

@@ -0,0 +1,3 @@
+import { CollectionOptions } from '@nocobase/database';
+declare const _default: CollectionOptions;
+export default _default;

package/lib/server/extensions/assignees/collections/users_jobs.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = {
+  name: 'users_jobs',
+  fields: [{
+    type: 'integer',
+    name: 'id',
+    primaryKey: true,
+    autoIncrement: true
+  }, {
+    type: 'belongsTo',
+    name: 'job'
+  }, {
+    type: 'belongsTo',
+    name: 'user'
+  }, {
+    type: 'belongsTo',
+    name: 'execution'
+  }, {
+    type: 'belongsTo',
+    name: 'node',
+    target: 'flow_nodes'
+  }, {
+    type: 'belongsTo',
+    name: 'workflow'
+  }, {
+    type: 'integer',
+    name: 'status'
+  }, {
+    type: 'jsonb',
+    name: 'result'
+  }]
+};
+exports.default = _default;

package/lib/server/extensions/assignees/index.d.ts

@@ -0,0 +1,2 @@
+import Plugin from '../../Plugin';
+export default function (plugin: Plugin): Promise<void>;

package/lib/server/extensions/assignees/index.js

@@ -0,0 +1,273 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+
+  _path = function _path() {
+    return data;
+  };
+
+  return data;
+}
+
+function _utils() {
+  const data = require("@nocobase/utils");
+
+  _utils = function _utils() {
+    return data;
+  };
+
+  return data;
+}
+
+var _actions = require("./actions");
+
+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); }); }; }
+
+// NOTE: for single record mode (mode: 0/null)
+function middleware(_x, _x2) {
+  return _middleware.apply(this, arguments);
+}
+
+function _middleware() {
+  _middleware = _asyncToGenerator(function* (context, next) {
+    const job = context.body,
+          state = context.state,
+          action = context.action;
+    const _job$node$config = job.node.config,
+          assignees = _job$node$config.assignees,
+          mode = _job$node$config.mode; // NOTE: skip to no user implementation
+
+    if (!assignees) {
+      return next();
+    }
+
+    if (!state.currentUser) {
+      return context.throw(401);
+    }
+
+    if (!assignees.includes(state.currentUser.id)) {
+      return context.throw(404);
+    } // NOTE: multiple record mode could not use jobs:submit action
+    // should use users_jobs:submit/:id instead
+
+
+    if (mode) {
+      return context.throw(400);
+    }
+
+    yield next();
+    const data = {
+      userId: context.state.currentUser.id,
+      jobId: job.id,
+      nodeId: job.nodeId,
+      executionId: job.executionId,
+      workflowId: job.execution.workflowId,
+      status: job.status,
+      result: job.result
+    }; // NOTE: update users job after main job is done
+
+    const UserJobModel = context.db.getModel('users_jobs');
+    let userJob = yield UserJobModel.findOne({
+      where: {
+        userId: context.state.currentUser.id,
+        jobId: job.id
+      }
+    });
+
+    if (userJob) {
+      yield userJob.update(data);
+    } else {
+      userJob = yield UserJobModel.create(data);
+    }
+  });
+  return _middleware.apply(this, arguments);
+}
+
+function run(_x3, _x4, _x5) {
+  return _run.apply(this, arguments);
+}
+
+function _run() {
+  _run = _asyncToGenerator(function* (node, prevJob, processor) {
+    var _prevJob$id;
+
+    const _node$config = node.config,
+          assignees = _node$config.assignees,
+          mode = _node$config.mode;
+
+    if (!assignees) {
+      const plugin = processor.options.plugin;
+      const origin = plugin.instructions.get('prompt');
+      return origin.constructor.prototype.run.call(this, node, prevJob, processor);
+    }
+
+    const job = yield processor.saveJob({
+      status: _constants.JOB_STATUS.PENDING,
+      result: mode ? [] : null,
+      nodeId: node.id,
+      upstreamId: (_prevJob$id = prevJob === null || prevJob === void 0 ? void 0 : prevJob.id) !== null && _prevJob$id !== void 0 ? _prevJob$id : null
+    }); // NOTE: batch create users jobs
+
+    const UserJobModel = processor.options.plugin.db.getModel('users_jobs');
+    yield UserJobModel.bulkCreate(assignees.map(userId => ({
+      userId,
+      jobId: job.id,
+      nodeId: node.id,
+      executionId: job.executionId,
+      workflowId: node.workflowId,
+      status: _constants.JOB_STATUS.PENDING
+    })), {
+      transaction: processor.transaction
+    });
+    return job;
+  });
+  return _run.apply(this, arguments);
+}
+
+const PROMPT_ASSIGNED_MODE = {
+  SINGLE: Symbol('single'),
+  ALL: Symbol('all'),
+  ANY: Symbol('any'),
+  ALL_PERCENTAGE: Symbol('all percentage'),
+  ANY_PERCENTAGE: Symbol('any percentage')
+};
+const Modes = {
+  [PROMPT_ASSIGNED_MODE.SINGLE]: {
+    getStatus(distribution, assignees) {
+      const done = distribution.find(item => item.status !== _constants.JOB_STATUS.PENDING && item.count > 0);
+      return done ? done.status : null;
+    }
+
+  },
+  [PROMPT_ASSIGNED_MODE.ALL]: {
+    getStatus(distribution, assignees) {
+      const resolved = distribution.find(item => item.status === _constants.JOB_STATUS.RESOLVED);
+
+      if (resolved && resolved.count === assignees.length) {
+        return _constants.JOB_STATUS.RESOLVED;
+      } // NOTE: `rejected` or `canceled`
+
+
+      const failed = distribution.find(item => item.status < _constants.JOB_STATUS.PENDING);
+
+      if (failed && failed.count) {
+        return failed.status;
+      }
+
+      return null;
+    }
+
+  },
+  [PROMPT_ASSIGNED_MODE.ANY]: {
+    getStatus(distribution, assignees) {
+      const resolved = distribution.find(item => item.status === _constants.JOB_STATUS.RESOLVED);
+
+      if (resolved && resolved.count) {
+        return _constants.JOB_STATUS.RESOLVED;
+      }
+
+      const failedCount = distribution.reduce((count, item) => item.status < _constants.JOB_STATUS.PENDING ? count + item.count : count, 0); // NOTE: all failures are considered as rejected for now
+
+      if (failedCount === assignees.length) {
+        return _constants.JOB_STATUS.REJECTED;
+      }
+
+      return null;
+    }
+
+  }
+};
+
+function getMode(mode) {
+  switch (true) {
+    case mode === 1:
+      return Modes[PROMPT_ASSIGNED_MODE.ALL];
+
+    case mode === -1:
+      return Modes[PROMPT_ASSIGNED_MODE.ANY];
+
+    case mode > 0:
+      return Modes[PROMPT_ASSIGNED_MODE.ALL_PERCENTAGE];
+
+    case mode < 0:
+      return Modes[PROMPT_ASSIGNED_MODE.ANY_PERCENTAGE];
+
+    default:
+      return Modes[PROMPT_ASSIGNED_MODE.SINGLE];
+  }
+}
+
+function resume(_x6, _x7, _x8) {
+  return _resume.apply(this, arguments);
+}
+
+function _resume() {
+  _resume = _asyncToGenerator(function* (node, job, processor) {
+    var _job$latestUserJob$re, _job$latestUserJob, _getMode$getStatus;
+
+    // NOTE: check all users jobs related if all done then continue as parallel
+    const _node$config2 = node.config,
+          assignees = _node$config2.assignees,
+          mode = _node$config2.mode;
+
+    if (!assignees) {
+      const plugin = processor.options.plugin;
+      const origin = plugin.instructions.get('prompt');
+      return origin.constructor.prototype.resume.call(this, node, job, processor);
+    }
+
+    const UserJobModel = processor.options.plugin.db.getModel('users_jobs');
+    const distribution = yield UserJobModel.count({
+      where: {
+        jobId: job.id
+      },
+      group: ['status']
+    });
+    const submitted = distribution.reduce((count, item) => item.status !== _constants.JOB_STATUS.PENDING ? count + item.count : count, 0);
+    const result = mode ? (submitted || 0) / assignees.length : (_job$latestUserJob$re = (_job$latestUserJob = job.latestUserJob) === null || _job$latestUserJob === void 0 ? void 0 : _job$latestUserJob.result) !== null && _job$latestUserJob$re !== void 0 ? _job$latestUserJob$re : job.result;
+    job.set({
+      status: (_getMode$getStatus = getMode(mode).getStatus(distribution, assignees)) !== null && _getMode$getStatus !== void 0 ? _getMode$getStatus : _constants.JOB_STATUS.PENDING,
+      result
+    });
+    return job;
+  });
+  return _resume.apply(this, arguments);
+}
+
+function _default(_x9) {
+  return _ref.apply(this, arguments);
+}
+
+function _ref() {
+  _ref = _asyncToGenerator(function* (plugin) {
+    const instruction = plugin.instructions.get('prompt');
+    instruction.extend({
+      run,
+      resume
+    });
+    instruction.use(middleware); // TODO(bug): through table should be load first because primary
+    // await plugin.db.import({
+    //   directory: path.join(__dirname, './collections')
+    // });
+
+    plugin.db.collection((0, _utils().requireModule)(_path().default.join(__dirname, './collections/users_jobs')));
+    plugin.db.collection((0, _utils().requireModule)(_path().default.join(__dirname, './collections/users')));
+    plugin.db.collection((0, _utils().requireModule)(_path().default.join(__dirname, './collections/jobs')));
+    plugin.app.actions({
+      'users_jobs:submit': _actions.submit
+    });
+  });
+  return _ref.apply(this, arguments);
+}

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

@@ -0,0 +1,3 @@
+import assignees from './assignees';
+declare const _default: (typeof assignees)[];
+export default _default;

package/lib/server/extensions/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _assignees = _interopRequireDefault(require("./assignees"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = [_assignees.default];
+exports.default = _default;

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

@@ -1,7 +1,8 @@
 /// <reference types="node" />
 import Plugin from '..';
 import Processor from '../Processor';
-export default class {
+import { Instruction } from '.';
+export default class implements Instruction {
     protected plugin: Plugin;
     timers: Map<number, NodeJS.Timeout>;
     constructor(plugin: Plugin);

package/lib/server/instructions/index.js

@@ -25,22 +25,6 @@ function _utils() {
   return data;
 }
 
-var _prompt = _interopRequireDefault(require("./prompt"));
-
-var _calculation = _interopRequireDefault(require("./calculation"));
-
-var _condition = _interopRequireDefault(require("./condition"));
-
-var _parallel = _interopRequireDefault(require("./parallel"));
-
-var _query = _interopRequireDefault(require("./query"));
-
-var _create = _interopRequireDefault(require("./create"));
-
-var _update = _interopRequireDefault(require("./update"));
-
-var _destroy = _interopRequireDefault(require("./destroy"));
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
@@ -55,23 +39,24 @@ function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Sy
 
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
 function _default(plugin, more = {}) {
   const instructions = plugin.instructions;
-  instructions.register('prompt', _prompt.default);
-  instructions.register('calculation', _calculation.default);
-  instructions.register('condition', _condition.default);
-  instructions.register('parallel', _parallel.default);
-  instructions.register('query', _query.default);
-  instructions.register('create', _create.default);
-  instructions.register('update', _update.default);
-  instructions.register('destroy', _destroy.default);
-  instructions.register('delay', new ((0, _utils().requireModule)(_path().default.join(__dirname, 'delay')))(plugin));
-
-  for (var _i = 0, _Object$entries = Object.entries(more); _i < _Object$entries.length; _i++) {
+  const natives = ['calculation', 'condition', 'parallel', 'delay', 'prompt', 'query', 'create', 'update', 'destroy'].reduce((result, key) => Object.assign(result, {
+    [key]: key
+  }), {});
+
+  for (var _i = 0, _Object$entries = Object.entries(_objectSpread(_objectSpread({}, more), natives)); _i < _Object$entries.length; _i++) {
     const _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
           name = _Object$entries$_i[0],
-          instruction = _Object$entries$_i[1];
+          value = _Object$entries$_i[1];
 
+    const instruction = typeof value === 'string' ? (0, _utils().requireModule)(_path().default.isAbsolute(value) ? value : _path().default.join(__dirname, value)) : value;
     instructions.register(name, typeof instruction === 'function' ? new instruction(plugin) : instruction);
   }
 }

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

@@ -1,7 +1,19 @@
-declare const _default: {
+import { Context } from '@nocobase/actions';
+import Plugin from '..';
+import { Instruction } from '.';
+export interface PromptConfig {
+    fields: [];
+    actions: any;
+}
+export default class implements Instruction {
+    protected plugin: Plugin;
+    middlewares: any[];
+    constructor(plugin: Plugin);
+    middleware: (context: Context, next: any) => Promise<void>;
+    use(middleware: any): void;
     run(node: any, input: any, processor: any): {
         status: number;
     };
     resume(node: any, job: any, processor: any): any;
-};
-export default _default;
+    extend(options: Instruction): void;
+}

package/lib/server/instructions/prompt.js

@@ -5,19 +5,126 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+function _koaCompose() {
+  const data = _interopRequireDefault(require("koa-compose"));
+
+  _koaCompose = function _koaCompose() {
+    return data;
+  };
+
+  return data;
+}
+
+function _actions() {
+  const data = require("@nocobase/actions");
+
+  _actions = function _actions() {
+    return data;
+  };
+
+  return data;
+}
+
 var _constants = require("../constants");
 
-var _default = {
+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); }); }; }
+
+function loadJob(_x, _x2) {
+  return _loadJob.apply(this, arguments);
+}
+
+function _loadJob() {
+  _loadJob = _asyncToGenerator(function* (context, next) {
+    const _context$action$param = context.action.params,
+          filterByTk = _context$action$param.filterByTk,
+          values = _context$action$param.values;
+
+    if (!context.body) {
+      const jobRepo = _actions().utils.getRepositoryFromParams(context);
+
+      const job = yield jobRepo.findOne({
+        filterByTk,
+        appends: ['node', 'execution'],
+        context
+      });
+
+      if (!filterByTk || !job) {
+        return context.throw(404);
+      } // cache
+
+
+      context.body = job;
+    }
+
+    const _context$body$node = context.body.node,
+          type = _context$body$node.type,
+          config = _context$body$node.config;
+
+    if (type === 'prompt' && config.actions && !config.actions[values.status]) {
+      return context.throw(400);
+    }
+
+    yield next();
+  });
+  return _loadJob.apply(this, arguments);
+}
+
+class _default {
+  constructor(plugin) {
+    var _this = this;
+
+    this.plugin = void 0;
+    this.middlewares = [];
+
+    this.middleware = /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator(function* (context, next) {
+        const _context$action = context.action,
+              actionName = _context$action.actionName,
+              resourceName = _context$action.resourceName;
+
+        if (actionName === 'submit' && resourceName === 'jobs' && _this.middlewares.length) {
+          return (0, _koaCompose().default)([loadJob, ..._this.middlewares])(context, next);
+        }
+
+        yield next();
+      });
+
+      return function (_x3, _x4) {
+        return _ref.apply(this, arguments);
+      };
+    }();
+
+    this.plugin = plugin;
+    plugin.app.resourcer.use(this.middleware);
+  }
+
+  use(middleware) {
+    this.middlewares.push(middleware);
+  }
+
   run(node, input, processor) {
     return {
       status: _constants.JOB_STATUS.PENDING
     };
-  },
+  }
 
   resume(node, job, processor) {
-    job.set('status', _constants.JOB_STATUS.RESOLVED);
+    if (!node.config.actions) {
+      job.set('status', _constants.JOB_STATUS.RESOLVED);
+    }
+
     return job;
   }
 
-};
-exports.default = _default;
+  extend(options) {
+    Object.assign(this, options);
+  }
+
+}
+
+exports.default = _default;
+;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/plugin-workflow",
-  "version": "0.7.3-alpha.1",
+  "version": "0.7.4-alpha.1",
   "main": "lib/index.js",
   "license": "Apache-2.0",
   "licenses": [
@@ -10,17 +10,17 @@
     }
   ],
   "dependencies": {
-    "@nocobase/actions": "0.7.3-alpha.1",
-    "@nocobase/client": "0.7.3-alpha.1",
-    "@nocobase/database": "0.7.3-alpha.1",
-    "@nocobase/server": "0.7.3-alpha.1",
-    "@nocobase/utils": "0.7.3-alpha.1",
+    "@nocobase/actions": "0.7.4-alpha.1",
+    "@nocobase/client": "0.7.4-alpha.1",
+    "@nocobase/database": "0.7.4-alpha.1",
+    "@nocobase/server": "0.7.4-alpha.1",
+    "@nocobase/utils": "0.7.4-alpha.1",
     "cron-parser": "4.4.0",
     "json-templates": "^4.2.0",
     "react-js-cron": "^1.4.0"
   },
   "devDependencies": {
-    "@nocobase/test": "0.7.3-alpha.1"
+    "@nocobase/test": "0.7.4-alpha.1"
   },
-  "gitHead": "09597f41800ec567f64000e928cd68c28bb927e3"
+  "gitHead": "543eb1c0308bb72a5ba54f208586cd78bfda8fa9"
 }