@tachybase/module-workflow 0.23.8

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

package/dist/server/features/sql/SQLInstruction.d.ts

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

package/dist/server/features/sql/SQLInstruction.js

@@ -0,0 +1,48 @@
+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 SQLInstruction_exports = {};
+__export(SQLInstruction_exports, {
+  default: () => SQLInstruction_default
+});
+module.exports = __toCommonJS(SQLInstruction_exports);
+var import__ = require("../..");
+class SQLInstruction_default extends import__.Instruction {
+  async run(node, input, processor) {
+    const { db } = this.workflow.app.dataSourceManager.dataSources.get(
+      node.config.dataSource || "main"
+    ).collectionManager;
+    if (!db) {
+      throw new Error(`type of data source "${node.config.dataSource}" is not database`);
+    }
+    const sql = processor.getParsedValue(node.config.sql || "", node.id).trim();
+    if (!sql) {
+      return {
+        status: import__.JOB_STATUS.RESOLVED
+      };
+    }
+    const result = await db.sequelize.query(sql, {
+      transaction: processor.transaction
+      // plain: true,
+      // model: db.getCollection(node.config.collection).model
+    });
+    return {
+      result,
+      status: import__.JOB_STATUS.RESOLVED
+    };
+  }
+}

package/dist/server/features/trigger-instruction/TriggerInstruction.d.ts

@@ -0,0 +1,15 @@
+import Instruction from '../../instructions';
+import Processor from '../../Processor';
+export declare class TriggerInstruction extends Instruction {
+    run(node: any, input: any, processor: Processor): Promise<{
+        status: -1;
+        result?: undefined;
+    } | {
+        status: 1;
+        result: any;
+    } | {
+        status: 0;
+        result?: undefined;
+    }>;
+    resume(node: any, prevJob: any, processor: Processor): Promise<any>;
+}

package/dist/server/features/trigger-instruction/TriggerInstruction.js

@@ -0,0 +1,71 @@
+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 TriggerInstruction_exports = {};
+__export(TriggerInstruction_exports, {
+  TriggerInstruction: () => TriggerInstruction
+});
+module.exports = __toCommonJS(TriggerInstruction_exports);
+var import_constants = require("../../constants");
+var import_instructions = __toESM(require("../../instructions"));
+class TriggerInstruction extends import_instructions.default {
+  async run(node, input, processor) {
+    const workflowKey = node.config.workflowKey;
+    const wfRepo = this.workflow.db.getRepository("workflows");
+    const wf = await wfRepo.findOne({ filter: { key: workflowKey, enabled: true } });
+    if (wf.sync) {
+      const p = await this.workflow.trigger(wf, input.result);
+      if (!p) {
+        return {
+          status: import_constants.JOB_STATUS.FAILED
+        };
+      }
+      const { lastSavedJob } = p;
+      return {
+        status: import_constants.JOB_STATUS.RESOLVED,
+        result: lastSavedJob == null ? void 0 : lastSavedJob.result
+      };
+    } else {
+      this.workflow.trigger(wf, input.result, {
+        parentNode: node.id,
+        parent: processor.execution
+      });
+      return {
+        status: import_constants.JOB_STATUS.PENDING
+      };
+    }
+  }
+  async resume(node, prevJob, processor) {
+    prevJob.set("result", prevJob.result);
+    prevJob.set("status", prevJob.status);
+    return prevJob;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TriggerInstruction
+});

package/dist/server/features/trigger-instruction/flownode-check.d.ts

@@ -0,0 +1,2 @@
+import { Context } from '@tachybase/actions';
+export declare function flownodeCheck(ctx: Context, next: any): Promise<any>;

package/dist/server/features/trigger-instruction/flownode-check.js

