@tachybase/module-workflow 0.23.8

package/dist/server/migrations/20241206122842-add-createdBy.js

@@ -0,0 +1,46 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var add_createdBy_exports = {};
+__export(add_createdBy_exports, {
+  default: () => add_createdBy_default
+});
+module.exports = __toCommonJS(add_createdBy_exports);
+var import_server = require("@tachybase/server");
+class add_createdBy_default extends import_server.Migration {
+  on = "afterLoad";
+  // 'beforeLoad' or 'afterLoad'
+  appVersion = "<0.22.59";
+  async up() {
+    const userRepo = this.context.db.getRepository("users");
+    const workflowRepo = this.context.db.getRepository("workflows");
+    const rootUser = await userRepo.findOne({
+      filter: {
+        specialRole: "root"
+      },
+      raw: true
+    });
+    const { id } = rootUser;
+    const result = await workflowRepo.update({
+      filter: {
+        createdById: null
+      },
+      values: { createdById: id, updatedById: id }
+    });
+    console.log("[workflows] add createdBy and updateBy", result.length, "rows");
+  }
+}

package/dist/server/migrations/20241220001154-bigInt.d.ts

@@ -0,0 +1,6 @@
+import { Migration } from '@tachybase/server';
+export default class extends Migration {
+    on: string;
+    appVersion: string;
+    up(): Promise<void>;
+}

package/dist/server/migrations/20241220001154-bigInt.js

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bigInt_exports = {};
+__export(bigInt_exports, {
+  default: () => bigInt_default
+});
+module.exports = __toCommonJS(bigInt_exports);
+var import_server = require("@tachybase/server");
+var import_sequelize = require("sequelize");
+class bigInt_default extends import_server.Migration {
+  on = "afterLoad";
+  // 'beforeLoad' or 'afterLoad'
+  appVersion = "<0.22.86";
+  async up() {
+    const queryInterface = this.db.sequelize.getQueryInterface();
+    await queryInterface.changeColumn("executions", "parentNode", {
+      type: import_sequelize.DataTypes.BIGINT
+    });
+    await queryInterface.changeColumn("jobs", "cost", {
+      type: import_sequelize.DataTypes.BIGINT
+    });
+    this.app.logger.info("change bigint success!");
+  }
+}

package/dist/server/triggers/CollectionTrigger.d.ts

@@ -0,0 +1,14 @@
+import { Transactionable } from '@tachybase/database';
+import Trigger from '.';
+import type { WorkflowModel } from '../types';
+export interface CollectionChangeTriggerConfig {
+    collection: string;
+    mode: number;
+    condition: any;
+}
+export default class CollectionTrigger extends Trigger {
+    events: Map<any, any>;
+    on(workflow: WorkflowModel): void;
+    off(workflow: WorkflowModel): void;
+    validateEvent(workflow: WorkflowModel, context: any, options: Transactionable): Promise<boolean>;
+}

package/dist/server/triggers/CollectionTrigger.js

