@nocobase/plugin-workflow-cc 2.0.0-beta.9 → 2.0.0

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

@@ -10,7 +10,7 @@
   "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-beta.9",
+  "version": "2.0.0",
   "main": "dist/server/index.js",
   "peerDependencies": {
     "@nocobase/actions": "2.x",
@@ -25,5 +25,5 @@
   "keywords": [
     "Workflow"
   ],
-  "gitHead": "36ef50291e22fe1024c819b8748d51a59a5ea4f8"
+  "gitHead": "3590c0087a56f0f285a5357f43a80bdc62b11bec"
 }