@nocobase/plugin-workflow 0.19.0-alpha.1 → 0.19.0-alpha.10

package/dist/server/triggers/CollectionTrigger.js

@@ -86,13 +86,17 @@ async function handler(workflow, data, options) {
     });
   }
   const json = (0, import_utils.toJSON)(result);
-  this.workflow.trigger(
-    workflow,
-    { data: json },
-    {
-      context
-    }
-  );
+  if (workflow.sync) {
+    await this.workflow.trigger(
+      workflow,
+      { data: json, stack: context == null ? void 0 : context.stack },
+      {
+        transaction
+      }
+    );
+  } else {
+    this.workflow.trigger(workflow, { data: json, stack: context == null ? void 0 : context.stack });
+  }
 }
 class CollectionTrigger extends import__.default {
   events = /* @__PURE__ */ new Map();
@@ -140,4 +144,21 @@ class CollectionTrigger extends import__.default {
       }
     }
   }
+  async validateEvent(workflow, context, options) {
+    if (context.stack) {
+      const existed = await workflow.countExecutions({
+        where: {
+          id: context.stack
+        },
+        transaction: options.transaction
+      });
+      if (existed) {
+        this.workflow.getLogger(workflow.id).warn(
+          `workflow ${workflow.id} has already been triggered in stack executions (${context.stack}), and newly triggering will be skipped.`
+        );
+        return false;
+      }
+    }
+    return true;
+  }
 }

package/dist/server/triggers/ScheduleTrigger/DateFieldScheduleTrigger.d.ts

@@ -0,0 +1,31 @@
+import { Transactionable } from '@nocobase/database';
+import type Plugin from '../../Plugin';
+import type { WorkflowModel } from '../../types';
+export type ScheduleOnField = {
+    field: string;
+    offset?: number;
+    unit?: 1000 | 60000 | 3600000 | 86400000;
+};
+export interface ScheduleTriggerConfig {
+    mode: number;
+    repeat?: string | number | null;
+    limit?: number;
+    startsOn?: ScheduleOnField;
+    endsOn?: string | ScheduleOnField;
+}
+export default class ScheduleTrigger {
+    workflow: Plugin;
+    events: Map<any, any>;
+    private timer;
+    private cache;
+    cacheCycle: number;
+    constructor(workflow: Plugin);
+    reload(): Promise<void>;
+    inspect(workflows: WorkflowModel[]): void;
+    loadRecordsToSchedule({ config: { collection, limit, startsOn, repeat, endsOn }, allExecuted }: WorkflowModel, currentDate: Date): Promise<import("@nocobase/database").Model<any, any>[]>;
+    getRecordNextTime(workflow: WorkflowModel, record: any, nextSecond?: boolean): any;
+    schedule(workflow: WorkflowModel, record: any, nextTime: any, toggle?: boolean, options?: {}): Promise<void>;
+    trigger(workflow: WorkflowModel, record: any, nextTime: any, { transaction }?: Transactionable): Promise<void>;
+    on(workflow: WorkflowModel): void;
+    off(workflow: WorkflowModel): void;
+}

package/dist/server/triggers/ScheduleTrigger/DateFieldScheduleTrigger.js

