@tachybase/module-workflow 0.23.8

package/dist/server/features/omni-trigger/CustomActionTrigger.js

@@ -0,0 +1,270 @@
+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 CustomActionTrigger_exports = {};
+__export(CustomActionTrigger_exports, {
+  OmniTrigger: () => OmniTrigger
+});
+module.exports = __toCommonJS(CustomActionTrigger_exports);
+var import_data_source = require("@tachybase/data-source");
+var import_database = require("@tachybase/database");
+var import_module_error_handler = __toESM(require("@tachybase/module-error-handler"));
+var import_lodash = __toESM(require("lodash"));
+var import_constants = require("../../constants");
+var import_triggers = __toESM(require("../../triggers"));
+var import_utils = require("../../utils");
+class CustomActionInterceptionError extends Error {
+  status = 400;
+  messages = [];
+  constructor(message) {
+    super(message);
+    this.name = "CustomActionInterceptionError";
+  }
+}
+class OmniTrigger extends import_triggers.default {
+  static TYPE = "general-action";
+  constructor(workflow) {
+    super(workflow);
+    this.workflow.app.resourcer.registerActionHandler("trigger", this.triggerAction);
+    this.workflow.app.acl.allow("*", "trigger", "loggedIn");
+    this.workflow.app.pm.get(import_module_error_handler.default).errorHandler.register(
+      (err) => err instanceof CustomActionInterceptionError,
+      async (err, ctx) => {
+        ctx.body = {
+          errors: err.messages
+        };
+        ctx.status = err.status;
+      }
+    );
+    workflow.app.use(this.middleware, { tag: "workflowTrigger", after: "dataSource" });
+  }
+  triggerAction = async (context, next) => {
+    const {
+      params: { filterByTk, values, triggerWorkflows = "", filter, resourceName, actionName }
+    } = context.action;
+    if (actionName !== "trigger" || resourceName === "workflows") {
+      return next();
+    }
+    const { currentUser, currentRole } = context.state;
+    const { model: UserModel } = this.workflow.db.getCollection("users");
+    const userInfo = {
+      user: UserModel.build(currentUser).desensitize(),
+      roleName: currentRole
+    };
+    const dataSourceHeader = context.get("x-data-source");
+    const jointCollectionName = (0, import_data_source.joinCollectionName)(dataSourceHeader, resourceName);
+    const triggerWorkflowsMap = /* @__PURE__ */ new Map();
+    const triggerWorkflowsArray = [];
+    for (const trigger of triggerWorkflows.split(",")) {
+      const [key, path] = trigger.split("!");
+      triggerWorkflowsMap.set(key, path);
+      triggerWorkflowsArray.push(key);
+    }
+    const workflows = Array.from(this.workflow.enabledCache.values()).filter(
+      (item) => item.type === OmniTrigger.TYPE && item.config.collection === jointCollectionName && triggerWorkflowsArray.includes(item.key)
+    ).sort((a, b) => {
+      const aIndex = triggerWorkflowsArray.indexOf(a.key);
+      const bIndex = triggerWorkflowsArray.indexOf(b.key);
+      if (aIndex === -1 && bIndex === -1) {
+        return a.id - b.id;
+      }
+      if (aIndex === -1) {
+        return 1;
+      }
+      if (bIndex === -1) {
+        return -1;
+      }
+      return aIndex - bIndex;
+    });
+    const syncGroup = [];
+    const asyncGroup = [];
+    for (const workflow of workflows) {
+      const { appends = [] } = workflow.config;
+      const [dataSourceName, collectionName] = (0, import_data_source.parseCollectionName)(workflow.config.collection);
+      const dataPath = triggerWorkflowsMap.get(workflow.key);
+      const event = [workflow];
+      const { repository } = context.app.dataSourceManager.dataSources.get(dataSourceName).collectionManager.getCollection(collectionName);
+      const formData = dataPath ? import_lodash.default.get(values, dataPath) : values;
+      let data = formData;
+      if (filterByTk != null) {
+        if ((0, import_lodash.isArray)(filterByTk)) {
+          data = await repository.find({ filterByTk, appends });
+        } else {
+          data = await repository.findOne({ filterByTk, appends });
+        }
+        if (!data) {
+          continue;
+        }
+        Object.assign(data, formData);
+      } else if (filter != null) {
+        data = await repository.find({ filter, appends });
+        if (!data) {
+          continue;
+        }
+        Object.assign(data, formData);
+      }
+      event.push({ data: (0, import_utils.toJSON)(data), ...userInfo });
+      (workflow.sync ? syncGroup : asyncGroup).push(event);
+    }
+    for (const event of syncGroup) {
+      const processor = await this.workflow.trigger(event[0], event[1], { httpContext: context });
+      if (!processor) {
+        return context.throw(500);
+      }
+      const { lastSavedJob, nodesMap } = processor;
+      const lastNode = nodesMap.get(lastSavedJob == null ? void 0 : lastSavedJob.nodeId);
+      if (processor.execution.status === import_constants.EXECUTION_STATUS.RESOLVED) {
+        if ((lastNode == null ? void 0 : lastNode.type) === "end") {
+          return;
+        }
+        continue;
+      }
+      if (processor.execution.status < import_constants.EXECUTION_STATUS.STARTED) {
+        if ((lastNode == null ? void 0 : lastNode.type) !== "end") {
+          return context.throw(500, "Workflow on your action failed, please contact the administrator");
+        }
+        const err = new CustomActionInterceptionError("Request is intercepted by workflow");
+        err.status = 400;
+        err.messages = context.state.messages;
+        return context.throw(err.status, err);
+      }
+      return context.throw(500, "Workflow on your action hangs, please contact the administrator");
+    }
+    for (const event of asyncGroup) {
+      this.workflow.trigger(event[0], event[1]);
+    }
+    await next();
+  };
+  middleware = async (context, next) => {
+    const {
+      resourceName,
+      actionName,
+      params: { triggerWorkflows }
+    } = context.action;
+    if (resourceName === "workflows" && actionName === "trigger") {
+      return this.triggerAction(context, next);
+    }
+    await next();
+    if (!triggerWorkflows) {
+      return;
+    }
+    if (!["create", "update"].includes(actionName)) {
+      return;
+    }
+    return this.trigger(context);
+  };
+  async trigger(context) {
+    const { triggerWorkflows = "", values } = context.action.params;
+    const dataSourceHeader = context.get("x-data-source") || "main";
+    const { currentUser, currentRole } = context.state;
+    const { model: UserModel } = this.workflow.db.getCollection("users");
+    const userInfo = {
+      user: UserModel.build(currentUser).desensitize(),
+      roleName: currentRole
+    };
+    const triggers = triggerWorkflows.split(",").map((trigger) => trigger.split("!"));
+    const workflowRepo = this.workflow.db.getRepository("workflows");
+    const workflows = (await workflowRepo.find({
+      filter: {
+        key: triggers.map((trigger) => trigger[0]),
+        current: true,
+        type: "general-action",
+        enabled: true
+      }
+    })).filter((workflow) => Boolean(workflow.config.collection));
+    const syncGroup = [];
+    const asyncGroup = [];
+    for (const workflow of workflows) {
+      const { collection, appends = [] } = workflow.config;
+      const [dataSourceName, collectionName] = (0, import_data_source.parseCollectionName)(collection);
+      const trigger = triggers.find((trigger2) => trigger2[0] === workflow.key);
+      const event = [workflow];
+      if (context.action.resourceName !== "workflows") {
+        if (!context.body) {
+          continue;
+        }
+        if (dataSourceName !== dataSourceHeader) {
+          continue;
+        }
+        const { body: data } = context;
+        for (const row of Array.isArray(data) ? data : [data]) {
+          let payload = row;
+          if (trigger[1]) {
+            const paths = trigger[1].split(".");
+            for (const field of paths) {
+              if (payload.get(field)) {
+                payload = payload.get(field);
+              } else {
+                const association = (0, import_database.modelAssociationByKey)(payload, field);
+                payload = await payload[association.accessors.get]();
+              }
+            }
+          }
+          const model = payload.constructor;
+          if (payload instanceof import_database.Model) {
+            if (collectionName !== model.collection.name) {
+              continue;
+            }
+            if (appends.length) {
+              payload = await model.collection.repository.findOne({
+                filterByTk: payload.get(model.primaryKeyAttribute),
+                appends
+              });
+            }
+          }
+          event.push({ data: (0, import_utils.toJSON)(payload), ...userInfo });
+        }
+      } else {
+        const { model, repository } = context.app.dataSourceManager.dataSources.get(dataSourceName).collectionManager.getCollection(collectionName);
+        let data = trigger[1] ? (0, import_lodash.get)(values, trigger[1]) : values;
+        const pk = (0, import_lodash.get)(data, model.primaryKeyAttribute);
+        if (appends.length && pk != null) {
+          data = await repository.findOne({
+            filterByTk: pk,
+            appends
+          });
+        }
+        event.push({ data, ...userInfo });
+      }
+      (workflow.sync ? syncGroup : asyncGroup).push(event);
+    }
+    for (const event of syncGroup) {
+      await this.workflow.trigger(event[0], event[1], { httpContext: context });
+    }
+    for (const event of asyncGroup) {
+      this.workflow.trigger(event[0], event[1]);
+    }
+  }
+  on() {
+  }
+  off() {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OmniTrigger
+});

