@tachybase/plugin-workflow-approval 0.23.8

package/dist/server/instructions/tools.js

@@ -0,0 +1,139 @@
+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 tools_exports = {};
+__export(tools_exports, {
+  ApprovalJobStatusMap: () => ApprovalJobStatusMap,
+  getNegotiationMode: () => getNegotiationMode,
+  parseAssignees: () => parseAssignees
+});
+module.exports = __toCommonJS(tools_exports);
+var import_module_workflow = require("@tachybase/module-workflow");
+var import_status = require("../constants/status");
+const NEGOTIATION_MODE = {
+  SINGLE: Symbol("single"),
+  ALL: Symbol("all"),
+  ANY: Symbol("any"),
+  PERCENTAGE: Symbol("percentage")
+};
+const JobStatusMap = {
+  [import_status.APPROVAL_ACTION_STATUS.PENDING]: import_module_workflow.JOB_STATUS.PENDING,
+  [import_status.APPROVAL_ACTION_STATUS.APPROVED]: import_module_workflow.JOB_STATUS.RESOLVED,
+  [import_status.APPROVAL_ACTION_STATUS.REJECTED]: import_module_workflow.JOB_STATUS.REJECTED,
+  [import_status.APPROVAL_ACTION_STATUS.RETURNED]: import_module_workflow.JOB_STATUS.RETRY_NEEDED
+};
+const ApprovalJobStatusMap = {
+  [import_module_workflow.JOB_STATUS.PENDING]: import_status.APPROVAL_ACTION_STATUS.PENDING,
+  [import_module_workflow.JOB_STATUS.RESOLVED]: import_status.APPROVAL_ACTION_STATUS.APPROVED,
+  [import_module_workflow.JOB_STATUS.REJECTED]: import_status.APPROVAL_ACTION_STATUS.REJECTED,
+  [import_module_workflow.JOB_STATUS.RETRY_NEEDED]: import_status.APPROVAL_ACTION_STATUS.RETURNED,
+  [import_module_workflow.JOB_STATUS.CANCELED]: import_status.APPROVAL_ACTION_STATUS.CANCELED
+};
+const Modes = {
+  [NEGOTIATION_MODE.SINGLE]: {
+    getStatus(distribution, assignees, mode) {
+      const done = distribution.find((item) => item.status !== import_status.APPROVAL_ACTION_STATUS.PENDING && item.count > 0);
+      return done ? JobStatusMap[done.status] : null;
+    }
+  },
+  [NEGOTIATION_MODE.ALL]: {
+    getStatus(distribution, assignees, mode) {
+      const rejected = distribution.find(
+        (item) => [import_status.APPROVAL_ACTION_STATUS.REJECTED, import_status.APPROVAL_ACTION_STATUS.RETURNED].includes(item.status)
+      );
+      if (rejected && rejected.count) {
+        return JobStatusMap[rejected.status];
+      }
+      const approved = distribution.find((item) => item.status === import_status.APPROVAL_ACTION_STATUS.APPROVED);
+      if (approved && approved.count === assignees.length) {
+        return import_module_workflow.JOB_STATUS.RESOLVED;
+      }
+      return null;
+    }
+  },
+  [NEGOTIATION_MODE.ANY]: {
+    getStatus(distribution, assignees, mode) {
+      const returned = distribution.find((item) => item.status === import_status.APPROVAL_ACTION_STATUS.RETURNED);
+      if (returned && returned.count) {
+        return import_module_workflow.JOB_STATUS.RETRY_NEEDED;
+      }
+      const approved = distribution.find((item) => item.status === import_status.APPROVAL_ACTION_STATUS.APPROVED);
+      if (approved && approved.count) {
+        return import_status.APPROVAL_ACTION_STATUS.APPROVED;
+      }
+      const rejectedCount = distribution.reduce(
+        (count, item) => item.status === import_status.APPROVAL_ACTION_STATUS.REJECTED ? count + item.count : count,
+        0
+      );
+      if (rejectedCount === assignees.length) {
+        return import_module_workflow.JOB_STATUS.REJECTED;
+      }
+      return null;
+    }
+  },
+  [NEGOTIATION_MODE.PERCENTAGE]: {
+    getStatus(distribution, assignees, mode) {
+      const returned = distribution.find((item) => item.status === import_status.APPROVAL_ACTION_STATUS.RETURNED);
+      if (returned && returned.count) {
+        return import_module_workflow.JOB_STATUS.RETRY_NEEDED;
+      }
+      const approved = distribution.find((item) => item.status === import_status.APPROVAL_ACTION_STATUS.APPROVED);
+      if (approved && approved.count / assignees.length > mode) {
+        return import_module_workflow.JOB_STATUS.RESOLVED;
+      }
+      const rejected = distribution.find((item) => item.status === import_status.APPROVAL_ACTION_STATUS.REJECTED);
+      if (rejected && rejected.count / assignees.length >= 1 - mode) {
+        return import_module_workflow.JOB_STATUS.REJECTED;
+      }
+      return null;
+    }
+  }
+};
+function getNegotiationMode(mode) {
+  switch (true) {
+    case mode === 1:
+      return Modes[NEGOTIATION_MODE.ALL];
+    case (0 < mode && mode < 1):
+      return Modes[NEGOTIATION_MODE.PERCENTAGE];
+    default:
+      return Modes[NEGOTIATION_MODE.SINGLE];
+  }
+}
+async function parseAssignees(node, processor) {
+  const configAssignees = processor.getParsedValue(node.config.assignees ?? [], node.id).flat().filter(Boolean);
+  const assignees = /* @__PURE__ */ new Set();
+  const UserRepo = processor.options.plugin.app.db.getRepository("users");
+  for (const item of configAssignees) {
+    if (typeof item === "object") {
+      const result = await UserRepo.find({
+        ...item,
+        fields: ["id"],
+        transaction: processor.transaction
+      });
+      result.forEach((item2) => assignees.add(item2.id));
+    } else {
+      assignees.add(item);
+    }
+  }
+  return [...assignees];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApprovalJobStatusMap,
+  getNegotiationMode,
+  parseAssignees
+});

