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

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

@@ -0,0 +1,200 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _actions() {
+  const data = _interopRequireDefault(require("@nocobase/actions"));
+
+  _actions = function _actions() {
+    return data;
+  };
+
+  return data;
+}
+
+var _constants = require("../../constants");
+
+var _jobs = _interopRequireDefault(require("./collecions/jobs"));
+
+var _users = _interopRequireDefault(require("./collecions/users"));
+
+var _users_jobs = _interopRequireDefault(require("./collecions/users_jobs"));
+
+var _actions2 = require("./actions");
+
+const _excluded = ["mode"];
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+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); }); }; }
+
+const MULTIPLE_ASSIGNED_MODE = {
+  SINGLE: Symbol('single'),
+  ALL: Symbol('all'),
+  ANY: Symbol('any'),
+  ALL_PERCENTAGE: Symbol('all percentage'),
+  ANY_PERCENTAGE: Symbol('any percentage')
+};
+const Modes = {
+  [MULTIPLE_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;
+    }
+
+  },
+  [MULTIPLE_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;
+      }
+
+      const rejected = distribution.find(item => item.status < _constants.JOB_STATUS.PENDING);
+
+      if (rejected && rejected.count) {
+        return rejected.status;
+      }
+
+      return null;
+    }
+
+  },
+  [MULTIPLE_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 rejectedCount = 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 (rejectedCount === assignees.length) {
+        return _constants.JOB_STATUS.REJECTED;
+      }
+
+      return null;
+    }
+
+  }
+};
+
+function getMode(mode) {
+  switch (true) {
+    case mode === 1:
+      return Modes[MULTIPLE_ASSIGNED_MODE.ALL];
+
+    case mode === -1:
+      return Modes[MULTIPLE_ASSIGNED_MODE.ANY];
+
+    case mode > 0:
+      return Modes[MULTIPLE_ASSIGNED_MODE.ALL_PERCENTAGE];
+
+    case mode < 0:
+      return Modes[MULTIPLE_ASSIGNED_MODE.ANY_PERCENTAGE];
+
+    default:
+      return Modes[MULTIPLE_ASSIGNED_MODE.SINGLE];
+  }
+}
+
+class _default {
+  constructor(plugin) {
+    this.plugin = void 0;
+    this.plugin = plugin;
+    plugin.db.collection(_users_jobs.default);
+    plugin.db.extendCollection(_users.default);
+    plugin.db.extendCollection(_jobs.default);
+    plugin.app.resource({
+      name: 'users_jobs',
+      actions: {
+        list: {
+          filter: {
+            $or: [{
+              'workflow.enabled': true
+            }, {
+              'workflow.enabled': false,
+              status: {
+                $ne: _constants.JOB_STATUS.PENDING
+              }
+            }]
+          },
+          handler: _actions().default.list
+        },
+        submit: _actions2.submit
+      }
+    });
+  }
+
+  run(node, prevJob, processor) {
+    return _asyncToGenerator(function* () {
+      var _prevJob$id;
+
+      const _node$config = node.config,
+            mode = _node$config.mode,
+            config = _objectWithoutProperties(_node$config, _excluded);
+
+      const assignees = [...new Set(processor.getParsedValue(config.assignees) || [])];
+      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;
+    })();
+  }
+
+  resume(node, job, processor) {
+    return _asyncToGenerator(function* () {
+      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,
+            _node$config2$assigne = _node$config2.assignees,
+            assignees = _node$config2$assigne === void 0 ? [] : _node$config2$assigne,
+            mode = _node$config2.mode;
+      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: job.status || ((_getMode$getStatus = getMode(mode).getStatus(distribution, assignees)) !== null && _getMode$getStatus !== void 0 ? _getMode$getStatus : _constants.JOB_STATUS.PENDING),
+        result
+      });
+      return job;
+    })();
+  }
+
+}
+
+exports.default = _default;
+;

package/lib/server/instructions/parallel.js