package/dist/server/features/omni-trigger/Plugin.d.ts

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

package/dist/server/features/omni-trigger/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, {
+  PluginOmniTrigger: () => PluginOmniTrigger
+});
+module.exports = __toCommonJS(Plugin_exports);
+var import_server = require("@tachybase/server");
+var import_Plugin = __toESM(require("../../Plugin"));
+var import_CustomActionTrigger = require("./CustomActionTrigger");
+class PluginOmniTrigger extends import_server.Plugin {
+  async load() {
+    const workflowPlugin = this.app.pm.get(import_Plugin.default);
+    workflowPlugin.registerTrigger("general-action", import_CustomActionTrigger.OmniTrigger);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginOmniTrigger
+});

package/dist/server/features/omni-trigger/index.d.ts

@@ -0,0 +1 @@
+export * from './Plugin';

package/dist/server/features/omni-trigger/index.js

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var omni_trigger_exports = {};
+module.exports = __toCommonJS(omni_trigger_exports);
+__reExport(omni_trigger_exports, require("./Plugin"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./Plugin")
+});

package/dist/server/features/parallel/ParallelInstruction.d.ts

@@ -0,0 +1,11 @@
+import { FlowNodeModel, Instruction, JobModel, Processor } from '../..';
+export declare const PARALLEL_MODE: {
+    readonly ALL: "all";
+    readonly ANY: "any";
+    readonly RACE: "race";
+    readonly ALL_SETTLED: "allSettled";
+};
+export default class extends Instruction {
+    run(node: FlowNodeModel, prevJob: JobModel, processor: Processor): Promise<any>;
+    resume(node: FlowNodeModel, branchJob: any, processor: Processor): Promise<any>;
+}