@@ -0,0 +1,114 @@
+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 flownode_check_exports = {};
+__export(flownode_check_exports, {
+  flownodeCheck: () => flownodeCheck
+});
+module.exports = __toCommonJS(flownode_check_exports);
+async function checkFlowNodeLoop(ctx, currentWorkflow, rootKey, includeRoot = true) {
+  var _a;
+  if (includeRoot && currentWorkflow.key === rootKey) {
+    return true;
+  }
+  const workflowNodes = currentWorkflow.nodes.filter((node) => node.type === "trigger-instruction");
+  if (!workflowNodes.length) {
+    return false;
+  }
+  if (workflowNodes.some((node) => {
+    var _a2;
+    return ((_a2 = node == null ? void 0 : node.config) == null ? void 0 : _a2.workflowKey) === rootKey;
+  })) {
+    return true;
+  }
+  for (const node of workflowNodes) {
+    if (!((_a = node == null ? void 0 : node.config) == null ? void 0 : _a.workflowKey)) {
+      continue;
+    }
+    const nodeWorkflow = await ctx.db.getRepository("workflows").findOne({
+      filter: {
+        key: node.config.workflowKey,
+        enabled: true
+      },
+      appends: ["nodes"]
+    });
+    if (!nodeWorkflow) {
+      continue;
+    }
+    const loop = await checkFlowNodeLoop(ctx, nodeWorkflow.toJSON(), rootKey);
+    if (loop) {
+      return true;
+    }
+  }
+}
+async function flownodeCheck(ctx, next) {
+  const { resourceName, actionName } = ctx.action;
+  if (resourceName === "flow_nodes" && actionName === "update") {
+    const { filterByTk, values } = ctx.action.params;
+    if (!values) {
+      return next();
+    }
+    const { config } = values;
+    if (!(config == null ? void 0 : config.workflowKey)) {
+      return next();
+    }
+    const node = await ctx.db.getRepository("flow_nodes").findOne({
+      filterByTk,
+      appends: ["workflow"]
+    });
+    if (!node) {
+      return next();
+    }
+    const currentWorkflow = await ctx.db.getRepository("workflows").findOne({
+      filter: {
+        key: config.workflowKey,
+        enabled: true
+      },
+      appends: ["nodes"]
+    });
+    if (!currentWorkflow) {
+      return next();
+    }
+    const loop = await checkFlowNodeLoop(ctx, currentWorkflow, node.workflow.key);
+    if (loop) {
+      ctx.throw(400, ctx.t("workflow loop!", { ns: "workflow" }));
+    }
+  } else if (resourceName === "workflows" && actionName === "update") {
+    const { filterByTk, values } = ctx.action.params;
+    if (!values) {
+      return next();
+    }
+    const { enabled } = values;
+    if (!enabled) {
+      return next();
+    }
+    const workflow = await ctx.db.getRepository("workflows").findOne({
+      filterByTk,
+      appends: ["nodes"]
+    });
+    const currentWorkflow = workflow.toJSON();
+    const loop = await checkFlowNodeLoop(ctx, currentWorkflow, currentWorkflow.key, false);
+    if (loop) {
+      ctx.throw(400, ctx.t("workflow loop!", { ns: "workflow" }));
+    }
+  }
+  return next();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  flownodeCheck
+});

package/dist/server/features/trigger-instruction/plugin.d.ts

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

package/dist/server/features/trigger-instruction/plugin.js