package/dist/server/plugin.d.ts

@@ -0,0 +1,12 @@
+import { Plugin } from '@tachybase/server';
+export declare class PluginWorkflowApproval extends Plugin {
+    workflow: any;
+    afterAdd(): void;
+    beforeLoad(): void;
+    load(): Promise<void>;
+    install(options: any): Promise<void>;
+    afterEnable(): Promise<void>;
+    afterDisable(): Promise<void>;
+    remove(): Promise<void>;
+}
+export default PluginWorkflowApproval;

package/dist/server/plugin.js

@@ -0,0 +1,89 @@
+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, {
+  PluginWorkflowApproval: () => PluginWorkflowApproval,
+  default: () => plugin_default
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_path = __toESM(require("path"));
+var import_module_workflow = require("@tachybase/module-workflow");
+var import_server = require("@tachybase/server");
+var import_collection_name = require("../common/collection-name");
+var import_actions = require("./actions");
+var import_Approval = __toESM(require("./instructions/Approval"));
+var import_ApprovalCarbonCopy = __toESM(require("./instructions/ApprovalCarbonCopy"));
+var import_Approval2 = __toESM(require("./triggers/Approval"));
+class PluginWorkflowApproval extends import_server.Plugin {
+  workflow;
+  afterAdd() {
+  }
+  beforeLoad() {
+    this.app.on("afterLoadPlugin", (plugin) => {
+      if (!(plugin instanceof import_module_workflow.PluginWorkflow)) {
+        return;
+      }
+      this.workflow = plugin;
+      plugin.triggers.register("approval", new import_Approval2.default(plugin));
+      plugin.instructions.register("approval", new import_Approval.default(plugin));
+      plugin.instructions.register(import_collection_name.COLLECTION_NAME_APPROVAL_CARBON_COPY, new import_ApprovalCarbonCopy.default(plugin));
+    });
+  }
+  async load() {
+    const { db } = this;
+    db.addMigrations({
+      namespace: "approval",
+      directory: import_path.default.resolve(__dirname, "migrations"),
+      context: {
+        plugin: this
+      }
+    });
+    await db.import({
+      directory: import_path.default.resolve(__dirname, "collections")
+    });
+    (0, import_actions.init)(this);
+    this.app.acl.allow("workflows", ["listApprovalFlows"], "loggedIn");
+    this.app.acl.allow("approvals", "*", "loggedIn");
+    this.app.acl.allow("approvalExecutions", ["get"], "loggedIn");
+    this.app.acl.allow("approvalRecords", ["get", "list", "listCentralized", "submit"], "loggedIn");
+    this.app.acl.allow(import_collection_name.COLLECTION_NAME_APPROVAL_CARBON_COPY, ["get", "list", "listCentralized", "submit"], "loggedIn");
+  }
+  async install(options) {
+  }
+  async afterEnable() {
+  }
+  async afterDisable() {
+  }
+  async remove() {
+  }
+}
+var plugin_default = PluginWorkflowApproval;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginWorkflowApproval
+});

