@nocobase/plugin-workflow 0.11.1-alpha.5 → 0.12.0-alpha.2

package/{src/server/triggers/schedule.ts → dist/server/triggers/schedule.js}

@@ -1,65 +1,38 @@
-import { fn, literal, Op, where } from '@nocobase/database';
-import parser from 'cron-parser';
-import Plugin, { Trigger } from '..';
-import type { WorkflowModel } from '../types';
+'use strict';
 
-export type ScheduleOnField =
-  | string
-  | {
-      field: string;
-      // in seconds
-      offset?: number;
-      unit?: 1000 | 60000 | 3600000 | 86400000;
-    };
-export interface ScheduleTriggerConfig {
-  // trigger mode
-  mode: number;
-  // how to repeat
-  repeat?: string | number | null;
-  // limit of repeat times
-  limit?: number;
-
-  startsOn?: ScheduleOnField;
-  endsOn?: ScheduleOnField;
-}
+Object.defineProperty(exports, '__esModule', { value: true });
 
-export const SCHEDULE_MODE = {
-  CONSTANT: 0,
-  COLLECTION_FIELD: 1,
-} as const;
+var database = require('@nocobase/database');
+var parser = require('cron-parser');
+var __ = require('..');
 
-interface ScheduleMode {
-  on?(this: ScheduleTrigger, workflow: WorkflowModel): void;
-  off?(this: ScheduleTrigger, workflow: WorkflowModel): void;
-  shouldCache(this: ScheduleTrigger, workflow: WorkflowModel, now: Date): Promise<boolean> | boolean;
-  trigger(this: ScheduleTrigger, workflow: WorkflowModel, now: Date): any;
-}
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-const ScheduleModes = new Map<number, ScheduleMode>();
+var parser__default = /*#__PURE__*/_interopDefault(parser);
 