@@ -0,0 +1,37 @@
+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 plugin_exports = {};
+__export(plugin_exports, {
+  PluginTriggerInstruction: () => PluginTriggerInstruction
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_server = require("@tachybase/server");
+var import__ = require("../..");
+var import_flownode_check = require("./flownode-check");
+var import_TriggerInstruction = require("./TriggerInstruction");
+class PluginTriggerInstruction extends import_server.Plugin {
+  async load() {
+    const workflowPlugin = this.app.getPlugin(import__.PluginWorkflow);
+    workflowPlugin.registerInstruction("trigger-instruction", import_TriggerInstruction.TriggerInstruction);
+    this.app.acl.use(import_flownode_check.flownodeCheck);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginTriggerInstruction
+});

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

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

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

package/dist/server/features/variables/VariableInstruction.d.ts

@@ -0,0 +1,7 @@
+import Instruction from '../../instructions';
+export declare class VariablesInstruction extends Instruction {
+    run(node: any, prevJob: any, processor: any): Promise<{
+        status: 1;
+        result: any;
+    }>;
+}

package/dist/server/features/variables/VariableInstruction.js

@@ -0,0 +1,61 @@
+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 VariableInstruction_exports = {};
+__export(VariableInstruction_exports, {
+  VariablesInstruction: () => VariablesInstruction
+});
+module.exports = __toCommonJS(VariableInstruction_exports);
+var import_constants = require("../../constants");
+var import_instructions = __toESM(require("../../instructions"));
+class VariablesInstruction extends import_instructions.default {
+  async run(node, prevJob, processor) {
+    const { target, value } = node.config;
+    const result = processor.getParsedValue(value, node.id);
+    if (target) {
+      const targetNode = processor.nodes.find((item) => item.key === target);
+      if (!targetNode) {
+        throw new Error(`target node by key "${target}" is not found`);
+      }
+      await processor.saveJob({
+        status: import_constants.JOB_STATUS.RESOLVED,
+        result,
+        nodeId: targetNode.id,
+        nodeKey: target,
+        upstreamId: prevJob && prevJob.id || null
+      });
+    }
+    return {
+      status: import_constants.JOB_STATUS.RESOLVED,
+      result
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VariablesInstruction
+});

package/dist/server/features/variables/index.d.ts

@@ -0,0 +1 @@
+export { PluginVariables } from './Plugin';

package/dist/server/features/variables/index.js

@@ -0,0 +1,27 @@
+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 variables_exports = {};
+__export(variables_exports, {
+  PluginVariables: () => import_Plugin.PluginVariables
+});
+module.exports = __toCommonJS(variables_exports);
+var import_Plugin = require("./Plugin");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginVariables
+});

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

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

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

@@ -0,0 +1,109 @@
+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, {
+  PluginWebhook: () => PluginWebhook
+});
+module.exports = __toCommonJS(Plugin_exports);
+var import_path = __toESM(require("path"));
+var import_server = require("@tachybase/server");
+var import_lodash = __toESM(require("lodash"));
+var import_webhooks = require("./webhooks");
+class PluginWebhook extends import_server.Plugin {
+  async load() {
+    this.app.on("afterStart", async () => {
+      const webhooksRepo = this.db.getRepository("webhooks");
+      const resources = await webhooksRepo.find({
+        filter: {
+          enabled: true,
+          type: "resource"
+        }
+      });
+      for (const resourceDef of resources) {
+        if (!this.app.resourcer.isDefined(resourceDef.resourceName)) {
+          this.app.resourcer.define({ name: resourceDef.resourceName });
+        }
+        this.app.resourcer.getResource(resourceDef.resourceName).addAction(resourceDef.actionName, async (ctx) => {
+          const body = await new import_webhooks.WebhookController().action(ctx, resourceDef);
+          await new import_webhooks.WebhookController().triggerWorkflow(ctx, resourceDef, body);
+        });
+        this.app.acl.allow(resourceDef.resourceName, resourceDef.actionName, "loggedIn");
+      }
+    });
+    await this.db.import({
+      directory: import_path.default.resolve(__dirname, "collections")
+    });
+    this.app.resourcer.define({
+      name: "webhooks",
+      actions: {
+        trigger: new import_webhooks.WebhookController().getLink,
+        test: new import_webhooks.WebhookController().test
+      }
+    });
+    this.app.acl.allow("webhooks", ["trigger", "test"], "loggedIn");
+    const app = this.app;
+    this.app.acl.use(
+      async (ctx, next) => {
+        if (import_lodash.default.isEmpty(ctx.action.params)) {
+          await next();
+          return;
+        }
+        const { resourceName, actionName } = ctx.action;
+        const webhooksRepo = ctx.db.getRepository("webhooks");
+        const actions = await app.cache.wrap(
+          "webhooks",
+          async () => {
+            return await webhooksRepo.find({
+              filter: {
+                enabled: true,
+                type: "action"
+              }
+            });
+          },
+          30 * 60 * 1e3
+        );
+        const actionObj = {};
+        const actionList = actions.filter((action) => {
+          return resourceName === action["resourceName"] && actionName === action["actionName"];
+        });
+        for (const action of actionList) {
+          actionObj[action.id] = await new import_webhooks.WebhookController().action(ctx, action);
+        }
+        await next();
+        for (const action of actionList) {
+          await new import_webhooks.WebhookController().triggerWorkflow(ctx, action, actionObj[action.id]);
+        }
+      },
+      { tag: "api-webhook", after: "core" }
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginWebhook
+});

package/dist/server/features/webhook/index.d.ts

@@ -0,0 +1 @@
+export { PluginWebhook } from './Plugin';

package/dist/server/features/webhook/index.js

@@ -0,0 +1,27 @@
+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 webhook_exports = {};
+__export(webhook_exports, {
+  PluginWebhook: () => import_Plugin.PluginWebhook
+});
+module.exports = __toCommonJS(webhook_exports);
+var import_Plugin = require("./Plugin");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginWebhook
+});

package/dist/server/features/webhook/webhooks.d.ts

@@ -0,0 +1,9 @@
+import { Context } from '@tachybase/actions';
+export declare class WebhookController {
+    getLink(ctx: Context): Promise<never>;
+    test(ctx: Context): Promise<void>;
+    action(ctx: Context, action: {
+        code: string;
+    }): Promise<string>;
+    triggerWorkflow(ctx: any, action: any, body: any): Promise<void>;
+}