@tachybase/plugin-workflow-approval 0.23.8

package/dist/server/actions/approvals.js

@@ -0,0 +1,275 @@
+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 approvals_exports = {};
+__export(approvals_exports, {
+  approvals: () => approvals
+});
+module.exports = __toCommonJS(approvals_exports);
+var import_actions = __toESM(require("@tachybase/actions"));
+var import_data_source = require("@tachybase/data-source");
+var import_database = require("@tachybase/database");
+var import_module_workflow = require("@tachybase/module-workflow");
+var import_status = require("../constants/status");
+var import_tools = require("../tools");
+const approvals = {
+  async create(context, next) {
+    const { status, collectionName, data, workflowId } = context.action.params.values ?? {};
+    const [dataSourceName, cName] = (0, import_data_source.parseCollectionName)(collectionName);
+    const dataSource = context.app.dataSourceManager.dataSources.get(dataSourceName);
+    if (!dataSource) {
+      return context.throw(400, `Data source "${dataSourceName}" not found`);
+    }
+    const collection = dataSource.collectionManager.getCollection(cName);
+    if (!collection) {
+      return context.throw(400, `Collection "${cName}" not found`);
+    }
+    const workflow = await context.db.getRepository("workflows").findOne({
+      filterByTk: workflowId
+    });
+    if (!(workflow == null ? void 0 : workflow.enabled)) {
+      return context.throw(400, "Current workflow not found or disabled, please refresh and try again");
+    }
+    if (status !== import_status.APPROVAL_STATUS.DRAFT) {
+      context.action.mergeParams({
+        values: {
+          status: import_status.APPROVAL_STATUS.SUBMITTED
+        }
+      });
+    }
+    const { repository, model } = collection;
+    const values = await repository.create({
+      values: {
+        ...(0, import_database.traverseJSON)(data, { collection }),
+        createdBy: context.state.currentUser.id,
+        updatedBy: context.state.currentUser.id
+      },
+      context
+    });
+    const instance = values.get();
+    const summary = (0, import_tools.getSummary)({
+      summaryConfig: workflow.config.summary,
+      data: {
+        ...instance,
+        ...data
+      }
+    });
+    Object.keys(model.associations).forEach((key) => {
+      delete instance[key];
+    });
+    context.action.mergeParams({
+      values: {
+        collectionName,
+        data: instance,
+        dataKey: values[collection.filterTargetKey],
+        workflowKey: workflow.key,
+        applicantRoleName: context.state.currentRole,
+        summary
+      }
+    });
+    return import_actions.default.create(context, next);
+  },
+  async update(context, next) {
+    const { collectionName, data, status, updateAssociationValues, summaryConfig } = context.action.params.values ?? {};
+    const [dataSourceName, cName] = (0, import_data_source.parseCollectionName)(collectionName);
+    const dataSource = context.app.dataSourceManager.dataSources.get(dataSourceName);
+    const collection = dataSource.collectionManager.getCollection(cName);
+    const [target] = await collection.repository.update({
+      filterByTk: data[collection.filterTargetKey],
+      values: data,
+      updateAssociationValues
+    });
+    const summary = (0, import_tools.getSummary)({
+      summaryConfig,
+      data
+    });
+    context.action.mergeParams({
+      values: {
+        status: status ?? import_status.APPROVAL_STATUS.SUBMITTED,
+        data,
+        applicantRoleName: context.state.currentRole,
+        summary
+      }
+    });
+    return import_actions.default.update(context, next);
+  },
+  // NOTE: 和 create 逻辑雷同, 但是 因为原本的 create 并非纯操作, 因此拷贝一份以便方便改动
+  async resubmit(context, next) {
+    const { status, collectionName, data, workflowId, collectionAppends } = context.action.params.values ?? {};
+    const [dataSourceName, cName] = (0, import_data_source.parseCollectionName)(collectionName);
+    const dataSource = context.app.dataSourceManager.dataSources.get(dataSourceName);
+    if (!dataSource) {
+      return context.throw(400, `Data source "${dataSourceName}" not found`);
+    }
+    const collection = dataSource.collectionManager.getCollection(cName);
+    if (!collection) {
+      return context.throw(400, `Collection "${cName}" not found`);
+    }
+    const workflow = await context.db.getRepository("workflows").findOne({
+      filterByTk: workflowId
+    });
+    if (!(workflow == null ? void 0 : workflow.enabled)) {
+      return context.throw(400, "Current workflow not found or disabled, please refresh and try again");
+    }
+    const { repository, model } = collection;
+    const values = await repository.create({
+      values: {
+        ...data,
+        createdBy: context.state.currentUser.id,
+        updatedBy: context.state.currentUser.id
+      },
+      context
+    });
+    const instance = values.get();
+    const valuesWithAppends = await repository.findOne({
+      filterByTk: values.id,
+      appends: [...collectionAppends]
+    });
+    const summary = (0, import_tools.getSummary)({
+      summaryConfig: workflow.config.summary,
+      data: valuesWithAppends
+    });
+    Object.keys(model.associations).forEach((key) => {
+      delete instance[key];
+    });
+    context.action.mergeParams({
+      values: {
+        collectionName,
+        data: instance,
+        dataKey: values[collection.filterTargetKey],
+        workflowKey: workflow.key,
+        applicantRoleName: context.state.currentRole,
+        summary
+      }
+    });
+    return import_actions.default.create(context, next);
+  },
+  async destroy(context, next) {
+    const {
+      filterByTk,
+      values: { status }
+    } = context.action.params ?? {};
+    if (status !== import_status.APPROVAL_STATUS.DRAFT) {
+      return context.throw(400);
+    }
+    const repository = import_actions.utils.getRepositoryFromParams(context);
+    const approval = await repository.findOne({
+      filterByTk,
+      filter: {
+        createdById: context.state.currentUser.id
+      }
+    });
+    if (!approval) {
+      return context.throw(404);
+    }
+    return import_actions.default.destroy(context, next);
+  },
+  async withdraw(context, next) {
+    var _a;
+    const { filterByTk } = context.action.params;
+    const repository = import_actions.utils.getRepositoryFromParams(context);
+    const approval = await repository.findOne({
+      filterByTk,
+      appends: ["workflow"],
+      except: ["workflow.options"]
+    });
+    if (!approval) {
+      return context.throw(404);
+    }
+    if (approval.createdById !== ((_a = context.state.currentUser) == null ? void 0 : _a.id)) {
+      return context.throw(403);
+    }
+    if (approval.status !== import_status.APPROVAL_STATUS.SUBMITTED || !approval.workflow.config.withdrawable) {
+      return context.throw(400);
+    }
+    const [execution] = await approval.getExecutions({
+      where: {
+        status: import_module_workflow.EXECUTION_STATUS.STARTED
+      },
+      limit: 1
+    });
+    execution.workflow = approval.workflow;
+    const jobs = await context.db.sequelize.transaction(async (transaction) => {
+      const records = await approval.getRecords({
+        where: {
+          executionId: execution.id
+        },
+        include: [
+          {
+            association: "job",
+            where: {
+              status: import_module_workflow.JOB_STATUS.PENDING
+            },
+            required: true
+          }
+        ],
+        transaction
+      });
+      await context.db.getRepository("approvalRecords").destroy({
+        filter: {
+          id: records.map((record) => record.id)
+        },
+        transaction
+      });
+      const jobsMap = records.reduce((map, record) => {
+        if (!map.has(record.job.id)) {
+          record.job.execution = execution;
+          record.job.latestUserJob = record.get();
+          record.job.latestUserJob.approval = approval;
+          map.set(record.job.id, record.job);
+        }
+        return map;
+      }, /* @__PURE__ */ new Map());
+      return Array.from(jobsMap.values());
+    });
+    context.body = approval;
+    context.status = 202;
+    await next();
+    await execution.update({
+      status: import_module_workflow.EXECUTION_STATUS.CANCELED
+    });
+  },
+  async listCentralized(context, next) {
+    const centralizedApprovalFlow = await context.db.getRepository("workflows").find({
+      filter: {
+        type: "approval",
+        "config.centralized": true
+      },
+      fields: ["id"]
+    });
+    context.action.mergeParams({
+      filter: {
+        workflowId: centralizedApprovalFlow.map((item) => item.id)
+      }
+    });
+    return await import_actions.default.list(context, next);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  approvals
+});

