@nocobase/plugin-workflow-cc 2.0.0-alpha.7 → 2.0.0-alpha.71

package/dist/server/actions.js

@@ -40,6 +40,12 @@ __export(actions_exports, {
 });
 module.exports = __toCommonJS(actions_exports);
 var import_actions = __toESM(require("@nocobase/actions"));
+var import_tempAssociationFields = require("./tempAssociationFields");
+const mergeAppends = (appends, required) => {
+  const result = /* @__PURE__ */ new Set([...appends || []]);
+  required.forEach((item) => result.add(item));
+  return Array.from(result);
+};
 const workflowCcTasks = {
   async get(context, next) {
     context.action.mergeParams({
@@ -50,12 +56,15 @@ const workflowCcTasks = {
     return import_actions.default.get(context, next);
   },
   async listMine(context, next) {
+    var _a;
     context.action.mergeParams({
       filter: {
         userId: context.state.currentUser.id
-      }
+      },
+      appends: mergeAppends((_a = context.action.params) == null ? void 0 : _a.appends, ["node", "workflow", "workflow.nodes"])
     });
-    return import_actions.default.list(context, next);
+    await import_actions.default.list(context, next);
+    await (0, import_tempAssociationFields.appendTempAssociationFields)(context);
   },
   async read(context, next) {
     const { filterByTk } = context.action.params;

package/dist/server/tempAssociationFields.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { Context } from '@nocobase/actions';
+export declare function appendTempAssociationFields(context: Context): Promise<void>;

package/dist/server/tempAssociationFields.js

@@ -0,0 +1,304 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+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 tempAssociationFields_exports = {};
+__export(tempAssociationFields_exports, {
+  appendTempAssociationFields: () => appendTempAssociationFields
+});
+module.exports = __toCommonJS(tempAssociationFields_exports);
+var import_data_source_manager = require("@nocobase/data-source-manager");
+var import_tempAssociation = require("../common/tempAssociation");
+const TEMP_ASSOCIATION_FIELDS_LIMIT = 50;
+const toPlainObject = (record) => {
+  if (!record || typeof record !== "object") return record;
+  if (typeof record.get === "function") return record.get();
+  if (typeof record.toJSON === "function") return record.toJSON();
+  return record;
+};
+const normalizeTempAssociationConfigs = (configs) => {
+  if (!Array.isArray(configs)) return [];
+  return configs.filter((config) => !!config && typeof config === "object").map((config) => ({
+    nodeId: config.nodeId,
+    nodeKey: config.nodeKey,
+    nodeType: config.nodeType
+  })).filter(
+    (config) => config.nodeId !== void 0 && typeof config.nodeKey === "string" && config.nodeKey.length > 0 && (config.nodeType === "workflow" || config.nodeType === "node")
+  ).slice(0, TEMP_ASSOCIATION_FIELDS_LIMIT);
+};
+const pickRecordData = (value) => {
+  if (!value) return null;
+  if (Array.isArray(value)) return value[0] ?? null;
+  if ((value == null ? void 0 : value.data) && typeof value.data === "object" && !Array.isArray(value.data)) return value.data;
+  return value;
+};
+const getRecordKey = (record, primaryKey) => {
+  if (!record || typeof record !== "object") return void 0;
+  if (primaryKey && record[primaryKey] != null) return record[primaryKey];
+  if (record.id != null) return record.id;
+  return void 0;
+};
+const setTaskFieldValue = (task, fieldName, value) => {
+  if (task && typeof task.setDataValue === "function") {
+    task.setDataValue(fieldName, value);
+    return;
+  }
+  task[fieldName] = value;
+};
+const normalizeNodeConfig = (config) => {
+  if (!config) return void 0;
+  if (typeof config === "string") {
+    try {
+      return JSON.parse(config);
+    } catch (error) {
+      return void 0;
+    }
+  }
+  return config;
+};
+const normalizeAppends = (appends) => {
+  if (!Array.isArray(appends)) return [];
+  const set = /* @__PURE__ */ new Set();
+  appends.forEach((field) => {
+    if (typeof field !== "string" || !field) return;
+    set.add(field.split(".")[0]);
+    set.add(field);
+  });
+  return Array.from(set);
+};
+const getConfigAppends = (config) => {
+  var _a;
+  return normalizeAppends(((_a = config == null ? void 0 : config.params) == null ? void 0 : _a.appends) ?? (config == null ? void 0 : config.appends));
+};
+async function appendTempAssociationFields(context) {
+  var _a, _b;
+  const body = context.body;
+  const bodyData = Array.isArray(body) ? body : body == null ? void 0 : body.rows;
+  if (!Array.isArray(bodyData) || bodyData.length === 0) {
+    return;
+  }
+  const tasksWithConfig = /* @__PURE__ */ new Map();
+  const executionIds = /* @__PURE__ */ new Set();
+  const tasksByNodeId = /* @__PURE__ */ new Map();
+  const ccNodeConfigMap = /* @__PURE__ */ new Map();
+  const ccNodeIdsToFetch = /* @__PURE__ */ new Set();
+  const workflowIds = /* @__PURE__ */ new Set();
+  bodyData.forEach((task) => {
+    var _a2, _b2, _c;
+    const nodeId = ((_a2 = task == null ? void 0 : task.node) == null ? void 0 : _a2.id) ?? (task == null ? void 0 : task.nodeId);
+    if (nodeId == null) return;
+    const tasks = tasksByNodeId.get(nodeId) || [];
+    tasks.push(task);
+    tasksByNodeId.set(nodeId, tasks);
+    if ((_b2 = task == null ? void 0 : task.node) == null ? void 0 : _b2.config) {
+      ccNodeConfigMap.set(nodeId, normalizeNodeConfig(task.node.config));
+    } else {
+      ccNodeIdsToFetch.add(nodeId);
+    }
+    if (task.executionId) {
+      executionIds.add(task.executionId);
+    }
+    const workflowId = task.workflowId ?? ((_c = task.workflow) == null ? void 0 : _c.id);
+    if (workflowId) {
+      workflowIds.add(workflowId);
+    }
+  });
+  if (ccNodeIdsToFetch.size) {
+    const nodeRepo = context.app.db.getRepository("flow_nodes");
+    const nodes = await nodeRepo.find({
+      filter: { id: Array.from(ccNodeIdsToFetch) }
+    });
+    nodes.forEach((node) => {
+      ccNodeConfigMap.set(node.id, normalizeNodeConfig(node.config) || {});
+    });
+  }
+  const referencedNodeIds = /* @__PURE__ */ new Set();
+  tasksByNodeId.forEach((tasks, nodeId) => {
+    const config = normalizeNodeConfig(ccNodeConfigMap.get(nodeId));
+    const configs = normalizeTempAssociationConfigs(config == null ? void 0 : config.tempAssociationFields);
+    if (!configs.length) return;
+    configs.forEach((item) => {
+      if (item.nodeType === "node") {
+        referencedNodeIds.add(item.nodeId);
+      }
+    });
+    tasks.forEach((task) => {
+      tasksWithConfig.set(task, configs);
+    });
+  });
+  if (!tasksWithConfig.size) return;
+  const workflowIdsNeedingConfig = /* @__PURE__ */ new Set();
+  for (const [task, configs] of tasksWithConfig.entries()) {
+    if (!configs.some((config) => config.nodeType === "workflow")) continue;
+    const workflow = task.workflow;
+    if ((_a = workflow == null ? void 0 : workflow.config) == null ? void 0 : _a.collection) continue;
+    const workflowId = task.workflowId ?? (workflow == null ? void 0 : workflow.id);
+    if (workflowId) {
+      workflowIdsNeedingConfig.add(workflowId);
+    }
+  }
+  if (workflowIdsNeedingConfig.size) {
+    const workflowRepo = context.app.db.getRepository("workflows");
+    const workflows = await workflowRepo.find({
+      filter: { id: Array.from(workflowIdsNeedingConfig) }
+    });
+    const workflowMap = new Map(workflows.map((workflow) => [workflow.id, workflow]));
+    for (const task of tasksWithConfig.keys()) {
+      const workflowId = task.workflowId ?? ((_b = task.workflow) == null ? void 0 : _b.id);
+      if (!workflowId) continue;
+      const stored = workflowMap.get(workflowId);
+      if (!stored) continue;
+      if (!task.workflow) {
+        task.workflow = toPlainObject(stored);
+        continue;
+      }
+      task.workflow.config = stored.config;
+    }
+  }
+  const executionRepo = context.app.db.getRepository("executions");
+  const executions = executionIds.size ? await executionRepo.find({
+    filter: { id: Array.from(executionIds) },
+    appends: ["jobs"]
+  }) : [];
+  const executionMap = new Map(executions.map((execution) => [execution.id, execution]));
+  const workflowNodeMap = /* @__PURE__ */ new Map();
+  const collectionCache = /* @__PURE__ */ new Map();
+  const pendingGroups = /* @__PURE__ */ new Map();
+  if (referencedNodeIds.size) {
+    const nodeRepo = context.app.db.getRepository("flow_nodes");
+    const nodes = await nodeRepo.find({
+      filter: { id: Array.from(referencedNodeIds) }
+    });
+    nodes.forEach((node) => {
+      workflowNodeMap.set(String(node.id), {
+        ...node,
+        config: normalizeNodeConfig(node.config)
+      });
+    });
+  }
+  const getRepository = (dataSourceName, collectionName) => {
+    var _a2;
+    const cacheKey = `${dataSourceName}:${collectionName}`;
+    if (collectionCache.has(cacheKey)) return collectionCache.get(cacheKey);
+    const dataSource = context.app.dataSourceManager.dataSources.get(dataSourceName);
+    if (!dataSource) return null;
+    const collection = dataSource.collectionManager.getCollection(collectionName);
+    if (!collection) return null;
+    const entry = {
+      repository: collection.repository,
+      collection,
+      filterTargetKey: collection.filterTargetKey || ((_a2 = collection.model) == null ? void 0 : _a2.primaryKeyAttribute)
+    };
+    collectionCache.set(cacheKey, entry);
+    return entry;
+  };
+  for (const [task, configs] of tasksWithConfig.entries()) {
+    const execution = executionMap.get(task.executionId);
+    const workflow = task.workflow;
+    configs.forEach((config) => {
+      var _a2, _b2, _c, _d, _e, _f;
+      const fieldName = (0, import_tempAssociation.buildTempAssociationFieldName)(config.nodeType, config.nodeKey);
+      let collectionConfig;
+      let recordData;
+      let appends = [];
+      if (config.nodeType === "workflow") {
+        collectionConfig = (_a2 = workflow == null ? void 0 : workflow.config) == null ? void 0 : _a2.collection;
+        recordData = pickRecordData((_b2 = execution == null ? void 0 : execution.context) == null ? void 0 : _b2.data);
+        appends = getConfigAppends(workflow == null ? void 0 : workflow.config);
+      } else {
+        const node = workflowNodeMap.get(String(config.nodeId));
+        collectionConfig = (_c = node == null ? void 0 : node.config) == null ? void 0 : _c.collection;
+        const job = (_d = execution == null ? void 0 : execution.jobs) == null ? void 0 : _d.find((item) => String(item.nodeId) === String(config.nodeId));
+        recordData = pickRecordData(job == null ? void 0 : job.result);
+        appends = getConfigAppends(node == null ? void 0 : node.config);
+      }
+      if (!collectionConfig) {
+        setTaskFieldValue(task, fieldName, null);
+        return;
+      }
+      const [dataSourceName, collectionName] = (0, import_data_source_manager.parseCollectionName)(collectionConfig);
+      if (!dataSourceName || !collectionName) {
+        setTaskFieldValue(task, fieldName, null);
+        return;
+      }
+      const repoEntry = getRepository(dataSourceName, collectionName);
+      if (!repoEntry) {
+        setTaskFieldValue(task, fieldName, null);
+        return;
+      }
+      const recordKey = getRecordKey(recordData, (_f = (_e = repoEntry.collection) == null ? void 0 : _e.model) == null ? void 0 : _f.primaryKeyAttribute);
+      if (recordKey == null) {
+        setTaskFieldValue(task, fieldName, recordData ? toPlainObject(recordData) : null);
+        return;
+      }
+      if (Array.isArray(repoEntry.filterTargetKey)) {
+        setTaskFieldValue(task, fieldName, recordData ? toPlainObject(recordData) : null);
+        return;
+      }
+      const groupKey = `${dataSourceName}:${collectionName}`;
+      const group = pendingGroups.get(groupKey) || {
+        dataSourceName,
+        collectionName,
+        recordKeys: /* @__PURE__ */ new Set(),
+        appends: /* @__PURE__ */ new Set(),
+        references: []
+      };
+      group.recordKeys.add(recordKey);
+      appends.forEach((append) => group.appends.add(append));
+      group.references.push({ task, fieldName, recordKey });
+      pendingGroups.set(groupKey, group);
+    });
+  }
+  for (const group of pendingGroups.values()) {
+    const repoEntry = getRepository(group.dataSourceName, group.collectionName);
+    if (!repoEntry) {
+      group.references.forEach(({ task, fieldName }) => {
+        setTaskFieldValue(task, fieldName, null);
+      });
+      continue;
+    }
+    const filterTargetKey = repoEntry.filterTargetKey;
+    if (!filterTargetKey) {
+      group.references.forEach(({ task, fieldName }) => {
+        setTaskFieldValue(task, fieldName, null);
+      });
+      continue;
+    }
+    const records = await repoEntry.repository.find({
+      filter: {
+        [filterTargetKey]: Array.from(group.recordKeys)
+      },
+      appends: group.appends.size ? Array.from(group.appends) : void 0
+    });
+    const recordMap = new Map(records.map((record) => [toPlainObject(record)[filterTargetKey], toPlainObject(record)]));
+    group.references.forEach(({ task, fieldName, recordKey }) => {
+      setTaskFieldValue(task, fieldName, recordMap.get(recordKey) ?? null);
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appendTempAssociationFields
+});

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "@nocobase/plugin-workflow-cc",
   "displayName": "Workflow: CC",
+  "displayName.ru-RU": "Рабочий процесс: Копия (CC)",
   "displayName.zh-CN": "工作流：抄送",
   "description": "Provide a CC (carbon copy) feature in workflows to send approvals, or any other type of information to specified users.",
   "description.zh-CN": "在工作流中提供抄送功能，将审批或其他任意信息抄送给特定的用户。",
+  "description.ru-RU": "Предоставляет функцию CC (копия) в рабочих процессах для отправки утверждений или любого другого типа информации указанным пользователям.",
   "homepage": "https://docs.nocobase.com/handbook/workflow-cc",
+  "homepage.ru-RU": "https://docs-ru.nocobase.com/handbook/workflow-cc",
   "homepage.zh-CN": "https://docs-cn.nocobase.com/handbook/workflow-cc",
   "license": "AGPL-3.0",
-  "version": "2.0.0-alpha.7",
+  "version": "2.0.0-alpha.71",
   "main": "dist/server/index.js",
   "peerDependencies": {
     "@nocobase/actions": "2.x",
@@ -22,5 +25,5 @@
   "keywords": [
     "Workflow"
   ],
-  "gitHead": "cb012f93256f534472d3ae56e075839ca1675779"
+  "gitHead": "b6fc484eb698fa12fba02dd468a04e39079b1e79"
 }