@nocobase/plugin-workflow 0.11.1-alpha.4 → 0.12.0-alpha.1

package/{src/server/actions/nodes.ts → dist/server/actions/nodes.js}

@@ -1,104 +1,91 @@
-import { Context, utils } from '@nocobase/actions';
-import { MultipleRelationRepository, Op } from '@nocobase/database';
-import type { WorkflowModel } from '../types';
+'use strict';
 
-export async function create(context: Context, next) {
+var actions = require('@nocobase/actions');
+var database = require('@nocobase/database');
+
+async function create(context, next) {
   const { db } = context;
-  const repository = utils.getRepositoryFromParams(context) as MultipleRelationRepository;
+  const repository = actions.utils.getRepositoryFromParams(context);
   const { whitelist, blacklist, updateAssociationValues, values, associatedIndex: workflowId } = context.action.params;
-
   context.body = await db.sequelize.transaction(async (transaction) => {
-    const workflow = (await repository.getSourceModel(transaction)) as WorkflowModel;
+    const workflow = await repository.getSourceModel(transaction);
     if (workflow.executed) {
-      context.throw(400, 'Node could not be created in executed workflow');
+      context.throw(400, "Node could not be created in executed workflow");
     }
-
     const instance = await repository.create({
       values,
       whitelist,
       blacklist,
       updateAssociationValues,
       context,
-      transaction,
+      transaction
     });
-
     if (!instance.upstreamId) {
       const previousHead = await repository.findOne({
         filter: {
           id: {
-            $ne: instance.id,
+            $ne: instance.id
           },
-          upstreamId: null,
+          upstreamId: null
         },
-        transaction,
+        transaction
       });
       if (previousHead) {
         await previousHead.setUpstream(instance, { transaction });
         await instance.setDownstream(previousHead, { transaction });
-        instance.set('downstream', previousHead);
+        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);
+        instance.set("downstream", downstream);
       }
-
       await upstream.update(
         {
-          downstreamId: instance.id,
+          downstreamId: instance.id
         },
-        { transaction },
+        { transaction }
       );
-
-      upstream.set('downstream', instance);
+      upstream.set("downstream", instance);
     } else {
       const [downstream] = await upstream.getBranches({
         where: {
           id: {
-            [Op.ne]: instance.id,
+            [database.Op.ne]: instance.id
           },
-          branchIndex: instance.branchIndex,
+          branchIndex: instance.branchIndex
         },
-        transaction,
+        transaction
       });
-
       if (downstream) {
         await downstream.update(
           {
             upstreamId: instance.id,
-            branchIndex: null,
+            branchIndex: null
           },
-          { transaction },
+          { transaction }
         );
         await instance.setDownstream(downstream, { transaction });
-        instance.set('downstream', downstream);
+        instance.set("downstream", downstream);
       }
     }
-
-    instance.set('upstream', upstream);
-
+    instance.set("upstream", upstream);
     return instance;
   });
-
   await next();
 }
-
-function searchBranchNodes(nodes, from): any[] {
-  const branchHeads = nodes.filter((item: any) => item.upstreamId === from.id && item.branchIndex != null);
+function searchBranchNodes(nodes, from) {
+  const branchHeads = nodes.filter((item) => item.upstreamId === from.id && item.branchIndex != null);
   return branchHeads.reduce(
-    (flatten: any[], head) => flatten.concat(searchBranchDownstreams(nodes, head)),
-    [],
-  ) as any[];
+    (flatten, head) => flatten.concat(searchBranchDownstreams(nodes, head)),
+    []
+  );
 }
