@nocobase/plugin-workflow 1.6.0-alpha.2 → 1.6.0-alpha.21

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,58 +525,78 @@ 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) {
-      await execution.update({ status: import_constants.EXECUTION_STATUS.STARTED }, { transaction: options.transaction });
+      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 {
       await (job ? processor.resume(job) : processor.start());
       logger.info(`execution (${execution.id}) finished with status: ${execution.status}`, { execution });
       if (execution.status && ((_b = (_a = execution.workflow.options) == null ? void 0 : _a.deleteExecutionOnStatus) == null ? void 0 : _b.includes(execution.status))) {
-        await execution.destroy();
+        await execution.destroy({ transaction: processor.mainTransaction });
       }
     } catch (err) {
       logger.error(`execution (${execution.id}) error: ${err.message}`, err);
     }
     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`);
@@ -533,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/Processor.d.ts

@@ -32,6 +32,10 @@ export default class Processor {
      * @experimental
      */
     transaction: Transaction;
+    /**
+     * @experimental
+     */
+    mainTransaction: Transaction;
     /**
      * @experimental
      */
@@ -105,6 +109,7 @@ export default class Processor {
         };
         $system: {};
         $scopes: {};
+        $env: {};
     };
     /**
      * @experimental

package/dist/server/Processor.js

@@ -66,6 +66,10 @@ class Processor {
    * @experimental
    */
   transaction;
+  /**
+   * @experimental
+   */
+  mainTransaction;
   /**
    * @experimental
    */
@@ -111,11 +115,12 @@ class Processor {
   async prepare() {
     const {
       execution,
-      transaction,
       options: { plugin }
     } = this;
+    this.mainTransaction = plugin.useDataSourceTransaction("main", this.transaction);
+    const transaction = this.mainTransaction;
     if (!execution.workflow) {
-      execution.workflow = plugin.enabledCache.get(execution.workflowId);
+      execution.workflow = plugin.enabledCache.get(execution.workflowId) || await execution.getWorkflow({ transaction });
     }
     const nodes = await execution.workflow.getNodes({ transaction });
     this.makeNodes(nodes);
@@ -154,7 +159,7 @@ class Processor {
       this.logger.debug(`config of node`, { data: node.config });
       job = await instruction(node, prevJob, this);
       if (!job) {
-        return null;
+        return this.exit();
       }
     } catch (err) {
       this.logger.error(
@@ -227,7 +232,10 @@ class Processor {
   async exit(s) {
     if (typeof s === "number") {
       const status = this.constructor.StatusMap[s] ?? Math.sign(s);
-      await this.execution.update({ status }, { transaction: this.transaction });
+      await this.execution.update({ status }, { transaction: this.mainTransaction });
+    }
+    if (this.mainTransaction && this.mainTransaction !== this.transaction) {
+      await this.mainTransaction.commit();
     }
     this.logger.info(`execution (${this.execution.id}) exiting with status ${this.execution.status}`);
     return null;
@@ -238,7 +246,7 @@ class Processor {
    */
   async saveJob(payload) {
     const { database } = this.execution.constructor;
-    const { transaction } = this;
+    const { mainTransaction: transaction } = this;
     const { model } = database.getCollection("jobs");
     let job;
     if (payload instanceof model) {
@@ -361,7 +369,8 @@ class Processor {
       $context: this.execution.context,
       $jobsMapByNodeKey: this.jobsMapByNodeKey,
       $system: systemFns,
-      $scopes
+      $scopes,
+      $env: this.options.plugin.app.environment.getVariables()
     };
   }
   /**

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

@@ -33,6 +33,7 @@ var executions_default = {
   dumpRules: {
     group: "log"
   },
+  migrationRules: ["schema-only"],
   name: "executions",
   shared: true,
   fields: [
@@ -61,6 +62,14 @@ var executions_default = {
     {
       type: "integer",
       name: "status"
+    },
+    {
+      type: "json",
+      name: "stack"
+    },
+    {
+      type: "json",
+      name: "output"
     }
   ]
 };

package/dist/server/collections/flow_nodes.js

@@ -31,6 +31,7 @@ __export(flow_nodes_exports, {
 module.exports = __toCommonJS(flow_nodes_exports);
 var flow_nodes_default = {
   dumpRules: "required",
+  migrationRules: ["overwrite", "schema-only"],
   name: "flow_nodes",
   shared: true,
   fields: [

package/dist/server/collections/jobs.js

@@ -33,6 +33,7 @@ var jobs_default = {
   dumpRules: {
     group: "log"
   },
+  migrationRules: ["schema-only"],
   name: "jobs",
   shared: true,
   fields: [

package/dist/server/collections/workflows.js

@@ -32,6 +32,7 @@ module.exports = __toCommonJS(workflows_exports);
 function workflows_default() {
   return {
     dumpRules: "required",
+    migrationRules: ["overwrite", "schema-only"],
     name: "workflows",
     shared: true,
     repository: "WorkflowRepository",

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