@@ -0,0 +1,334 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var DateFieldScheduleTrigger_exports = {};
+__export(DateFieldScheduleTrigger_exports, {
+  default: () => ScheduleTrigger
+});
+module.exports = __toCommonJS(DateFieldScheduleTrigger_exports);
+var import_database = require("@nocobase/database");
+var import_cron_parser = __toESM(require("cron-parser"));
+var import_utils = require("./utils");
+function getOnTimestampWithOffset({ field, offset = 0, unit = 1e3 }, now) {
+  if (!field) {
+    return null;
+  }
+  const timestamp = now.getTime();
+  return timestamp - offset * unit;
+}
+function getDataOptionTime(record, on, dir = 1) {
+  if (!on) {
+    return null;
+  }
+  switch (typeof on) {
+    case "string": {
+      const time = (0, import_utils.parseDateWithoutMs)(on);
+      return time ? time : null;
+    }
+    case "object": {
+      const { field, offset = 0, unit = 1e3 } = on;
+      if (!record.get(field)) {
+        return null;
+      }
+      const second = new Date(record.get(field).getTime());
+      second.setMilliseconds(0);
+      return second.getTime() + offset * unit * dir;
+    }
+    default:
+      return null;
+  }
+}
+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;
+function getCronNextTime(cron, currentDate) {
+  const interval = import_cron_parser.default.parseExpression(cron, { currentDate });
+  const next = interval.next();
+  return next.getTime();
+}
+function matchCronNextTime(cron, currentDate, range) {
+  return getCronNextTime(cron, currentDate) - currentDate.getTime() <= range;
+}
+function getHookId(workflow, type) {
+  return `${type}#${workflow.id}`;
+}
+class ScheduleTrigger {
+  constructor(workflow) {
+    this.workflow = workflow;
+    workflow.app.on("afterStart", async () => {
+      if (this.timer) {
+        return;
+      }
+      this.timer = setInterval(() => this.reload(), this.cacheCycle);
+      this.reload();
+    });
+    workflow.app.on("beforeStop", () => {
+      if (this.timer) {
+        clearInterval(this.timer);
+      }
+      for (const [key, timer] of this.cache.entries()) {
+        clearTimeout(timer);
+        this.cache.delete(key);
+      }
+    });
+  }
+  events = /* @__PURE__ */ new Map();
+  timer = null;
+  cache = /* @__PURE__ */ new Map();
+  // caching workflows in range, default to 5min
+  cacheCycle = 3e5;
+  async reload() {
+    const WorkflowRepo = this.workflow.app.db.getRepository("workflows");
+    const workflows = await WorkflowRepo.find({
+      filter: { enabled: true, type: "schedule", "config.mode": import_utils.SCHEDULE_MODE.DATE_FIELD }
+    });
+    this.cache = /* @__PURE__ */ new Map();
+    this.inspect(workflows);
+  }
+  inspect(workflows) {
+    const now = /* @__PURE__ */ new Date();
+    workflows.forEach(async (workflow) => {
+      const records = await this.loadRecordsToSchedule(workflow, now);
+      records.forEach((record) => {
+        const nextTime = this.getRecordNextTime(workflow, record);
+        this.schedule(workflow, record, nextTime, Boolean(nextTime));
+      });
+    });
+  }
+  // 1. startsOn in range -> yes
+  // 2. startsOn before now, has no repeat -> no
+  // 3. startsOn before now, and has repeat:
+  //   a. repeat out of range -> no
+  //   b. repeat in range (number or cron):
+  //     i. endsOn after now -> yes
+  //     ii. endsOn before now -> no
+  async loadRecordsToSchedule({ config: { collection, limit, startsOn, repeat, endsOn }, allExecuted }, currentDate) {
+    const { db } = this.workflow.app;
+    if (limit && allExecuted >= limit) {
+      return [];
+    }
+    if (!startsOn) {
+      return [];
+    }
+    const timestamp = currentDate.getTime();
+    const startTimestamp = getOnTimestampWithOffset(startsOn, currentDate);
+    if (!startTimestamp) {
+      return [];
+    }
+    const range = this.cacheCycle * 2;
+    const conditions = [
+      {
+        [startsOn.field]: {
+          // cache next 2 cycles
+          [import_database.Op.lt]: new Date(startTimestamp + range)
+        }
+      }
+    ];
+    if (repeat) {
+      if (typeof repeat === "number") {
+        const tsFn = DialectTimestampFnMap[db.options.dialect];
+        if (repeat > range && tsFn) {
+          const modExp = (0, import_database.fn)(
+            "MOD",
+            (0, import_database.literal)(`${Math.round(timestamp / 1e3)} - ${tsFn(startsOn.field)}`),
+            Math.round(repeat / 1e3)
+          );
+          conditions.push((0, import_database.where)(modExp, { [import_database.Op.lt]: Math.round(range / 1e3) }));
+        }
+      } else if (typeof repeat === "string") {
+        if (!matchCronNextTime(repeat, currentDate, range)) {
+          return [];
+        }
+      }
+      if (endsOn) {
+        const now = /* @__PURE__ */ new Date();
+        const endTimestamp = getOnTimestampWithOffset(endsOn, now);
+        if (!endTimestamp) {
+          return [];
+        }
+        if (typeof endsOn === "string") {
+          if (endTimestamp <= timestamp) {
+            return [];
+          }
+        } else {
+          conditions.push({
+            [endsOn.field]: {
+              [import_database.Op.gte]: new Date(endTimestamp)
+            }
+          });
+        }
+      }
+    } else {
+      conditions.push({
+        [startsOn.field]: {
+          [import_database.Op.gte]: new Date(startTimestamp)
+        }
+      });
+    }
+    const { model } = db.getCollection(collection);
+    return model.findAll({
+      where: {
+        [import_database.Op.and]: conditions
+      }
+    });
+  }
+  getRecordNextTime(workflow, record, nextSecond = false) {
+    const {
+      config: { startsOn, endsOn, repeat, limit },
+      allExecuted
+    } = workflow;
+    if (limit && allExecuted >= limit) {
+      return null;
+    }
+    const range = this.cacheCycle;
+    const now = /* @__PURE__ */ new Date();
+    now.setMilliseconds(nextSecond ? 1e3 : 0);
+    const timestamp = now.getTime();
+    const startTime = getDataOptionTime(record, startsOn);
+    const endTime = getDataOptionTime(record, endsOn);
+    let nextTime = null;
+    if (!startTime) {
+      return null;
+    }
+    if (startTime > timestamp + range) {
+      return null;
+    }
+    if (startTime >= timestamp) {
+      return !endTime || endTime >= startTime && endTime < timestamp + range ? startTime : null;
+    } else {
+      if (!repeat) {
+        return null;
+      }
+    }
+    if (typeof repeat === "number") {
+      const nextRepeatTime = (startTime - timestamp) % repeat + repeat;
+      if (nextRepeatTime > range) {
+        return null;
+      }
+      if (endTime && endTime < timestamp + nextRepeatTime) {
+        return null;
+      }
+      nextTime = timestamp + nextRepeatTime;
+    } else if (typeof repeat === "string") {
+      nextTime = getCronNextTime(repeat, now);
+      if (nextTime - timestamp > range) {
+        return null;
+      }
+      if (endTime && endTime < nextTime) {
+        return null;
+      }
+    }
+    if (endTime && endTime <= timestamp) {
+      return null;
+    }
+    return nextTime;
+  }
+  schedule(workflow, record, nextTime, toggle = true, options = {}) {
+    const { model } = this.workflow.app.db.getCollection(workflow.config.collection);
+    const recordPk = record.get(model.primaryKeyAttribute);
+    if (toggle) {
+      const nextInterval = Math.max(0, nextTime - Date.now());
+      const key = `${workflow.id}:${recordPk}@${nextTime}`;
+      if (!this.cache.has(key)) {
+        if (nextInterval) {
+          this.cache.set(key, setTimeout(this.trigger.bind(this, workflow, record, nextTime), nextInterval));
+        } else {
+          return this.trigger(workflow, record, nextTime, options);
+        }
+      }
+    } else {
+      for (const [key, timer] of this.cache.entries()) {
+        if (key.startsWith(`${workflow.id}:${recordPk}@`)) {
+          clearTimeout(timer);
+          this.cache.delete(key);
+        }
+      }
+    }
+  }
+  async trigger(workflow, record, nextTime, { transaction } = {}) {
+    const { repository, model } = this.workflow.app.db.getCollection(workflow.config.collection);
+    const recordPk = record.get(model.primaryKeyAttribute);
+    const data = await repository.findOne({
+      filterByTk: recordPk,
+      appends: workflow.config.appends,
+      transaction
+    });
+    const key = `${workflow.id}:${recordPk}@${nextTime}`;
+    this.cache.delete(key);
+    this.workflow.trigger(workflow, {
+      data: data.toJSON(),
+      date: new Date(nextTime)
+    });
+    if (!workflow.config.repeat || workflow.config.limit && workflow.allExecuted >= workflow.config.limit - 1) {
+      return;
+    }
+    const n = this.getRecordNextTime(workflow, data, true);
+    if (n) {
+      this.schedule(workflow, data, n, true);
+    }
+  }
+  on(workflow) {
+    this.inspect([workflow]);
+    const { collection } = workflow.config;
+    const event = `${collection}.afterSaveWithAssociations`;
+    const name = getHookId(workflow, event);
+    if (this.events.has(name)) {
+      return;
+    }
+    const listener = async (data, { transaction }) => {
+      const nextTime = this.getRecordNextTime(workflow, data);
+      return this.schedule(workflow, data, nextTime, Boolean(nextTime), { transaction });
+    };
+    this.events.set(name, listener);
+    this.workflow.app.db.on(event, listener);
+  }
+  off(workflow) {
+    for (const [key, timer] of this.cache.entries()) {
+      if (key.startsWith(`${workflow.id}:`)) {
+        clearTimeout(timer);
+        this.cache.delete(key);
+      }
+    }
+    const { collection } = workflow.config;
+    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.workflow.app.db.off(event, listener);
+    }
+  }
+}

