@nocobase/plugin-workflow 2.0.0-alpha.7 → 2.0.0-alpha.70

package/dist/server/actions/nodes.js

@@ -38,6 +38,9 @@ var nodes_exports = {};
 __export(nodes_exports, {
   create: () => create,
   destroy: () => destroy,
+  destroyBranch: () => destroyBranch,
+  duplicate: () => duplicate,
+  move: () => move,
   test: () => test,
   update: () => update
 });
@@ -48,10 +51,10 @@ var import__ = __toESM(require(".."));
 async function create(context, next) {
   const { db } = context;
   const repository = import_actions.utils.getRepositoryFromParams(context);
-  const { whitelist, blacklist, updateAssociationValues, values, associatedIndex: workflowId } = context.action.params;
+  const { whitelist, blacklist, updateAssociationValues, values } = context.action.params;
   const workflowPlugin = context.app.pm.get(import__.default);
   context.body = await db.sequelize.transaction(async (transaction) => {
-    const workflow = workflowPlugin.enabledCache.get(Number.parseInt(workflowId, 10)) || await repository.getSourceModel(transaction);
+    const workflow = workflowPlugin.enabledCache.get(Number.parseInt(context.action.sourceId, 10)) || await repository.getSourceModel(transaction);
     if (!workflow.versionStats) {
       workflow.versionStats = await workflow.getVersionStats({ transaction });
     }
@@ -132,6 +135,117 @@ async function create(context, next) {
   });
   await next();
 }
+async function duplicate(context, next) {
+  const { db } = context;
+  const repository = import_actions.utils.getRepositoryFromParams(context);
+  const { whitelist, blacklist, filterByTk, values = {} } = context.action.params;
+  const workflowPlugin = context.app.pm.get(import__.default);
+  context.body = await db.sequelize.transaction(async (transaction) => {
+    const origin = filterByTk ? await repository.findOne({ filterByTk, transaction }) : null;
+    if (!origin) {
+      return context.throw(404, "Node not found");
+    }
+    const workflow = workflowPlugin.enabledCache.get(origin.workflowId) || await db.getRepository("workflows").findOne({
+      filterByTk: origin.workflowId,
+      transaction
+    });
+    if (!workflow) {
+      return context.throw(400, "Workflow not found");
+    }
+    if (!workflow.versionStats) {
+      workflow.versionStats = await workflow.getVersionStats({ transaction });
+    }
+    if (workflow.versionStats.executed > 0) {
+      context.throw(400, "Node could not be created in executed workflow");
+    }
+    const NODES_LIMIT = process.env.WORKFLOW_NODES_LIMIT ? parseInt(process.env.WORKFLOW_NODES_LIMIT, 10) : null;
+    if (NODES_LIMIT) {
+      const nodesCount = await workflow.countNodes({ transaction });
+      if (nodesCount >= NODES_LIMIT) {
+        context.throw(400, `The number of nodes in a workflow cannot exceed ${NODES_LIMIT}`);
+      }
+    }
+    let nextConfig = values.config;
+    if (!nextConfig) {
+      const instruction = workflowPlugin.instructions.get(origin.type);
+      if (instruction && typeof instruction.duplicateConfig === "function") {
+        nextConfig = await instruction.duplicateConfig(origin, { origin: origin ?? void 0, transaction });
+      }
+    }
+    const instance = await repository.create({
+      values: {
+        config: nextConfig ?? origin.config,
+        upstreamId: values.upstreamId,
+        branchIndex: values.branchIndex,
+        type: origin.type,
+        title: origin.title,
+        workflowId: origin.workflowId
+      },
+      whitelist,
+      blacklist,
+      context,
+      transaction
+    });
+    if (!instance.upstreamId) {
+      const previousHead = await repository.findOne({
+        filter: {
+          id: {
+            $ne: instance.id
+          },
+          workflowId: origin.workflowId,
+          upstreamId: null
+        },
+        transaction
+      });
+      if (previousHead) {
+        await previousHead.setUpstream(instance, { transaction });
+        await instance.setDownstream(previousHead, { transaction });
+        instance.set("downstream", previousHead);
+      }
+      return instance;
+    }
+    const upstream = await instance.getUpstream({ transaction });
+    if (instance.branchIndex == null) {
+      const downstream = await upstream.getDownstream({ transaction });
+      if (downstream) {
+        await downstream.setUpstream(instance, { transaction });
+        await instance.setDownstream(downstream, { transaction });
+        instance.set("downstream", downstream);
+      }
+      await upstream.update(
+        {
+          downstreamId: instance.id
+        },
+        { transaction }
+      );
+      upstream.set("downstream", instance);
+    } else {
+      const [downstream] = await upstream.getBranches({
+        where: {
+          id: {
+            [import_database.Op.ne]: instance.id
+          },
+          branchIndex: instance.branchIndex
+        },
+        transaction
+      });
+      if (downstream) {
+        await downstream.update(
+          {
+            upstreamId: instance.id,
+            branchIndex: null
+          },
+          { transaction }
+        );
+        await instance.setDownstream(downstream, { transaction });
+        instance.set("downstream", downstream);
+      }
+    }
+    instance.set("upstream", upstream);
+    return instance;
+  });
+  await next();
+}
 function searchBranchNodes(nodes, from) {
   const branchHeads = nodes.filter((item) => item.upstreamId === from.id && item.branchIndex != null);
   return branchHeads.reduce(
@@ -146,38 +260,146 @@ function searchBranchDownstreams(nodes, from) {
   }
   return result;
 }
+function findBranchTail(branchHead) {
+  let tail = branchHead;
+  while (tail.downstream) {
+    tail = tail.downstream;
+  }
+  return tail;
+}
 async function destroy(context, next) {
   const { db } = context;
   const repository = import_actions.utils.getRepositoryFromParams(context);
-  const { filterByTk } = context.action.params;
-  const fields = ["id", "upstreamId", "downstreamId", "branchIndex"];
+  const { filterByTk, keepBranch } = context.action.params;
+  const keepBranchIndex = keepBranch == null || keepBranch === "" ? null : Number.parseInt(keepBranch, 10);
+  const fields = ["id", "upstreamId", "downstreamId", "branchIndex", "key"];
   const instance = await repository.findOne({
     filterByTk,
     fields: [...fields, "workflowId"],
     appends: ["upstream", "downstream", "workflow.versionStats.executed"]
   });
+  if (!instance) {
+    context.throw(404, "Node not found");
+  }
   if (instance.workflow.versionStats.executed > 0) {
     context.throw(400, "Nodes in executed workflow could not be deleted");
   }
   await db.sequelize.transaction(async (transaction) => {
     const { upstream, downstream } = instance.get();
-    if (upstream && upstream.downstreamId === instance.id) {
-      await upstream.update(
-        {
-          downstreamId: instance.downstreamId
-        },
-        { transaction }
-      );
+    const nodes = await repository.find({
+      filter: {
+        workflowId: instance.workflowId
+      },
+      fields,
+      transaction
+    });
+    const nodesMap = /* @__PURE__ */ new Map();
+    nodes.forEach((item) => {
+      nodesMap.set(item.id, item);
+    });
+    nodes.forEach((item) => {
+      if (item.upstreamId) {
+        item.upstream = nodesMap.get(item.upstreamId);
+      }
+      if (item.downstreamId) {
+        item.downstream = nodesMap.get(item.downstreamId);
+      }
+    });
+    const keepBranchHead = keepBranchIndex != null ? nodes.find((item) => item.upstreamId === instance.id && item.branchIndex == keepBranchIndex) : null;
+    if (keepBranchIndex != null && !keepBranchHead) {
+      context.throw(400, `Branch ${keepBranchIndex} not found`);
     }
-    if (downstream) {
-      await downstream.update(
+    const keepBranchNodes = keepBranchHead ? searchBranchDownstreams(nodes, keepBranchHead) : [];
+    const keepBranchNodeIds = new Set(keepBranchNodes.map((item) => item.id));
+    const branchNodes = instance ? searchBranchNodes(nodes, instance) : [];
+    const branchNodesToDelete = keepBranchHead ? branchNodes.filter((item) => !keepBranchNodeIds.has(item.id)) : branchNodes;
+    if (keepBranchHead) {
+      if (upstream && upstream.downstreamId === instance.id) {
+        await upstream.update(
+          {
+            downstreamId: keepBranchHead.id
+          },
+          { transaction }
+        );
+      }
+      await keepBranchHead.update(
         {
           upstreamId: instance.upstreamId,
           branchIndex: instance.branchIndex
         },
         { transaction }
       );
+      if (downstream) {
+        const branchTail = findBranchTail(keepBranchHead);
+        await branchTail.update(
+          {
+            downstreamId: instance.downstreamId
+          },
+          { transaction }
+        );
+        branchTail.downstreamId = instance.downstreamId;
+        branchTail.downstream = downstream;
+        await downstream.update(
+          {
+            upstreamId: branchTail.id,
+            branchIndex: null
+          },
+          { transaction }
+        );
+      }
+    } else {
+      if (upstream && upstream.downstreamId === instance.id) {
+        await upstream.update(
+          {
+            downstreamId: instance.downstreamId
+          },
+          { transaction }
+        );
+      }
+      if (downstream) {
+        await downstream.update(
+          {
+            upstreamId: instance.upstreamId,
+            branchIndex: instance.branchIndex
+          },
+          { transaction }
+        );
+      }
     }
+    await repository.destroy({
+      filterByTk: [instance.id, ...branchNodesToDelete.map((item) => item.id)],
+      transaction
+    });
+  });
+  context.body = instance;
+  await next();
+}
+async function destroyBranch(context, next) {
+  const { db } = context;
+  const repository = import_actions.utils.getRepositoryFromParams(context);
+  const { filterByTk, branchIndex: branchIndexParam, shift: shiftParam } = context.action.params;
+  if (branchIndexParam == null || branchIndexParam === "") {
+    context.throw(400, "branchIndex is required");
+  }
+  const branchIndex = Number.parseInt(branchIndexParam, 10);
+  if (Number.isNaN(branchIndex)) {
+    context.throw(400, "branchIndex must be a number");
+  }
+  const shift = !(shiftParam == null || shiftParam === "") && Number.parseInt(String(shiftParam), 10) === 1;
+  const fields = ["id", "upstreamId", "downstreamId", "branchIndex", "key"];
+  const instance = await repository.findOne({
+    filterByTk,
+    fields: [...fields, "workflowId"],
+    appends: ["workflow.versionStats.executed"]
+  });
+  if (!instance) {
+    context.throw(404, "Node not found");
+  }
+  if (instance.workflow.versionStats.executed > 0) {
+    context.throw(400, "Branches in executed workflow could not be deleted");
+  }
+  let deletedBranchHead = null;
+  await db.sequelize.transaction(async (transaction) => {
     const nodes = await repository.find({
       filter: {
         workflowId: instance.workflowId
@@ -197,13 +419,198 @@ async function destroy(context, next) {
         item.downstream = nodesMap.get(item.downstreamId);
       }
     });
-    const branchNodes = searchBranchNodes(nodes, nodesMap.get(instance.id));
-    await repository.destroy({
-      filterByTk: [instance.id, ...branchNodes.map((item) => item.id)],
+    const branchHeads = nodes.filter((item) => item.upstreamId === instance.id && item.branchIndex != null).sort((a, b) => a.branchIndex - b.branchIndex);
+    const branchHead = branchHeads.find((item) => item.branchIndex === branchIndex);
+    deletedBranchHead = branchHead || null;
+    if (branchHead) {
+      const nodesToDelete = searchBranchDownstreams(nodes, branchHead);
+      const idsToDelete = nodesToDelete.map((item) => item.id);
+      if (idsToDelete.length) {
+        await repository.destroy({
+          filterByTk: idsToDelete,
+          transaction
+        });
+      }
+    }
+    if (shift) {
+      const headsToShift = branchHeads.filter((item) => item.branchIndex > branchIndex);
+      await Promise.all(
+        headsToShift.map(
+          (item) => item.update(
+            {
+              branchIndex: item.branchIndex - 1
+            },
+            { transaction }
+          )
+        )
+      );
+    }
+  });
+  context.body = deletedBranchHead;
+  await next();
+}
+async function move(context, next) {
+  const { db } = context;
+  const repository = import_actions.utils.getRepositoryFromParams(context);
+  const { filterByTk, values = {} } = context.action.params;
+  const rawUpstreamId = values.upstreamId;
+  const rawBranchIndex = values.branchIndex;
+  const upstreamId = rawUpstreamId == null || rawUpstreamId === "" ? null : rawUpstreamId;
+  let branchIndex = rawBranchIndex == null || rawBranchIndex === "" ? null : Number.parseInt(rawBranchIndex, 10);
+  if (rawBranchIndex != null && rawBranchIndex !== "" && Number.isNaN(branchIndex)) {
+    context.throw(400, "branchIndex must be a number");
+  }
+  if (upstreamId == null) {
+    branchIndex = null;
+  }
+  const fields = ["id", "key", "upstreamId", "downstreamId", "branchIndex", "workflowId"];
+  context.body = await db.sequelize.transaction(async (transaction) => {
+    const instance = await repository.findOne({
+      filterByTk,
+      fields,
+      appends: ["upstream", "downstream", "workflow.versionStats"],
+      transaction
+    });
+    if (!instance) {
+      context.throw(404, "Node not found");
+    }
+    if (instance.workflow.versionStats.executed > 0) {
+      context.throw(400, "Nodes in executed workflow could not be moved");
+    }
+    if (upstreamId != null && String(upstreamId) === String(instance.id)) {
+      context.throw(400, "Invalid upstream node");
+    }
+    const sameUpstream = (instance.upstreamId ?? null) == (upstreamId ?? null);
+    const sameBranchIndex = (instance.branchIndex ?? null) == (branchIndex ?? null);
+    if (sameUpstream && sameBranchIndex) {
+      context.throw(400, "Node does not need to be moved");
+    }
+    const { upstream: oldUpstream, downstream: oldDownstream } = instance.get();
+    if (oldUpstream && oldUpstream.downstreamId === instance.id) {
+      await oldUpstream.update(
+        {
+          downstreamId: oldDownstream ? oldDownstream.id : null
+        },
+        { transaction }
+      );
+    }
+    if (oldDownstream && oldDownstream.upstreamId === instance.id) {
+      await oldDownstream.update(
+        {
+          upstreamId: oldUpstream ? oldUpstream.id : null,
+          branchIndex: instance.branchIndex ?? null
+        },
+        { transaction }
+      );
+    }
+    let targetUpstream = null;
+    if (upstreamId != null) {
+      targetUpstream = await repository.findOne({
+        filterByTk: upstreamId,
+        fields,
+        transaction
+      });
+      if (!targetUpstream) {
+        context.throw(404, "Upstream node not found");
+      }
+      if (targetUpstream.workflowId !== instance.workflowId) {
+        context.throw(400, "Upstream node is not in the same workflow");
+      }
+    }
+    let newDownstream = null;
+    if (!targetUpstream) {
+      const previousHead = await repository.findOne({
+        filter: {
+          workflowId: instance.workflowId,
+          upstreamId: null,
+          id: {
+            [import_database.Op.ne]: instance.id
+          }
+        },
+        fields,
+        transaction
+      });
+      if (previousHead) {
+        await previousHead.update(
+          {
+            upstreamId: instance.id,
+            branchIndex: null
+          },
+          { transaction }
+        );
+        newDownstream = previousHead;
+      }
+      await instance.update(
+        {
+          upstreamId: null,
+          branchIndex: null,
+          downstreamId: newDownstream ? newDownstream.id : null
+        },
+        { transaction }
+      );
+      return instance;
+    }
+    if (branchIndex == null) {
+      if (targetUpstream.downstreamId) {
+        newDownstream = await repository.findOne({
+          filterByTk: targetUpstream.downstreamId,
+          fields,
+          transaction
+        });
+      }
+      if (newDownstream) {
+        await newDownstream.update(
+          {
+            upstreamId: instance.id,
+            branchIndex: null
+          },
+          { transaction }
+        );
+      }
+      await targetUpstream.update(
+        {
+          downstreamId: instance.id
+        },
+        { transaction }
+      );
+      await instance.update(
+        {
+          upstreamId: targetUpstream.id,
+          branchIndex: null,
+          downstreamId: newDownstream ? newDownstream.id : null
+        },
+        { transaction }
+      );
+      return instance;
+    }
+    const branchHead = await repository.findOne({
+      filter: {
+        upstreamId: targetUpstream.id,
+        branchIndex
+      },
+      fields,
       transaction
     });
+    if (branchHead) {
+      await branchHead.update(
+        {
+          upstreamId: instance.id,
+          branchIndex: null
+        },
+        { transaction }
+      );
+      newDownstream = branchHead;
+    }
+    await instance.update(
+      {
+        upstreamId: targetUpstream.id,
+        branchIndex,
+        downstreamId: newDownstream ? newDownstream.id : null
+      },
+      { transaction }
+    );
+    return instance;
   });
-  context.body = instance;
   await next();
 }
 async function update(context, next) {
@@ -254,6 +661,9 @@ async function test(context, next) {
 0 && (module.exports = {
   create,
   destroy,
+  destroyBranch,
+  duplicate,
+  move,
   test,
   update
 });

package/dist/server/instructions/ConditionInstruction.js

@@ -81,7 +81,10 @@ class ConditionInstruction extends import__.Instruction {
     if (branchJob.status === import_constants.JOB_STATUS.RESOLVED) {
       return job;
     }
-    return processor.exit(branchJob.status);
+    if (branchJob.status === import_constants.JOB_STATUS.PENDING) {
+      return processor.exit(branchJob.status);
+    }
+    return branchJob;
   }
   async test({ engine, calculation, expression = "" }) {
     const evaluator = import_evaluators.evaluators.get(engine);

package/dist/server/instructions/MultiConditionsInstruction.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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 { Instruction } from '.';
+import type Processor from '../Processor';
+import type { FlowNodeModel, JobModel } from '../types';
+export declare class MultiConditionsInstruction extends Instruction {
+    run(node: FlowNodeModel, prevJob: any, processor: Processor): Promise<JobModel>;
+    resume(node: FlowNodeModel, branchJob: JobModel, processor: Processor): Promise<any>;
+    private evaluateCondition;
+    private getBranchNode;
+}
+export default MultiConditionsInstruction;

package/dist/server/instructions/MultiConditionsInstruction.js

@@ -0,0 +1,118 @@
+/**
+ * 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 MultiConditionsInstruction_exports = {};
+__export(MultiConditionsInstruction_exports, {
+  MultiConditionsInstruction: () => MultiConditionsInstruction,
+  default: () => MultiConditionsInstruction_default
+});
+module.exports = __toCommonJS(MultiConditionsInstruction_exports);
+var import_evaluators = require("@nocobase/evaluators");
+var import__ = require(".");
+var import_constants = require("../constants");
+var import_logicCalculate = require("../logicCalculate");
+class MultiConditionsInstruction extends import__.Instruction {
+  async run(node, prevJob, processor) {
+    const { conditions = [], continueOnNoMatch = false } = node.config || {};
+    const meta = { conditions: [] };
+    const job = processor.saveJob({
+      status: import_constants.JOB_STATUS.PENDING,
+      result: null,
+      meta,
+      nodeId: node.id,
+      nodeKey: node.key,
+      upstreamId: (prevJob == null ? void 0 : prevJob.id) ?? null
+    });
+    for (let cursor = 0; cursor < conditions.length; cursor++) {
+      const branchIndex = cursor + 1;
+      const condition = conditions[cursor];
+      let conditionResult;
+      try {
+        conditionResult = this.evaluateCondition(condition, node, processor);
+      } catch (error) {
+        conditionResult = error instanceof Error ? error.message : String(error);
+        processor.logger.error(`[multi-conditions] evaluate condition[${cursor}] error:`, { error });
+      } finally {
+        meta.conditions.push(conditionResult);
+        job.set("result", conditionResult);
+      }
+      if (typeof conditionResult === "string") {
+        job.set("status", import_constants.JOB_STATUS.ERROR);
+        return job;
+      }
+      if (conditionResult === true) {
+        const branchNode = this.getBranchNode(node, processor, branchIndex);
+        job.set("status", import_constants.JOB_STATUS.RESOLVED);
+        if (branchNode) {
+          await processor.run(branchNode, job);
+          return;
+        }
+        return job;
+      }
+    }
+    job.set("status", continueOnNoMatch ? import_constants.JOB_STATUS.RESOLVED : import_constants.JOB_STATUS.FAILED);
+    const defaultBranch = this.getBranchNode(node, processor, 0);
+    if (defaultBranch) {
+      await processor.run(defaultBranch, job);
+      return;
+    }
+    return job;
+  }
+  async resume(node, branchJob, processor) {
+    const job = processor.findBranchParentJob(branchJob, node);
+    if (!job) {
+      throw new Error("Parent job not found");
+    }
+    const { continueOnNoMatch = false } = node.config || {};
+    const jobNode = processor.nodesMap.get(branchJob.nodeId);
+    const branchStartNode = processor.findBranchStartNode(jobNode, node);
+    const branchIndex = branchStartNode.branchIndex;
+    if (branchJob.status === import_constants.JOB_STATUS.RESOLVED) {
+      if (branchIndex > 0) {
+        job.set({
+          status: import_constants.JOB_STATUS.RESOLVED
+        });
+        return job;
+      }
+      job.set({ status: continueOnNoMatch ? import_constants.JOB_STATUS.RESOLVED : import_constants.JOB_STATUS.FAILED });
+      return job;
+    }
+    return processor.exit(branchJob.status);
+  }
+  evaluateCondition(condition, node, processor) {
+    const { engine = "basic", calculation, expression } = condition ?? {};
+    const evaluator = import_evaluators.evaluators.get(engine);
+    return evaluator ? evaluator(expression, processor.getScope(node.id)) : (0, import_logicCalculate.logicCalculate)(processor.getParsedValue(calculation, node.id));
+  }
+  getBranchNode(node, processor, branchIndex) {
+    return processor.getBranches(node).find((item) => Number(item.branchIndex) === Number(branchIndex));
+  }
+}
+var MultiConditionsInstruction_default = MultiConditionsInstruction;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MultiConditionsInstruction
+});

package/dist/server/instructions/OutputInstruction.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 { Instruction } from '.';
+import Processor from '../Processor';
+import { FlowNodeModel } from '../types';
+export default class ExecutionResultInstruction extends Instruction {
+    run(node: FlowNodeModel, prevJob: any, processor: Processor): Promise<{
+        result: any;
+        status: -1;
+    } | {
+        result: any;
+        status: 1;
+    }>;
+    resume(node: FlowNodeModel, job: any, processor: Processor): Promise<any>;
+}