@tachybase/module-workflow 0.23.8

package/dist/server/features/_deprecated-js-parse/JSParse.instruction.js

@@ -0,0 +1,100 @@
+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 JSParse_instruction_exports = {};
+__export(JSParse_instruction_exports, {
+  JSParseInstruction: () => JSParseInstruction
+});
+module.exports = __toCommonJS(JSParse_instruction_exports);
+var import_crypto = __toESM(require("crypto"));
+var import_lodash = __toESM(require("lodash"));
+var import_qrcode = __toESM(require("qrcode"));
+var import__ = require("../..");
+class JSParseInstruction extends import__.Instruction {
+  async run(node, input, processor) {
+    const { source = "", JSCode = "", model } = node.config;
+    const data = processor.getParsedValue(source, node.id);
+    try {
+      const ctx = {
+        data,
+        body: {}
+      };
+      await evalSimulate(JSCode, {
+        ctx,
+        lib: {
+          JSON,
+          qrcode: import_qrcode.default,
+          crypto: import_crypto.default,
+          log: console.log
+        }
+      });
+      let result = ctx.body;
+      if (typeof result === "object" && result && (model == null ? void 0 : model.length)) {
+        if (Array.isArray(result)) {
+          result = result.map((item) => mapModel(item, model));
+        } else {
+          result = mapModel(result, model);
+        }
+      }
+      return {
+        result,
+        status: import__.JOB_STATUS.RESOLVED
+      };
+    } catch (err) {
+      return {
+        result: err.toString(),
+        status: import__.JOB_STATUS.ERROR
+      };
+    }
+  }
+}
+function mapModel(data, model) {
+  if (typeof data !== "object" || data === null) {
+    throw new Error("Invalid data: data should be a non-null object");
+  }
+  const result = model.reduce((acc, { path, alias }) => {
+    const key = alias ?? path.replace(/\./g, "_");
+    const value = import_lodash.default.get(data, path);
+    acc[key] = value;
+    return acc;
+  }, {});
+  return result;
+}
+async function evalSimulate(jsCode, { ctx, lib }) {
+  const AsyncFunction = async function() {
+  }.constructor;
+  return await new AsyncFunction("$root", `with($root) { ${jsCode}; }`)({
+    ctx,
+    // 允许用户覆盖，这个时候可以使用 _ctx
+    __ctx: ctx,
+    lib
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JSParseInstruction
+});

package/dist/server/features/_deprecated-js-parse/index.d.ts

@@ -0,0 +1 @@
+export { default } from './plugin';

package/dist/server/features/_deprecated-js-parse/index.js

@@ -0,0 +1,33 @@
+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 deprecated_js_parse_exports = {};
+__export(deprecated_js_parse_exports, {
+  default: () => import_plugin.default
+});
+module.exports = __toCommonJS(deprecated_js_parse_exports);
+var import_plugin = __toESM(require("./plugin"));

package/dist/server/features/_deprecated-js-parse/plugin.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from '@tachybase/server';
+export declare class PluginWorkflowJSParseServer extends Plugin {
+    load(): Promise<void>;
+}
+export default PluginWorkflowJSParseServer;

package/dist/server/features/_deprecated-js-parse/plugin.js

@@ -0,0 +1,48 @@
+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 plugin_exports = {};
+__export(plugin_exports, {
+  PluginWorkflowJSParseServer: () => PluginWorkflowJSParseServer,
+  default: () => plugin_default
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_server = require("@tachybase/server");
+var import__ = __toESM(require("../.."));
+var import_constants = require("../../../common/constants");
+var import_JSParse = require("./JSParse.instruction");
+class PluginWorkflowJSParseServer extends import_server.Plugin {
+  async load() {
+    const pluginWorkflow = this.app.pm.get(import__.default);
+    pluginWorkflow.registerInstruction(import_constants.NAMESPACE_INSTRUCTION_JS_PARSE, import_JSParse.JSParseInstruction);
+  }
+}
+var plugin_default = PluginWorkflowJSParseServer;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginWorkflowJSParseServer
+});

package/dist/server/features/_deprecated-json-parse/JSONParse.instruction.d.ts

@@ -0,0 +1,11 @@
+import { FlowNodeModel, Instruction, Processor } from '../..';
+export declare class JSONParseInstruction extends Instruction {
+    engine: (expression: any, scope: any) => Promise<any>;
+    run(node: FlowNodeModel, input: any, processor: Processor): Promise<{
+        result: any;
+        status: 1;
+    } | {
+        result: any;
+        status: -2;
+    }>;
+}

package/dist/server/features/_deprecated-json-parse/JSONParse.instruction.js

@@ -0,0 +1,81 @@
+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 JSONParse_instruction_exports = {};
+__export(JSONParse_instruction_exports, {
+  JSONParseInstruction: () => JSONParseInstruction
+});
+module.exports = __toCommonJS(JSONParse_instruction_exports);
+var import_jsonata = __toESM(require("jsonata"));
+var import_lodash = __toESM(require("lodash"));
+var import__ = require("../..");
+class JSONParseInstruction extends import__.Instruction {
+  engine = (expression, scope) => (0, import_jsonata.default)(expression).evaluate(scope);
+  async run(node, input, processor) {
+    const { source = "", expression = "", model } = node.config;
+    const data = processor.getParsedValue(source, node.id);
+    const query = this.engine;
+    try {
+      let result = data;
+      if (expression) {
+        result = query ? await query(expression, data) : data;
+      }
+      if (typeof result === "object" && result && (model == null ? void 0 : model.length)) {
+        if (Array.isArray(result)) {
+          result = result.map((item) => mapModel(item, model));
+        } else {
+          result = mapModel(result, model);
+        }
+      }
+      return {
+        result,
+        status: import__.JOB_STATUS.RESOLVED
+      };
+    } catch (err) {
+      return {
+        result: err.toString(),
+        status: import__.JOB_STATUS.ERROR
+      };
+    }
+  }
+}
+function mapModel(data, model) {
+  if (typeof data !== "object" || data === null) {
+    throw new Error("Invalid data: data should be a non-null object");
+  }
+  const result = model.reduce((acc, { path, alias }) => {
+    const key = alias || path.replace(/\./g, "_");
+    const value = import_lodash.default.get(data, path);
+    acc[key] = value;
+    return acc;
+  }, {});
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JSONParseInstruction
+});

