@nocobase/plugin-workflow 1.5.0-beta.8 → 1.5.0

package/dist/server/Plugin.js

@@ -41,6 +41,7 @@ __export(Plugin_exports, {
 module.exports = __toCommonJS(Plugin_exports);
 var import_path = __toESM(require("path"));
 var import_crypto = require("crypto");
+var import_sequelize = require("sequelize");
 var import_lru_cache = __toESM(require("lru-cache"));
 var import_database = require("@nocobase/database");
 var import_server = require("@nocobase/server");
@@ -126,7 +127,7 @@ class PluginWorkflowServer extends import_server.Plugin {
   /**
    * @experimental
    */
-  getLogger(workflowId) {
+  getLogger(workflowId = "dispatcher") {
     const now = /* @__PURE__ */ new Date();
     const date = `${now.getFullYear()}-${`0${now.getMonth() + 1}`.slice(-2)}-${`0${now.getDate()}`.slice(-2)}`;
     const key = `${date}-${workflowId}}`;
@@ -256,7 +257,6 @@ class PluginWorkflowServer extends import_server.Plugin {
       (model, { transaction }) => this.toggle(model, false, { transaction })
     );
     this.app.on("afterStart", async () => {
-      this.app.setMaintainingMessage("check for not started executions");
       this.ready = true;
       const collection = db.getCollection("workflows");
       const workflows = await collection.repository.find({
@@ -266,8 +266,14 @@ class PluginWorkflowServer extends import_server.Plugin {
         this.toggle(workflow, true, { silent: true });
       });
       this.checker = setInterval(() => {
+        this.getLogger("dispatcher").info(`(cycling) check for queueing executions`);
         this.dispatch();
       }, 3e5);
+      this.app.on("workflow:dispatch", () => {
+        this.app.logger.info("workflow:dispatch");
+        this.dispatch();
+      });
+      this.getLogger("dispatcher").info("(starting) check for queueing executions");
       this.dispatch();
     });
     this.app.on("beforeStop", async () => {
@@ -323,10 +329,19 @@ class PluginWorkflowServer extends import_server.Plugin {
       logger.debug(`ignored event data:`, context);
       return;
     }
-    if (!options.manually && !workflow.enabled) {
+    if (!options.force && !options.manually && !workflow.enabled) {
       logger.warn(`workflow ${workflow.id} is not enabled, event will be ignored`);
       return;
     }
+    const duplicated = this.events.find(([w, c, { eventKey }]) => {
+      if (eventKey && options.eventKey) {
+        return eventKey === options.eventKey;
+      }
+    });
+    if (duplicated) {
+      logger.warn(`event of workflow ${workflow.id} is duplicated (${options.eventKey}), event will be ignored`);
+      return;
+    }
     if (context == null) {
       logger.warn(`workflow ${workflow.id} event data context is null, event will be ignored`);
       return;
@@ -340,9 +355,10 @@ class PluginWorkflowServer extends import_server.Plugin {
     logger.info(`new event triggered, now events: ${this.events.length}`);
     logger.debug(`event data:`, { context });
     if (this.events.length > 1) {
+      logger.info(`new event is pending to be prepared after previous preparation is finished`);
       return;
     }
-    setTimeout(this.prepare);
+    setImmediate(this.prepare);
   }
   async triggerSync(workflow, context, { deferred, ...options } = {}) {
     let execution;
@@ -367,33 +383,63 @@ class PluginWorkflowServer extends import_server.Plugin {
       `execution (${job.execution.id}) resuming from job (${job.id}) added to pending list`
     );
     this.pending.push([job.execution, job]);
+    if (this.executing) {
+      await this.executing;
+    }
     this.dispatch();
   }
   /**
    * Start a deferred execution
    * @experimental
    */
-  start(execution) {
+  async start(execution) {
     if (execution.status !== import_constants.EXECUTION_STATUS.STARTED) {
       return;
     }
+    this.getLogger(execution.workflowId).info(`starting deferred execution (${execution.id})`);
     this.pending.push([execution]);
+    if (this.executing) {
+      await this.executing;
+    }
     this.dispatch();
   }
-  createProcessor(execution, options = {}) {
-    return new import_Processor.default(execution, { ...options, plugin: this });
+  async validateEvent(workflow, context, options) {
+    const trigger = this.triggers.get(workflow.type);
+    const triggerValid = await trigger.validateEvent(workflow, context, options);
+    if (!triggerValid) {
+      return false;
+    }
+    const { stack } = options;
+    let valid = true;
+    if ((stack == null ? void 0 : stack.length) > 0) {
+      const existed = await workflow.countExecutions({
+        where: {
+          id: stack
+        },
+        transaction: options.transaction
+      });
+      const limitCount = workflow.options.stackLimit || 1;
+      if (existed >= limitCount) {
+        this.getLogger(workflow.id).warn(
+          `workflow ${workflow.id} has already been triggered in stacks executions (${stack}), and max call coont is ${limitCount}, newly triggering will be skipped.`
+        );
+        valid = false;
+      }
+    }
+    return valid;
   }
   async createExecution(workflow, context, options) {
+    var _a;
     const { deferred } = options;
     const transaction = await this.useDataSourceTransaction("main", options.transaction, true);
     const sameTransaction = options.transaction === transaction;
-    const trigger = this.triggers.get(workflow.type);
-    const valid = await trigger.validateEvent(workflow, context, { ...options, transaction });
+    const valid = await this.validateEvent(workflow, context, { ...options, transaction });
     if (!valid) {
       if (!sameTransaction) {
         await transaction.commit();
       }
-      return null;
+      (_a = options.onTriggerFail) == null ? void 0 : _a.call(options, workflow, context, options);
+      return Promise.reject(new Error("event is not valid"));
     }
     let execution;
     try {
@@ -402,6 +448,7 @@ class PluginWorkflowServer extends import_server.Plugin {
           context,
           key: workflow.key,
           eventKey: options.eventKey ?? (0, import_crypto.randomUUID)(),
+          stack: options.stack,
           status: deferred ? import_constants.EXECUTION_STATUS.STARTED : import_constants.EXECUTION_STATUS.QUEUEING
         },
         { transaction }
@@ -441,7 +488,7 @@ class PluginWorkflowServer extends import_server.Plugin {
     const event = this.events.shift();
     this.eventsCount = this.events.length;
     if (!event) {
-      this.getLogger("dispatcher").warn(`events queue is empty, no need to prepare`);
+      this.getLogger("dispatcher").info(`events queue is empty, no need to prepare`);
       return;
     }
     const logger = this.getLogger(event[0].id);
@@ -451,12 +498,16 @@ class PluginWorkflowServer extends import_server.Plugin {
       if ((execution == null ? void 0 : execution.status) === import_constants.EXECUTION_STATUS.QUEUEING && !this.executing && !this.pending.length) {
         this.pending.push([execution]);
       }
-    } catch (err) {
-      logger.error(`failed to create execution: ${err.message}`, err);
+    } catch (error) {
+      logger.error(`failed to create execution:`, { error });
     }
     if (this.events.length) {
       await this.prepare();
     } else {
+      this.getLogger("dispatcher").info("no more events need to be prepared, dispatching...");
+      if (this.executing) {
+        await this.executing;
+      }
       this.dispatch();
     }
   };
@@ -474,45 +525,64 @@ class PluginWorkflowServer extends import_server.Plugin {
     }
     this.executing = (async () => {
       let next = null;
-      try {
-        if (this.pending.length) {
-          next = this.pending.shift();
-          this.getLogger(next[0].workflowId).info(`pending execution (${next[0].id}) ready to process`);
-        } else {
-          const execution = await this.db.getRepository("executions").findOne({
-            filter: {
-              status: import_constants.EXECUTION_STATUS.QUEUEING,
-              "workflow.enabled": true,
-              "workflow.id": {
-                [import_database.Op.not]: null
-              }
+      if (this.pending.length) {
+        next = this.pending.shift();
+        this.getLogger(next[0].workflowId).info(`pending execution (${next[0].id}) ready to process`);
+      } else {
+        try {
+          await this.db.sequelize.transaction(
+            {
+              isolationLevel: this.db.options.dialect === "sqlite" ? [][0] : import_sequelize.Transaction.ISOLATION_LEVELS.REPEATABLE_READ
             },
-            appends: ["workflow"],
-            sort: "id"
-          });
-          if (execution) {
-            this.getLogger(execution.workflowId).info(`execution (${execution.id}) fetched from db`);
-            next = [execution];
-          }
-        }
-        if (next) {
-          await this.process(...next);
-        }
-      } finally {
-        this.executing = null;
-        if (next) {
-          this.dispatch();
+            async (transaction) => {
+              const execution = await this.db.getRepository("executions").findOne({
+                filter: {
+                  status: import_constants.EXECUTION_STATUS.QUEUEING,
+                  "workflow.enabled": true
+                },
+                sort: "id",
+                transaction
+              });
+              if (execution) {
+                this.getLogger(execution.workflowId).info(`execution (${execution.id}) fetched from db`);
+                await execution.update(
+                  {
+                    status: import_constants.EXECUTION_STATUS.STARTED
+                  },
+                  { transaction }
+                );
+                execution.workflow = this.enabledCache.get(execution.workflowId);
+                next = [execution];
+              } else {
+                this.getLogger("dispatcher").info(`no execution in db queued to process`);
+              }
+            }
+          );
+        } catch (error) {
+          this.getLogger("dispatcher").error(`fetching execution from db failed: ${error.message}`, { error });
         }
       }
+      if (next) {
+        await this.process(...next);
+      }
+      this.executing = null;
+      if (next || this.pending.length) {
+        this.getLogger("dispatcher").info(`last process finished, will do another dispatch`);
+        this.dispatch();
+      }
     })();
   }
+  createProcessor(execution, options = {}) {
+    return new import_Processor.default(execution, { ...options, plugin: this });
+  }
   async process(execution, job, options = {}) {
     var _a, _b;
+    const logger = this.getLogger(execution.workflowId);
     if (execution.status === import_constants.EXECUTION_STATUS.QUEUEING) {
       const transaction = await this.useDataSourceTransaction("main", options.transaction);
       await execution.update({ status: import_constants.EXECUTION_STATUS.STARTED }, { transaction });
+      logger.info(`queueing execution (${execution.id}) from pending list updated to started`);
     }
-    const logger = this.getLogger(execution.workflowId);
     const processor = this.createProcessor(execution, options);
     logger.info(`execution (${execution.id}) ${job ? "resuming" : "starting"}...`);
     try {
@@ -526,7 +596,7 @@ class PluginWorkflowServer extends import_server.Plugin {
     }
     return processor;
   }
-  async execute(workflow, context, options = {}) {
+  async execute(workflow, values, options = {}) {
     const trigger = this.triggers.get(workflow.type);
     if (!trigger) {
       throw new Error(`trigger type "${workflow.type}" of workflow ${workflow.id} is not registered`);
@@ -534,7 +604,7 @@ class PluginWorkflowServer extends import_server.Plugin {
     if (!trigger.execute) {
       throw new Error(`"execute" method of trigger ${workflow.type} is not implemented`);
     }
-    return trigger.execute(workflow, context, options);
+    return trigger.execute(workflow, values, options);
   }
   /**
    * @experimental

package/dist/server/actions/workflows.js

@@ -121,7 +121,10 @@ async function trigger(context, next) {
 }
 async function execute(context, next) {
   const plugin = context.app.pm.get(import_Plugin.default);
-  const { filterByTk, autoRevision } = context.action.params;
+  const { filterByTk, values, autoRevision } = context.action.params;
+  if (!values) {
+    return context.throw(400, "values is required");
+  }
   if (!filterByTk) {
     return context.throw(400, "filterByTk is required");
   }
@@ -137,7 +140,7 @@ async function execute(context, next) {
   const { executed } = workflow;
   let processor;
   try {
-    processor = await plugin.execute(workflow, context, { manually: true });
+    processor = await plugin.execute(workflow, values, { manually: true });
     if (!processor) {
       return context.throw(400, "workflow not triggered");
     }

package/dist/server/collections/executions.js

@@ -61,6 +61,14 @@ var executions_default = {
     {
       type: "integer",
       name: "status"
+    },
+    {
+      type: "json",
+      name: "stack"
+    },
+    {
+      type: "json",
+      name: "output"
     }
   ]
 };

package/dist/server/instructions/CreateInstruction.js

@@ -44,7 +44,7 @@ class CreateInstruction extends import__.Instruction {
     const created = await repository.create({
       ...options,
       context: {
-        stack: Array.from(new Set((processor.execution.context.stack ?? []).concat(processor.execution.id)))
+        stack: Array.from(new Set((processor.execution.stack ?? []).concat(processor.execution.id)))
       },
       transaction
     });

package/dist/server/instructions/DestroyInstruction.js

@@ -42,7 +42,7 @@ class DestroyInstruction extends import__.Instruction {
     const result = await repository.destroy({
       ...options,
       context: {
-        stack: Array.from(new Set((processor.execution.context.stack ?? []).concat(processor.execution.id)))
+        stack: Array.from(new Set((processor.execution.stack ?? []).concat(processor.execution.id)))
       },
       transaction: this.workflow.useDataSourceTransaction(dataSourceName, processor.transaction)
     });

package/dist/server/instructions/UpdateInstruction.js

@@ -42,7 +42,7 @@ class UpdateInstruction extends import__.Instruction {
     const result = await repository.update({
       ...options,
       context: {
-        stack: Array.from(new Set((processor.execution.context.stack ?? []).concat(processor.execution.id)))
+        stack: Array.from(new Set((processor.execution.stack ?? []).concat(processor.execution.id)))
       },
       transaction: this.workflow.useDataSourceTransaction(dataSourceName, processor.transaction)
     });

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

@@ -6,11 +6,10 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-import { Model, Transactionable } from '@nocobase/database';
+import { Model } from '@nocobase/database';
 import Trigger from '.';
 import type { WorkflowModel } from '../types';
 import type { EventOptions } from '../Plugin';
-import { Context } from '@nocobase/actions';
 export interface CollectionChangeTriggerConfig {
     collection: string;
     mode: number;
@@ -19,12 +18,13 @@ export interface CollectionChangeTriggerConfig {
 export default class CollectionTrigger extends Trigger {
     events: Map<any, any>;
     private static handler;
-    prepare(workflow: WorkflowModel, data: Model | Record<string, any>, options: any): Promise<{
+    prepare(workflow: WorkflowModel, data: Model | Record<string, any> | string | number, options: any): Promise<{
         data: any;
-        stack: any;
     }>;
     on(workflow: WorkflowModel): void;
     off(workflow: WorkflowModel): void;
-    validateEvent(workflow: WorkflowModel, context: any, options: Transactionable): Promise<boolean>;
-    execute(workflow: WorkflowModel, context: Context, options: EventOptions): Promise<void | import("..").Processor>;
+    execute(workflow: WorkflowModel, values: any, options: EventOptions): Promise<void | import("..").Processor>;
+    validateContext(values: any): {
+        data: string;
+    };
 }

package/dist/server/triggers/CollectionTrigger.js

@@ -74,17 +74,19 @@ class CollectionTrigger extends import__.default {
     if (!ctx) {
       return;
     }
+    const { stack } = options.context ?? {};
     if (workflow.sync) {
       await this.workflow.trigger(workflow, ctx, {
-        transaction
+        transaction,
+        stack
       });
     } else {
       if (transaction) {
         transaction.afterCommit(() => {
-          this.workflow.trigger(workflow, ctx);
+          this.workflow.trigger(workflow, ctx, { stack });
         });
       } else {
-        this.workflow.trigger(workflow, ctx);
+        this.workflow.trigger(workflow, ctx, { stack });
       }
     }
   }
@@ -95,13 +97,24 @@ class CollectionTrigger extends import__.default {
     const collection = collectionManager.getCollection(collectionName);
     const { transaction, context } = options;
     const { repository, filterTargetKey } = collection;
-    if (data instanceof import_database.Model && changed && changed.length && changed.filter((name) => {
+    let target = data;
+    let filterByTk;
+    let loadNeeded = false;
+    if (target && typeof target === "object") {
+      filterByTk = Array.isArray(filterTargetKey) ? (0, import_lodash.pick)(
+        target,
+        filterTargetKey.sort((a, b) => a.localeCompare(b))
+      ) : target[filterTargetKey];
+    } else {
+      filterByTk = target;
+      loadNeeded = true;
+    }
+    if (target instanceof import_database.Model && changed && changed.length && changed.filter((name) => {
       const field = collection.getField(name);
       return field && !["linkTo", "hasOne", "hasMany", "belongsToMany"].includes(field.options.type);
-    }).every((name) => !data.changedWithAssociations(getFieldRawName(collection, name)))) {
+    }).every((name) => !target.changedWithAssociations(getFieldRawName(collection, name)))) {
       return null;
     }
-    const filterByTk = Array.isArray(filterTargetKey) ? (0, import_lodash.pick)(data, filterTargetKey) : { [filterTargetKey]: data[filterTargetKey] };
     if ((0, import_utils.isValidFilter)(condition) && !(mode & MODE_BITMAP.DESTROY)) {
       const count = await repository.count({
         filterByTk,
@@ -113,22 +126,20 @@ class CollectionTrigger extends import__.default {
         return null;
       }
     }
-    let result = data;
-    if ((appends == null ? void 0 : appends.length) && !(mode & MODE_BITMAP.DESTROY)) {
+    if (loadNeeded || (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({
+      target = await repository.findOne({
         filterByTk,
         appends: Array.from(includeFields),
         transaction
       });
     }
     return {
-      data: (0, import_utils2.toJSON)(result),
-      stack: context == null ? void 0 : context.stack
+      data: (0, import_utils2.toJSON)(target)
     };
   }
   on(workflow) {
@@ -182,26 +193,27 @@ 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;
-  }
-  async execute(workflow, context, options) {
-    var _a;
-    const ctx = await this.prepare(workflow, (_a = context.action.params.values) == null ? void 0 : _a.data, options);
+  // async validateEvent(workflow: WorkflowModel, context: any, options: Transactionable): Promise<boolean> {
+  //   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;
+  // }
+  async execute(workflow, values, options) {
+    const ctx = await this.prepare(workflow, values == null ? void 0 : values.data, options);
     const [dataSourceName] = (0, import_data_source_manager.parseCollectionName)(workflow.config.collection);
     const { transaction } = options;
     return this.workflow.trigger(workflow, ctx, {
@@ -209,4 +221,12 @@ class CollectionTrigger extends import__.default {
       transaction: this.workflow.useDataSourceTransaction(dataSourceName, transaction)
     });
   }
+  validateContext(values) {
+    if (!values.data) {
+      return {
+        data: "Data is required"
+      };
+    }
+    return null;
+  }
 }

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

@@ -30,10 +30,14 @@ export default class DateFieldScheduleTrigger {
     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>[]>;
+    loadRecordsToSchedule({ id, 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;
+    execute(workflow: any, values: any, options: any): Promise<void | import("../..").Processor>;
+    validateContext(values: any): {
+        data: string;
+    };
 }

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

@@ -43,6 +43,7 @@ var import_database = require("@nocobase/database");
 var import_cron_parser = __toESM(require("cron-parser"));
 var import_utils = require("./utils");
 var import_data_source_manager = require("@nocobase/data-source-manager");
+var import_lodash = require("lodash");
 function getOnTimestampWithOffset({ field, offset = 0, unit = 1e3 }, now) {
   if (!field) {
     return null;
@@ -64,7 +65,7 @@ function getDataOptionTime(record, on, dir = 1) {
       if (!field || !record.get(field)) {
         return null;
       }
-      const second = new Date(record.get(field).getTime());
+      const second = new Date(record.get(field));
       second.setMilliseconds(0);
       return second.getTime() + offset * unit * dir;
     }
@@ -131,6 +132,7 @@ class DateFieldScheduleTrigger {
     const now = /* @__PURE__ */ new Date();
     workflows.forEach(async (workflow) => {
       const records = await this.loadRecordsToSchedule(workflow, now);
+      this.workflow.getLogger(workflow.id).info(`[Schedule on date field] ${records.length} records to schedule`);
       records.forEach((record) => {
         const nextTime = this.getRecordNextTime(workflow, record);
         this.schedule(workflow, record, nextTime, Boolean(nextTime));
@@ -144,17 +146,20 @@ class DateFieldScheduleTrigger {
   //   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) {
+  async loadRecordsToSchedule({ id, config: { collection, limit, startsOn, repeat, endsOn }, allExecuted }, currentDate) {
     const { dataSourceManager } = this.workflow.app;
     if (limit && allExecuted >= limit) {
+      this.workflow.getLogger(id).warn(`[Schedule on date field] limit reached (all executed ${allExecuted})`);
       return [];
     }
     if (!startsOn) {
+      this.workflow.getLogger(id).warn(`[Schedule on date field] "startsOn" is not configured`);
       return [];
     }
     const timestamp = currentDate.getTime();
     const startTimestamp = getOnTimestampWithOffset(startsOn, currentDate);
     if (!startTimestamp) {
+      this.workflow.getLogger(id).warn(`[Schedule on date field] "startsOn.field" is not configured`);
       return [];
     }
     const [dataSourceName, collectionName] = (0, import_data_source_manager.parseCollectionName)(collection);
@@ -181,7 +186,7 @@ class DateFieldScheduleTrigger {
           const modExp = (0, import_database.fn)(
             "MOD",
             (0, import_database.literal)(
-              `${Math.round(timestamp / 1e3)} - ${db.sequelize.getQueryInterface().quoteIdentifiers(tsFn(field))}`
+              `${Math.round(timestamp / 1e3)} - ${tsFn(db.sequelize.getQueryInterface().quoteIdentifiers(field))}`
             ),
             Math.round(repeat / 1e3)
           );
@@ -193,21 +198,21 @@ class DateFieldScheduleTrigger {
         }
       }
       if (endsOn) {
-        const now = /* @__PURE__ */ new Date();
-        const endTimestamp = getOnTimestampWithOffset(endsOn, now);
-        if (!endTimestamp) {
-          return [];
-        }
         if (typeof endsOn === "string") {
-          if (endTimestamp <= timestamp) {
+          if ((0, import_utils.parseDateWithoutMs)(endsOn) <= timestamp) {
             return [];
           }
         } else {
-          conditions.push({
-            [endsOn.field]: {
-              [import_database.Op.gte]: new Date(endTimestamp)
-            }
-          });
+          const endTimestamp = getOnTimestampWithOffset(endsOn, currentDate);
+          if (endTimestamp) {
+            conditions.push({
+              [endsOn.field]: {
+                [import_database.Op.gte]: new Date(endTimestamp)
+              }
+            });
+          } else {
+            this.workflow.getLogger(id).warn(`[Schedule on date field] "endsOn.field" is not configured`);
+          }
         }
       }
     } else {
@@ -217,6 +222,7 @@ class DateFieldScheduleTrigger {
         }
       });
     }
+    this.workflow.getLogger(id).debug(`[Schedule on date field] conditions: `, { conditions });
     return model.findAll({
       where: {
         [import_database.Op.and]: conditions
@@ -363,4 +369,37 @@ class DateFieldScheduleTrigger {
       this.events.delete(name);
     }
   }
+  async execute(workflow, values, options) {
+    var _a;
+    const [dataSourceName, collectionName] = (0, import_data_source_manager.parseCollectionName)(workflow.config.collection);
+    const { collectionManager } = this.workflow.app.dataSourceManager.dataSources.get(dataSourceName);
+    const { filterTargetKey, repository } = collectionManager.getCollection(collectionName);
+    let { data } = values;
+    let filterByTk;
+    let loadNeeded = false;
+    if (data && typeof data === "object") {
+      filterByTk = Array.isArray(filterTargetKey) ? (0, import_lodash.pick)(
+        data,
+        filterTargetKey.sort((a, b) => a.localeCompare(b))
+      ) : data[filterTargetKey];
+    } else {
+      filterByTk = data;
+      loadNeeded = true;
+    }
+    if (loadNeeded || ((_a = workflow.config.appends) == null ? void 0 : _a.length)) {
+      data = await repository.findOne({
+        filterByTk,
+        appends: workflow.config.appends
+      });
+    }
+    return this.workflow.trigger(workflow, { ...values, data, date: (values == null ? void 0 : values.date) ?? /* @__PURE__ */ new Date() }, options);
+  }
+  validateContext(values) {
+    if (!(values == null ? void 0 : values.data)) {
+      return {
+        data: "Data is required"
+      };
+    }
+    return null;
+  }
 }