package/dist/server/tools.d.ts

@@ -0,0 +1,11 @@
+interface ParamsType {
+    summaryConfig: Array<string>;
+    data: object;
+}
+export declare function getSummary(params: ParamsType): object;
+export declare function parsePerson({ node, processor, keyName }: {
+    node: any;
+    processor: any;
+    keyName: any;
+}): Promise<unknown[]>;
+export {};

package/dist/server/tools.js

@@ -0,0 +1,70 @@
+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 tools_exports = {};
+__export(tools_exports, {
+  getSummary: () => getSummary,
+  parsePerson: () => parsePerson
+});
+module.exports = __toCommonJS(tools_exports);
+var import_lodash = __toESM(require("lodash"));
+function getSummary(params) {
+  const { summaryConfig = [], data } = params;
+  const result = summaryConfig.reduce((summary, key) => {
+    const value = import_lodash.default.get(data, key);
+    const realValue = Object.prototype.toString.call(value) === "[object Object]" ? value == null ? void 0 : value["name"] : value;
+    return {
+      ...summary,
+      [key]: realValue
+    };
+  }, {});
+  return result;
+}
+async function parsePerson({ node, processor, keyName }) {
+  var _a;
+  const configPerson = processor.getParsedValue(((_a = node.config) == null ? void 0 : _a[keyName]) ?? [], node.id).flat().filter(Boolean);
+  const targetPerson = /* @__PURE__ */ new Set();
+  const UserRepo = processor.options.plugin.app.db.getRepository("users");
+  for (const item of configPerson) {
+    if (typeof item === "object") {
+      const users = await UserRepo.find({
+        ...item,
+        fields: ["id"],
+        transaction: processor.transaction
+      });
+      users.forEach((userData) => targetPerson.add(userData.id));
+    } else {
+      targetPerson.add(item);
+    }
+  }
+  return [...targetPerson];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getSummary,
+  parsePerson
+});

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

@@ -0,0 +1,23 @@
+import { Trigger } from '@tachybase/module-workflow';
+export default class ApprovalTrigger extends Trigger {
+    static TYPE: string;
+    sync: boolean;
+    triggerHandler: (approval: any, { transaction }: {
+        transaction: any;
+    }) => Promise<void>;
+    onExecutionCreate: (execution: any, { transaction }: {
+        transaction: any;
+    }) => Promise<void>;
+    onExecutionUpdate: (execution: any, { transaction }: {
+        transaction: any;
+    }) => Promise<void>;
+    middleware: (context: any, next: any) => Promise<any>;
+    constructor(workflow: any);
+    workflowTriggerAction(context: any, next: any): Promise<any>;
+    collectionTriggerAction(context: any): Promise<void>;
+    on(workflow: any): void;
+    off(workflow: any): void;
+    duplicateConfig(workflow: any, { transaction }: {
+        transaction: any;
+    }): Promise<any>;
+}