package/dist/server/features/_deprecated-json-parse/index.d.ts

@@ -0,0 +1 @@
+export { default } from './plugin';

package/dist/server/features/_deprecated-json-parse/index.js

@@ -0,0 +1,33 @@
+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 deprecated_json_parse_exports = {};
+__export(deprecated_json_parse_exports, {
+  default: () => import_plugin.default
+});
+module.exports = __toCommonJS(deprecated_json_parse_exports);
+var import_plugin = __toESM(require("./plugin"));

package/dist/server/features/_deprecated-json-parse/plugin.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from '@tachybase/server';
+export declare class PluginWorkflowJSONParseServer extends Plugin {
+    load(): Promise<void>;
+}
+export default PluginWorkflowJSONParseServer;

package/dist/server/features/_deprecated-json-parse/plugin.js

@@ -0,0 +1,48 @@
+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 plugin_exports = {};
+__export(plugin_exports, {
+  PluginWorkflowJSONParseServer: () => PluginWorkflowJSONParseServer,
+  default: () => plugin_default
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_server = require("@tachybase/server");
+var import__ = __toESM(require("../.."));
+var import_constants = require("../../../common/constants");
+var import_JSONParse = require("./JSONParse.instruction");
+class PluginWorkflowJSONParseServer extends import_server.Plugin {
+  async load() {
+    const pluginWorkflow = this.app.pm.get(import__.default);
+    pluginWorkflow.registerInstruction(import_constants.NAMESPACE_INSTRUCTION_JSON_PARSE, import_JSONParse.JSONParseInstruction);
+  }
+}
+var plugin_default = PluginWorkflowJSONParseServer;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginWorkflowJSONParseServer
+});

package/dist/server/features/aggregate/AggregateInstruction.d.ts