package/dist/server/features/parallel/ParallelInstruction.js

@@ -0,0 +1,137 @@
+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 ParallelInstruction_exports = {};
+__export(ParallelInstruction_exports, {
+  PARALLEL_MODE: () => PARALLEL_MODE,
+  default: () => ParallelInstruction_default
+});
+module.exports = __toCommonJS(ParallelInstruction_exports);
+var import__ = require("../..");
+const PARALLEL_MODE = {
+  ALL: "all",
+  ANY: "any",
+  RACE: "race",
+  ALL_SETTLED: "allSettled"
+};
+const Modes = {
+  [PARALLEL_MODE.ALL]: {
+    next(previous) {
+      return previous.status >= import__.JOB_STATUS.PENDING;
+    },
+    getStatus(result) {
+      const failedStatus = result.find((status) => status != null && status < import__.JOB_STATUS.PENDING);
+      if (typeof failedStatus !== "undefined") {
+        return failedStatus;
+      }
+      if (result.every((status) => status != null && status === import__.JOB_STATUS.RESOLVED)) {
+        return import__.JOB_STATUS.RESOLVED;
+      }
+      return import__.JOB_STATUS.PENDING;
+    }
+  },
+  [PARALLEL_MODE.ALL_SETTLED]: {
+    next(previous) {
+      return true;
+    },
+    getStatus(result) {
+      if (result.every((status) => status != null)) {
+        return import__.JOB_STATUS.RESOLVED;
+      }
+      return import__.JOB_STATUS.PENDING;
+    }
+  },
+  [PARALLEL_MODE.ANY]: {
+    next(previous) {
+      return previous.status <= import__.JOB_STATUS.PENDING;
+    },
+    getStatus(result) {
+      if (result.some((status) => status != null && status === import__.JOB_STATUS.RESOLVED)) {
+        return import__.JOB_STATUS.RESOLVED;
+      }
+      if (result.some((status) => status != null ? status === import__.JOB_STATUS.PENDING : true)) {
+        return import__.JOB_STATUS.PENDING;
+      }
+      return import__.JOB_STATUS.FAILED;
+    }
+  },
+  [PARALLEL_MODE.RACE]: {
+    next(previous) {
+      return previous.status === import__.JOB_STATUS.PENDING;
+    },
+    getStatus(result) {
+      if (result.some((status) => status != null && status === import__.JOB_STATUS.RESOLVED)) {
+        return import__.JOB_STATUS.RESOLVED;
+      }
+      const failedStatus = result.find((status) => status != null && status < import__.JOB_STATUS.PENDING);
+      if (typeof failedStatus !== "undefined") {
+        return failedStatus;
+      }
+      return import__.JOB_STATUS.PENDING;
+    }
+  }
+};
+class ParallelInstruction_default extends import__.Instruction {
+  async run(node, prevJob, processor) {
+    const branches = processor.getBranches(node);
+    const job = await processor.saveJob({
+      status: import__.JOB_STATUS.PENDING,
+      result: Array(branches.length).fill(null),
+      nodeId: node.id,
+      nodeKey: node.key,
+      upstreamId: (prevJob == null ? void 0 : prevJob.id) ?? null
+    });
+    const { mode = PARALLEL_MODE.ALL } = node.config;
+    await branches.reduce(
+      (promise, branch, i) => promise.then(async (previous) => {
+        if (i && !Modes[mode].next(previous)) {
+          return previous;
+        }
+        await processor.run(branch, job);
+        return processor.findBranchLastJob(branch, job);
+      }),
+      Promise.resolve()
+    );
+    return null;
+  }
+  async resume(node, branchJob, processor) {
+    const job = processor.findBranchParentJob(branchJob, node);
+    const { result, status } = job;
+    if (status !== import__.JOB_STATUS.PENDING) {
+      return processor.exit();
+    }
+    const jobNode = processor.nodesMap.get(branchJob.nodeId);
+    const branchStartNode = processor.findBranchStartNode(jobNode, node);
+    const branches = processor.getBranches(node);
+    const branchIndex = branches.indexOf(branchStartNode);
+    const { mode = PARALLEL_MODE.ALL } = node.config || {};
+    const newResult = [...result.slice(0, branchIndex), branchJob.status, ...result.slice(branchIndex + 1)];
+    job.set({
+      result: newResult,
+      status: Modes[mode].getStatus(newResult)
+    });
+    if (job.status === import__.JOB_STATUS.PENDING) {
+      await job.save();
+      return processor.exit();
+    }
+    return job;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PARALLEL_MODE
+});

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

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

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

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

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

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

package/dist/server/features/request/RequestInstruction.d.ts

@@ -0,0 +1,14 @@
+import { AxiosRequestConfig } from 'axios';
+import { FlowNodeModel, Instruction, Processor } from '../..';
+export interface Header {
+    name: string;
+    value: string;
+}
+export type RequestConfig = Pick<AxiosRequestConfig, 'url' | 'method' | 'params' | 'data' | 'timeout'> & {
+    headers: Array<Header>;
+    ignoreFail: boolean;
+};
+export default class extends Instruction {
+    run(node: FlowNodeModel, prevJob: any, processor: Processor): Promise<any>;
+    resume(node: FlowNodeModel, job: any, processor: Processor): Promise<any>;
+}