@nocobase/plugin-workflow 0.7.0-alpha.83 → 0.7.1-alpha.5

package/lib/triggers/schedule.js

@@ -15,16 +15,18 @@ function _cronParser() {
   return data;
 }
 
-function _lodash() {
-  const data = require("lodash");
+function _sequelize() {
+  const data = require("sequelize");
 
-  _lodash = function _lodash() {
+  _sequelize = function _sequelize() {
     return data;
   };
 
   return data;
 }
 
+var _ = require("..");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
@@ -51,7 +53,8 @@ ScheduleModes.set(SCHEDULE_MODE.CONSTANT, {
   shouldCache(workflow, now) {
     const _workflow$config = workflow.config,
           startsOn = _workflow$config.startsOn,
-          endsOn = _workflow$config.endsOn;
+          endsOn = _workflow$config.endsOn,
+          repeat = _workflow$config.repeat;
     const timestamp = now.getTime();
 
     if (startsOn) {
@@ -60,6 +63,10 @@ ScheduleModes.set(SCHEDULE_MODE.CONSTANT, {
       if (!startTime || startTime > timestamp + this.cacheCycle) {
         return false;
       }
+
+      if (typeof repeat === 'number' && repeat > this.cacheCycle && (timestamp - startTime) % repeat > this.cacheCycle) {
+        return false;
+      }
     }
 
     if (endsOn) {
@@ -74,7 +81,20 @@ ScheduleModes.set(SCHEDULE_MODE.CONSTANT, {
   },
 
   trigger(workflow, date) {
-    return workflow.trigger({
+    const _workflow$config2 = workflow.config,
+          startsOn = _workflow$config2.startsOn,
+          endsOn = _workflow$config2.endsOn,
+          repeat = _workflow$config2.repeat;
+
+    if (startsOn && typeof repeat === 'number') {
+      const startTime = Date.parse(startsOn);
+
+      if ((startTime - date.getTime()) % repeat) {
+        return;
+      }
+    }
+
+    return this.plugin.trigger(workflow, {
       date
     });
   }
@@ -83,7 +103,7 @@ ScheduleModes.set(SCHEDULE_MODE.CONSTANT, {
 
 function getDateRangeFilter(on, now, dir) {
   const timestamp = now.getTime();
-  const op = dir < 0 ? '$lt' : '$gte';
+  const op = dir < 0 ? _sequelize().Op.lt : _sequelize().Op.gte;
 
   switch (typeof on) {
     case 'string':
@@ -101,6 +121,11 @@ function getDateRangeFilter(on, now, dir) {
             offset = _on$offset === void 0 ? 0 : _on$offset,
             _on$unit = on.unit,
             unit = _on$unit === void 0 ? 1000 : _on$unit;
+
+      if (!field) {
+        return {};
+      }
+
       return {
         [field]: {
           [op]: new Date(timestamp + offset * unit * dir)
@@ -114,7 +139,7 @@ function getDateRangeFilter(on, now, dir) {
   return {};
 }
 
-function getDataOptionTime(data, on, now, dir = 1) {
+function getDataOptionTime(data, on, dir = 1) {
   switch (typeof on) {
     case 'string':
       const time = Date.parse(on);
@@ -137,66 +162,75 @@ function getHookId(workflow, type) {
   return `${type}#${workflow.id}`;
 }
 
+const DialectTimestampFnMap = {
+  postgres(col) {
+    return `CAST(FLOOR(extract(epoch from "${col}")) AS INTEGER)`;
+  },
+
+  mysql(col) {
+    return `CAST(FLOOR(UNIX_TIMESTAMP(\`${col}\`)) AS SIGNED INTEGER)`;
+  },
+
+  sqlite(col) {
+    return `CAST(FLOOR(unixepoch(${col})) AS INTEGER)`;
+  }
+
+};
+DialectTimestampFnMap.mariadb = DialectTimestampFnMap.mysql;
 ScheduleModes.set(SCHEDULE_MODE.COLLECTION_FIELD, {
   on(workflow) {
-    const _workflow$config2 = workflow.config,
-          collection = _workflow$config2.collection,
-          startsOn = _workflow$config2.startsOn,
-          endsOn = _workflow$config2.endsOn,
-          cron = _workflow$config2.cron;
+    var _this = this;
+
+    const _workflow$config3 = workflow.config,
+          collection = _workflow$config3.collection,
+          startsOn = _workflow$config3.startsOn,
+          endsOn = _workflow$config3.endsOn,
+          repeat = _workflow$config3.repeat;
     const event = `${collection}.afterSave`;
     const name = getHookId(workflow, event);
 
     if (!this.events.has(name)) {
       // NOTE: toggle cache depends on new date
-      const listener = (data, options) => {
-        // check if saved collection data in cache cycle
-        //   in: add workflow to cache
-        //   out: 1. do nothing because if any other data in
-        //        2. another way is always check all data to match cycle
-        //           by calling: inspect(workflow)
-        //           this may lead to performance issues
-        //        so we can only check single row and only set in if true
-        // how to check?
-        // * startsOn only      : startsOn in cycle
-        // * endsOn only        : invalid
-        // * cron only          : invalid
-        // * startsOn and endsOn: equal to only startsOn
-        // * startsOn and cron  : startsOn in cycle and cron in cycle
-        // * endsOn and cron    : invalid
-        // * all                : all rules effect
-        // * none               : invalid
-        // this means, startsOn and cron should be present at least one
-        // and no startsOn equals run on cron, and could ends on endsOn,
-        // this will be a little wired, only means the end date should use collection field.
-        const now = new Date();
-        now.setMilliseconds(0);
-        const timestamp = now.getTime();
-        const startTime = getDataOptionTime(data, startsOn, now);
-        const endTime = getDataOptionTime(data, endsOn, now, -1);
-
-        if (!startTime && !cron) {
-          return;
-        }
+      const listener = /*#__PURE__*/function () {
+        var _ref = _asyncToGenerator(function* (data, options) {
+          const now = new Date();
+          now.setMilliseconds(0);
+          const timestamp = now.getTime();
+          const startTime = getDataOptionTime(data, startsOn);
+          const endTime = getDataOptionTime(data, endsOn, -1);
+
+          if (!startTime && !repeat) {
+            return;
+          }
 
-        if (startTime && startTime > timestamp + this.cacheCycle) {
-          return;
-        }
+          if (startTime && startTime > timestamp + _this.cacheCycle) {
+            return;
+          }
 
-        if (endTime && endTime <= timestamp) {
-          return;
-        }
+          if (endTime && endTime <= timestamp) {
+            return;
+          }
 
-        if (!cronInCycle.call(this, workflow, now)) {
-          return;
-        }
+          if (!nextInCycle.call(_this, workflow, now)) {
+            return;
+          }
 
-        console.log('set cache', now);
-        this.setCache(workflow);
-      };
+          if (typeof repeat === 'number' && repeat > _this.cacheCycle && (timestamp - startTime) % repeat > _this.cacheCycle) {
+            return;
+          }
+
+          console.log('set cache', now);
+
+          _this.setCache(workflow);
+        });
+
+        return function listener(_x, _x2) {
+          return _ref.apply(this, arguments);
+        };
+      }();
 
       this.events.set(name, listener);
-      this.db.on(`${collection}.afterSave`, listener);
+      this.plugin.app.db.on(`${collection}.afterSave`, listener);
     }
   },
 
@@ -208,21 +242,22 @@ ScheduleModes.set(SCHEDULE_MODE.COLLECTION_FIELD, {
     if (this.events.has(name)) {
       const listener = this.events.get(name);
       this.events.delete(name);
-      this.db.off(`${collection}.afterSave`, listener);
+      this.plugin.app.db.off(`${collection}.afterSave`, listener);
     }
   },
 
   shouldCache(workflow, now) {
-    var _this = this;
+    var _this2 = this;
 
     return _asyncToGenerator(function* () {
-      const _workflow$config3 = workflow.config,
-            startsOn = _workflow$config3.startsOn,
-            endsOn = _workflow$config3.endsOn,
-            collection = _workflow$config3.collection;
+      const _workflow$config4 = workflow.config,
+            startsOn = _workflow$config4.startsOn,
+            endsOn = _workflow$config4.endsOn,
+            repeat = _workflow$config4.repeat,
+            collection = _workflow$config4.collection;
       const starts = getDateRangeFilter(startsOn, now, -1);
 
-      if (!starts) {
+      if (!starts || !Object.keys(starts).length) {
         return false;
       }
 
@@ -232,33 +267,42 @@ ScheduleModes.set(SCHEDULE_MODE.COLLECTION_FIELD, {
         return false;
       }
 
-      const filter = (0, _lodash().merge)(starts, ends); // if neither startsOn nor endsOn is provided
+      const conditions = [starts, ends].filter(item => Boolean(Object.keys(item).length)); // when repeat is number, means repeat after startsOn
+      // (now - startsOn) % repeat <= cacheCycle
 
-      if (!Object.keys(filter).length) {
-        // consider as invalid
-        return false;
+      const db = _this2.plugin.app.db;
+      const tsFn = DialectTimestampFnMap[db.options.dialect];
+
+      if (repeat && typeof repeat === 'number' && repeat > _this2.cacheCycle && tsFn) {
+        const uts = now.getTime();
+        conditions.push((0, _sequelize().where)((0, _sequelize().fn)('MOD', (0, _sequelize().literal)(`${Math.round(uts / 1000)} - ${tsFn(startsOn.field)}`), Math.round(repeat / 1000)), {
+          [_sequelize().Op.lt]: Math.round(_this2.cacheCycle / 1000)
+        })); // conditions.push(literal(`mod(${uts} - ${tsFn(startsOn.field)} * 1000, ${repeat}) < ${this.cacheCycle}`));
       }
 
-      const repo = _this.db.getCollection(collection).repository;
+      const _db$getCollection = db.getCollection(collection),
+            model = _db$getCollection.model;
 
-      const count = yield repo.count({
-        filter
+      const count = yield model.count({
+        where: {
+          [_sequelize().Op.and]: conditions
+        }
       });
       return Boolean(count);
     })();
   },
 
   trigger(workflow, date) {
-    var _this2 = this;
+    var _this3 = this;
 
     return _asyncToGenerator(function* () {
-      var _startsOn$offset, _startsOn$unit, _endsOn$offset, _endsOn$unit;
+      var _startsOn$offset, _startsOn$unit;
 
-      const _workflow$config4 = workflow.config,
-            collection = _workflow$config4.collection,
-            startsOn = _workflow$config4.startsOn,
-            endsOn = _workflow$config4.endsOn,
-            cron = _workflow$config4.cron;
+      const _workflow$config5 = workflow.config,
+            collection = _workflow$config5.collection,
+            startsOn = _workflow$config5.startsOn,
+            endsOn = _workflow$config5.endsOn,
+            repeat = _workflow$config5.repeat;
 
       if (typeof startsOn !== 'object') {
         return;
@@ -266,23 +310,30 @@ ScheduleModes.set(SCHEDULE_MODE.COLLECTION_FIELD, {
 
       const timestamp = date.getTime();
       const startTimestamp = timestamp - ((_startsOn$offset = startsOn.offset) !== null && _startsOn$offset !== void 0 ? _startsOn$offset : 0) * ((_startsOn$unit = startsOn.unit) !== null && _startsOn$unit !== void 0 ? _startsOn$unit : 1000);
-      let filter;
+      const conditions = [];
 
-      if (!cron) {
+      if (!repeat) {
         // startsOn exactly equal to now in 1s
-        filter = {
+        conditions.push({
           [startsOn.field]: {
-            $gte: new Date(startTimestamp),
-            $lt: new Date(startTimestamp + 1000)
+            [_sequelize().Op.gte]: new Date(startTimestamp),
+            [_sequelize().Op.lt]: new Date(startTimestamp + 1000)
           }
-        };
+        });
       } else {
         // startsOn not after now
-        filter = {
+        conditions.push({
           [startsOn.field]: {
-            $lt: new Date(startTimestamp)
+            [_sequelize().Op.lt]: new Date(startTimestamp)
           }
-        };
+        });
+        const tsFn = DialectTimestampFnMap[_this3.plugin.app.db.options.dialect];
+
+        if (typeof repeat === 'number' && tsFn) {
+          conditions.push((0, _sequelize().where)((0, _sequelize().fn)('MOD', (0, _sequelize().literal)(`${Math.round(timestamp / 1000)} - ${tsFn(startsOn.field)}`), Math.round(repeat / 1000)), {
+            [_sequelize().Op.eq]: 0
+          })); // conditions.push(literal(`MOD(CAST(${timestamp} AS BIGINT) - CAST((FLOOR(${tsFn(startsOn.field)}) AS BIGINT) * 1000), ${repeat}) = 0`));
+        }
 
         switch (typeof endsOn) {
           case 'string':
@@ -295,9 +346,16 @@ ScheduleModes.set(SCHEDULE_MODE.COLLECTION_FIELD, {
             break;
 
           case 'object':
-            filter[endsOn.field] = {
-              $gte: new Date(timestamp - ((_endsOn$offset = endsOn.offset) !== null && _endsOn$offset !== void 0 ? _endsOn$offset : 0) * ((_endsOn$unit = endsOn.unit) !== null && _endsOn$unit !== void 0 ? _endsOn$unit : 1000) + 1000)
-            };
+            if (endsOn.field) {
+              var _endsOn$offset, _endsOn$unit;
+
+              conditions.push({
+                [endsOn.field]: {
+                  [_sequelize().Op.gte]: new Date(timestamp - ((_endsOn$offset = endsOn.offset) !== null && _endsOn$offset !== void 0 ? _endsOn$offset : 0) * ((_endsOn$unit = endsOn.unit) !== null && _endsOn$unit !== void 0 ? _endsOn$unit : 1000) + 1000)
+                }
+              });
+            }
+
             break;
 
           default:
@@ -305,14 +363,21 @@ ScheduleModes.set(SCHEDULE_MODE.COLLECTION_FIELD, {
         }
       }
 
-      const repo = _this2.db.getCollection(collection).repository;
+      const _this3$plugin$app$db$ = _this3.plugin.app.db.getCollection(collection),
+            model = _this3$plugin$app$db$.model;
 
-      const instances = yield repo.find({
-        filter
+      const instances = yield model.findAll({
+        where: {
+          [_sequelize().Op.and]: conditions
+        }
       });
-      console.log('trigger at', date);
+
+      if (instances.length) {
+        console.log(instances.length, 'rows trigger at', date);
+      }
+
       instances.forEach(item => {
-        workflow.trigger({
+        _this3.plugin.trigger(workflow, {
           date,
           data: item.get()
         });
@@ -322,21 +387,29 @@ ScheduleModes.set(SCHEDULE_MODE.COLLECTION_FIELD, {
 
 });
 
-function cronInCycle(workflow, now) {
-  const cron = workflow.config.cron; // no cron means no need to rerun
+function nextInCycle(workflow, now) {
+  const repeat = workflow.config.repeat; // no repeat means no need to rerun
   // but if in current cycle, should be put in cache
-  // no cron but in current cycle means startsOn or endsOn has been configured
+  // no repeat but in current cycle means startsOn has been configured
   // so we need to more info to determine if necessary config items
 
-  if (!cron) {
+  if (!repeat) {
     return true;
   }
 
+  switch (typeof repeat) {
+    case 'string':
+      break;
+
+    default:
+      return true;
+  }
+
   const currentDate = new Date(now);
   currentDate.setMilliseconds(-1);
   const timestamp = now.getTime();
 
-  const interval = _cronParser().default.parseExpression(cron, {
+  const interval = _cronParser().default.parseExpression(repeat, {
     currentDate
   });
 
@@ -349,13 +422,11 @@ function cronInCycle(workflow, now) {
   return false;
 }
 
-class ScheduleTrigger {
+class ScheduleTrigger extends _.Trigger {
   // running interval, default to 1s
   // caching workflows in range, default to 1min
-  constructor({
-    app
-  }) {
-    this.db = void 0;
+  constructor(plugin) {
+    super(plugin);
     this.events = new Map();
     this.timer = null;
     this.cache = new Map();
@@ -373,8 +444,7 @@ class ScheduleTrigger {
       }
     };
 
-    this.db = app.db;
-    app.on('beforeStop', () => {
+    plugin.app.on('beforeStop', () => {
       if (this.timer) {
         clearInterval(this.timer);
       }
@@ -397,21 +467,21 @@ class ScheduleTrigger {
   }
 
   onTick(now) {
-    var _this3 = this;
+    var _this4 = this;
 
     return _asyncToGenerator(function* () {
       // NOTE: trigger workflows in sequence when sqlite due to only one transaction
-      const isSqlite = _this3.db.options.dialect === 'sqlite';
-      return Array.from(_this3.cache.values()).reduce((prev, workflow) => {
-        if (!_this3.shouldTrigger(workflow, now)) {
+      const isSqlite = _this4.plugin.app.db.options.dialect === 'sqlite';
+      return Array.from(_this4.cache.values()).reduce((prev, workflow) => {
+        if (!_this4.shouldTrigger(workflow, now)) {
           return prev;
         }
 
         if (isSqlite) {
-          return prev.then(() => _this3.trigger(workflow, now));
+          return prev.then(() => _this4.trigger(workflow, now));
         }
 
-        _this3.trigger(workflow, now);
+        _this4.trigger(workflow, now);
 
         return null;
       }, isSqlite ? Promise.resolve() : null);
@@ -419,10 +489,10 @@ class ScheduleTrigger {
   }
 
   reload() {
-    var _this4 = this;
+    var _this5 = this;
 
     return _asyncToGenerator(function* () {
-      const WorkflowModel = _this4.db.getCollection('workflows').model;
+      const WorkflowModel = _this5.plugin.app.db.getCollection('workflows').model;
 
       const workflows = yield WorkflowModel.findAll({
         where: {
@@ -432,33 +502,33 @@ class ScheduleTrigger {
         include: [{
           association: 'executions',
           attributes: ['id', 'createdAt'],
-          seperate: true,
+          separate: true,
           limit: 1,
           order: [['createdAt', 'DESC']]
         }],
         group: ['id']
       }); // NOTE: clear cached jobs in last cycle
 
-      _this4.cache = new Map();
+      _this5.cache = new Map();
 
-      _this4.inspect(workflows);
+      _this5.inspect(workflows);
     })();
   }
 
   inspect(workflows) {
-    var _this5 = this;
+    var _this6 = this;
 
     const now = new Date();
     now.setMilliseconds(0);
     workflows.forEach( /*#__PURE__*/function () {
-      var _ref = _asyncToGenerator(function* (workflow) {
-        const should = yield _this5.shouldCache(workflow, now);
+      var _ref2 = _asyncToGenerator(function* (workflow) {
+        const should = yield _this6.shouldCache(workflow, now);
 
-        _this5.setCache(workflow, !should);
+        _this6.setCache(workflow, !should);
       });
 
-      return function (_x) {
-        return _ref.apply(this, arguments);
+      return function (_x3) {
+        return _ref2.apply(this, arguments);
       };
     }());
   }
@@ -468,7 +538,7 @@ class ScheduleTrigger {
   }
 
   shouldCache(workflow, now) {
-    var _this6 = this;
+    var _this7 = this;
 
     return _asyncToGenerator(function* () {
       var _iteratorAbruptCompletion = false;
@@ -477,10 +547,10 @@ class ScheduleTrigger {
       var _iteratorError;
 
       try {
-        for (var _iterator = _asyncIterator(_this6.constructor.CacheRules), _step; _iteratorAbruptCompletion = !(_step = yield _iterator.next()).done; _iteratorAbruptCompletion = false) {
+        for (var _iterator = _asyncIterator(_this7.constructor.CacheRules), _step; _iteratorAbruptCompletion = !(_step = yield _iterator.next()).done; _iteratorAbruptCompletion = false) {
           const rule = _step.value;
 
-          if (!(yield rule.call(_this6, workflow, now))) {
+          if (!(yield rule.call(_this7, workflow, now))) {
             return false;
           }
         }
@@ -525,12 +595,12 @@ class ScheduleTrigger {
   }
 
   trigger(workflow, date) {
-    var _this7 = this;
+    var _this8 = this;
 
     return _asyncToGenerator(function* () {
       const mode = workflow.config.mode;
       const modeHandlers = ScheduleModes.get(mode);
-      return modeHandlers.trigger.call(_this7, workflow, date);
+      return modeHandlers.trigger.call(_this8, workflow, date);
     })();
   }
 
@@ -564,23 +634,23 @@ exports.default = ScheduleTrigger;
 ScheduleTrigger.CacheRules = [// ({ enabled }) => enabled,
 ({
   config,
-  executed
-}) => config.limit ? executed < config.limit : true, ({
+  allExecuted
+}) => config.limit ? allExecuted < config.limit : true, ({
   config
-}) => ['cron', 'startsOn'].some(key => config[key]), cronInCycle, function (workflow, now) {
+}) => ['repeat', 'startsOn'].some(key => config[key]), nextInCycle, function (workflow, now) {
   const mode = workflow.config.mode;
   const modeHandlers = ScheduleModes.get(mode);
   return modeHandlers.shouldCache.call(this, workflow, now);
 }];
 ScheduleTrigger.TriggerRules = [({
   config,
-  executed
-}) => config.limit ? executed < config.limit : true, ({
+  allExecuted
+}) => config.limit ? allExecuted < config.limit : true, ({
   config
-}) => ['cron', 'startsOn'].some(key => config[key]), function (workflow, now) {
-  const cron = workflow.config.cron;
+}) => ['repeat', 'startsOn'].some(key => config[key]), function (workflow, now) {
+  const repeat = workflow.config.repeat;
 
-  if (!cron) {
+  if (typeof repeat !== 'string') {
     return true;
   }
 
@@ -588,7 +658,7 @@ ScheduleTrigger.TriggerRules = [({
   currentDate.setMilliseconds(-1);
   const timestamp = now.getTime();
 
-  const interval = _cronParser().default.parseExpression(cron, {
+  const interval = _cronParser().default.parseExpression(repeat, {
     currentDate
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/plugin-workflow",
-  "version": "0.7.0-alpha.83",
+  "version": "0.7.1-alpha.5",
   "main": "lib/index.js",
   "license": "Apache-2.0",
   "licenses": [
@@ -10,16 +10,15 @@
     }
   ],
   "dependencies": {
-    "@nocobase/actions": "0.7.0-alpha.83",
-    "@nocobase/database": "0.7.0-alpha.83",
-    "@nocobase/server": "0.7.0-alpha.83",
-    "@nocobase/utils": "0.7.0-alpha.83",
+    "@nocobase/actions": "0.7.1-alpha.5",
+    "@nocobase/database": "0.7.1-alpha.5",
+    "@nocobase/server": "0.7.1-alpha.5",
+    "@nocobase/utils": "0.7.1-alpha.5",
     "cron-parser": "4.4.0",
-    "json-templates": "^4.2.0",
-    "lodash": "^4.17.21"
+    "json-templates": "^4.2.0"
   },
   "devDependencies": {
-    "@nocobase/test": "0.7.0-alpha.83"
+    "@nocobase/test": "0.7.1-alpha.5"
   },
-  "gitHead": "838f4f18dcd9ed4fe2ae2660a4918e2a5bd3a869"
+  "gitHead": "c9159c6cf4b7deb80e87122d4b7967a510b8ae7c"
 }

package/lib/server.d.ts

@@ -1,10 +0,0 @@
-import { Plugin } from '@nocobase/server';
-import WorkflowModel from './models/Workflow';
-import { Trigger } from './triggers';
-import { Registry } from '@nocobase/utils';
-export default class extends Plugin {
-    triggers: Registry<Trigger>;
-    getName(): string;
-    load(options?: {}): Promise<void>;
-    toggle(workflow: WorkflowModel, enable?: boolean): void;
-}