@@ -0,0 +1,7 @@
+import { FlowNodeModel, Instruction, Processor } from '../..';
+export default class extends Instruction {
+    run(node: FlowNodeModel, input: any, processor: Processor): Promise<{
+        result: any;
+        status: 1;
+    }>;
+}

package/dist/server/features/aggregate/AggregateInstruction.js

@@ -0,0 +1,56 @@
+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 AggregateInstruction_exports = {};
+__export(AggregateInstruction_exports, {
+  default: () => AggregateInstruction_default
+});
+module.exports = __toCommonJS(AggregateInstruction_exports);
+var import_data_source = require("@tachybase/data-source");
+var import_database = require("@tachybase/database");
+var import__ = require("../..");
+const aggregators = {
+  count: "count",
+  sum: "sum",
+  avg: "avg",
+  min: "min",
+  max: "max"
+};
+class AggregateInstruction_default extends import__.Instruction {
+  async run(node, input, processor) {
+    const { aggregator, associated, collection, association = {}, params = {} } = node.config;
+    const options = processor.getParsedValue(params, node.id);
+    const [dataSourceName, collectionName] = (0, import_data_source.parseCollectionName)(collection);
+    const { collectionManager } = this.workflow.app.dataSourceManager.dataSources.get(dataSourceName);
+    const repo = associated ? collectionManager.getRepository(
+      `${association == null ? void 0 : association.associatedCollection}.${association.name}`,
+      processor.getParsedValue(association == null ? void 0 : association.associatedKey, node.id)
+    ) : collectionManager.getRepository(collectionName);
+    if (!options.dataType && aggregator === "avg") {
+      options.dataType = import_database.DataTypes.DOUBLE;
+    }
+    const result = await repo.aggregate({
+      ...options,
+      method: aggregators[aggregator]
+      // transaction: processor.transaction,
+    });
+    return {
+      result: options.dataType === import_database.DataTypes.DOUBLE ? Number(result) : result,
+      status: import__.JOB_STATUS.RESOLVED
+    };
+  }
+}

package/dist/server/features/aggregate/Plugin.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from '@tachybase/server';
+export declare class PluginAggregate extends Plugin {
+    load(): Promise<void>;
+}

package/dist/server/features/aggregate/Plugin.js

@@ -0,0 +1,45 @@
+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 Plugin_exports = {};
+__export(Plugin_exports, {
+  PluginAggregate: () => PluginAggregate
+});
+module.exports = __toCommonJS(Plugin_exports);
+var import_server = require("@tachybase/server");
+var import__ = __toESM(require("../.."));
+var import_AggregateInstruction = __toESM(require("./AggregateInstruction"));
+class PluginAggregate extends import_server.Plugin {
+  async load() {
+    const workflowPlugin = this.app.getPlugin(import__.default);
+    workflowPlugin.registerInstruction("aggregate", import_AggregateInstruction.default);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginAggregate
+});

package/dist/server/features/common/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const NOTICE_INSTRUCTION_NAMESPACE = "notice";
+export declare const COLLECTION_NOTICE_NAME = "workflowNotice";
+export declare const COLLECTION_NAME_APPROVAL_CARBON_COPY = "approvalCarbonCopy";
+export declare const COLLECTION_WORKFLOWS_NAME = "workflows";

package/dist/server/features/common/constants.js

@@ -0,0 +1,36 @@
+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 constants_exports = {};
+__export(constants_exports, {
+  COLLECTION_NAME_APPROVAL_CARBON_COPY: () => COLLECTION_NAME_APPROVAL_CARBON_COPY,
+  COLLECTION_NOTICE_NAME: () => COLLECTION_NOTICE_NAME,
+  COLLECTION_WORKFLOWS_NAME: () => COLLECTION_WORKFLOWS_NAME,
+  NOTICE_INSTRUCTION_NAMESPACE: () => NOTICE_INSTRUCTION_NAMESPACE
+});
+module.exports = __toCommonJS(constants_exports);
+const NOTICE_INSTRUCTION_NAMESPACE = "notice";
+const COLLECTION_NOTICE_NAME = "workflowNotice";
+const COLLECTION_NAME_APPROVAL_CARBON_COPY = "approvalCarbonCopy";
+const COLLECTION_WORKFLOWS_NAME = "workflows";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  COLLECTION_NAME_APPROVAL_CARBON_COPY,
+  COLLECTION_NOTICE_NAME,
+  COLLECTION_WORKFLOWS_NAME,
+  NOTICE_INSTRUCTION_NAMESPACE
+});

