@nocobase/plugin-workflow 0.11.1-alpha.5 → 0.12.0-alpha.2

package/{src/server/instructions/loop.ts → dist/server/instructions/loop.js}

@@ -1,12 +1,12 @@
-import Processor from '../Processor';
-import { JOB_STATUS } from '../constants';
-import type { FlowNodeModel, JobModel } from '../types';
+'use strict';
+
+var constants = require('../constants');
 
 function getTargetLength(target) {
   let length = 0;
-  if (typeof target === 'number') {
+  if (typeof target === "number") {
     if (target < 0) {
-      throw new Error('Loop target in number type must be greater than 0');
+      throw new Error("Loop target in number type must be greater than 0");
     }
     length = Math.floor(target);
   } else {
@@ -15,57 +15,39 @@ function getTargetLength(target) {
   }
   return length;
 }
-
-export default {
-  async run(node: FlowNodeModel, prevJob: JobModel, processor: Processor) {
+var loop_default = {
+  async run(node, prevJob, processor) {
     const [branch] = processor.getBranches(node);
     const target = processor.getParsedValue(node.config.target, node);
     const length = getTargetLength(target);
-
     if (!branch || !length) {
       return {
-        status: JOB_STATUS.RESOLVED,
-        result: 0,
+        status: constants.JOB_STATUS.RESOLVED,
+        result: 0
       };
     }
-
     const job = await processor.saveJob({
-      status: JOB_STATUS.PENDING,
+      status: constants.JOB_STATUS.PENDING,
       // save loop index
       result: 0,
       nodeId: node.id,
-      upstreamId: prevJob?.id ?? null,
+      upstreamId: (prevJob == null ? void 0 : prevJob.id) ?? null
     });
-
-    // TODO: add loop scope to stack
-    // processor.stack.push({
-    //   label: node.title,
-    //   value: node.id
-    // });
-
     await processor.run(branch, job);
-
     return null;
   },
-
-  async resume(node: FlowNodeModel, branchJob, processor: Processor) {
-    const job = processor.findBranchParentJob(branchJob, node) as JobModel;
+  async resume(node, branchJob, processor) {
+    const job = processor.findBranchParentJob(branchJob, node);
     const loop = processor.nodesMap.get(job.nodeId);
     const [branch] = processor.getBranches(node);
-
     const { result, status } = job;
-    // if loop has been done (resolved / rejected), do not care newly executed branch jobs.
-    if (status !== JOB_STATUS.PENDING) {
+    if (status !== constants.JOB_STATUS.PENDING) {
       return processor.exit();
     }
-
     const nextIndex = result + 1;
-
     const target = processor.getParsedValue(loop.config.target, node);
-    // branchJob.status === JOB_STATUS.RESOLVED means branchJob is done, try next loop or exit as resolved
-    if (branchJob.status > JOB_STATUS.PENDING) {
+    if (branchJob.status > constants.JOB_STATUS.PENDING) {
       job.set({ result: nextIndex });
-
       const length = getTargetLength(target);
       if (nextIndex < length) {
         await processor.saveJob(job);
@@ -73,27 +55,23 @@ export default {
         return null;
       }
     }
-
-    // branchJob.status < JOB_STATUS.PENDING means branchJob is rejected, any rejection should cause loop rejected
     job.set({
-      status: branchJob.status,
+      status: branchJob.status
     });
-
     return job;
   },
-
   getScope(node, index, processor) {
     const target = processor.getParsedValue(node.config.target, node);
     const targets = (Array.isArray(target) ? target : [target]).filter((t) => t != null);
     const length = getTargetLength(target);
-    const item = typeof target === 'number' ? index : targets[index];
-
+    const item = typeof target === "number" ? index : targets[index];
     const result = {
       item,
       index,
-      length,
+      length
     };
-
     return result;
-  },
+  }
 };
+
+module.exports = loop_default;

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

@@ -1,55 +1,39 @@
-import { Context, utils } from '@nocobase/actions';
+'use strict';
 
-import Plugin from '../..';
-import { EXECUTION_STATUS, JOB_STATUS } from '../../constants';
-import ManualInstruction from '.';
+var actions = require('@nocobase/actions');
+var constants = require('../../constants');
 
-export async function submit(context: Context, next) {
-  const repository = utils.getRepositoryFromParams(context);
+async function submit(context, next) {
+  var _a, _b, _c;
+  const repository = actions.utils.getRepositoryFromParams(context);
   const { filterByTk, values } = context.action.params;
   const { currentUser } = context.state;
-
   if (!currentUser) {
     return context.throw(401);
   }
-
-  const plugin: Plugin = context.app.pm.get('workflow') as Plugin;
-  const instruction = plugin.instructions.get('manual') as ManualInstruction;
-
+  const plugin = context.app.pm.get("workflow");
+  const instruction = plugin.instructions.get("manual");
   const userJob = await repository.findOne({
     filterByTk,
     // filter: {
     //   userId: currentUser?.id
     // },
-    appends: ['job', 'node', 'execution', 'workflow'],
-    context,
+    appends: ["job", "node", "execution", "workflow"],
+    context
   });
-
   if (!userJob) {
     return context.throw(404);
   }
-
   const { forms = {} } = userJob.node.config;
-  const [formKey] = Object.keys(values.result ?? {}).filter(key => key !== '_');
-  const actionKey = values.result?._;
-
-  const actionItem = forms[formKey]?.actions?.find((item) => item.key === actionKey);
-  // NOTE: validate status
-  if (
-    userJob.status !== JOB_STATUS.PENDING ||
-    userJob.job.status !== JOB_STATUS.PENDING ||
-    userJob.execution.status !== EXECUTION_STATUS.STARTED ||
-    !userJob.workflow.enabled ||
-    !actionKey || actionItem?.status == null
-  ) {
+  const [formKey] = Object.keys(values.result ?? {}).filter((key) => key !== "_");
+  const actionKey = (_a = values.result) == null ? void 0 : _a._;
+  const actionItem = (_c = (_b = forms[formKey]) == null ? void 0 : _b.actions) == null ? void 0 : _c.find((item) => item.key === actionKey);
+  if (userJob.status !== constants.JOB_STATUS.PENDING || userJob.job.status !== constants.JOB_STATUS.PENDING || userJob.execution.status !== constants.EXECUTION_STATUS.STARTED || !userJob.workflow.enabled || !actionKey || (actionItem == null ? void 0 : actionItem.status) == null) {
     return context.throw(400);
   }
-
   userJob.execution.workflow = userJob.workflow;
   const processor = plugin.createProcessor(userJob.execution);
   await processor.prepare();
-
-  // NOTE: validate assignee
   const assignees = processor.getParsedValue(userJob.node.config.assignees ?? []);
   if (!assignees.includes(currentUser.id) || userJob.userId !== currentUser.id) {
     return context.throw(403);
@@ -57,35 +41,25 @@ export async function submit(context: Context, next) {
   const presetValues = processor.getParsedValue(actionItem.values ?? {}, null, {
     currentUser: currentUser.toJSON(),
     currentRecord: values.result[formKey],
-    currentTime: new Date(),
+    currentTime: /* @__PURE__ */ new Date()
   });
-
   userJob.set({
     status: actionItem.status,
-    result: actionItem.status > JOB_STATUS.PENDING
-      ? { [formKey]: Object.assign(values.result[formKey], presetValues), _: actionKey }
-      : Object.assign(userJob.result ?? {}, values.result),
+    result: actionItem.status > constants.JOB_STATUS.PENDING ? { [formKey]: Object.assign(values.result[formKey], presetValues), _: actionKey } : Object.assign(userJob.result ?? {}, values.result)
   });
-
   const handler = instruction.formTypes.get(forms[formKey].type);
   if (handler && userJob.status) {
     await handler.call(instruction, userJob, forms[formKey], processor);
   }
-
   await userJob.save({ transaction: processor.transaction });
-
   await processor.exit();
-
   context.body = userJob;
   context.status = 202;
-
   await next();
-
   userJob.job.execution = userJob.execution;
   userJob.job.latestUserJob = userJob;
-
-  // NOTE: resume the process and no `await` for quick returning
   processor.logger.info(`manual node (${userJob.nodeId}) action trigger execution (${userJob.execution.id}) to resume`);
-
   plugin.resume(userJob.job);
 }
+
+exports.submit = submit;

package/dist/server/instructions/manual/collecions/jobs.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var jobs_default = {
+  name: "jobs",
+  fields: [
+    {
+      type: "belongsToMany",
+      name: "users",
+      through: "users_jobs"
+    },
+    {
+      type: "hasMany",
+      name: "usersJobs",
+      target: "users_jobs",
+      foreignKey: "jobId",
+      onDelete: "CASCADE"
+    }
+  ]
+};
+
+module.exports = jobs_default;

package/dist/server/instructions/manual/collecions/users.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var users_default = {
+  name: "users",
+  fields: [
+    {
+      type: "belongsToMany",
+      name: "jobs",
+      through: "users_jobs"
+    },
+    {
+      type: "hasMany",
+      name: "usersJobs",
+      target: "users_jobs"
+    }
+  ]
+};
+
+module.exports = users_default;

package/dist/server/instructions/manual/collecions/users_jobs.js

@@ -0,0 +1,52 @@
+'use strict';
+
+var users_jobs_default = {
+  namespace: "workflow.executionLogs",
+  name: "users_jobs",
+  duplicator: "optional",
+  fields: [
+    {
+      type: "bigInt",
+      name: "id",
+      primaryKey: true,
+      autoIncrement: true
+    },
+    {
+      type: "belongsTo",
+      name: "job",
+      target: "jobs",
+      foreignKey: "jobId",
+      primaryKey: false
+    },
+    {
+      type: "belongsTo",
+      name: "user",
+      target: "users",
+      foreignKey: "userId",
+      primaryKey: false
+    },
+    {
+      type: "belongsTo",
+      name: "execution"
+    },
+    {
+      type: "belongsTo",
+      name: "node",
+      target: "flow_nodes"
+    },
+    {
+      type: "belongsTo",
+      name: "workflow"
+    },
+    {
+      type: "integer",
+      name: "status"
+    },
+    {
+      type: "jsonb",
+      name: "result"
+    }
+  ]
+};
+
+module.exports = users_jobs_default;

package/{src/server/instructions/manual/forms/create.ts → dist/server/instructions/manual/forms/create.js}

@@ -1,23 +1,23 @@
-import { Processor } from '../../..';
-import ManualInstruction from '..';
+'use strict';
 
-export default async function (this: ManualInstruction, instance, { collection }, processor: Processor) {
+async function create_default(instance, { collection }, processor) {
   const repo = this.plugin.db.getRepository(collection);
   if (!repo) {
     throw new Error(`collection ${collection} for create data on manual node not found`);
   }
-
   const { _, ...form } = instance.result;
   const [values] = Object.values(form);
   await repo.create({
     values: {
-      ...((values as { [key: string]: any }) ?? {}),
+      ...values ?? {},
       createdBy: instance.userId,
-      updatedBy: instance.userId,
+      updatedBy: instance.userId
     },
     context: {
-      executionId: processor.execution.id,
+      executionId: processor.execution.id
     },
-    transaction: processor.transaction,
+    transaction: processor.transaction
   });
 }
+
+module.exports = create_default;

package/dist/server/instructions/manual/forms/index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var create = require('./create');
+var update = require('./update');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var create__default = /*#__PURE__*/_interopDefault(create);
+var update__default = /*#__PURE__*/_interopDefault(update);
+
+function forms_default({ formTypes }) {
+  formTypes.register("create", create__default.default);
+  formTypes.register("update", update__default.default);
+}
+
+module.exports = forms_default;

package/{src/server/instructions/manual/forms/update.ts → dist/server/instructions/manual/forms/update.js}

@@ -1,23 +1,23 @@
-import { Processor } from '../../..';
-import ManualInstruction from '..';
+'use strict';
 
-export default async function (this: ManualInstruction, instance, { collection, filter = {} }, processor: Processor) {
+async function update_default(instance, { collection, filter = {} }, processor) {
   const repo = this.plugin.db.getRepository(collection);
   if (!repo) {
     throw new Error(`collection ${collection} for update data on manual node not found`);
   }
-
   const { _, ...form } = instance.result;
   const [values] = Object.values(form);
   await repo.update({
     filter: processor.getParsedValue(filter),
     values: {
-      ...((values as { [key: string]: any }) ?? {}),
-      updatedBy: instance.userId,
+      ...values ?? {},
+      updatedBy: instance.userId
     },
     context: {
-      executionId: processor.execution.id,
+      executionId: processor.execution.id
     },
-    transaction: processor.transaction,
+    transaction: processor.transaction
   });
 }
+
+module.exports = update_default;

package/dist/server/instructions/manual/index.js

@@ -0,0 +1,160 @@
+'use strict';
+
+var actions = require('@nocobase/actions');
+var utils = require('@nocobase/utils');
+var constants = require('../../constants');
+var jobsCollection = require('./collecions/jobs');
+var usersCollection = require('./collecions/users');
+var usersJobsCollection = require('./collecions/users_jobs');
+var actions$1 = require('./actions');
+var initFormTypes = require('./forms');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var actions__default = /*#__PURE__*/_interopDefault(actions);
+var jobsCollection__default = /*#__PURE__*/_interopDefault(jobsCollection);
+var usersCollection__default = /*#__PURE__*/_interopDefault(usersCollection);
+var usersJobsCollection__default = /*#__PURE__*/_interopDefault(usersJobsCollection);
+var initFormTypes__default = /*#__PURE__*/_interopDefault(initFormTypes);
+
+const MULTIPLE_ASSIGNED_MODE = {
+  SINGLE: Symbol("single"),
+  ALL: Symbol("all"),
+  ANY: Symbol("any"),
+  ALL_PERCENTAGE: Symbol("all percentage"),
+  ANY_PERCENTAGE: Symbol("any percentage")
+};
+const Modes = {
+  [MULTIPLE_ASSIGNED_MODE.SINGLE]: {
+    getStatus(distribution, assignees) {
+      const done = distribution.find((item) => item.status !== constants.JOB_STATUS.PENDING && item.count > 0);
+      return done ? done.status : null;
+    }
+  },
+  [MULTIPLE_ASSIGNED_MODE.ALL]: {
+    getStatus(distribution, assignees) {
+      const resolved = distribution.find((item) => item.status === constants.JOB_STATUS.RESOLVED);
+      if (resolved && resolved.count === assignees.length) {
+        return constants.JOB_STATUS.RESOLVED;
+      }
+      const rejected = distribution.find((item) => item.status < constants.JOB_STATUS.PENDING);
+      if (rejected && rejected.count) {
+        return rejected.status;
+      }
+      return null;
+    }
+  },
+  [MULTIPLE_ASSIGNED_MODE.ANY]: {
+    getStatus(distribution, assignees) {
+      const resolved = distribution.find((item) => item.status === constants.JOB_STATUS.RESOLVED);
+      if (resolved && resolved.count) {
+        return constants.JOB_STATUS.RESOLVED;
+      }
+      const rejectedCount = distribution.reduce(
+        (count, item) => item.status < constants.JOB_STATUS.PENDING ? count + item.count : count,
+        0
+      );
+      if (rejectedCount === assignees.length) {
+        return constants.JOB_STATUS.REJECTED;
+      }
+      return null;
+    }
+  }
+};
+function getMode(mode) {
+  switch (true) {
+    case mode === 1:
+      return Modes[MULTIPLE_ASSIGNED_MODE.ALL];
+    case mode === -1:
+      return Modes[MULTIPLE_ASSIGNED_MODE.ANY];
+    case mode > 0:
+      return Modes[MULTIPLE_ASSIGNED_MODE.ALL_PERCENTAGE];
+    case mode < 0:
+      return Modes[MULTIPLE_ASSIGNED_MODE.ANY_PERCENTAGE];
+    default:
+      return Modes[MULTIPLE_ASSIGNED_MODE.SINGLE];
+  }
+}
+class manual_default {
+  constructor(plugin) {
+    this.plugin = plugin;
+    plugin.db.collection(usersJobsCollection__default.default);
+    plugin.db.extendCollection(usersCollection__default.default);
+    plugin.db.extendCollection(jobsCollection__default.default);
+    plugin.app.resource({
+      name: "users_jobs",
+      actions: {
+        list: {
+          filter: {
+            $or: [
+              {
+                "workflow.enabled": true
+              },
+              {
+                "workflow.enabled": false,
+                status: {
+                  $ne: constants.JOB_STATUS.PENDING
+                }
+              }
+            ]
+          },
+          handler: actions__default.default.list
+        },
+        submit: actions$1.submit
+      }
+    });
+    initFormTypes__default.default(this);
+  }
+  formTypes = new utils.Registry();
+  async run(node, prevJob, processor) {
+    const { mode, ...config } = node.config;
+    const assignees = [...new Set(processor.getParsedValue(config.assignees) || [])];
+    const job = await processor.saveJob({
+      status: constants.JOB_STATUS.PENDING,
+      result: mode ? [] : null,
+      nodeId: node.id,
+      upstreamId: (prevJob == null ? void 0 : prevJob.id) ?? null
+    });
+    const UserJobModel = processor.options.plugin.db.getModel("users_jobs");
+    await UserJobModel.bulkCreate(
+      assignees.map((userId) => ({
+        userId,
+        jobId: job.id,
+        nodeId: node.id,
+        executionId: job.executionId,
+        workflowId: node.workflowId,
+        status: constants.JOB_STATUS.PENDING
+      })),
+      {
+        transaction: processor.transaction
+      }
+    );
+    return job;
+  }
+  async resume(node, job, processor) {
+    var _a;
+    const { assignees = [], mode } = node.config;
+    const UserJobModel = processor.options.plugin.db.getModel("users_jobs");
+    const distribution = await UserJobModel.count({
+      where: {
+        jobId: job.id
+      },
+      group: ["status"],
+      transaction: processor.transaction
+    });
+    const submitted = distribution.reduce(
+      (count, item) => item.status !== constants.JOB_STATUS.PENDING ? count + item.count : count,
+      0
+    );
+    const status = job.status || (getMode(mode).getStatus(distribution, assignees) ?? constants.JOB_STATUS.PENDING);
+    const result = mode ? (submitted || 0) / assignees.length : ((_a = job.latestUserJob) == null ? void 0 : _a.result) ?? job.result;
+    processor.logger.debug(`manual resume job and next status: ${status}`);
+    job.set({
+      status,
+      result
+    });
+    return job;
+  }
+}
+
+module.exports = manual_default;

package/dist/server/instructions/parallel.js

@@ -0,0 +1,105 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('../constants');
+
+const PARALLEL_MODE = {
+  ALL: "all",
+  ANY: "any",
+  RACE: "race"
+};
+const Modes = {
+  [PARALLEL_MODE.ALL]: {
+    next(previous) {
+      return previous.status >= constants.JOB_STATUS.PENDING;
+    },
+    getStatus(result) {
+      const failedStatus = result.find((status) => status != null && status < constants.JOB_STATUS.PENDING);
+      if (typeof failedStatus !== "undefined") {
+        return failedStatus;
+      }
+      if (result.every((status) => status != null && status === constants.JOB_STATUS.RESOLVED)) {
+        return constants.JOB_STATUS.RESOLVED;
+      }
+      return constants.JOB_STATUS.PENDING;
+    }
+  },
+  [PARALLEL_MODE.ANY]: {
+    next(previous) {
+      return previous.status <= constants.JOB_STATUS.PENDING;
+    },
+    getStatus(result) {
+      if (result.some((status) => status != null && status === constants.JOB_STATUS.RESOLVED)) {
+        return constants.JOB_STATUS.RESOLVED;
+      }
+      if (result.some((status) => status != null ? status === constants.JOB_STATUS.PENDING : true)) {
+        return constants.JOB_STATUS.PENDING;
+      }
+      return constants.JOB_STATUS.FAILED;
+    }
+  },
+  [PARALLEL_MODE.RACE]: {
+    next(previous) {
+      return previous.status === constants.JOB_STATUS.PENDING;
+    },
+    getStatus(result) {
+      if (result.some((status) => status != null && status === constants.JOB_STATUS.RESOLVED)) {
+        return constants.JOB_STATUS.RESOLVED;
+      }
+      const failedStatus = result.find((status) => status != null && status < constants.JOB_STATUS.PENDING);
+      if (typeof failedStatus !== "undefined") {
+        return failedStatus;
+      }
+      return constants.JOB_STATUS.PENDING;
+    }
+  }
+};
+var parallel_default = {
+  async run(node, prevJob, processor) {
+    const branches = processor.getBranches(node);
+    const job = await processor.saveJob({
+      status: constants.JOB_STATUS.PENDING,
+      result: Array(branches.length).fill(null),
+      nodeId: node.id,
+      upstreamId: (prevJob == null ? void 0 : prevJob.id) ?? null
+    });
+    const { mode = PARALLEL_MODE.ALL } = node.config;
+    await branches.reduce(
+      (promise, branch, i) => promise.then(async (previous) => {
+        if (i && !Modes[mode].next(previous)) {
+          return previous;
+        }
+        await processor.run(branch, job);
+        return processor.findBranchLastJob(branch);
+      }),
+      Promise.resolve()
+    );
+    return null;
+  },
+  async resume(node, branchJob, processor) {
+    const job = processor.findBranchParentJob(branchJob, node);
+    const { result, status } = job;
+    if (status !== constants.JOB_STATUS.PENDING) {
+      return processor.exit();
+    }
+    const jobNode = processor.nodesMap.get(branchJob.nodeId);
+    const branchStartNode = processor.findBranchStartNode(jobNode, node);
+    const branches = processor.getBranches(node);
+    const branchIndex = branches.indexOf(branchStartNode);
+    const { mode = PARALLEL_MODE.ALL } = node.config || {};
+    const newResult = [...result.slice(0, branchIndex), branchJob.status, ...result.slice(branchIndex + 1)];
+    job.set({
+      result: newResult,
+      status: Modes[mode].getStatus(newResult)
+    });
+    if (job.status === constants.JOB_STATUS.PENDING) {
+      await job.save({ transaction: processor.transaction });
+      return processor.exit();
+    }
+    return job;
+  }
+};
+
+exports.PARALLEL_MODE = PARALLEL_MODE;
+exports.default = parallel_default;