-function parseDateWithoutMs(date: string) {
-  return Math.floor(Date.parse(date) / 1000) * 1000;
+const SCHEDULE_MODE = {
+  CONSTANT: 0,
+  COLLECTION_FIELD: 1
+};
+const ScheduleModes = /* @__PURE__ */ new Map();
+function parseDateWithoutMs(date) {
+  return Math.floor(Date.parse(date) / 1e3) * 1e3;
 }
-
 ScheduleModes.set(SCHEDULE_MODE.CONSTANT, {
   shouldCache(workflow, now) {
     const { startsOn, endsOn, repeat } = workflow.config;
     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 (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) {
@@ -71,25 +44,21 @@ ScheduleModes.set(SCHEDULE_MODE.CONSTANT, {
         return false;
       }
     }
-
     return true;
   },
   trigger(workflow, now) {
     const { startsOn, endsOn, repeat } = workflow.config;
     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 (typeof repeat === "number") {
         if (Math.round(timestamp - startTime) % repeat) {
           return;
         }
       }
-
       if (endsOn) {
         const endTime = parseDateWithoutMs(endsOn);
         if (!endTime || endTime < timestamp) {
@@ -101,53 +70,46 @@ ScheduleModes.set(SCHEDULE_MODE.CONSTANT, {
         return;
       }
     }
-
     return this.plugin.trigger(workflow, { date: now });
-  },
+  }
 });
-
-function getOnTimestampWithOffset(on, now: Date) {
+function getOnTimestampWithOffset(on, now) {
   switch (typeof on) {
-    case 'string':
+    case "string":
       return parseDateWithoutMs(on);
-    case 'object': {
-      const { field, offset = 0, unit = 1000 } = on;
+    case "object": {
+      const { field, offset = 0, unit = 1e3 } = on;
       if (!field) {
         return null;
       }
       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': {
+    case "string": {
       const time = parseDateWithoutMs(on);
       return time ? time : null;
     }
-    case 'object': {
-      const { field, offset = 0, unit = 1000 } = on;
+    case "object": {
+      const { field, offset = 0, unit = 1e3 } = on;
       return data.get(field) ? data.get(field).getTime() - offset * unit * dir : null;
     }
     default:
       return null;
   }
 }
-
-function getHookId(workflow, type: string) {
+function getHookId(workflow, type) {
   return `${type}#${workflow.id}`;
 }
-
-const DialectTimestampFnMap: { [key: string]: (col: string) => string } = {
+const DialectTimestampFnMap = {
   postgres(col) {
     return `CAST(FLOOR(extract(epoch from "${col}")) AS INTEGER)`;
   },
@@ -156,10 +118,9 @@ const DialectTimestampFnMap: { [key: string]: (col: string) => string } = {
   },
   sqlite(col) {
     return `CAST(FLOOR(unixepoch(${col})) AS INTEGER)`;
-  },
+  }
 };
 DialectTimestampFnMap.mariadb = DialectTimestampFnMap.mysql;
-
 ScheduleModes.set(SCHEDULE_MODE.COLLECTION_FIELD, {
   on(workflow) {
     const { collection, startsOn, endsOn, repeat } = workflow.config;
@@ -168,9 +129,8 @@ ScheduleModes.set(SCHEDULE_MODE.COLLECTION_FIELD, {
     if (this.events.has(name)) {
       return;
     }
-    // NOTE: toggle cache depends on new date
     const listener = async (data, options) => {
-      const now = new Date();
+      const now = /* @__PURE__ */ new Date();
       now.setMilliseconds(0);
       const timestamp = now.getTime();
       const startTime = getDataOptionTime(data, startsOn);
@@ -187,20 +147,14 @@ ScheduleModes.set(SCHEDULE_MODE.COLLECTION_FIELD, {
       if (!matchNext.call(this, workflow, now)) {
         return;
       }
-      if (
-        typeof repeat === 'number' &&
-        repeat > this.cacheCycle &&
-        (timestamp - startTime) % repeat > this.cacheCycle
-      ) {
+      if (typeof repeat === "number" && repeat > this.cacheCycle && (timestamp - startTime) % repeat > this.cacheCycle) {
         return;
       }
-
       this.setCache(workflow);
     };
     this.events.set(name, listener);
     this.plugin.app.db.on(event, listener);
   },
-
   off(workflow) {
     const { collection } = workflow.config;
     const event = `${collection}.afterSave`;
@@ -211,261 +165,207 @@ ScheduleModes.set(SCHEDULE_MODE.COLLECTION_FIELD, {
       this.plugin.app.db.off(event, listener);
     }
   },
-
   async shouldCache(workflow, now) {
     const { db } = this.plugin.app;
     const { startsOn, endsOn, repeat, collection } = workflow.config;
     const timestamp = now.getTime();
-
     const startTimestamp = getOnTimestampWithOffset(startsOn, now);
     if (!startTimestamp) {
       return false;
     }
-
-    const conditions: any[] = [
+    const conditions = [
       {
         [startsOn.field]: {
-          [Op.lt]: new Date(startTimestamp + this.cacheCycle),
-        },
-      },
+          [database.Op.lt]: new Date(startTimestamp + this.cacheCycle)
+        }
+      }
     ];
-
-    // 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 > this.cacheCycle && tsFn) {
+      const tsFn = DialectTimestampFnMap[db.options.dialect];
+      if (typeof repeat === "number" && repeat > this.cacheCycle && tsFn) {
         conditions.push(
-          where(
-            fn('MOD', literal(`${Math.round(timestamp / 1000)} - ${tsFn(startsOn.field)}`), Math.round(repeat / 1000)),
-            { [Op.lt]: Math.round(this.cacheCycle / 1000) },
-          ),
+          database.where(
+            database.fn("MOD", database.literal(`${Math.round(timestamp / 1e3)} - ${tsFn(startsOn.field)}`), Math.round(repeat / 1e3)),
+            { [database.Op.lt]: Math.round(this.cacheCycle / 1e3) }
+          )
         );
-        // 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 (typeof endsOn === "string") {
           if (endTimestamp <= timestamp) {
             return false;
           }
         } else {
           conditions.push({
             [endsOn.field]: {
-              [Op.gte]: new Date(endTimestamp + this.interval),
-            },
+              [database.Op.gte]: new Date(endTimestamp + this.interval)
+            }
           });
         }
       }
     } else {
       conditions.push({
         [startsOn.field]: {
-          [Op.gte]: new Date(startTimestamp),
-        },
+          [database.Op.gte]: new Date(startTimestamp)
+        }
       });
     }
-
     const { model } = db.getCollection(collection);
     const count = await model.count({
-      where: { [Op.and]: conditions },
+      where: { [database.Op.and]: conditions }
     });
-
     return Boolean(count);
   },
-
-  async trigger(workflow, now: Date) {
+  async trigger(workflow, now) {
     const { startsOn, repeat, endsOn, collection, appends } = workflow.config;
     const timestamp = now.getTime();
-
     const startTimestamp = getOnTimestampWithOffset(startsOn, now);
     if (!startTimestamp) {
       return false;
     }
-
-    const conditions: any[] = [
+    const conditions = [
       {
         [startsOn.field]: {
-          [Op.lt]: new Date(startTimestamp + this.interval),
-        },
-      },
+          [database.Op.lt]: new Date(startTimestamp + this.interval)
+        }
+      }
     ];
-
     if (repeat) {
-      // startsOn not after now
       conditions.push({
         [startsOn.field]: {
-          [Op.lt]: new Date(startTimestamp),
-        },
+          [database.Op.lt]: new Date(startTimestamp)
+        }
       });
-
-      const tsFn = DialectTimestampFnMap[this.plugin.app.db.options.dialect!];
-      if (typeof repeat === 'number' && tsFn) {
+      const tsFn = DialectTimestampFnMap[this.plugin.app.db.options.dialect];
+      if (typeof repeat === "number" && tsFn) {
         conditions.push(
-          where(
-            fn('MOD', literal(`${Math.round(timestamp / 1000)} - ${tsFn(startsOn.field)}`), Math.round(repeat / 1000)),
-            { [Op.eq]: 0 },
-          ),
+          database.where(
+            database.fn("MOD", database.literal(`${Math.round(timestamp / 1e3)} - ${tsFn(startsOn.field)}`), Math.round(repeat / 1e3)),
+            { [database.Op.eq]: 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 (typeof endsOn === "string") {
           if (endTimestamp <= timestamp) {
             return false;
           }
         } else {
           conditions.push({
             [endsOn.field]: {
-              [Op.gte]: new Date(endTimestamp + this.interval),
-            },
+              [database.Op.gte]: new Date(endTimestamp + this.interval)
+            }
           });
         }
       }
     } else {
-      // startsOn exactly equal to now in 1s
       conditions.push({
         [startsOn.field]: {
-          [Op.gte]: new Date(startTimestamp),
-        },
+          [database.Op.gte]: new Date(startTimestamp)
+        }
       });
     }
-
     const repo = this.plugin.app.db.getRepository(collection);
     const instances = await repo.find({
       filter: {
-        $and: conditions,
+        $and: conditions
       },
-      appends,
+      appends
     });
-
     instances.forEach((item) => {
       this.plugin.trigger(workflow, {
         date: now,
-        data: item.toJSON(),
+        data: item.toJSON()
       });
     });
-  },
+  }
 });
-
-function matchNext(this: ScheduleTrigger, workflow, now: Date, range: number = this.cacheCycle): boolean {
+function matchNext(workflow, now, range = this.cacheCycle) {
   const { repeat } = workflow.config;
-  // 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') {
+  if (typeof repeat !== "string") {
     return true;
   }
-
   const currentDate = new Date(now);
   currentDate.setMilliseconds(-1);
   const timestamp = now.getTime();
-  const interval = parser.parseExpression(repeat, { currentDate });
+  const interval = parser__default.default.parseExpression(repeat, { currentDate });
   const next = interval.next();
-
-  // NOTE: cache all workflows will be matched in current cycle
   if (next.getTime() - timestamp <= range) {
     return true;
   }
-
   return false;
 }
-
-export default class ScheduleTrigger extends Trigger {
+class ScheduleTrigger extends __.Trigger {
   static CacheRules = [
     ({ config, allExecuted }) => (config.limit ? allExecuted < config.limit : true) && config.startsOn,
     matchNext,
-    function (workflow, now) {
+    function(workflow, now) {
       const { mode } = workflow.config;
       const modeHandlers = ScheduleModes.get(mode);
       if (!modeHandlers) {
         return false;
       }
       return modeHandlers.shouldCache.call(this, workflow, now);
-    },
+    }
   ];
-
   static TriggerRules = [
     ({ config, allExecuted }) => (config.limit ? allExecuted < config.limit : true) && config.startsOn,
-    function (workflow, now) {
+    function(workflow, now) {
       return matchNext.call(this, workflow, now, 0);
-    },
+    }
   ];
-
-  events = new Map();
-
-  private timer: NodeJS.Timeout | null = null;
-
-  private cache: Map<number | string, any> = new Map();
-
+  events = /* @__PURE__ */ new Map();
+  timer = null;
+  cache = /* @__PURE__ */ new Map();
   // running interval, default to 1s
-  interval = 1_000;
+  interval = 1e3;
   // caching workflows in range, default to 1min
-  cacheCycle = 60_000;
-
-  constructor(plugin: Plugin) {
+  cacheCycle = 6e4;
+  constructor(plugin) {
     super(plugin);
-
-    plugin.app.on('beforeStop', () => {
+    plugin.app.on("beforeStop", () => {
       if (this.timer) {
         clearInterval(this.timer);
       }
     });
   }
-
   init() {
-    if (this.plugin.app.name !== 'main') {
+    if (this.plugin.app.name !== "main") {
       return;
     }
-
     if (this.timer) {
       return;
     }
-
-    const now = new Date();
-
-    // NOTE: assign to this.timer to avoid duplicated initialization
+    const now = /* @__PURE__ */ new Date();
     this.timer = setTimeout(
       this.run,
       // NOTE:
       //  try to align to system time on each second starts,
       //  after at least 1 second initialized for everything to get ready.
       //  so jobs in 2 seconds will be missed at first start.
-      1_000 - now.getMilliseconds(),
+      1e3 - now.getMilliseconds()
     );
   }
-
   run = () => {
-    const now = new Date();
-    // 1001 to avoid 999
-    const nextInterval = 1_001 - now.getMilliseconds();
+    const now = /* @__PURE__ */ new Date();
+    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
     if (!(now.getTime() % this.cacheCycle)) {
       this.reload();
     }
-
     this.timer = setTimeout(this.run, nextInterval);
   };
-
   async onTick(now) {
-    // NOTE: trigger workflows in sequence when sqlite due to only one transaction
-    const isSqlite = this.plugin.app.db.options.dialect === 'sqlite';
-
+    const isSqlite = this.plugin.app.db.options.dialect === "sqlite";
     return Array.from(this.cache.values()).reduce(
       (prev, workflow) => {
         if (!this.shouldTrigger(workflow, now)) {
@@ -477,70 +377,58 @@ export default class ScheduleTrigger extends Trigger {
         this.trigger(workflow, now);
         return null;
       },
-      isSqlite ? Promise.resolve() : null,
+      isSqlite ? Promise.resolve() : null
     );
   }
-
   async reload() {
-    const WorkflowModel = this.plugin.app.db.getCollection('workflows').model;
+    const WorkflowModel = this.plugin.app.db.getCollection("workflows").model;
     const workflows = await WorkflowModel.findAll({
-      where: { enabled: true, type: 'schedule' },
+      where: { enabled: true, type: "schedule" },
       include: [
         {
-          association: 'executions',
-          attributes: ['id', 'createdAt'],
+          association: "executions",
+          attributes: ["id", "createdAt"],
           separate: true,
           limit: 1,
-          order: [['createdAt', 'DESC']],
-        },
+          order: [["createdAt", "DESC"]]
+        }
       ],
-      group: ['id'],
+      group: ["id"]
     });
-
-    // NOTE: clear cached jobs in last cycle
-    this.cache = new Map();
-
+    this.cache = /* @__PURE__ */ new Map();
     this.inspect(workflows);
   }
-
   inspect(workflows) {
-    const now = new Date();
+    const now = /* @__PURE__ */ new Date();
     now.setMilliseconds(0);
-
     workflows.forEach(async (workflow) => {
       const should = await this.shouldCache(workflow, now);
-
       if (should) {
-        this.plugin.app.logger.info('caching scheduled workflow will run in next minute:', workflow.id);
+        this.plugin.app.logger.info("caching scheduled workflow will run in next minute:", workflow.id);
       }
-
       this.setCache(workflow, !should);
     });
   }
-
   setCache(workflow, out = false) {
     out ? this.cache.delete(workflow.id) : this.cache.set(workflow.id, workflow);
   }
-
   async shouldCache(workflow, now) {
-    for await (const rule of (<typeof ScheduleTrigger>this.constructor).CacheRules) {
-      if (!(await rule.call(this, workflow, now))) {
+    for await (const rule of this.constructor.CacheRules) {
+      if (!await rule.call(this, workflow, now)) {
         return false;
       }
     }
     return true;
   }
-
-  shouldTrigger(workflow, now): boolean {
-    for (const rule of (<typeof ScheduleTrigger>this.constructor).TriggerRules) {
+  shouldTrigger(workflow, now) {
+    for (const rule of this.constructor.TriggerRules) {
       if (!rule.call(this, workflow, now)) {
         return false;
       }
     }
     return true;
   }
-
-  async trigger(workflow, date: Date) {
+  async trigger(workflow, date) {
     const { mode } = workflow.config;
     const modeHandlers = ScheduleModes.get(mode);
     if (!modeHandlers) {
@@ -548,11 +436,8 @@ export default class ScheduleTrigger extends Trigger {
     }
     return modeHandlers.trigger.call(this, workflow, date);
   }
-
   on(workflow) {
-    // NOTE: lazy initialization
     this.init();
-
     const { mode } = workflow.config;
     const modeHandlers = ScheduleModes.get(mode);
     if (modeHandlers && modeHandlers.on) {
@@ -569,3 +454,6 @@ export default class ScheduleTrigger extends Trigger {
     this.cache.delete(workflow.id);
   }
 }
+
+exports.SCHEDULE_MODE = SCHEDULE_MODE;
+exports.default = ScheduleTrigger;

package/dist/server/types/Execution.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var database = require('@nocobase/database');
+
+class ExecutionModel extends database.Model {
+}
+
+module.exports = ExecutionModel;

package/dist/server/types/FlowNode.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var database = require('@nocobase/database');
+
+class FlowNodeModel extends database.Model {
+}
+
+module.exports = FlowNodeModel;

package/dist/server/types/Job.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var database = require('@nocobase/database');
+
+class JobModel extends database.Model {
+}
+
+module.exports = JobModel;

package/dist/server/types/Workflow.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var database = require('@nocobase/database');
+
+class WorkflowModel extends database.Model {
+}
+
+module.exports = WorkflowModel;

package/dist/server/types/index.js

@@ -0,0 +1,2 @@
+'use strict';
+