package/dist/server/features/delay/DelayInstruction.d.ts

@@ -0,0 +1,12 @@
+import WorkflowPlugin, { Instruction, Processor } from '../..';
+export default class extends Instruction {
+    workflow: WorkflowPlugin;
+    timers: Map<number, NodeJS.Timeout>;
+    constructor(workflow: WorkflowPlugin);
+    load: () => Promise<void>;
+    unload: () => void;
+    schedule(job: any): void;
+    trigger(job: any): Promise<void>;
+    run(node: any, prevJob: any, processor: Processor): Promise<any>;
+    resume(node: any, prevJob: any, processor: Processor): Promise<any>;
+}

package/dist/server/features/delay/DelayInstruction.js

@@ -0,0 +1,106 @@
+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 DelayInstruction_exports = {};
+__export(DelayInstruction_exports, {
+  default: () => DelayInstruction_default
+});
+module.exports = __toCommonJS(DelayInstruction_exports);
+var import__ = require("../..");
+class DelayInstruction_default extends import__.Instruction {
+  constructor(workflow) {
+    super(workflow);
+    this.workflow = workflow;
+    workflow.app.on("afterStart", this.load);
+    workflow.app.on("beforeStop", this.unload);
+  }
+  timers = /* @__PURE__ */ new Map();
+  load = async () => {
+    const { model } = this.workflow.app.db.getCollection("jobs");
+    const jobs = await model.findAll({
+      where: {
+        status: import__.JOB_STATUS.PENDING
+      },
+      include: [
+        {
+          association: "execution",
+          attributes: [],
+          where: {
+            status: import__.EXECUTION_STATUS.STARTED
+          },
+          required: true
+        },
+        {
+          association: "node",
+          attributes: ["config"],
+          where: {
+            type: "delay"
+          },
+          required: true
+        }
+      ]
+    });
+    jobs.forEach((job) => {
+      this.schedule(job);
+    });
+  };
+  unload = () => {
+    for (const timer of this.timers.values()) {
+      clearTimeout(timer);
+    }
+    this.timers = /* @__PURE__ */ new Map();
+  };
+  schedule(job) {
+    const now = /* @__PURE__ */ new Date();
+    const createdAt = Date.parse(job.createdAt);
+    const delay = createdAt + job.node.config.duration - now.getTime();
+    if (delay > 0) {
+      const trigger = this.trigger.bind(this, job);
+      this.timers.set(job.id, setTimeout(trigger, delay));
+    } else {
+      this.trigger(job);
+    }
+  }
+  async trigger(job) {
+    if (!job.execution) {
+      job.execution = await job.getExecution();
+    }
+    if (job.execution.status === import__.EXECUTION_STATUS.STARTED) {
+      this.workflow.resume(job);
+    }
+    if (this.timers.get(job.id)) {
+      this.timers.delete(job.id);
+    }
+  }
+  async run(node, prevJob, processor) {
+    const job = await processor.saveJob({
+      status: import__.JOB_STATUS.PENDING,
+      result: null,
+      nodeId: node.id,
+      nodeKey: node.key,
+      upstreamId: (prevJob == null ? void 0 : prevJob.id) ?? null
+    });
+    job.node = node;
+    this.schedule(job);
+    return processor.exit();
+  }
+  async resume(node, prevJob, processor) {
+    const { endStatus } = node.config;
+    prevJob.set("status", endStatus);
+    return prevJob;
+  }
+}

package/dist/server/features/delay/Plugin.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from '@tachybase/server';
+export declare class PluginDelay extends Plugin {
+    load(): Promise<void>;
+}