package/dist/server/triggers/Approval.js

@@ -0,0 +1,313 @@
+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 Approval_exports = {};
+__export(Approval_exports, {
+  default: () => ApprovalTrigger
+});
+module.exports = __toCommonJS(Approval_exports);
+var import_data_source = require("@tachybase/data-source");
+var import_database = require("@tachybase/database");
+var import_module_workflow = require("@tachybase/module-workflow");
+var import_lodash = require("lodash");
+var import_sequelize = require("sequelize");
+var import_status = require("../constants/status");
+var import_tools = require("../tools");
+var import_tools2 = require("./tools");
+class ApprovalTrigger extends import_module_workflow.Trigger {
+  static TYPE = "approval";
+  sync = false;
+  triggerHandler = async (approval, { transaction }) => {
+    const workflow = await approval.getWorkflow({
+      where: {
+        id: approval.get("workflowId"),
+        type: ApprovalTrigger.TYPE,
+        enabled: true,
+        "config.collection": approval.collectionName
+      },
+      transaction
+    });
+    const isChangedStatus = approval.changed("status");
+    const isAllowStatusList = [import_status.APPROVAL_STATUS.DRAFT, import_status.APPROVAL_STATUS.SUBMITTED, import_status.APPROVAL_STATUS.RESUBMIT].includes(
+      approval.status
+    );
+    const previousApprovalStatus = approval.previous("status");
+    const currentApprovalStatus = approval.status;
+    const forbiddenList = [[import_status.APPROVAL_STATUS.SUBMITTED, import_status.APPROVAL_STATUS.DRAFT]];
+    const isForbiddenWhenStatusChange = forbiddenList.some(
+      ([prev, curr]) => prev === previousApprovalStatus && curr === currentApprovalStatus
+    );
+    if (!workflow || !isChangedStatus || !isAllowStatusList || isForbiddenWhenStatusChange) {
+      return;
+    }
+    const [dataSourceName, collectionName] = (0, import_data_source.parseCollectionName)(approval.collectionName);
+    const { repository } = this.workflow.app.dataSourceManager.dataSources.get(dataSourceName).collectionManager.getCollection(collectionName);
+    const data = await repository.findOne({
+      filterByTk: approval.get("dataKey"),
+      appends: workflow.config.appends,
+      transaction: this.workflow.useDataSourceTransaction(dataSourceName, transaction)
+    });
+    this.workflow.trigger(
+      workflow,
+      {
+        data: (0, import_module_workflow.toJSON)(data),
+        approvalId: approval.id,
+        applicantRoleName: approval.applicantRoleName,
+        summary: (0, import_tools.getSummary)({
+          summaryConfig: workflow.config.summary,
+          data
+        }),
+        collectionName: approval.collectionName
+      },
+      { transaction }
+    );
+  };
+  onExecutionCreate = async (execution, { transaction }) => {
+    const workflow = await execution.getWorkflow({ transaction });
+    if (workflow.type !== ApprovalTrigger.TYPE) {
+      return;
+    }
+    const { approvalId, data, summary, collectionName } = execution.context;
+    const ApprovalExecutionRepo = this.workflow.db.getRepository("approvalExecutions");
+    const approvalExecution = await ApprovalExecutionRepo.create({
+      values: {
+        approvalId,
+        executionId: execution.id,
+        status: execution.status,
+        snapshot: data,
+        summary,
+        collectionName
+      },
+      transaction
+    });
+    const ApprovalsRepo = this.workflow.db.getRepository("approvals");
+    await ApprovalsRepo.update({
+      filterByTk: approvalId,
+      values: { latestExecutionId: approvalExecution.id },
+      transaction
+    });
+  };
+  onExecutionUpdate = async (execution, { transaction }) => {
+    if (!execution.workflow) {
+      execution.workflow = await execution.getWorkflow({ transaction });
+    }
+    if (!execution.status || execution.workflow.type !== ApprovalTrigger.TYPE) {
+      return;
+    }
+    const approvalExecution = await this.workflow.db.getRepository("approvalExecutions").findOne({
+      filter: {
+        executionId: execution.id,
+        approvalId: execution.context.approvalId
+      },
+      appends: ["approval"],
+      transaction
+    });
+    const { approval } = approvalExecution;
+    if (![import_status.APPROVAL_STATUS.SUBMITTED, import_status.APPROVAL_STATUS.PROCESSING].includes(approval.status)) {
+      return;
+    }
+    let status = import_status.APPROVAL_STATUS.APPROVED;
+    if (execution.status === import_module_workflow.EXECUTION_STATUS.RESOLVED) {
+      const [approvalNodeJob] = await execution.getJobs({
+        where: {
+          status: {
+            [import_sequelize.Op.ne]: import_module_workflow.JOB_STATUS.PENDING
+          }
+        },
+        include: [
+          {
+            association: "node",
+            where: {
+              type: "approval"
+            },
+            required: true
+          }
+        ],
+        order: [["updatedAt", "DESC"]],
+        limit: 1,
+        transaction
+      });
+      if (approvalNodeJob && import_tools2.ApprovalJobStatusMap[approvalNodeJob.result] != null) {
+        status = import_tools2.ApprovalJobStatusMap[approvalNodeJob.result];
+      }
+    } else {
+      if (import_tools2.ExecutionStatusMap[execution.status] != null) {
+        status = import_tools2.ExecutionStatusMap[execution.status];
+      }
+    }
+    await approval.update({ status }, { transaction });
+    await approvalExecution.update({ status: execution.status }, { transaction });
+  };
+  middleware = async (context, next) => {
+    if (!context.action) {
+      return;
+    }
+    const {
+      resourceName,
+      actionName,
+      params: { triggerWorkflows }
+    } = context.action;
+    if (resourceName === "workflows" && actionName === "trigger") {
+      return this.workflowTriggerAction(context, next);
+    }
+    await next();
+    if (!triggerWorkflows || !["create", "update"].includes(actionName)) {
+      return;
+    }
+    this.collectionTriggerAction(context);
+  };
+  constructor(workflow) {
+    super(workflow);
+    const { db } = workflow.app;
+    db.on("approvals.afterSave", this.triggerHandler);
+    db.on("executions.afterCreate", this.onExecutionCreate);
+    db.on("executions.afterUpdate", this.onExecutionUpdate);
+    workflow.app.use(this.middleware, { tag: "workflow-trigger", after: "dataSource" });
+  }
+  async workflowTriggerAction(context, next) {
+    const { triggerWorkflows, values } = context.action.params;
+    if (!triggerWorkflows) {
+      return context.throw(400);
+    }
+    const triggers = triggerWorkflows.split(",").map((trigger) => trigger.split("!"));
+    const workflowRepo = this.workflow.db.getRepository("workflows");
+    const workflows = await workflowRepo.find({
+      filter: {
+        type: ApprovalTrigger.TYPE,
+        key: triggers.map((trigger) => trigger[0]),
+        current: true,
+        enabled: true
+      }
+    });
+    context.status = 202;
+    await next();
+    workflows.forEach(async (workflow) => {
+      const trigger = triggers.find((trigger2) => trigger2[0] === workflow.key);
+      const [dataSourceName, collectionName] = (0, import_data_source.parseCollectionName)(workflow.config.collection);
+      const collecton = this.workflow.app.dataSourceManager.dataSources.get(dataSourceName).collectionManager.getCollection(collectionName);
+      const data = await collecton.repository.create({
+        values: {
+          ...trigger[1] ? (0, import_lodash.get)(values, trigger[1]) : values
+          // createdBy: currentUser.id,
+          // updatedById: currentUser.id,
+        },
+        context
+      });
+      const approvalRepo = this.workflow.db.getRepository("approvals");
+      await approvalRepo.create({
+        values: {
+          collectionName: workflow.config.collection,
+          data: (0, import_module_workflow.toJSON)(data),
+          dataKey: data.get(collecton.filterTargetKey),
+          status: import_status.APPROVAL_STATUS.SUBMITTED,
+          // createdBy: currentUser.id,
+          // updatedById: currentUser.id,
+          workflowId: workflow.id,
+          workflowKey: workflow.key,
+          summary: (0, import_tools.getSummary)({
+            summaryConfig: workflow.config.summary,
+            data
+          })
+        },
+        context
+      });
+    });
+  }
+  async collectionTriggerAction(context) {
+    const { triggerWorkflows = "" } = context.action.params;
+    const dataSourceHeader = context.get("x-data-source") || "main";
+    const approvalRepo = this.workflow.db.getRepository("approvals");
+    const triggers = triggerWorkflows.split(",").map((trigger) => trigger.split("!"));
+    const triggersKeysMap = new Map(triggers);
+    const workflows = Array.from(this.workflow.enabledCache.values()).filter(
+      (item) => item.type === ApprovalTrigger.TYPE && triggersKeysMap.has(item.key)
+    );
+    for (const workflow of workflows) {
+      const [dataSourceName, collectionName] = (0, import_data_source.parseCollectionName)(workflow.config.collection);
+      const trigger = triggers.find((trigger2) => trigger2[0] === workflow.key);
+      const { body: data } = context;
+      if (!data) {
+        return;
+      }
+      if (dataSourceName !== dataSourceHeader) {
+        continue;
+      }
+      (Array.isArray(data) ? data : [data]).forEach(async (row) => {
+        let dataCurrent = {};
+        if (row.id) {
+          const { repository } = this.workflow.app.dataSourceManager.dataSources.get(dataSourceName).collectionManager.getCollection(collectionName);
+          dataCurrent = await repository.findOne({
+            filterByTk: data.id,
+            appends: [...workflow.config.appends]
+          });
+        }
+        let payload = row;
+        if (trigger[1]) {
+          const paths = trigger[1].split(".");
+          for await (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 collection = context.app.dataSourceManager.dataSources.get(dataSourceName).collectionManager.getCollection(collectionName);
+        if (!collection || collection.model !== payload.constructor) {
+          return;
+        }
+        await approvalRepo.create({
+          values: {
+            collectionName: workflow.config.collection,
+            data: (0, import_module_workflow.toJSON)(payload),
+            dataKey: payload.get(collection.filterTargetKey),
+            status: import_status.APPROVAL_STATUS.SUBMITTED,
+            // createdBy: currentUser.id,
+            // updatedBy: currentUser.id,
+            workflowId: workflow.id,
+            workflowKey: workflow.key,
+            applicantRoleName: context.state.currentRole,
+            summary: (0, import_tools.getSummary)({
+              summaryConfig: workflow.config.summary,
+              data: dataCurrent
+            })
+          },
+          context
+        });
+      });
+    }
+  }
+  on(workflow) {
+  }
+  off(workflow) {
+  }
+  async duplicateConfig(workflow, { transaction }) {
+    const { db } = this.workflow;
+    const uiSchemaRepo = db.getRepository("uiSchemas");
+    if (!workflow.config.applyForm) {
+      return workflow.config;
+    }
+    const result = await uiSchemaRepo.duplicate(workflow.config.applyForm, {
+      transaction
+    });
+    return {
+      ...workflow.config,
+      applyForm: result["x-uid"]
+    };
+  }
+}

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

@@ -0,0 +1,12 @@
+export declare const ExecutionStatusMap: {
+    1: number;
+    [-5]: number;
+    [-4]: number;
+    [-6]: number;
+    [-1]: number;
+    [-2]: number;
+    [-3]: number;
+};
+export declare const ApprovalJobStatusMap: {
+    [x: number]: number;
+};