package/dist/server/triggers/ScheduleTrigger/StaticScheduleTrigger.d.ts

@@ -0,0 +1,15 @@
+import type Plugin from '../../Plugin';
+export default class StaticScheduleTrigger {
+    workflow: Plugin;
+    private timers;
+    constructor(workflow: Plugin);
+    inspect(workflows: any): void;
+    getNextTime({ config, allExecuted }: {
+        config: any;
+        allExecuted: any;
+    }, currentDate: any, nextSecond?: boolean): any;
+    schedule(workflow: any, nextTime: any, toggle?: boolean): void;
+    trigger(workflow: any, time: any): Promise<void>;
+    on(workflow: any): void;
+    off(workflow: any): void;
+}

package/dist/server/triggers/ScheduleTrigger/StaticScheduleTrigger.js

@@ -0,0 +1,143 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var StaticScheduleTrigger_exports = {};
+__export(StaticScheduleTrigger_exports, {
+  default: () => StaticScheduleTrigger
+});
+module.exports = __toCommonJS(StaticScheduleTrigger_exports);
+var import_cron_parser = __toESM(require("cron-parser"));
+var import_utils = require("./utils");
+const MAX_SAFE_INTERVAL = 2147483647;
+class StaticScheduleTrigger {
+  constructor(workflow) {
+    this.workflow = workflow;
+    workflow.app.on("afterStart", async () => {
+      const WorkflowRepo = this.workflow.app.db.getRepository("workflows");
+      const workflows = await WorkflowRepo.find({
+        filter: { enabled: true, type: "schedule", "config.mode": import_utils.SCHEDULE_MODE.STATIC }
+      });
+      this.inspect(workflows);
+    });
+    workflow.app.on("beforeStop", () => {
+      for (const timer of this.timers.values()) {
+        clearInterval(timer);
+      }
+    });
+  }
+  timers = /* @__PURE__ */ new Map();
+  inspect(workflows) {
+    const now = /* @__PURE__ */ new Date();
+    now.setMilliseconds(0);
+    workflows.forEach((workflow) => {
+      const nextTime = this.getNextTime(workflow, now);
+      if (nextTime) {
+        this.workflow.getLogger(workflow.id).info(`caching scheduled workflow will run at: ${new Date(nextTime).toISOString()}`);
+      } else {
+        this.workflow.getLogger(workflow.id).info("workflow will not be scheduled");
+      }
+      this.schedule(workflow, nextTime, nextTime >= now.getTime());
+    });
+  }
+  getNextTime({ config, allExecuted }, currentDate, nextSecond = false) {
+    if (config.limit && allExecuted >= config.limit) {
+      return null;
+    }
+    if (!config.startsOn) {
+      return null;
+    }
+    currentDate.setMilliseconds(nextSecond ? 1e3 : 0);
+    const timestamp = currentDate.getTime();
+    const startTime = (0, import_utils.parseDateWithoutMs)(config.startsOn);
+    if (startTime > timestamp) {
+      return startTime;
+    }
+    if (config.repeat) {
+      const endTime = config.endsOn ? (0, import_utils.parseDateWithoutMs)(config.endsOn) : null;
+      if (endTime && endTime < timestamp) {
+        return null;
+      }
+      if (typeof config.repeat === "string") {
+        const interval = import_cron_parser.default.parseExpression(config.repeat, { currentDate });
+        const next = interval.next();
+        return next.getTime();
+      } else if (typeof config.repeat === "number") {
+        return timestamp + (timestamp - startTime) % config.repeat;
+      } else {
+        return null;
+      }
+    } else {
+      if (startTime < timestamp) {
+        return null;
+      }
+      return timestamp;
+    }
+  }
+  schedule(workflow, nextTime, toggle = true) {
+    if (toggle) {
+      const key = `${workflow.id}@${nextTime}`;
+      if (!this.timers.has(key)) {
+        const interval = Math.max(nextTime - Date.now(), 0);
+        if (interval > MAX_SAFE_INTERVAL) {
+          this.timers.set(
+            key,
+            setTimeout(() => {
+              this.timers.delete(key);
+              this.schedule(workflow, nextTime);
+            }, MAX_SAFE_INTERVAL)
+          );
+        } else {
+          this.timers.set(key, setTimeout(this.trigger.bind(this, workflow, nextTime), interval));
+        }
+      }
+    } else {
+      for (const [key, timer] of this.timers.entries()) {
+        if (key.startsWith(`${workflow.id}@`)) {
+          clearTimeout(timer);
+          this.timers.delete(key);
+        }
+      }
+    }
+  }
+  async trigger(workflow, time) {
+    this.timers.delete(`${workflow.id}@${time}`);
+    this.workflow.trigger(workflow, { date: new Date(time) });
+    if (!workflow.config.repeat || workflow.config.limit && workflow.allExecuted >= workflow.config.limit - 1) {
+      return;
+    }
+    const nextTime = this.getNextTime(workflow, /* @__PURE__ */ new Date(), true);
+    if (nextTime) {
+      this.schedule(workflow, nextTime);
+    }
+  }
+  on(workflow) {
+    this.inspect([workflow]);
+  }
+  off(workflow) {
+    this.schedule(workflow, null, false);
+  }
+}