@@ -20,12 +20,14 @@ exports.PARALLEL_MODE = PARALLEL_MODE;
 const Modes = {
   [PARALLEL_MODE.ALL]: {
     next(previous) {
-      return previous.status !== _constants.JOB_STATUS.REJECTED;
+      return previous.status >= _constants.JOB_STATUS.PENDING;
     },
 
     getStatus(result) {
-      if (result.some(status => status != null && status === _constants.JOB_STATUS.REJECTED)) {
-        return _constants.JOB_STATUS.REJECTED;
+      const failedStatus = result.find(status => status != null && status < _constants.JOB_STATUS.PENDING);
+
+      if (typeof failedStatus !== 'undefined') {
+        return failedStatus;
       }
 
       if (result.every(status => status != null && status === _constants.JOB_STATUS.RESOLVED)) {
@@ -38,7 +40,7 @@ const Modes = {
   },
   [PARALLEL_MODE.ANY]: {
     next(previous) {
-      return previous.status !== _constants.JOB_STATUS.RESOLVED;
+      return previous.status <= _constants.JOB_STATUS.PENDING;
     },
 
     getStatus(result) {
@@ -50,7 +52,7 @@ const Modes = {
         return _constants.JOB_STATUS.PENDING;
       }
 
-      return _constants.JOB_STATUS.REJECTED;
+      return _constants.JOB_STATUS.FAILED;
     }
 
   },
@@ -64,8 +66,10 @@ const Modes = {
         return _constants.JOB_STATUS.RESOLVED;
       }
 
-      if (result.some(status => status != null && status === _constants.JOB_STATUS.REJECTED)) {
-        return _constants.JOB_STATUS.REJECTED;
+      const failedStatus = result.find(status => status != null && status < _constants.JOB_STATUS.PENDING);
+
+      if (typeof failedStatus !== 'undefined') {
+        return failedStatus;
       }
 
       return _constants.JOB_STATUS.PENDING;

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

@@ -1,17 +1,18 @@
 import { AxiosRequestConfig } from 'axios';
 import { Instruction } from './index';
+import Processor from '../Processor';
+import FlowNodeModel from '../models/FlowNode';
 export interface Header {
     name: string;
     value: string;
 }
-export declare type RequestConfig = Pick<AxiosRequestConfig, 'url' | 'method' | 'data' | 'timeout'> & {
+export declare type RequestConfig = Pick<AxiosRequestConfig, 'url' | 'method' | 'params' | 'data' | 'timeout'> & {
     headers: Array<Header>;
     ignoreFail: boolean;
 };
 export default class implements Instruction {
     plugin: any;
     constructor(plugin: any);
-    request: (node: any, job: any, processor: any) => Promise<any>;
-    run(node: any, input: any, processor: any): Promise<any>;
-    resume(node: any, job: any, processor: any): Promise<any>;
+    run(node: FlowNodeModel, input: any, processor: Processor): Promise<any>;
+    resume(node: FlowNodeModel, job: any, processor: Processor): Promise<any>;
 }

package/lib/server/instructions/request.js

@@ -5,16 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-function _ejs() {
-  const data = require("ejs");
-
-  _ejs = function _ejs() {
-    return data;
-  };
-
-  return data;
-}
-
 function _axios() {
   const data = _interopRequireDefault(require("axios"));
 
@@ -33,91 +23,82 @@ function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try
 
 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); }); }; }
 
-class _default {
-  constructor(plugin) {
-    var _this = this;
+function request(_x) {
+  return _request.apply(this, arguments);
+}
 
-    this.plugin = void 0;
+function _request() {
+  _request = _asyncToGenerator(function* (config) {
+    var _config$headers, _config$params;
+
+    // default headers
+    const url = config.url,
+          _config$method = config.method,
+          method = _config$method === void 0 ? 'POST' : _config$method,
+          data = config.data,
+          _config$timeout = config.timeout,
+          timeout = _config$timeout === void 0 ? 5000 : _config$timeout;
+    const headers = ((_config$headers = config.headers) !== null && _config$headers !== void 0 ? _config$headers : []).reduce((result, header) => {
+      if (header.name.toLowerCase() === 'content-type') {
+        return result;
+      }
 
-    this.request = /*#__PURE__*/function () {
-      var _ref = _asyncToGenerator(function* (node, job, processor) {
-        const templateVars = {
-          node: processor.jobsMapByNodeId,
-          ctx: processor.execution.context,
-          $jobsMapByNodeId: processor.jobsMapByNodeId,
-          $context: processor.execution.context
-        };
-        const requestConfig = node.config; // default headers
-
-        const headers = {
-          'Content-Type': 'application/json'
-        };
-        const _requestConfig$header = requestConfig.headers,
-              headerArr = _requestConfig$header === void 0 ? [] : _requestConfig$header,
-              _requestConfig$method = requestConfig.method,
-              method = _requestConfig$method === void 0 ? 'POST' : _requestConfig$method,
-              _requestConfig$timeou = requestConfig.timeout,
-              timeout = _requestConfig$timeou === void 0 ? 5000 : _requestConfig$timeou;
-        headerArr.forEach(header => headers[header.name] = header.value);
-        let url, data;
-
-        try {
-          url = yield (0, _ejs().render)(requestConfig.url.trim(), templateVars, {
-            async: true
-          });
-          data = requestConfig.data ? yield (0, _ejs().render)(requestConfig.data.trim(), templateVars, {
-            async: true
-          }) : undefined;
-        } catch (error2) {
-          // console.error(error2);
-          job.set({
-            status: _constants.JOB_STATUS.REJECTED,
-            result: error2.message
-          });
-        }
-
-        try {
-          const response = yield _axios().default.request({
-            url,
-            method,
-            headers,
-            data,
-            timeout
-          });
-          job.set({
-            status: _constants.JOB_STATUS.RESOLVED,
-            result: response.data
-          });
-        } catch (error1) {
-          // console.error('axios error?', error1);
-          job.set({
-            status: _constants.JOB_STATUS.REJECTED,
-            result: error1.isAxiosError ? error1.toJSON() : error1.message
-          });
-        }
-
-        return _this.plugin.resume(job);
+      return Object.assign(result, {
+        [header.name]: header.value
       });
+    }, {});
+    const params = ((_config$params = config.params) !== null && _config$params !== void 0 ? _config$params : []).reduce((result, param) => Object.assign(result, {
+      [param.name]: param.value
+    }), {}); // TODO(feat): only support JSON type for now, should support others in future
+
+    headers['Content-Type'] = 'application/json';
+    return _axios().default.request({
+      url,
+      method,
+      headers,
+      params,
+      data,
+      timeout
+    });
+  });
+  return _request.apply(this, arguments);
+}
 
-      return function (_x, _x2, _x3) {
-        return _ref.apply(this, arguments);
-      };
-    }();
+;
 
+class _default {
+  constructor(plugin) {
+    this.plugin = void 0;
     this.plugin = plugin;
   }
 
   run(node, input, processor) {
-    var _this2 = this;
+    var _this = this;
 
     return _asyncToGenerator(function* () {
       const job = yield processor.saveJob({
         status: _constants.JOB_STATUS.PENDING,
         nodeId: node.id
       });
-      setTimeout(() => {
-        _this2.request(node, job, processor);
+      const config = processor.getParsedValue(node.config);
+      request(config).then(response => {
+        job.set({
+          status: _constants.JOB_STATUS.RESOLVED,
+          result: response.data
+        });
+      }).catch(error => {
+        job.set({
+          status: _constants.JOB_STATUS.FAILED,
+          result: error.isAxiosError ? error.toJSON() : error.message
+        });
+      }).finally(() => {
+        _this.plugin.app.logger.info(`[Workflow] request (#${node.id}) response received, status: ${job.get('status')}`);
+
+        _this.plugin.resume(job);
       });
+
+      _this.plugin.app.logger.info(`[Workflow] request (#${node.id}) sent to "${config.url}", waiting for response...`);
+
       return job;
     })();
   }

package/lib/server/migrations/20230221032941-change-request-body-type.d.ts

@@ -0,0 +1,5 @@
+import { Migration } from '@nocobase/server';
+export default class extends Migration {
+    up(): Promise<void>;
+    down(): Promise<void>;
+}

package/lib/server/migrations/20230221032941-change-request-body-type.js

@@ -0,0 +1,113 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _server() {
+  const data = require("@nocobase/server");
+
+  _server = function _server() {
+    return data;
+  };
+
+  return data;
+}
+
+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 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); }); }; }
+
+const EJS_RE = /"?<%=\s*(ctx|node)([\w\.\[\]-]+)\s*.*%>"?/;
+
+function migrateData(input) {
+  if (typeof input !== 'string') {
+    return input;
+  }
+
+  if (!input) {
+    return null;
+  }
+
+  const typeMap = {
+    ctx: '$context',
+    node: '$jobsMapByNodeId'
+  };
+  return input.replace(EJS_RE, (_, type, path) => {
+    if (type === 'ctx') {
+      return `"{{$context${path}}}"`;
+    }
+
+    if (type === 'node') {
+      return `"{{$jobsMapByNodeId${path.replace('[', '.').replace(']', '.').replace(/\.$/, '')}}}"`;
+    }
+
+    return _;
+  });
+}
+
+class _default extends _server().Migration {
+  up() {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      const match = yield _this.app.version.satisfies('<0.9.0-alpha.3');
+
+      if (!match) {
+        return;
+      }
+
+      const NodeRepo = _this.context.db.getRepository('flow_nodes');
+
+      yield _this.context.db.sequelize.transaction( /*#__PURE__*/function () {
+        var _ref = _asyncToGenerator(function* (transaction) {
+          const nodes = yield NodeRepo.find({
+            filter: {
+              type: 'request'
+            },
+            transaction
+          });
+          console.log('%d nodes need to be migrated.', nodes.length);
+          yield nodes.reduce((promise, node) => promise.then( /*#__PURE__*/_asyncToGenerator(function* () {
+            if (typeof node.config.data !== 'string') {
+              return;
+            }
+
+            let data = migrateData(node.config.data);
+
+            try {
+              data = JSON.parse(node.config.data);
+              return node.update({
+                config: _objectSpread(_objectSpread({}, node.config), {}, {
+                  data
+                })
+              }, {
+                transaction
+              });
+            } catch (error) {
+              console.error(`flow_node #${node.id} config migrating failed! you should migrate its format from ejs to json-templates manually in your db.`);
+            }
+          })), Promise.resolve());
+        });
+
+        return function (_x) {
+          return _ref.apply(this, arguments);
+        };
+      }());
+    })();
+  }
+
+  down() {
+    return _asyncToGenerator(function* () {})();
+  }
+
+}
+
+exports.default = _default;

package/lib/server/migrations/20230221071831-calculation-expression.d.ts

@@ -0,0 +1,4 @@
+import { Migration } from '@nocobase/server';
+export default class extends Migration {
+    up(): Promise<void>;
+}