@@ -0,0 +1,188 @@
+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 CollectionTrigger_exports = {};
+__export(CollectionTrigger_exports, {
+  default: () => CollectionTrigger
+});
+module.exports = __toCommonJS(CollectionTrigger_exports);
+var import_data_source = require("@tachybase/data-source");
+var import__ = __toESM(require("."));
+var import_utils = require("../utils");
+const MODE_BITMAP = {
+  CREATE: 1,
+  UPDATE: 2,
+  DESTROY: 4
+};
+const MODE_BITMAP_EVENTS = /* @__PURE__ */ new Map();
+MODE_BITMAP_EVENTS.set(MODE_BITMAP.CREATE, "afterCreateWithAssociations");
+MODE_BITMAP_EVENTS.set(MODE_BITMAP.UPDATE, "afterUpdateWithAssociations");
+MODE_BITMAP_EVENTS.set(MODE_BITMAP.DESTROY, "afterDestroy");
+function getHookId(workflow, type) {
+  return `${type}#${workflow.id}`;
+}
+function getFieldRawName(collection, name) {
+  const field = collection.getField(name);
+  if (field && field.options.type === "belongsTo") {
+    return field.options.foreignKey;
+  }
+  return name;
+}
+async function handler(workflow, data, options) {
+  var _a, _b;
+  const { condition, changed, mode, appends, blacklist } = workflow.config;
+  const [dataSourceName, collectionName] = (0, import_data_source.parseCollectionName)(workflow.config.collection);
+  const collection = (_a = this.workflow.app.dataSourceManager) == null ? void 0 : _a.dataSources.get(dataSourceName).collectionManager.getCollection(collectionName);
+  const { transaction, context } = options;
+  const { repository, filterTargetKey } = collection;
+  if (changed && changed.length && changed.filter(
+    (name) => !["linkTo", "hasOne", "hasMany", "belongsToMany"].includes(collection.getField(name).options.type)
+  ).every((name) => !data.changedWithAssociations(getFieldRawName(collection, name)))) {
+    return;
+  }
+  if (blacklist && blacklist.length) {
+    const changedWithAssociations = data.changedWithAssociations();
+    const presetFields = ["createdBy", "createdById", "createdAt", "updatedBy", "updatedById", "updatedAt"];
+    if (changedWithAssociations) {
+      const userFields = changedWithAssociations.filter(
+        (field) => !presetFields.includes(field) && collection.getField(field) && !["linkTo", "hasOne", "hasMany", "belongsToMany"].includes(collection.getField(field).options.type)
+      );
+      const allInBlacklist = userFields.every((name) => blacklist.includes(name));
+      if (allInBlacklist) {
+        return;
+      }
+    }
+  }
+  if (condition && ((_b = condition.$and) == null ? void 0 : _b.length)) {
+    const count = await repository.count({
+      filter: {
+        $and: [condition, { [filterTargetKey]: data[filterTargetKey] }]
+      },
+      context,
+      transaction
+    });
+    if (!count) {
+      return;
+    }
+  }
+  let result = data;
+  if ((appends == null ? void 0 : appends.length) && !(mode & MODE_BITMAP.DESTROY)) {
+    const includeFields = appends.reduce((set, field) => {
+      set.add(field.split(".")[0]);
+      set.add(field);
+      return set;
+    }, /* @__PURE__ */ new Set());
+    result = await repository.findOne({
+      filterByTk: data[filterTargetKey],
+      appends: Array.from(includeFields),
+      transaction
+    });
+  }
+  const json = (0, import_utils.toJSON)(result);
+  if (workflow.sync) {
+    await this.workflow.trigger(
+      workflow,
+      { data: json, stack: context == null ? void 0 : context.stack },
+      {
+        transaction: this.workflow.useDataSourceTransaction(dataSourceName, transaction)
+      }
+    );
+  } else {
+    this.workflow.trigger(workflow, { data: json, stack: context == null ? void 0 : context.stack });
+  }
+}
+class CollectionTrigger extends import__.default {
+  events = /* @__PURE__ */ new Map();
+  on(workflow) {
+    var _a, _b;
+    const { collection, mode } = workflow.config;
+    if (!collection) {
+      return;
+    }
+    const [dataSourceName, collectionName] = (0, import_data_source.parseCollectionName)(collection);
+    const { db } = ((_b = (_a = this.workflow.app.dataSourceManager) == null ? void 0 : _a.dataSources.get(dataSourceName)) == null ? void 0 : _b.collectionManager) ?? {};
+    if (!db || !db.getCollection(collectionName)) {
+      return;
+    }
+    for (const [key, type] of MODE_BITMAP_EVENTS.entries()) {
+      const event = `${collectionName}.${type}`;
+      const name = getHookId(workflow, `${collection}.${type}`);
+      if (mode & key) {
+        if (!this.events.has(name)) {
+          const listener = handler.bind(this, workflow);
+          this.events.set(name, listener);
+          db.on(event, listener);
+        }
+      } else {
+        const listener = this.events.get(name);
+        if (listener) {
+          db.off(event, listener);
+          this.events.delete(name);
+        }
+      }
+    }
+  }
+  off(workflow) {
+    var _a;
+    const { collection, mode } = workflow.config;
+    if (!collection) {
+      return;
+    }
+    const [dataSourceName, collectionName] = (0, import_data_source.parseCollectionName)(collection);
+    const { db } = ((_a = this.workflow.app.dataSourceManager.dataSources.get(dataSourceName)) == null ? void 0 : _a.collectionManager) ?? {};
+    if (!db || !db.getCollection(collectionName)) {
+      return;
+    }
+    for (const [key, type] of MODE_BITMAP_EVENTS.entries()) {
+      const name = getHookId(workflow, `${collection}.${type}`);
+      if (mode & key) {
+        const listener = this.events.get(name);
+        if (listener) {
+          db.off(`${collectionName}.${type}`, listener);
+          this.events.delete(name);
+        }
+      }
+    }
+  }
+  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 '@tachybase/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("@tachybase/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,342 @@
+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_data_source = require("@tachybase/data-source");
+var import_database = require("@tachybase/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 [dataSourceName, collectionName] = (0, import_data_source.parseCollectionName)(workflow.config.collection);
+    const { filterTargetKey } = this.workflow.app.dataSourceManager.dataSources.get(dataSourceName).collectionManager.getCollection(collectionName);
+    const recordPk = record.get(filterTargetKey);
+    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 [dataSourceName, collectionName] = (0, import_data_source.parseCollectionName)(workflow.config.collection);
+    const { repository, filterTargetKey } = this.workflow.app.dataSourceManager.dataSources.get(dataSourceName).collectionManager.getCollection(collectionName);
+    const recordPk = record.get(filterTargetKey);
+    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 [dataSourceName, collectionName] = (0, import_data_source.parseCollectionName)(collection);
+    const event = `${collectionName}.afterSaveWithAssociations`;
+    const eventKey = `${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.dataSourceManager.dataSources.get(dataSourceName).collectionManager.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 [dataSourceName, collectionName] = (0, import_data_source.parseCollectionName)(collection);
+    const event = `${collectionName}.afterSaveWithAssociations`;
+    const eventKey = `${collection}.afterSaveWithAssociations`;
+    const name = getHookId(workflow, event);
+    if (this.events.has(eventKey)) {
+      const listener = this.events.get(name);
+      const { db } = this.workflow.app.dataSourceManager.dataSources.get(dataSourceName).collectionManager;
+      db.off(event, listener);
+      this.events.delete(eventKey);
+    }
+  }
+}

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;
+}