@nocobase/plugin-workflow 0.7.0-alpha.80 → 0.7.0-alpha.83

package/lib/server.d.ts

@@ -6,5 +6,5 @@ export default class extends Plugin {
     triggers: Registry<Trigger>;
     getName(): string;
     load(options?: {}): Promise<void>;
-    toggle(workflow: WorkflowModel, enable?: boolean): Promise<void>;
+    toggle(workflow: WorkflowModel, enable?: boolean): void;
 }

package/lib/server.js

@@ -45,6 +45,12 @@ function _utils() {
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+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); }); }; }
@@ -87,8 +93,7 @@ class _default extends _server().Plugin {
         workflows.forEach(workflow => {
           _this.toggle(workflow);
         });
-        db.on('workflows.afterCreate', model => _this.toggle(model));
-        db.on('workflows.afterUpdate', model => _this.toggle(model));
+        db.on('workflows.afterSave', model => _this.toggle(model));
         db.on('workflows.afterDestroy', model => _this.toggle(model, false));
       })); // [Life Cycle]: initialize all necessary seed data
       // this.app.on('db.init', async () => {});
@@ -97,19 +102,21 @@ class _default extends _server().Plugin {
   }
 
   toggle(workflow, enable) {
-    var _this2 = this;
+    const type = workflow.get('type');
+    const trigger = this.triggers.get(type);
 
-    return _asyncToGenerator(function* () {
-      const type = workflow.get('type');
+    if (typeof enable !== 'undefined' ? enable : workflow.get('enabled')) {
+      // NOTE: remove previous listener if config updated
+      const prev = workflow.previous();
 
-      const trigger = _this2.triggers.get(type);
-
-      if (typeof enable !== 'undefined' ? enable : workflow.get('enabled')) {
-        yield trigger.on(workflow);
-      } else {
-        yield trigger.off(workflow);
+      if (prev.config) {
+        trigger.off(_objectSpread(_objectSpread({}, workflow.get()), prev));
       }
-    })();
+
+      trigger.on(workflow);
+    } else {
+      trigger.off(workflow);
+    }
   }
 
 }

package/lib/triggers/collection.js

@@ -19,12 +19,6 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
 