package/dist/server/triggers/ScheduleTrigger/index.d.ts

@@ -0,0 +1,13 @@
+import { Transactionable } from 'sequelize';
+import Trigger from '..';
+import type Plugin from '../../Plugin';
+import { WorkflowModel } from '../../types';
+export default class ScheduleTrigger extends Trigger {
+    sync: boolean;
+    private modes;
+    constructor(workflow: Plugin);
+    private getTrigger;
+    on(workflow: any): void;
+    off(workflow: any): void;
+    validateEvent(workflow: WorkflowModel, context: any, options: Transactionable): Promise<boolean>;
+}

package/dist/server/triggers/ScheduleTrigger/index.js

@@ -0,0 +1,74 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ScheduleTrigger_exports = {};
+__export(ScheduleTrigger_exports, {
+  default: () => ScheduleTrigger
+});
+module.exports = __toCommonJS(ScheduleTrigger_exports);
+var import__ = __toESM(require(".."));
+var import_DateFieldScheduleTrigger = __toESM(require("./DateFieldScheduleTrigger"));
+var import_StaticScheduleTrigger = __toESM(require("./StaticScheduleTrigger"));
+var import_utils = require("./utils");
+class ScheduleTrigger extends import__.default {
+  sync = false;
+  modes = /* @__PURE__ */ new Map();
+  constructor(workflow) {
+    super(workflow);
+    this.modes.set(import_utils.SCHEDULE_MODE.STATIC, new import_StaticScheduleTrigger.default(workflow));
+    this.modes.set(import_utils.SCHEDULE_MODE.DATE_FIELD, new import_DateFieldScheduleTrigger.default(workflow));
+  }
+  getTrigger(mode) {
+    return this.modes.get(mode);
+  }
+  on(workflow) {
+    const mode = workflow.config.mode;
+    const trigger = this.getTrigger(mode);
+    if (trigger) {
+      trigger.on(workflow);
+    }
+  }
+  off(workflow) {
+    const mode = workflow.config.mode;
+    const trigger = this.getTrigger(mode);
+    if (trigger) {
+      trigger.off(workflow);
+    }
+  }
+  async validateEvent(workflow, context, options) {
+    if (!context.date) {
+      return false;
+    }
+    const existed = await workflow.countExecutions({
+      where: {
+        "context.date": context.date
+      },
+      transaction: options.transaction
+    });
+    return !existed;
+  }
+}

package/dist/server/triggers/ScheduleTrigger/utils.d.ts

@@ -0,0 +1,5 @@
+export declare const SCHEDULE_MODE: {
+    readonly STATIC: 0;
+    readonly DATE_FIELD: 1;
+};
+export declare function parseDateWithoutMs(date: string): number;