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

package/lib/server/triggers/schedule.js

@@ -4,82 +4,59 @@ 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 _sequelize() {
   const data = require("sequelize");
-
   _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; } } }; }
-
 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();
-
 function parseDateWithoutMs(date) {
   return Math.floor(Date.parse(date) / 1000) * 1000;
 }
-
 ScheduleModes.set(SCHEDULE_MODE.CONSTANT, {
   shouldCache(workflow, now) {
     const _workflow$config = workflow.config,
-          startsOn = _workflow$config.startsOn,
-          endsOn = _workflow$config.endsOn,
-          repeat = _workflow$config.repeat;
-    const timestamp = now.getTime(); // NOTE: align to second start
-
+      startsOn = _workflow$config.startsOn,
+      endsOn = _workflow$config.endsOn,
+      repeat = _workflow$config.repeat;
+    const timestamp = now.getTime();
+    // NOTE: align to second start
     const startTime = parseDateWithoutMs(startsOn);
-
     if (!startTime || startTime > timestamp + this.cacheCycle) {
       return false;
     }
-
     if (repeat) {
       if (typeof repeat === 'number') {
         const next = timestamp - (timestamp - startTime) % repeat + repeat;
-
         if (next <= timestamp || next > timestamp + this.cacheCycle) {
           return false;
         }
       }
-
       if (endsOn) {
         const endTime = parseDateWithoutMs(endsOn);
-
         if (!endTime || endTime <= timestamp) {
           return false;
         }
@@ -89,33 +66,27 @@ ScheduleModes.set(SCHEDULE_MODE.CONSTANT, {
         return false;
       }
     }
-
     return true;
   },
-
   trigger(workflow, now) {
     const _workflow$config2 = workflow.config,
-          startsOn = _workflow$config2.startsOn,
-          endsOn = _workflow$config2.endsOn,
-          repeat = _workflow$config2.repeat;
-    const timestamp = now.getTime(); // NOTE: align to second start
-
+      startsOn = _workflow$config2.startsOn,
+      endsOn = _workflow$config2.endsOn,
+      repeat = _workflow$config2.repeat;
+    const timestamp = now.getTime();
+    // NOTE: align to second start
     const startTime = parseDateWithoutMs(startsOn);
-
     if (!startTime || startTime > timestamp) {
       return;
     }
-
     if (repeat) {
       if (typeof repeat === 'number') {
         if (Math.round(timestamp - startTime) % repeat) {
           return;
         }
       }
-
       if (endsOn) {
         const endTime = parseDateWithoutMs(endsOn);
-
         if (!endTime || endTime < timestamp) {
           return;
         }
@@ -125,99 +96,80 @@ ScheduleModes.set(SCHEDULE_MODE.CONSTANT, {
         return;
       }
     }
-
     return this.plugin.trigger(workflow, {
       date: now
     });
   }
-
 });
-
 function getOnTimestampWithOffset(on, now) {
   switch (typeof on) {
     case 'string':
       return parseDateWithoutMs(on);
-
     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;
-
+        _on$offset = on.offset,
+        offset = _on$offset === void 0 ? 0 : _on$offset,
+        _on$unit = on.unit,
+        unit = _on$unit === void 0 ? 1000 : _on$unit;
       if (!field) {
         return null;
       }
-
-      const timestamp = now.getTime(); // onDate + offset > now
+      const timestamp = now.getTime();
+      // onDate + offset > now
       // onDate > now - offset
-
       return timestamp - offset * unit;
-
     default:
       return null;
   }
 }
-
 function getDataOptionTime(data, on, dir = 1) {
   if (!on) {
     return null;
   }
-
   switch (typeof on) {
     case 'string':
       const time = parseDateWithoutMs(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;
+        _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.get(field) ? data.get(field).getTime() - offset * unit * dir : null;
-
     default:
       return null;
   }
 }
-
 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) {
     var _this = this;
-
     const _workflow$config3 = workflow.config,
-          collection = _workflow$config3.collection,
-          startsOn = _workflow$config3.startsOn,
-          endsOn = _workflow$config3.endsOn,
-          repeat = _workflow$config3.repeat;
+      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)) {
       return;
-    } // NOTE: toggle cache depends on new date
-
-
+    }
+    // NOTE: toggle cache depends on new date
     const listener = /*#__PURE__*/function () {
       var _ref = _asyncToGenerator(function* (data, options) {
         const now = new Date();
@@ -225,91 +177,75 @@ ScheduleModes.set(SCHEDULE_MODE.COLLECTION_FIELD, {
         const timestamp = now.getTime();
         const startTime = getDataOptionTime(data, startsOn);
         const endTime = getDataOptionTime(data, endsOn, -1);
-
         if (!startTime) {
           return;
         }
-
         if (startTime && startTime > timestamp + _this.cacheCycle) {
           return;
         }
-
         if (endTime && endTime <= timestamp) {
           return;
         }
-
         if (!matchNext.call(_this, workflow, now)) {
           return;
         }
-
         if (typeof repeat === 'number' && repeat > _this.cacheCycle && (timestamp - startTime) % repeat > _this.cacheCycle) {
           return;
         }
-
         _this.setCache(workflow);
       });
-
       return function listener(_x, _x2) {
         return _ref.apply(this, arguments);
       };
     }();
-
     this.events.set(name, listener);
     this.plugin.app.db.on(event, 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.plugin.app.db.off(event, listener);
     }
   },
-
   shouldCache(workflow, now) {
     var _this2 = this;
-
     return _asyncToGenerator(function* () {
       const db = _this2.plugin.app.db;
       const _workflow$config4 = workflow.config,
-            startsOn = _workflow$config4.startsOn,
-            endsOn = _workflow$config4.endsOn,
-            repeat = _workflow$config4.repeat,
-            collection = _workflow$config4.collection;
+        startsOn = _workflow$config4.startsOn,
+        endsOn = _workflow$config4.endsOn,
+        repeat = _workflow$config4.repeat,
+        collection = _workflow$config4.collection;
       const timestamp = now.getTime();
       const startTimestamp = getOnTimestampWithOffset(startsOn, now);
-
       if (!startTimestamp) {
         return false;
       }
-
       const conditions = [{
         [startsOn.field]: {
           [_sequelize().Op.lt]: new Date(startTimestamp + _this2.cacheCycle)
         }
-      }]; // when repeat is number, means repeat after startsOn
+      }];
+      // when repeat is number, means repeat after startsOn
       // (now - startsOn) % repeat <= cacheCycle
-
       if (repeat) {
         const tsFn = DialectTimestampFnMap[db.options.dialect];
-
         if (typeof repeat === 'number' && repeat > _this2.cacheCycle && 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.lt]: Math.round(_this2.cacheCycle / 1000)
-          })); // conditions.push(literal(`mod(${timestamp} - ${tsFn(startsOn.field)} * 1000, ${repeat}) < ${this.cacheCycle}`));
+          }));
+          // conditions.push(literal(`mod(${timestamp} - ${tsFn(startsOn.field)} * 1000, ${repeat}) < ${this.cacheCycle}`));
         }
 
         if (endsOn) {
           const endTimestamp = getOnTimestampWithOffset(endsOn, now);
-
           if (!endTimestamp) {
             return false;
           }
-
           if (typeof endsOn === 'string') {
             if (endTimestamp <= timestamp) {
               return false;
@@ -329,10 +265,8 @@ ScheduleModes.set(SCHEDULE_MODE.COLLECTION_FIELD, {
           }
         });
       }
-
       const _db$getCollection = db.getCollection(collection),
-            model = _db$getCollection.model;
-
+        model = _db$getCollection.model;
       const count = yield model.count({
         where: {
           [_sequelize().Op.and]: conditions
@@ -341,29 +275,25 @@ ScheduleModes.set(SCHEDULE_MODE.COLLECTION_FIELD, {
       return Boolean(count);
     })();
   },
-
   trigger(workflow, now) {
     var _this3 = this;
-
     return _asyncToGenerator(function* () {
       const _workflow$config5 = workflow.config,
-            startsOn = _workflow$config5.startsOn,
-            repeat = _workflow$config5.repeat,
-            endsOn = _workflow$config5.endsOn,
-            collection = _workflow$config5.collection;
+        startsOn = _workflow$config5.startsOn,
+        repeat = _workflow$config5.repeat,
+        endsOn = _workflow$config5.endsOn,
+        collection = _workflow$config5.collection,
+        appends = _workflow$config5.appends;
       const timestamp = now.getTime();
       const startTimestamp = getOnTimestampWithOffset(startsOn, now);
-
       if (!startTimestamp) {
         return false;
       }
-
       const conditions = [{
         [startsOn.field]: {
           [_sequelize().Op.lt]: new Date(startTimestamp + _this3.interval)
         }
       }];
-
       if (repeat) {
         // startsOn not after now
         conditions.push({
@@ -372,20 +302,18 @@ ScheduleModes.set(SCHEDULE_MODE.COLLECTION_FIELD, {
           }
         });
         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`));
+          }));
+          // conditions.push(literal(`MOD(CAST(${timestamp} AS BIGINT) - CAST((FLOOR(${tsFn(startsOn.field)}) AS BIGINT) * 1000), ${repeat}) = 0`));
         }
 
         if (endsOn) {
           const endTimestamp = getOnTimestampWithOffset(endsOn, now);
-
           if (!endTimestamp) {
             return false;
           }
-
           if (typeof endsOn === 'string') {
             if (endTimestamp <= timestamp) {
               return false;
@@ -406,103 +334,88 @@ ScheduleModes.set(SCHEDULE_MODE.COLLECTION_FIELD, {
           }
         });
       }
-
-      const _this3$plugin$app$db$ = _this3.plugin.app.db.getCollection(collection),
-            model = _this3$plugin$app$db$.model;
-
-      const instances = yield model.findAll({
-        where: {
-          [_sequelize().Op.and]: conditions
-        }
+      const repo = _this3.plugin.app.db.getRepository(collection);
+      const instances = yield repo.find({
+        filter: {
+          $and: conditions
+        },
+        appends
       });
       instances.forEach(item => {
         _this3.plugin.trigger(workflow, {
           date: now,
-          data: item.get()
+          data: item.toJSON()
         });
       });
     })();
   }
-
 });
-
 function matchNext(workflow, now, range = this.cacheCycle) {
-  const repeat = workflow.config.repeat; // no repeat means no need to rerun
+  const repeat = workflow.config.repeat;
+  // no repeat means no need to rerun
   // but if in current cycle, should be put in cache
   // no repeat but in current cycle means startsOn has been configured
   // so we need to more info to determine if necessary config items
-
   if (typeof repeat !== 'string') {
     return true;
   }
-
   const currentDate = new Date(now);
   currentDate.setMilliseconds(-1);
   const timestamp = now.getTime();
-
   const interval = _cronParser().default.parseExpression(repeat, {
     currentDate
   });
-
-  let next = interval.next(); // NOTE: cache all workflows will be matched in current cycle
-
+  let next = interval.next();
+  // NOTE: cache all workflows will be matched in current cycle
   if (next.getTime() - timestamp <= range) {
     return true;
   }
-
   return false;
 }
-
 class ScheduleTrigger extends _.Trigger {
-  // running interval, default to 1s
-  // caching workflows in range, default to 1min
   constructor(plugin) {
     super(plugin);
     this.events = new Map();
     this.timer = null;
     this.cache = new Map();
+    // running interval, default to 1s
     this.interval = 1000;
+    // caching workflows in range, default to 1min
     this.cacheCycle = 60000;
-
     this.run = () => {
-      const now = new Date(); // 1001 to avoid 999
-
+      const now = new Date();
+      // 1001 to avoid 999
       const nextInterval = 1001 - now.getMilliseconds();
-      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
-
+      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.timer = setTimeout(this.run, nextInterval);
     };
-
     plugin.app.on('beforeStop', () => {
       if (this.timer) {
         clearInterval(this.timer);
       }
     });
   }
-
   init() {
     if (this.timer) {
       return;
     }
-
-    const now = new Date(); // NOTE: assign to this.timer to avoid duplicated initialization
-
-    this.timer = setTimeout(this.run, // NOTE:
+    const now = new Date();
+    // NOTE: assign to this.timer to avoid duplicated initialization
+    this.timer = setTimeout(this.run,
+    // 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 _this4 = this;
-
     return _asyncToGenerator(function* () {
       // NOTE: trigger workflows in sequence when sqlite due to only one transaction
       const isSqlite = _this4.plugin.app.db.options.dialect === 'sqlite';
@@ -510,24 +423,18 @@ class ScheduleTrigger extends _.Trigger {
         if (!_this4.shouldTrigger(workflow, now)) {
           return prev;
         }
-
         if (isSqlite) {
           return prev.then(() => _this4.trigger(workflow, now));
         }
-
         _this4.trigger(workflow, now);
-
         return null;
       }, isSqlite ? Promise.resolve() : null);
     })();
   }
-
   reload() {
     var _this5 = this;
-
     return _asyncToGenerator(function* () {
       const WorkflowModel = _this5.plugin.app.db.getCollection('workflows').model;
-
       const workflows = yield WorkflowModel.findAll({
         where: {
           enabled: true,
@@ -541,55 +448,45 @@ class ScheduleTrigger extends _.Trigger {
           order: [['createdAt', 'DESC']]
         }],
         group: ['id']
-      }); // NOTE: clear cached jobs in last cycle
-
+      });
+      // NOTE: clear cached jobs in last cycle
       _this5.cache = new Map();
-
       _this5.inspect(workflows);
     })();
   }
-
   inspect(workflows) {
     var _this6 = this;
-
     const now = new Date();
     now.setMilliseconds(0);
     workflows.forEach( /*#__PURE__*/function () {
       var _ref2 = _asyncToGenerator(function* (workflow) {
         const should = yield _this6.shouldCache(workflow, now);
-
         if (should) {
           _this6.plugin.app.logger.info('caching scheduled workflow will run in next minute:', workflow.id);
         }
-
         _this6.setCache(workflow, !should);
       });
-
       return function (_x3) {
         return _ref2.apply(this, arguments);
       };
     }());
   }
-
   setCache(workflow, out = false) {
     out ? this.cache.delete(workflow.id) : this.cache.set(workflow.id, workflow);
   }
-
   shouldCache(workflow, now) {
     var _this7 = this;
-
     return _asyncToGenerator(function* () {
       var _iteratorAbruptCompletion = false;
       var _didIteratorError = false;
-
       var _iteratorError;
-
       try {
         for (var _iterator = _asyncIterator(_this7.constructor.CacheRules), _step; _iteratorAbruptCompletion = !(_step = yield _iterator.next()).done; _iteratorAbruptCompletion = false) {
           const rule = _step.value;
-
-          if (!(yield rule.call(_this7, workflow, now))) {
-            return false;
+          {
+            if (!(yield rule.call(_this7, workflow, now))) {
+              return false;
+            }
           }
         }
       } catch (err) {
@@ -606,19 +503,15 @@ class ScheduleTrigger extends _.Trigger {
           }
         }
       }
-
       return true;
     })();
   }
-
   shouldTrigger(workflow, now) {
     var _iterator2 = _createForOfIteratorHelper(this.constructor.TriggerRules),
-        _step2;
-
+      _step2;
     try {
       for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
         const rule = _step2.value;
-
         if (!rule.call(this, workflow, now)) {
           return false;
         }
@@ -628,51 +521,38 @@ class ScheduleTrigger extends _.Trigger {
     } finally {
       _iterator2.f();
     }
-
     return true;
   }
-
   trigger(workflow, date) {
     var _this8 = this;
-
     return _asyncToGenerator(function* () {
       const mode = workflow.config.mode;
       const modeHandlers = ScheduleModes.get(mode);
-
       if (!modeHandlers) {
         return;
       }
-
       return modeHandlers.trigger.call(_this8, 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 = [({
   config,
@@ -680,11 +560,9 @@ ScheduleTrigger.CacheRules = [({
 }) => (config.limit ? allExecuted < config.limit : true) && config.startsOn, matchNext, function (workflow, now) {
   const mode = workflow.config.mode;
   const modeHandlers = ScheduleModes.get(mode);
-
   if (!modeHandlers) {
     return false;
   }
-
   return modeHandlers.shouldCache.call(this, workflow, now);
 }];
 ScheduleTrigger.TriggerRules = [({