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

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>;
+}

package/lib/server/migrations/20230221071831-calculation-expression.js

@@ -0,0 +1,143 @@
+"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;
+}
+
+const _excluded = ["calculation"];
+
+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 _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 addQuote(v) {
+  if (typeof v !== 'string') {
+    return v;
+  }
+
+  if (v.match(/^{{\s*([^{}]+)\s*}}$/)) {
+    return v;
+  }
+
+  return `'${v}'`;
+}
+
+const calculatorsMap = {
+  'equal': '==',
+  '===': '==',
+  'notEqual': '!=',
+  '!==': '!=',
+  'gt': '>',
+  'gte': '>=',
+  'lt': '<',
+  'lte': '<=',
+  'add': '+',
+  'minus': '-',
+  'multiple': '*',
+  'divide': '/',
+  'mod': '%',
+
+  includes(a, b) {
+    return `SEARCH(${b}, ${a}) >= 0`;
+  },
+
+  notIncludes(a, b) {
+    return `SEARCH(${b}, ${a}) < 0`;
+  },
+
+  startsWith(a, b) {
+    return `SEARCH(${b}, ${a}) == 0`;
+  },
+
+  endsWith(a, b) {
+    return `RIGHT(${a}, LEN(${b})) == ${b}`;
+  },
+
+  notStartsWith(a, b) {
+    return `SEARCH(${b}, ${a}) != 0`;
+  },
+
+  notEndsWith(a, b) {
+    return `RIGHT(${a}, LEN(${b})) != ${b}`;
+  },
+
+  concat(a, b) {
+    return `CONCATENATE(${a}, ${b})`;
+  }
+
+};
+
+function migrateConfig(_ref = {}) {
+  var _calculation$operands, _calculator$operands;
+
+  let calculation = _ref.calculation,
+      config = _objectWithoutProperties(_ref, _excluded);
+
+  if (!(calculation === null || calculation === void 0 ? void 0 : calculation.calculator) || !(calculation === null || calculation === void 0 ? void 0 : (_calculation$operands = calculation.operands) === null || _calculation$operands === void 0 ? void 0 : _calculation$operands.length)) {
+    return config;
+  }
+
+  const calculator = calculatorsMap[calculation.calculator];
+  const operands = ((_calculator$operands = calculator.operands) !== null && _calculator$operands !== void 0 ? _calculator$operands : []).map(operand => addQuote(operand));
+  return {
+    engine: 'formula.js',
+    expression: typeof calculator === 'function' ? calculator(...operands) : operands.join(` ${calculator !== null && calculator !== void 0 ? calculator : calculation.calculator} `)
+  };
+}
+
+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 _ref2 = _asyncToGenerator(function* (transaction) {
+          const nodes = yield NodeRepo.find({
+            filter: {
+              type: 'calculation'
+            },
+            transaction
+          });
+          console.log('%d nodes need to be migrated.', nodes.length);
+          yield nodes.reduce((promise, node) => promise.then(() => {
+            return node.update({
+              config: migrateConfig(node.config)
+            }, {
+              transaction
+            });
+          }), Promise.resolve());
+        });
+
+        return function (_x) {
+          return _ref2.apply(this, arguments);
+        };
+      }());
+    })();
+  }
+
+}
+
+exports.default = _default;

package/lib/server/migrations/20230221121203-condition-calculation.d.ts

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

package/lib/server/migrations/20230221121203-condition-calculation.js

