@tachybase/plugin-workflow-approval 1.5.1 → 1.6.1

package/dist/server/actions/approvals.js

@@ -26,69 +26,48 @@ var import_constants = require("../../common/constants");
 var import_status = require("../constants/status");
 var import_tools = require("../tools");
 const approvals = {
-  async create(context, next) {
-    const { status, collectionName, data, workflowId, workflowKey } = context.action.params.values ?? {};
+  async create(ctx, next) {
+    const { status, collectionName, data, workflowId, workflowKey } = ctx.action.params.values ?? {};
     const [dataSourceName, cName] = (0, import_server.parseCollectionName)(collectionName);
-    const dataSource = context.app.dataSourceManager.dataSources.get(dataSourceName);
+    const dataSource = ctx.tego.dataSourceManager.dataSources.get(dataSourceName);
     if (!dataSource) {
-      return context.throw(400, `Data source "${dataSourceName}" not found`);
+      return ctx.throw(400, `Data source "${dataSourceName}" not found`);
     }
     const collection = dataSource.collectionManager.getCollection(cName);
     if (!collection) {
-      return context.throw(400, `Collection "${cName}" not found`);
+      return ctx.throw(400, `Collection "${cName}" not found`);
     }
     let workflow;
     if (workflowKey) {
-      workflow = await context.db.getRepository("workflows").findOne({
+      workflow = await ctx.db.getRepository("workflows").findOne({
         filter: {
           key: workflowKey,
           enabled: true
         }
       });
     } else {
-      workflow = await context.db.getRepository("workflows").findOne({
+      workflow = await ctx.db.getRepository("workflows").findOne({
         filterByTk: workflowId
       });
     }
     if (!workflow) {
-      return context.throw(400, "Current workflow not found or disabled, please refresh and try again");
+      return ctx.throw(400, "Current workflow not found or disabled, please refresh and try again");
     }
     if (status !== import_status.APPROVAL_STATUS.DRAFT) {
-      context.action.mergeParams({
+      ctx.action.mergeParams({
         values: {
           status: import_status.APPROVAL_STATUS.SUBMITTED
         }
       });
     }
     const { repository, model } = collection;
-    let dataToCreate = (0, import_server.traverseJSON)(data, { collection });
-    if (workflowKey) {
-      Object.values(collection.model.associations || {}).forEach((assocUnknown) => {
-        var _a, _b;
-        const assoc = assocUnknown;
-        if (assoc.foreignKey && Object.prototype.hasOwnProperty.call(dataToCreate, assoc.foreignKey)) {
-          delete dataToCreate[assoc.foreignKey];
-        }
-        if (assoc.associationType === "BelongsToMany" && assoc.as && Array.isArray(dataToCreate[assoc.as])) {
-          const targetKey = assoc.targetKey && typeof assoc.targetKey === "string" ? assoc.targetKey : (
-            // fallback: 一般为 target model 的主键
-            ((_a = assoc.target) == null ? void 0 : _a.primaryKeyAttribute) || ((_b = assoc.target) == null ? void 0 : _b.primaryKey) || "id"
-          );
-          dataToCreate[assoc.as].forEach((item) => {
-            if (item && typeof item === "object" && Object.prototype.hasOwnProperty.call(item, targetKey)) {
-              delete item[targetKey];
-            }
-          });
-        }
-      });
-    }
     const values = await repository.create({
       values: {
-        ...dataToCreate,
-        createdBy: context.state.currentUser.id,
-        updatedBy: context.state.currentUser.id
+        ...(0, import_server.traverseJSON)(data, { collection }),
+        createdBy: ctx.state.currentUser.id,
+        updatedBy: ctx.state.currentUser.id
       },
-      context
+      context: ctx
     });
     const instance = values.get();
     const summary = (0, import_tools.getSummary)({
@@ -96,28 +75,30 @@ const approvals = {
       data: {
         ...instance,
         ...data
-      }
+      },
+      collection,
+      app: ctx.tego
     });
     Object.keys(model.associations).forEach((key) => {
       delete instance[key];
     });
-    context.action.mergeParams({
+    ctx.action.mergeParams({
       values: {
         collectionName,
         data: instance,
         dataKey: values[collection.filterTargetKey],
         workflowKey: workflow.key,
         workflowId: workflow.id,
-        applicantRoleName: context.state.currentRole,
+        applicantRoleName: ctx.state.currentRole,
         summary
       }
     });
-    return import_server.actions.create(context, next);
+    return import_server.actions.create(ctx, next);
   },
-  async update(context, next) {
-    const { collectionName, data, status, updateAssociationValues, summaryConfig } = context.action.params.values ?? {};
+  async update(ctx, next) {
+    const { collectionName, data, status, updateAssociationValues, summaryConfig } = ctx.action.params.values ?? {};
     const [dataSourceName, cName] = (0, import_server.parseCollectionName)(collectionName);
-    const dataSource = context.app.dataSourceManager.dataSources.get(dataSourceName);
+    const dataSource = ctx.tego.dataSourceManager.dataSources.get(dataSourceName);
     const collection = dataSource.collectionManager.getCollection(cName);
     const [target] = await collection.repository.update({
       filterByTk: data[collection.filterTargetKey],
@@ -126,55 +107,57 @@ const approvals = {
     });
     const summary = (0, import_tools.getSummary)({
       summaryConfig,
-      data
+      data,
+      collection,
+      app: ctx.tego
     });
-    context.action.mergeParams({
+    ctx.action.mergeParams({
       values: {
         status: status ?? import_status.APPROVAL_STATUS.SUBMITTED,
         data,
-        applicantRoleName: context.state.currentRole,
+        applicantRoleName: ctx.state.currentRole,
         summary
       }
     });
-    return import_server.actions.update(context, next);
+    return import_server.actions.update(ctx, next);
   },
-  async destroy(context, next) {
+  async destroy(ctx, next) {
     const {
       filterByTk,
       values: { status }
-    } = context.action.params ?? {};
+    } = ctx.action.params ?? {};
     if (status !== import_status.APPROVAL_STATUS.DRAFT) {
-      return context.throw(400);
+      return ctx.throw(400);
     }
-    const repository = import_server.utils.getRepositoryFromParams(context);
+    const repository = import_server.utils.getRepositoryFromParams(ctx);
     const approval = await repository.findOne({
       filterByTk,
       filter: {
-        createdById: context.state.currentUser.id
+        createdById: ctx.state.currentUser.id
       }
     });
     if (!approval) {
-      return context.throw(404);
+      return ctx.throw(404);
     }
-    return import_server.actions.destroy(context, next);
+    return import_server.actions.destroy(ctx, next);
   },
-  async withdraw(context, next) {
+  async withdraw(ctx, next) {
     var _a, _b;
-    const { filterByTk } = context.action.params;
-    const repository = import_server.utils.getRepositoryFromParams(context);
+    const { filterByTk } = ctx.action.params;
+    const repository = import_server.utils.getRepositoryFromParams(ctx);
     const approval = await repository.findOne({
       filterByTk,
       appends: ["workflow"],
       except: ["workflow.options"]
     });
     if (!approval) {
-      return context.throw(404);
+      return ctx.throw(404);
     }
-    if (approval.createdById !== ((_a = context.state.currentUser) == null ? void 0 : _a.id)) {
-      return context.throw(403);
+    if (approval.createdById !== ((_a = ctx.state.currentUser) == null ? void 0 : _a.id)) {
+      return ctx.throw(403);
     }
     if (approval.status !== import_status.APPROVAL_STATUS.SUBMITTED || !approval.workflow.config.withdrawable) {
-      return context.throw(400);
+      return ctx.throw(400);
     }
     const [execution] = await approval.getExecutions({
       where: {
@@ -183,10 +166,10 @@ const approvals = {
       limit: 1
     });
     if (!execution) {
-      return context.throw(404, "Execution not found! Please contact the administrator.");
+      return ctx.throw(404, "Execution not found! Please contact the administrator.");
     }
     if (!approval.workflow.enabled && ((_b = approval.workflow) == null ? void 0 : _b.key)) {
-      const latestWorkflow = await context.db.getRepository("workflows").findOne({
+      const latestWorkflow = await ctx.db.getRepository("workflows").findOne({
         filter: {
           key: approval.workflow.key,
           enabled: true
@@ -200,13 +183,13 @@ const approvals = {
             workflowId: latestWorkflow.id
           },
           {
-            transaction: context.transaction
+            transaction: ctx.transaction
           }
         );
       }
     }
     execution.workflow = approval.workflow;
-    await context.db.sequelize.transaction(async (transaction) => {
+    await ctx.db.sequelize.transaction(async (transaction) => {
       const records = await approval.getRecords({
         where: {
           executionId: execution.id
@@ -222,7 +205,7 @@ const approvals = {
         ],
         transaction
       });
-      await context.db.getRepository("approvalRecords").destroy({
+      await ctx.db.getRepository("approvalRecords").destroy({
         filter: {
           id: records.map((record) => record.id)
         },
@@ -239,52 +222,52 @@ const approvals = {
       }, /* @__PURE__ */ new Map());
       return Array.from(jobsMap.values());
     });
-    context.body = approval;
-    context.status = 202;
+    ctx.body = approval;
+    ctx.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({
+  async listCentralized(ctx, next) {
+    const centralizedApprovalFlow = await ctx.db.getRepository("workflows").find({
       filter: {
         type: "approval",
         "config.centralized": true
       },
       fields: ["id"]
     });
-    context.action.mergeParams({
+    ctx.action.mergeParams({
       filter: {
         workflowId: centralizedApprovalFlow.map((item) => item.id)
       }
     });
-    return await import_server.actions.list(context, next);
+    return await import_server.actions.list(ctx, next);
   },
-  async reminder(context, next) {
+  async reminder(ctx, next) {
     var _a, _b, _c;
-    const { filterByTk } = context.action.params;
-    const repository = import_server.utils.getRepositoryFromParams(context);
+    const { filterByTk } = ctx.action.params;
+    const repository = import_server.utils.getRepositoryFromParams(ctx);
     const approval = await repository.findOne({
       filterByTk,
       appends: ["records", "workflow", "createdBy.nickname"]
     });
     if (!approval) {
-      return context.throw(404);
+      return ctx.throw(404);
     }
-    if (approval.createdById !== ((_a = context.state.currentUser) == null ? void 0 : _a.id)) {
-      return context.throw(403);
+    if (approval.createdById !== ((_a = ctx.state.currentUser) == null ? void 0 : _a.id)) {
+      return ctx.throw(403);
     }
     if ([import_status.APPROVAL_STATUS.APPROVED, import_status.APPROVAL_STATUS.REJECTED, import_status.APPROVAL_STATUS.ERROR].includes(approval.status)) {
-      return context.throw(400);
+      return ctx.throw(400);
     }
     if (((_b = approval.records) == null ? void 0 : _b.length) === 0) {
-      return context.throw(400);
+      return ctx.throw(400);
     }
     const assignees = approval.records.map((record) => record.userId);
     for (const userId of assignees) {
       const [dataSourceName] = (0, import_server.parseCollectionName)(approval.collectionName);
-      const collection = context.app.dataSourceManager.dataSources.get(dataSourceName).collectionManager.getCollection(approval.collectionName);
+      const collection = ctx.tego.dataSourceManager.dataSources.get(dataSourceName).collectionManager.getCollection(approval.collectionName);
       const message = {
         userId,
         title: `{{t("Approval", { ns: '${import_constants.NAMESPACE}' })}}`,
@@ -294,11 +277,11 @@ const approvals = {
         schemaName: (_c = approval.workflow) == null ? void 0 : _c.config.applyDetail,
         dataKey: approval.data[collection.filterTargetKey]
       };
-      context.app.messageManager.sendMessage(+userId, message);
+      ctx.tego.messageManager.sendMessage(+userId, message);
     }
     await next();
-    context.status = 200;
-    context.body = {
+    ctx.status = 200;
+    ctx.body = {
       message: "reminder sent",
       success: true
     };

package/dist/server/actions/index.js

@@ -35,7 +35,7 @@ function make(name, mod) {
   );
 }
 function init({ app }) {
-  app.actions({
+  app.resourcer.registerActions({
     ...make("workflows", import_workflows.workflows),
     ...make("approvals", import_approvals.approvals),
     ...make("approvalRecords", import_approvalRecords.approvalRecords),

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

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

package/dist/server/actions/workflows.js

@@ -22,15 +22,15 @@ __export(workflows_exports, {
 module.exports = __toCommonJS(workflows_exports);
 var import_server = require("@tego/server");
 const workflows = {
-  async listApprovalFlows(context, next) {
-    context.action.mergeParams({
+  async listApprovalFlows(ctx, next) {
+    ctx.action.mergeParams({
       filter: {
         type: "approval",
         enabled: true
         // TODO: 仅显示当前用户有权限的流程
       }
     });
-    return import_server.actions.list(context, next);
+    return import_server.actions.list(ctx, next);
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/server/plugin.js

@@ -62,9 +62,6 @@ class PluginWorkflowApproval extends import_server.Plugin {
         plugin: this
       }
     });
-    await db.import({
-      directory: import_node_path.default.resolve(__dirname, "collections")
-    });
     (0, import_actions.init)(this);
     this.app.acl.allow("workflows", ["listApprovalFlows"], "loggedIn");
     this.app.acl.allow("approvals", "*", "loggedIn");

package/dist/server/tools.d.ts

@@ -1,11 +1,8 @@
-interface ParamsType {
-    summaryConfig: Array<string>;
-    data: object;
-}
-export declare function getSummary(params: ParamsType): object;
-export declare function parsePerson({ node, processor, keyName }: {
+import { type ParamsType } from '../common/interface';
+declare function parsePerson({ node, processor, keyName }: {
     node: any;
     processor: any;
     keyName: any;
 }): Promise<unknown[]>;
-export {};
+declare function getSummary(params: ParamsType): object;
+export { getSummary, parsePerson };

package/dist/server/tools.js

@@ -32,18 +32,8 @@ __export(tools_exports, {
 });
 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;
-}
+var import_constants = require("../common/constants");
+var import_utils = require("../common/utils");
 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);
@@ -63,6 +53,257 @@ async function parsePerson({ node, processor, keyName }) {
   }
   return [...targetPerson];
 }
+function getSummary(params) {
+  const { summaryConfig = [], data, collection, app } = params;
+  const summaryDataSource = getSummaryDataSource({ summaryConfig, data, collection, app });
+  return summaryDataSource;
+}
+function getAssociationTitleFieldValue(value, fieldName, collection, app) {
+  if (!collection && !app || typeof value !== "object" || value === null || Array.isArray(value)) {
+    return void 0;
+  }
+  let field;
+  let dataSource;
+  let targetCollection;
+  if (collection) {
+    field = collection.getField(fieldName);
+    if (!field || !field.target) {
+      return void 0;
+    }
+    const db = collection.db;
+    if (db) {
+      targetCollection = db.getCollection(field.target);
+    } else if (app && app.dataSourceManager) {
+      const collectionDataSource = collection.dataSource;
+      if (collectionDataSource) {
+        dataSource = app.dataSourceManager.dataSources.get(collectionDataSource);
+      } else {
+        dataSource = app.dataSourceManager.dataSources.get("main");
+      }
+      if (dataSource) {
+        targetCollection = dataSource.collectionManager.getCollection(field.target);
+      }
+    } else {
+      try {
+        const cm = collection.collectionManager;
+        if (cm) {
+          dataSource = cm.dataSource;
+          targetCollection = dataSource.collectionManager.getCollection(field.target);
+        }
+      } catch (e) {
+      }
+    }
+  } else if (app) {
+    return void 0;
+  }
+  if (!targetCollection) {
+    return void 0;
+  }
+  const titleField = targetCollection.titleField || targetCollection.getPrimaryKey() || "id";
+  const titleValue = value[titleField];
+  return titleValue !== void 0 && titleValue !== null ? String(titleValue) : void 0;
+}
+function getFieldLabel(key, collection) {
+  var _a;
+  if (!collection) {
+    return key;
+  }
+  const field = collection.getField(key);
+  if (field) {
+    const uiSchema = (_a = field.options) == null ? void 0 : _a.uiSchema;
+    if (uiSchema == null ? void 0 : uiSchema.title) {
+      return uiSchema.title;
+    }
+    if (field.title) {
+      return field.title;
+    }
+  }
+  return key;
+}
+function processValue(value, fieldName, collection, app) {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (value instanceof Date || typeof value.toDate === "function" && value.toDate() instanceof Date) {
+    const dateObj = value instanceof Date ? value : value.toDate();
+    return dateObj.toISOString();
+  }
+  if (typeof value === "object" && !Array.isArray(value)) {
+    const titleFieldValue = getAssociationTitleFieldValue(value, fieldName, collection, app);
+    if (titleFieldValue !== void 0) {
+      return titleFieldValue;
+    }
+    if (value.name !== void 0) {
+      return String(value.name);
+    }
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  return String(value);
+}
+function getSummaryItem(key, data, collection, app) {
+  const value = import_lodash.default.get(data, key);
+  const label = getFieldLabel(key, collection);
+  if (value === void 0 || value === null) {
+    return {
+      key,
+      label,
+      type: import_constants.SUMMARY_TYPE.LITERAL,
+      value: ""
+    };
+  }
+  if (Array.isArray(value)) {
+    const processedArray = [];
+    for (const item of value) {
+      const processedValue2 = processValue(item, key, collection, app);
+      processedArray.push(processedValue2);
+    }
+    return {
+      key,
+      label,
+      type: import_constants.SUMMARY_TYPE.ARRAY,
+      value: processedArray
+    };
+  }
+  if (value instanceof Date || typeof value.toDate === "function" && value.toDate() instanceof Date) {
+    const dateObj = value instanceof Date ? value : value.toDate();
+    return {
+      key,
+      label,
+      type: import_constants.SUMMARY_TYPE.DATE,
+      value: dateObj.toISOString()
+    };
+  }
+  const processedValue = processValue(value, key, collection, app);
+  const valueStr = String(processedValue);
+  const finalType = (0, import_utils.isDateType)(valueStr) ? import_constants.SUMMARY_TYPE.DATE : import_constants.SUMMARY_TYPE.LITERAL;
+  return {
+    key,
+    label,
+    type: finalType,
+    value: processedValue
+  };
+}
+function getTargetCollection(mainKey, collection, app) {
+  if (!collection) {
+    return void 0;
+  }
+  const field = collection.getField(mainKey);
+  if (!field || !field.target) {
+    return void 0;
+  }
+  let targetCollection;
+  const db = collection.db;
+  if (db) {
+    targetCollection = db.getCollection(field.target);
+  } else if (app && app.dataSourceManager) {
+    const collectionDataSource = collection.dataSource;
+    let dataSource;
+    if (collectionDataSource) {
+      dataSource = app.dataSourceManager.dataSources.get(collectionDataSource);
+    } else {
+      dataSource = app.dataSourceManager.dataSources.get("main");
+    }
+    if (dataSource) {
+      targetCollection = dataSource.collectionManager.getCollection(field.target);
+    }
+  }
+  return targetCollection;
+}
+function isManyToManyField(mainKey, collection) {
+  if (!collection) {
+    return false;
+  }
+  const field = collection.getField(mainKey);
+  if (!field) {
+    return false;
+  }
+  return field.type === "belongsToMany" || field.type === "hasMany";
+}
+function getSummaryDataSource({ summaryConfig = [], data, collection, app }) {
+  const mainPathKeys = [];
+  const subPathKeys = [];
+  for (const key of summaryConfig) {
+    if (key.includes(".")) {
+      subPathKeys.push(key);
+    } else {
+      mainPathKeys.push(key);
+    }
+  }
+  const summaryDataSource = [];
+  for (const mainKey of mainPathKeys) {
+    const parentValue = import_lodash.default.get(data, mainKey);
+    const label = getFieldLabel(mainKey, collection);
+    const isManyToMany = isManyToManyField(mainKey, collection);
+    if (isManyToMany && Array.isArray(parentValue) && parentValue.length > 0) {
+      const mainKeyPrefix = `${mainKey}.`;
+      const relevantSubKeys = subPathKeys.filter((subKey) => subKey.startsWith(mainKeyPrefix));
+      if (relevantSubKeys.length === 0) {
+        summaryDataSource.push(getSummaryItem(mainKey, data, collection, app));
+      } else {
+        const fieldPathMap = /* @__PURE__ */ new Map();
+        for (const subKey of relevantSubKeys) {
+          const relativePath = subKey.slice(mainKeyPrefix.length);
+          const fieldName = relativePath.split(".")[0];
+          if (!fieldPathMap.has(fieldName)) {
+            fieldPathMap.set(fieldName, relativePath);
+          } else {
+            const existingPath = fieldPathMap.get(fieldName);
+            if (relativePath.length > existingPath.length) {
+              fieldPathMap.set(fieldName, relativePath);
+            }
+          }
+        }
+        const targetFields = Array.from(fieldPathMap.keys());
+        const childValues = [];
+        let isValidTable = true;
+        let rowCount = 0;
+        for (const fieldName of targetFields) {
+          const relativePath = fieldPathMap.get(fieldName);
+          const fullSubKey = `${mainKey}.${fieldName}`;
+          const childArray = [];
+          for (let i = 0; i < parentValue.length; i++) {
+            const item = parentValue[i];
+            const childValue = import_lodash.default.get(item, relativePath);
+            const processedValue = processValue(childValue, fullSubKey, collection, app);
+            childArray.push(processedValue);
+          }
+          childValues.push(childArray);
+          if (rowCount === 0) {
+            rowCount = childArray.length;
+          } else if (rowCount !== childArray.length) {
+            isValidTable = false;
+          }
+        }
+        if (isValidTable && rowCount > 0) {
+          const targetCollection = getTargetCollection(mainKey, collection, app);
+          const tableFields = targetFields.map((fieldName, idx) => {
+            const childLabel = targetCollection ? getFieldLabel(fieldName, targetCollection) : fieldName;
+            return {
+              key: fieldName,
+              label: childLabel,
+              type: import_constants.SUMMARY_TYPE.ARRAY,
+              value: childValues[idx]
+            };
+          });
+          summaryDataSource.push({
+            key: mainKey,
+            label,
+            type: import_constants.SUMMARY_TYPE.TABLE,
+            value: tableFields
+          });
+        } else {
+          summaryDataSource.push(getSummaryItem(mainKey, data, collection, app));
+        }
+      }
+    } else {
+      summaryDataSource.push(getSummaryItem(mainKey, data, collection, app));
+    }
+  }
+  return summaryDataSource;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getSummary,

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

@@ -11,10 +11,10 @@ export default class ApprovalTrigger extends Trigger {
     onExecutionUpdate: (execution: any, { transaction }: {
         transaction: any;
     }) => Promise<void>;
-    middleware: (context: any, next: any) => Promise<any>;
+    middleware: (ctx: any, next: any) => Promise<any>;
     constructor(workflow: any);
-    workflowTriggerAction(context: any, next: any): Promise<any>;
-    collectionTriggerAction(context: any, workflowList: any): Promise<void>;
+    workflowTriggerAction(ctx: any, next: any): Promise<any>;
+    collectionTriggerAction(ctx: any, workflowList: any): Promise<void>;
     on(workflow: any): void;
     off(workflow: any): void;
     duplicateConfig(workflow: any, { transaction }: {