-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; }
-
 const MODE_BITMAP = {
   CREATE: 1,
   UPDATE: 2,
@@ -69,13 +63,6 @@ class CollectionTrigger {
   }
 
   on(workflow) {
-    // NOTE: remove previous listener if config updated
-    const prev = workflow.previous();
-
-    if (prev.config) {
-      this.off(_objectSpread(_objectSpread({}, workflow.get()), prev));
-    }
-
     const _workflow$config = workflow.config,
           collection = _workflow$config.collection,
           mode = _workflow$config.mode;

package/lib/triggers/index.js

@@ -7,9 +7,12 @@ exports.default = _default;
 
 var _collection = _interopRequireDefault(require("./collection"));
 
+var _schedule = _interopRequireDefault(require("./schedule"));
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function _default(plugin) {
   const triggers = plugin.triggers;
-  triggers.register('collection', new _collection.default(plugin)); // triggers.register('schedule', new Schedule(plugin));
+  triggers.register('collection', new _collection.default(plugin));
+  triggers.register('schedule', new _schedule.default(plugin));
 }

package/lib/triggers/schedule.d.ts

@@ -0,0 +1,41 @@
+import { Trigger } from '.';
+export declare type ScheduleOnField = string | {
+    field: string;
+    offset?: number;
+    unit?: 1000 | 60000 | 3600000 | 86400000;
+};
+export interface ScheduleTriggerConfig {
+    mode: number;
+    cron?: string;
+    limit?: number;
+    startsOn?: ScheduleOnField;
+    endsOn?: ScheduleOnField;
+}
+export declare const SCHEDULE_MODE: {
+    readonly CONSTANT: 0;
+    readonly COLLECTION_FIELD: 1;
+};
+export default class ScheduleTrigger implements Trigger {
+    static CacheRules: ((workflow: any, now: any) => any)[];
+    static TriggerRules: ((workflow: any, now: any) => boolean)[];
+    readonly db: any;
+    events: Map<any, any>;
+    private timer;
+    private cache;
+    interval: number;
+    cacheCycle: number;
+    constructor({ app }: {
+        app: any;
+    });
+    init(): void;
+    run: () => void;
+    onTick(now: any): Promise<any>;
+    reload(): Promise<void>;
+    inspect(workflows: any): void;
+    setCache(workflow: any, out?: boolean): void;
+    shouldCache(workflow: any, now: any): Promise<boolean>;
+    shouldTrigger(workflow: any, now: any): boolean;
+    trigger(workflow: any, date: Date): Promise<any>;
+    on(workflow: any): void;
+    off(workflow: any): void;
+}

package/lib/triggers/schedule.js

@@ -0,0 +1,602 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.SCHEDULE_MODE = void 0;
+
+function _cronParser() {
+  const data = _interopRequireDefault(require("cron-parser"));
+
+  _cronParser = function _cronParser() {
+    return data;
+  };
+
+  return data;
+}
+
+function _lodash() {
+  const data = require("lodash");
+
+  _lodash = function _lodash() {
+    return data;
+  };
+
+  return data;
+}
+
+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; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+
+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 _asyncIterator(iterable) { var method, async, sync, retry = 2; for ("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;) { if (async && null != (method = iterable[async])) return method.call(iterable); if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable)); async = "@@asyncIterator", sync = "@@iterator"; } throw new TypeError("Object is not async iterable"); }
+
+function AsyncFromSyncIterator(s) { function AsyncFromSyncIteratorContinuation(r) { if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object.")); var done = r.done; return Promise.resolve(r.value).then(function (value) { return { value: value, done: done }; }); } return AsyncFromSyncIterator = function AsyncFromSyncIterator(s) { this.s = s, this.n = s.next; }, AsyncFromSyncIterator.prototype = { s: null, n: null, next: function next() { return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments)); }, return: function _return(value) { var ret = this.s.return; return void 0 === ret ? Promise.resolve({ value: value, done: !0 }) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments)); }, throw: function _throw(value) { var thr = this.s.return; return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments)); } }, new AsyncFromSyncIterator(s); }
+
+const SCHEDULE_MODE = {
+  CONSTANT: 0,
+  COLLECTION_FIELD: 1
+};
+exports.SCHEDULE_MODE = SCHEDULE_MODE;
+const ScheduleModes = new Map();
+ScheduleModes.set(SCHEDULE_MODE.CONSTANT, {
+  shouldCache(workflow, now) {
+    const _workflow$config = workflow.config,
+          startsOn = _workflow$config.startsOn,
+          endsOn = _workflow$config.endsOn;
+    const timestamp = now.getTime();
+
+    if (startsOn) {
+      const startTime = Date.parse(startsOn);
+
+      if (!startTime || startTime > timestamp + this.cacheCycle) {
+        return false;
+      }
+    }
+
+    if (endsOn) {
+      const endTime = Date.parse(endsOn);
+
+      if (!endTime || endTime <= timestamp) {
+        return false;
+      }
+    }
+
+    return true;
+  },
+
+  trigger(workflow, date) {
+    return workflow.trigger({
+      date
+    });
+  }
+
+});
+
+function getDateRangeFilter(on, now, dir) {
+  const timestamp = now.getTime();
+  const op = dir < 0 ? '$lt' : '$gte';
+
+  switch (typeof on) {
+    case 'string':
+      const time = Date.parse(on);
+
+      if (!time || (dir < 0 ? timestamp < time : time <= timestamp)) {
+        return null;
+      }
+
+      break;
+
+    case 'object':
+      const field = on.field,
+            _on$offset = on.offset,
+            offset = _on$offset === void 0 ? 0 : _on$offset,
+            _on$unit = on.unit,
+            unit = _on$unit === void 0 ? 1000 : _on$unit;
+      return {
+        [field]: {
+          [op]: new Date(timestamp + offset * unit * dir)
+        }
+      };
+
+    default:
+      break;
+  }
+
+  return {};
+}
+
+function getDataOptionTime(data, on, now, dir = 1) {
+  switch (typeof on) {
+    case 'string':
+      const time = Date.parse(on);
+      return time ? time : null;
+
+    case 'object':
+      const field = on.field,
+            _on$offset2 = on.offset,
+            offset = _on$offset2 === void 0 ? 0 : _on$offset2,
+            _on$unit2 = on.unit,
+            unit = _on$unit2 === void 0 ? 1000 : _on$unit2;
+      return data[field] ? data[field].getTime() - offset * unit * dir : null;
+
+    default:
+      return null;
+  }
+}
+
+function getHookId(workflow, type) {
+  return `${type}#${workflow.id}`;
+}
+
+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;
+    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;
+        }
+
+        if (startTime && startTime > timestamp + this.cacheCycle) {
+          return;
+        }
+
+        if (endTime && endTime <= timestamp) {
+          return;
+        }
+
+        if (!cronInCycle.call(this, workflow, now)) {
+          return;
+        }
+
+        console.log('set cache', now);
+        this.setCache(workflow);
+      };
+
+      this.events.set(name, listener);
+      this.db.on(`${collection}.afterSave`, listener);
+    }
+  },
+
+  off(workflow) {
+    const collection = workflow.config.collection;
+    const event = `${collection}.afterSave`;
+    const name = getHookId(workflow, event);
+
+    if (this.events.has(name)) {
+      const listener = this.events.get(name);
+      this.events.delete(name);
+      this.db.off(`${collection}.afterSave`, listener);
+    }
+  },
+
+  shouldCache(workflow, now) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      const _workflow$config3 = workflow.config,
+            startsOn = _workflow$config3.startsOn,
+            endsOn = _workflow$config3.endsOn,
+            collection = _workflow$config3.collection;
+      const starts = getDateRangeFilter(startsOn, now, -1);
+
+      if (!starts) {
+        return false;
+      }
+
+      const ends = getDateRangeFilter(endsOn, now, 1);
+
+      if (!ends) {
+        return false;
+      }
+
+      const filter = (0, _lodash().merge)(starts, ends); // if neither startsOn nor endsOn is provided
+
+      if (!Object.keys(filter).length) {
+        // consider as invalid
+        return false;
+      }
+
+      const repo = _this.db.getCollection(collection).repository;
+
+      const count = yield repo.count({
+        filter
+      });
+      return Boolean(count);
+    })();
+  },
+
+  trigger(workflow, date) {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      var _startsOn$offset, _startsOn$unit, _endsOn$offset, _endsOn$unit;
+
+      const _workflow$config4 = workflow.config,
+            collection = _workflow$config4.collection,
+            startsOn = _workflow$config4.startsOn,
+            endsOn = _workflow$config4.endsOn,
+            cron = _workflow$config4.cron;
+
+      if (typeof startsOn !== 'object') {
+        return;
+      }
+
+      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;
+
+      if (!cron) {
+        // startsOn exactly equal to now in 1s
+        filter = {
+          [startsOn.field]: {
+            $gte: new Date(startTimestamp),
+            $lt: new Date(startTimestamp + 1000)
+          }
+        };
+      } else {
+        // startsOn not after now
+        filter = {
+          [startsOn.field]: {
+            $lt: new Date(startTimestamp)
+          }
+        };
+
+        switch (typeof endsOn) {
+          case 'string':
+            const endTime = Date.parse(endsOn);
+
+            if (!endTime || endTime <= timestamp) {
+              return;
+            }
+
+            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)
+            };
+            break;
+
+          default:
+            break;
+        }
+      }
+
+      const repo = _this2.db.getCollection(collection).repository;
+
+      const instances = yield repo.find({
+        filter
+      });
+      console.log('trigger at', date);
+      instances.forEach(item => {
+        workflow.trigger({
+          date,
+          data: item.get()
+        });
+      });
+    })();
+  }
+
+});
+
+function cronInCycle(workflow, now) {
+  const cron = workflow.config.cron; // no cron 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
+  // so we need to more info to determine if necessary config items
+
+  if (!cron) {
+    return true;
+  }
+
+  const currentDate = new Date(now);
+  currentDate.setMilliseconds(-1);
+  const timestamp = now.getTime();
+
+  const interval = _cronParser().default.parseExpression(cron, {
+    currentDate
+  });
+
+  let next = interval.next(); // NOTE: cache all workflows will be matched in current cycle
+
+  if (next.getTime() - timestamp <= this.cacheCycle) {
+    return true;
+  }
+
+  return false;
+}
+
+class ScheduleTrigger {
+  // running interval, default to 1s
+  // caching workflows in range, default to 1min
+  constructor({
+    app
+  }) {
+    this.db = void 0;
+    this.events = new Map();
+    this.timer = null;
+    this.cache = new Map();
+    this.interval = 1000;
+    this.cacheCycle = 60000;
+
+    this.run = () => {
+      const now = new Date();
+      now.setMilliseconds(0); // NOTE: trigger `onTick` for high interval jobs which are cached in last 1 min
+
+      this.onTick(now); // NOTE: reload when second match cache cycle
+
+      if (!(now.getTime() % this.cacheCycle)) {
+        this.reload();
+      }
+    };
+
+    this.db = app.db;
+    app.on('beforeStop', () => {
+      if (this.timer) {
+        clearInterval(this.timer);
+      }
+    });
+  }
+
+  init() {
+    if (!this.timer) {
+      const now = new Date(); // NOTE: assign to this.timer to avoid duplicated initialization
+
+      this.timer = setTimeout(() => {
+        this.timer = setInterval(this.run, this.interval); // initially trigger
+        // this.onTick(now);
+      }, // NOTE:
+      //  try to align to system time on each second starts,
+      //  after at least 1 second initialized for anything to get ready.
+      //  so jobs in 2 seconds will be missed at first start.
+      1000 - now.getMilliseconds());
+    }
+  }
+
+  onTick(now) {
+    var _this3 = 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)) {
+          return prev;
+        }
+
+        if (isSqlite) {
+          return prev.then(() => _this3.trigger(workflow, now));
+        }
+
+        _this3.trigger(workflow, now);
+
+        return null;
+      }, isSqlite ? Promise.resolve() : null);
+    })();
+  }
+
+  reload() {
+    var _this4 = this;
+
+    return _asyncToGenerator(function* () {
+      const WorkflowModel = _this4.db.getCollection('workflows').model;
+
+      const workflows = yield WorkflowModel.findAll({
+        where: {
+          enabled: true,
+          type: 'schedule'
+        },
+        include: [{
+          association: 'executions',
+          attributes: ['id', 'createdAt'],
+          seperate: true,
+          limit: 1,
+          order: [['createdAt', 'DESC']]
+        }],
+        group: ['id']
+      }); // NOTE: clear cached jobs in last cycle
+
+      _this4.cache = new Map();
+
+      _this4.inspect(workflows);
+    })();
+  }
+
+  inspect(workflows) {
+    var _this5 = this;
+
+    const now = new Date();
+    now.setMilliseconds(0);
+    workflows.forEach( /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator(function* (workflow) {
+        const should = yield _this5.shouldCache(workflow, now);
+
+        _this5.setCache(workflow, !should);
+      });
+
+      return function (_x) {
+        return _ref.apply(this, arguments);
+      };
+    }());
+  }
+
+  setCache(workflow, out = false) {
+    out ? this.cache.delete(workflow.id) : this.cache.set(workflow.id, workflow);
+  }
+
+  shouldCache(workflow, now) {
+    var _this6 = this;
+
+    return _asyncToGenerator(function* () {
+      var _iteratorAbruptCompletion = false;
+      var _didIteratorError = false;
+
+      var _iteratorError;
+
+      try {
+        for (var _iterator = _asyncIterator(_this6.constructor.CacheRules), _step; _iteratorAbruptCompletion = !(_step = yield _iterator.next()).done; _iteratorAbruptCompletion = false) {
+          const rule = _step.value;
+
+          if (!(yield rule.call(_this6, workflow, now))) {
+            return false;
+          }
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (_iteratorAbruptCompletion && _iterator.return != null) {
+            yield _iterator.return();
+          }
+        } finally {
+          if (_didIteratorError) {
+            throw _iteratorError;
+          }
+        }
+      }
+
+      return true;
+    })();
+  }
+
+  shouldTrigger(workflow, now) {
+    var _iterator2 = _createForOfIteratorHelper(this.constructor.TriggerRules),
+        _step2;
+
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        const rule = _step2.value;
+
+        if (!rule.call(this, workflow, now)) {
+          return false;
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+
+    return true;
+  }
+
+  trigger(workflow, date) {
+    var _this7 = this;
+
+    return _asyncToGenerator(function* () {
+      const mode = workflow.config.mode;
+      const modeHandlers = ScheduleModes.get(mode);
+      return modeHandlers.trigger.call(_this7, workflow, date);
+    })();
+  }
+
+  on(workflow) {
+    // NOTE: lazy initialization
+    this.init();
+    const mode = workflow.config.mode;
+    const modeHandlers = ScheduleModes.get(mode);
+
+    if (modeHandlers && modeHandlers.on) {
+      modeHandlers.on.call(this, workflow);
+    }
+
+    this.inspect([workflow]);
+  }
+
+  off(workflow) {
+    const mode = workflow.config.mode;
+    const modeHandlers = ScheduleModes.get(mode);
+
+    if (modeHandlers && modeHandlers.off) {
+      modeHandlers.off.call(this, workflow);
+    }
+
+    this.cache.delete(workflow.id);
+  }
+
+}
+
+exports.default = ScheduleTrigger;
+ScheduleTrigger.CacheRules = [// ({ enabled }) => enabled,
+({
+  config,
+  executed
+}) => config.limit ? executed < config.limit : true, ({
+  config
+}) => ['cron', 'startsOn'].some(key => config[key]), cronInCycle, 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, ({
+  config
+}) => ['cron', 'startsOn'].some(key => config[key]), function (workflow, now) {
+  const cron = workflow.config.cron;
+
+  if (!cron) {
+    return true;
+  }
+
+  const currentDate = new Date(now);
+  currentDate.setMilliseconds(-1);
+  const timestamp = now.getTime();
+
+  const interval = _cronParser().default.parseExpression(cron, {
+    currentDate
+  });
+
+  let next = interval.next();
+
+  if (next.getTime() === timestamp) {
+    return true;
+  }
+
+  return false;
+}];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/plugin-workflow",
-  "version": "0.7.0-alpha.80",
+  "version": "0.7.0-alpha.83",
   "main": "lib/index.js",
   "license": "Apache-2.0",
   "licenses": [
@@ -10,14 +10,16 @@
     }
   ],
   "dependencies": {
-    "@nocobase/actions": "0.7.0-alpha.80",
-    "@nocobase/database": "0.7.0-alpha.80",
-    "@nocobase/server": "0.7.0-alpha.80",
-    "@nocobase/utils": "0.7.0-alpha.80",
-    "json-templates": "^4.2.0"
+    "@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",
+    "cron-parser": "4.4.0",
+    "json-templates": "^4.2.0",
+    "lodash": "^4.17.21"
   },
   "devDependencies": {
-    "@nocobase/test": "0.7.0-alpha.80"
+    "@nocobase/test": "0.7.0-alpha.83"
   },
-  "gitHead": "9ec196c514d958d2c32c0879def6b98f24bf92fc"
+  "gitHead": "838f4f18dcd9ed4fe2ae2660a4918e2a5bd3a869"
 }