package/dist/server/actions/index.d.ts

@@ -0,0 +1,3 @@
+export declare function init({ app }: {
+    app: any;
+}): void;

package/dist/server/actions/index.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 actions_exports = {};
+__export(actions_exports, {
+  init: () => init
+});
+module.exports = __toCommonJS(actions_exports);
+var import_collection_name = require("../../common/collection-name");
+var import_approvalCarbonCopy = require("./approvalCarbonCopy");
+var import_approvalRecords = require("./approvalRecords");
+var import_approvals = require("./approvals");
+var import_workflows = require("./workflows");
+function make(name, mod) {
+  return Object.keys(mod).reduce(
+    (result, key) => ({
+      ...result,
+      [`${name}:${key}`]: mod[key]
+    }),
+    {}
+  );
+}
+function init({ app }) {
+  app.actions({
+    ...make("workflows", import_workflows.workflows),
+    ...make("approvals", import_approvals.approvals),
+    ...make("approvalRecords", import_approvalRecords.approvalRecords),
+    ...make(import_collection_name.COLLECTION_NAME_APPROVAL_CARBON_COPY, import_approvalCarbonCopy.approvalCarbonCopy)
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  init
+});

package/dist/server/actions/workflows.d.ts

@@ -0,0 +1,3 @@
+export declare const workflows: {
+    listApprovalFlows(context: any, next: any): Promise<void>;
+};

package/dist/server/actions/workflows.js

@@ -0,0 +1,49 @@
+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 workflows_exports = {};
+__export(workflows_exports, {
+  workflows: () => workflows
+});
+module.exports = __toCommonJS(workflows_exports);
+var import_actions = __toESM(require("@tachybase/actions"));
+const workflows = {
+  async listApprovalFlows(context, next) {
+    context.action.mergeParams({
+      filter: {
+        type: "approval",
+        enabled: true
+        // TODO: 仅显示当前用户有权限的流程
+      }
+    });
+    return import_actions.default.list(context, next);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  workflows
+});

package/dist/server/collections/approvalCarbonCopy.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@tachybase/database").CollectionOptions;
+export default _default;

package/dist/server/collections/approvalCarbonCopy.js

@@ -0,0 +1,87 @@
+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 approvalCarbonCopy_exports = {};
+__export(approvalCarbonCopy_exports, {
+  default: () => approvalCarbonCopy_default
+});
+module.exports = __toCommonJS(approvalCarbonCopy_exports);
+var import_database = require("@tachybase/database");
+var import_collection_name = require("../../common/collection-name");
+var approvalCarbonCopy_default = (0, import_database.defineCollection)({
+  namespace: "workflow.approvalCarbonCopy",
+  dumpRules: "required",
+  name: import_collection_name.COLLECTION_NAME_APPROVAL_CARBON_COPY,
+  createdBy: true,
+  updatedBy: true,
+  fields: [
+    {
+      type: "string",
+      name: "collectionName"
+    },
+    {
+      type: "string",
+      name: "index"
+    },
+    {
+      type: "string",
+      name: "dataKey"
+    },
+    {
+      type: "belongsTo",
+      name: "approval"
+    },
+    {
+      type: "integer",
+      name: "status"
+    },
+    {
+      type: "belongsTo",
+      name: "user",
+      target: "users"
+    },
+    {
+      type: "belongsTo",
+      name: "workflow",
+      onDelete: "CASCADE"
+    },
+    {
+      type: "belongsTo",
+      name: "execution"
+    },
+    {
+      type: "belongsTo",
+      name: "node",
+      target: "flow_nodes"
+    },
+    {
+      type: "belongsTo",
+      name: "job",
+      target: "jobs"
+    },
+    {
+      type: "jsonb",
+      name: "summary",
+      defaultValue: {}
+    },
+    {
+      type: "jsonb",
+      name: "snapshot",
+      defaultValue: {}
+    }
+  ]
+});

package/dist/server/collections/approvalExecutions.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@tachybase/database").CollectionOptions;
+export default _default;

package/dist/server/collections/approvalExecutions.js

@@ -0,0 +1,70 @@
+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 approvalExecutions_exports = {};
+__export(approvalExecutions_exports, {
+  default: () => approvalExecutions_default
+});
+module.exports = __toCommonJS(approvalExecutions_exports);
+var import_database = require("@tachybase/database");
+var approvalExecutions_default = (0, import_database.defineCollection)({
+  namespace: "workflow.approvalExecutions",
+  dumpRules: "required",
+  name: "approvalExecutions",
+  fields: [
+    {
+      type: "string",
+      name: "collectionName"
+    },
+    {
+      type: "bigInt",
+      name: "id",
+      primaryKey: true,
+      autoIncrement: true
+    },
+    {
+      type: "belongsTo",
+      name: "approval",
+      foreignKey: "approvalId",
+      primaryKey: false
+    },
+    {
+      type: "belongsTo",
+      name: "execution",
+      foreignKey: "executionId",
+      primaryKey: false
+    },
+    {
+      type: "integer",
+      name: "status"
+    },
+    {
+      type: "jsonb",
+      name: "snapshot"
+    },
+    {
+      type: "jsonb",
+      name: "summary",
+      defaultValue: {}
+    },
+    {
+      type: "hasMany",
+      name: "records",
+      target: "approvalRecords"
+    }
+  ]
+});

package/dist/server/collections/approvalRecords.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@tachybase/database").CollectionOptions;
+export default _default;

package/dist/server/collections/approvalRecords.js

@@ -0,0 +1,88 @@
+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 approvalRecords_exports = {};
+__export(approvalRecords_exports, {
+  default: () => approvalRecords_default
+});
+module.exports = __toCommonJS(approvalRecords_exports);
+var import_database = require("@tachybase/database");
+var approvalRecords_default = (0, import_database.defineCollection)({
+  namespace: "workflow.approvalRecords",
+  dumpRules: "required",
+  name: "approvalRecords",
+  createdBy: true,
+  fields: [
+    {
+      type: "string",
+      name: "collectionName"
+    },
+    {
+      type: "belongsTo",
+      name: "approval"
+    },
+    {
+      type: "belongsTo",
+      name: "approvalExecution"
+    },
+    {
+      type: "belongsTo",
+      name: "user",
+      target: "users"
+    },
+    {
+      type: "belongsTo",
+      name: "job",
+      target: "jobs"
+    },
+    {
+      type: "belongsTo",
+      name: "execution"
+    },
+    {
+      type: "belongsTo",
+      name: "node",
+      target: "flow_nodes"
+    },
+    {
+      type: "belongsTo",
+      name: "workflow"
+    },
+    {
+      type: "string",
+      name: "index"
+    },
+    {
+      type: "integer",
+      name: "status"
+    },
+    {
+      type: "jsonb",
+      name: "snapshot",
+      defaultValue: {}
+    },
+    {
+      type: "jsonb",
+      name: "summary",
+      defaultValue: {}
+    },
+    {
+      type: "text",
+      name: "comment"
+    }
+  ]
+});

package/dist/server/collections/approvals.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@tachybase/database").CollectionOptions;
+export default _default;