-
 function searchBranchDownstreams(nodes, from) {
   let result = [];
   for (let search = from; search; search = search.downstream) {
@@ -106,61 +93,52 @@ function searchBranchDownstreams(nodes, from) {
   }
   return result;
 }
-
-export async function destroy(context: Context, next) {
+async function destroy(context, next) {
   const { db } = context;
-  const repository = utils.getRepositoryFromParams(context) as MultipleRelationRepository;
+  const repository = actions.utils.getRepositoryFromParams(context);
   const { filterByTk } = context.action.params;
-
   context.body = await db.sequelize.transaction(async (transaction) => {
-    const workflow = (await repository.getSourceModel(transaction)) as WorkflowModel;
+    const workflow = await repository.getSourceModel(transaction);
     if (workflow.executed) {
-      context.throw(400, 'Nodes in executed workflow could not be deleted');
+      context.throw(400, "Nodes in executed workflow could not be deleted");
     }
-
-    const fields = ['id', 'upstreamId', 'downstreamId', 'branchIndex'];
+    const fields = ["id", "upstreamId", "downstreamId", "branchIndex"];
     const instance = await repository.findOne({
       filterByTk,
-      fields: [...fields, 'workflowId'],
-      appends: ['upstream', 'downstream'],
-      transaction,
+      fields: [...fields, "workflowId"],
+      appends: ["upstream", "downstream"],
+      transaction
     });
     const { upstream, downstream } = instance.get();
-
     if (upstream && upstream.downstreamId === instance.id) {
       await upstream.update(
         {
-          downstreamId: instance.downstreamId,
+          downstreamId: instance.downstreamId
         },
-        { transaction },
+        { transaction }
       );
     }
-
     if (downstream) {
       await downstream.update(
         {
           upstreamId: instance.upstreamId,
-          branchIndex: instance.branchIndex,
+          branchIndex: instance.branchIndex
         },
-        { transaction },
+        { transaction }
       );
     }
-
     const nodes = await repository.find({
       filter: {
-        workflowId: instance.workflowId,
+        workflowId: instance.workflowId
       },
       fields,
-      transaction,
+      transaction
     });
-    const nodesMap = new Map();
-    // make map
+    const nodesMap = /* @__PURE__ */ new Map();
     nodes.forEach((item) => {
       nodesMap.set(item.id, item);
     });
-    // overwrite
     nodesMap.set(instance.id, instance);
-    // make linked list
     nodes.forEach((item) => {
       if (item.upstreamId) {
         item.upstream = nodesMap.get(item.upstreamId);
@@ -169,35 +147,28 @@ export async function destroy(context: Context, next) {
         item.downstream = nodesMap.get(item.downstreamId);
       }
     });
-
     const branchNodes = searchBranchNodes(nodes, instance);
-
     await repository.destroy({
       filterByTk: [instance.id, ...branchNodes.map((item) => item.id)],
-      transaction,
+      transaction
     });
-
     return instance;
   });
-
   await next();
 }
-
-export async function update(context: Context, next) {
+async function update(context, next) {
   const { db } = context;
-  const repository = utils.getRepositoryFromParams(context);
+  const repository = actions.utils.getRepositoryFromParams(context);
   const { filterByTk, values, whitelist, blacklist, filter, updateAssociationValues } = context.action.params;
   context.body = await db.sequelize.transaction(async (transaction) => {
-    // TODO(optimize): duplicated instance query
     const { workflow } = await repository.findOne({
       filterByTk,
-      appends: ['workflow.executed'],
-      transaction,
+      appends: ["workflow.executed"],
+      transaction
     });
     if (workflow.executed) {
-      context.throw(400, 'Nodes in executed workflow could not be reconfigured');
+      context.throw(400, "Nodes in executed workflow could not be reconfigured");
     }
-
     return repository.update({
       filterByTk,
       values,
@@ -206,9 +177,12 @@ export async function update(context: Context, next) {
       filter,
       updateAssociationValues,
       context,
-      transaction,
+      transaction
     });
   });
-
   await next();
 }
+
+exports.create = create;
+exports.destroy = destroy;
+exports.update = update;

package/{src/server/actions/workflows.ts → dist/server/actions/workflows.js}

@@ -1,89 +1,87 @@
-import actions, { Context, utils } from '@nocobase/actions';
-import { Op, Repository } from '@nocobase/database';
+'use strict';
 
-export async function update(context: Context, next) {
-  const repository = utils.getRepositoryFromParams(context) as Repository;
+var actions = require('@nocobase/actions');
+var database = require('@nocobase/database');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var actions__default = /*#__PURE__*/_interopDefault(actions);
+
+async function update(context, next) {
+  const repository = actions.utils.getRepositoryFromParams(context);
   const { filterByTk, values } = context.action.params;
   context.action.mergeParams({
-    whitelist: ['title', 'description', 'enabled', 'config'],
+    whitelist: ["title", "description", "enabled", "config"]
   });
-  // only enable/disable
-  if (Object.keys(values).includes('config')) {
+  if (Object.keys(values).includes("config")) {
     const workflow = await repository.findById(filterByTk);
-    if (workflow.get('executed')) {
-      return context.throw(400, 'config of executed workflow can not be updated');
+    if (workflow.get("executed")) {
+      return context.throw(400, "config of executed workflow can not be updated");
     }
   }
-  return actions.update(context, next);
+  return actions__default.default.update(context, next);
 }
-
-export async function destroy(context: Context, next) {
-  const repository = utils.getRepositoryFromParams(context) as Repository;
+async function destroy(context, next) {
+  const repository = actions.utils.getRepositoryFromParams(context);
   const { filterByTk, filter } = context.action.params;
-
   await context.db.sequelize.transaction(async (transaction) => {
     const items = await repository.find({
       filterByTk,
       filter,
-      fields: ['id', 'key', 'current'],
-      transaction,
+      fields: ["id", "key", "current"],
+      transaction
     });
-    const ids = new Set<number>(items.map((item) => item.id));
-    const keysSet = new Set<string>(items.filter((item) => item.current).map((item) => item.key));
+    const ids = new Set(items.map((item) => item.id));
+    const keysSet = new Set(items.filter((item) => item.current).map((item) => item.key));
     const revisions = await repository.find({
       filter: {
         key: Array.from(keysSet),
-        current: { [Op.not]: true },
+        current: { [database.Op.not]: true }
       },
-      fields: ['id'],
-      transaction,
+      fields: ["id"],
+      transaction
     });
-
     revisions.forEach((item) => ids.add(item.id));
-
     context.body = await repository.destroy({
       filterByTk: Array.from(ids),
       individualHooks: true,
-      transaction,
+      transaction
     });
   });
-
   next();
 }
-
 function typeOf(value) {
   if (Array.isArray(value)) {
-    return 'array';
+    return "array";
   } else if (value instanceof Date) {
-    return 'date';
+    return "date";
   } else if (value === null) {
-    return 'null';
+    return "null";
   }
-
   return typeof value;
 }
-
 function migrateConfig(config, oldToNew) {
   function migrate(value) {
+    var _a, _b;
     switch (typeOf(value)) {
-      case 'object':
-        if (value.type === '$jobsMapByNodeId') {
+      case "object":
+        if (value.type === "$jobsMapByNodeId") {
           return {
             ...value,
             options: {
               ...value.options,
-              nodeId: oldToNew.get(value.options?.nodeId)?.id,
-            },
+              nodeId: (_b = oldToNew.get((_a = value.options) == null ? void 0 : _a.nodeId)) == null ? void 0 : _b.id
+            }
           };
         }
         return Object.keys(value).reduce((result, key) => ({ ...result, [key]: migrate(value[key]) }), {});
-      case 'array':
+      case "array":
         return value.map((item) => migrate(item));
-      case 'string':
+      case "string":
         return value.replace(/({{\$jobsMapByNodeId|{{\$scopes)\.([\w-]+)/g, (_, jobVar, oldNodeId) => {
           const newNode = oldToNew.get(Number.parseInt(oldNodeId, 10));
           if (!newNode) {
-            throw new Error('node configurated for result is not existed');
+            throw new Error("node configurated for result is not existed");
           }
           return `${jobVar}.${newNode.id}`;
         });
@@ -91,65 +89,54 @@ function migrateConfig(config, oldToNew) {
         return value;
     }
   }
-
   return migrate(config);
 }
-
-export async function revision(context: Context, next) {
+async function revision(context, next) {
   const { db } = context;
-  const repository = utils.getRepositoryFromParams(context);
+  const repository = actions.utils.getRepositoryFromParams(context);
   const { filterByTk, filter = {} } = context.action.params;
-
   context.body = await db.sequelize.transaction(async (transaction) => {
     const origin = await repository.findOne({
       filterByTk,
       filter,
-      appends: ['nodes'],
+      appends: ["nodes"],
       context,
-      transaction,
+      transaction
     });
-
-    const revisionData = filter.key
-      ? {
-          key: filter.key,
-          title: origin.title,
-          allExecuted: origin.allExecuted,
-        }
-      : {};
-
+    const revisionData = filter.key ? {
+      key: filter.key,
+      title: origin.title,
+      allExecuted: origin.allExecuted
+    } : {};
     const instance = await repository.create({
       values: {
         title: `${origin.title} copy`,
         description: origin.description,
         type: origin.type,
         config: origin.config,
-        ...revisionData,
+        ...revisionData
       },
-      transaction,
+      transaction
     });
-
-    const originalNodesMap = new Map();
+    const originalNodesMap = /* @__PURE__ */ new Map();
     origin.nodes.forEach((node) => {
       originalNodesMap.set(node.id, node);
     });
-
-    const oldToNew = new Map();
-    const newToOld = new Map();
+    const oldToNew = /* @__PURE__ */ new Map();
+    const newToOld = /* @__PURE__ */ new Map();
     for await (const node of origin.nodes) {
       const newNode = await instance.createNode(
         {
           type: node.type,
           config: node.config,
           title: node.title,
-          branchIndex: node.branchIndex,
+          branchIndex: node.branchIndex
         },
-        { transaction },
+        { transaction }
       );
-      // NOTE: keep original node references for later replacement
       oldToNew.set(node.id, newNode);
       newToOld.set(newNode.id, node);
     }
-
     for await (const [oldId, newNode] of oldToNew.entries()) {
       const oldNode = originalNodesMap.get(oldId);
       const newUpstream = oldNode.upstreamId ? oldToNew.get(oldNode.upstreamId) : null;
@@ -160,19 +147,20 @@ export async function revision(context: Context, next) {
       } catch (err) {
         return context.throw(400, err.message);
       }
-
       await newNode.update(
         {
-          upstreamId: newUpstream?.id ?? null,
-          downstreamId: newDownstream?.id ?? null,
-          config: migratedConfig,
+          upstreamId: (newUpstream == null ? void 0 : newUpstream.id) ?? null,
+          downstreamId: (newDownstream == null ? void 0 : newDownstream.id) ?? null,
+          config: migratedConfig
         },
-        { transaction },
+        { transaction }
       );
     }
-
     return instance;
   });
-
   await next();
 }
+
+exports.destroy = destroy;
+exports.revision = revision;
+exports.update = update;

package/dist/server/collections/executions.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var executions_default = {
+  namespace: "workflow.executionLogs",
+  duplicator: "optional",
+  name: "executions",
+  fields: [
+    {
+      type: "belongsTo",
+      name: "workflow"
+    },
+    {
+      type: "uid",
+      name: "key"
+    },
+    {
+      type: "boolean",
+      name: "useTransaction",
+      defaultValue: false
+    },
+    {
+      type: "hasMany",
+      name: "jobs",
+      onDelete: "CASCADE"
+    },
+    {
+      type: "json",
+      name: "context"
+    },
+    {
+      type: "integer",
+      name: "status"
+    }
+  ]
+};
+
+module.exports = executions_default;

package/dist/server/collections/flow_nodes.js

@@ -0,0 +1,56 @@
+'use strict';
+
+var flow_nodes_default = {
+  namespace: "workflow.workflowConfig",
+  duplicator: "required",
+  name: "flow_nodes",
+  fields: [
+    {
+      type: "string",
+      name: "title"
+    },
+    // which workflow belongs to
+    {
+      name: "workflow",
+      type: "belongsTo"
+    },
+    {
+      name: "upstream",
+      type: "belongsTo",
+      target: "flow_nodes"
+    },
+    {
+      name: "branches",
+      type: "hasMany",
+      target: "flow_nodes",
+      sourceKey: "id",
+      foreignKey: "upstreamId"
+    },
+    // only works when upstream node is branching type, such as condition and parallel.
+    // put here because the design of flow-links model is not really necessary for now.
+    // or it should be put into flow-links model.
+    {
+      name: "branchIndex",
+      type: "integer"
+    },
+    // Note: for reasons:
+    // 1. redirect type node to solve cycle flow.
+    // 2. recognize as real next node after branches.
+    {
+      name: "downstream",
+      type: "belongsTo",
+      target: "flow_nodes"
+    },
+    {
+      type: "string",
+      name: "type"
+    },
+    {
+      type: "json",
+      name: "config",
+      defaultValue: {}
+    }
+  ]
+};
+
+module.exports = flow_nodes_default;

package/dist/server/collections/jobs.js

@@ -0,0 +1,33 @@
+'use strict';
+
+var jobs_default = {
+  namespace: "workflow.executionLogs",
+  duplicator: "optional",
+  name: "jobs",
+  fields: [
+    {
+      type: "belongsTo",
+      name: "execution"
+    },
+    {
+      type: "belongsTo",
+      name: "node",
+      target: "flow_nodes"
+    },
+    {
+      type: "belongsTo",
+      name: "upstream",
+      target: "jobs"
+    },
+    {
+      type: "integer",
+      name: "status"
+    },
+    {
+      type: "json",
+      name: "result"
+    }
+  ]
+};
+
+module.exports = jobs_default;