@@ -0,0 +1,126 @@
+"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 calculatorsMap = {
+  'equal': '==',
+  '===': '==',
+  'notEqual': '!=',
+  '!==': '!=',
+  'gt': '>',
+  'gte': '>=',
+  'lt': '<',
+  'lte': '<=',
+
+  includes(a, b) {
+    return `SEARCH('${b}', '${a}') >= 0`;
+  },
+
+  notIncludes(a, b) {
+    return `SEARCH('${b}', '${a}') < 0`;
+  },
+
+  startsWith(a, b) {
+    return `SEARCH('${b}', '${a}') == 0`;
+  },
+
+  endsWith(a, b) {
+    return `RIGHT('${a}', LEN('${b}')) == '${b}'`;
+  },
+
+  notStartsWith(a, b) {
+    return `SEARCH('${b}', '${a}') != 0`;
+  },
+
+  notEndsWith(a, b) {
+    return `RIGHT('${a}', LEN('${b}')) != '${b}'`;
+  }
+
+};
+
+function migrateConfig({
+  group: {
+    type = 'and',
+    calculations = []
+  }
+}) {
+  return {
+    group: {
+      type,
+      calculations: calculations.map(({
+        calculator = '===',
+        operands = []
+      }) => {
+        return `(${operands.map(operand => (operand === null || operand === void 0 ? void 0 : operand.group) ? migrateConfig(operand) : operand).join(` ${calculatorsMap[calculator]} `)})`;
+      })
+    }
+  };
+}
+
+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: 'condition'
+            },
+            transaction
+          });
+          console.log('%d nodes need to be migrated.', nodes.length);
+          yield nodes.reduce((promise, node) => promise.then(() => {
+            return node.update({
+              config: _objectSpread(_objectSpread({}, node.config), {}, {
+                engine: 'basic' // calculation: migrateConfig(node.config.calculation)
+
+              })
+            }, {
+              transaction
+            });
+          }), Promise.resolve());
+        });
+
+        return function (_x) {
+          return _ref.apply(this, arguments);
+        };
+      }());
+    })();
+  }
+
+}
+
+exports.default = _default;

package/lib/server/migrations/20230221162902-jsonb-to-json.d.ts

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

package/lib/server/migrations/20230221162902-jsonb-to-json.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+function _sequelize() {
+  const data = require("sequelize");
+
+  _sequelize = function _sequelize() {
+    return data;
+  };
+
+  return data;
+}
+
+function _server() {
+  const data = require("@nocobase/server");
+
+  _server = function _server() {
+    return data;
+  };
+
+  return data;
+}
+
+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); }); }; }
+
+class _default extends _server().Migration {
+  up() {
+    var _arguments = arguments,
+        _this = this;
+
+    return _asyncToGenerator(function* () {
+      const match = yield _this.app.version.satisfies('<0.9.0-alpha.3');
+
+      if (!match) {
+        return;
+      }
+
+      const _arguments$0$context = _arguments[0].context,
+            sequelize = _arguments$0$context.sequelize,
+            queryInterface = _arguments$0$context.queryInterface;
+      const db = _this.app.db;
+      yield sequelize.transaction( /*#__PURE__*/function () {
+        var _ref = _asyncToGenerator(function* (transaction) {
+          yield queryInterface.changeColumn(db.getCollection('workflows').model.getTableName(), 'config', {
+            type: _sequelize().DataTypes.JSON
+          }, {
+            transaction
+          });
+          yield queryInterface.changeColumn(db.getCollection('flow_nodes').model.getTableName(), 'config', {
+            type: _sequelize().DataTypes.JSON
+          }, {
+            transaction
+          });
+          yield queryInterface.changeColumn(db.getCollection('executions').model.getTableName(), 'context', {
+            type: _sequelize().DataTypes.JSON
+          }, {
+            transaction
+          });
+          yield queryInterface.changeColumn(db.getCollection('jobs').model.getTableName(), 'result', {
+            type: _sequelize().DataTypes.JSON
+          }, {
+            transaction
+          });
+        });
+
+        return function (_x) {
+          return _ref.apply(this, arguments);
+        };
+      }());
+    })();
+  }
+
+}
+
+exports.default = _default;

package/lib/server/triggers/schedule.js

@@ -69,8 +69,12 @@ ScheduleModes.set(SCHEDULE_MODE.CONSTANT, {
     }
 
     if (repeat) {
-      if (typeof repeat === 'number' && repeat > this.cacheCycle && (timestamp - startTime) % repeat > this.cacheCycle) {
-        return false;
+      if (typeof repeat === 'number') {
+        const next = timestamp - (timestamp - startTime) % repeat + repeat;
+
+        if (next <= timestamp || next > timestamp + this.cacheCycle) {
+          return false;
+        }
       }
 
       if (endsOn) {
@@ -156,6 +160,10 @@ function getOnTimestampWithOffset(on, now) {
 }
 
 function getDataOptionTime(data, on, dir = 1) {
+  if (!on) {
+    return null;
+  }
+
   switch (typeof on) {
     case 'string':
       const time = parseDateWithoutMs(on);
@@ -551,7 +559,7 @@ class ScheduleTrigger extends _.Trigger {
         const should = yield _this6.shouldCache(workflow, now);
 
         if (should) {
-          console.log('caching schedule workflow:', workflow.id);
+          _this6.plugin.app.logger.info('caching scheduled workflow will run in next minute:', workflow.id);
         }
 
         _this6.setCache(workflow, !should);