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

package/{src/server/Processor.ts → dist/server/Processor.js}

@@ -1,104 +1,77 @@
-import { Model, Transaction, Transactionable } from '@nocobase/database';
-import { appendArrayColumn } from '@nocobase/evaluators';
-import { Logger } from '@nocobase/logger';
-import { parse } from '@nocobase/utils';
-import Plugin from '.';
-import { EXECUTION_STATUS, JOB_STATUS } from './constants';
-import { Runner } from './instructions';
-import type { ExecutionModel, FlowNodeModel, JobModel } from './types';
+'use strict';
 
-export interface ProcessorOptions extends Transactionable {
-  plugin: Plugin;
-}
-
-export default class Processor {
-  static StatusMap = {
-    [JOB_STATUS.PENDING]: EXECUTION_STATUS.STARTED,
-    [JOB_STATUS.RESOLVED]: EXECUTION_STATUS.RESOLVED,
-    [JOB_STATUS.FAILED]: EXECUTION_STATUS.FAILED,
-    [JOB_STATUS.ERROR]: EXECUTION_STATUS.ERROR,
-    [JOB_STATUS.ABORTED]: EXECUTION_STATUS.ABORTED,
-    [JOB_STATUS.CANCELED]: EXECUTION_STATUS.CANCELED,
-    [JOB_STATUS.REJECTED]: EXECUTION_STATUS.REJECTED,
-  };
-
-  logger: Logger;
-
-  transaction?: Transaction;
-
-  nodes: FlowNodeModel[] = [];
-  nodesMap = new Map<number, FlowNodeModel>();
-  jobsMap = new Map<number, JobModel>();
-  jobsMapByNodeId: { [key: number]: any } = {};
+var database = require('@nocobase/database');
+var evaluators = require('@nocobase/evaluators');
+var utils = require('@nocobase/utils');
+var constants = require('./constants');
 
-  constructor(public execution: ExecutionModel, public options: ProcessorOptions) {
+class Processor {
+  constructor(execution, options) {
+    this.execution = execution;
+    this.options = options;
     this.logger = options.plugin.getLogger(execution.workflowId);
   }
-
+  static StatusMap = {
+    [constants.JOB_STATUS.PENDING]: constants.EXECUTION_STATUS.STARTED,
+    [constants.JOB_STATUS.RESOLVED]: constants.EXECUTION_STATUS.RESOLVED,
+    [constants.JOB_STATUS.FAILED]: constants.EXECUTION_STATUS.FAILED,
+    [constants.JOB_STATUS.ERROR]: constants.EXECUTION_STATUS.ERROR,
+    [constants.JOB_STATUS.ABORTED]: constants.EXECUTION_STATUS.ABORTED,
+    [constants.JOB_STATUS.CANCELED]: constants.EXECUTION_STATUS.CANCELED,
+    [constants.JOB_STATUS.REJECTED]: constants.EXECUTION_STATUS.REJECTED
+  };
+  logger;
+  transaction;
+  nodes = [];
+  nodesMap = /* @__PURE__ */ new Map();
+  jobsMap = /* @__PURE__ */ new Map();
+  jobsMapByNodeId = {};
   // make dual linked nodes list then cache
-  private makeNodes(nodes: FlowNodeModel[] = []) {
+  makeNodes(nodes = []) {
     this.nodes = nodes;
-
     nodes.forEach((node) => {
       this.nodesMap.set(node.id, node);
     });
-
     nodes.forEach((node) => {
       if (node.upstreamId) {
-        node.upstream = this.nodesMap.get(node.upstreamId) as FlowNodeModel;
+        node.upstream = this.nodesMap.get(node.upstreamId);
       }
-
       if (node.downstreamId) {
-        node.downstream = this.nodesMap.get(node.downstreamId) as FlowNodeModel;
+        node.downstream = this.nodesMap.get(node.downstreamId);
       }
     });
   }
-
-  private makeJobs(jobs: Array<JobModel>) {
+  makeJobs(jobs) {
     jobs.forEach((job) => {
       this.jobsMap.set(job.id, job);
-      // TODO: should consider cycle, and from previous job
       this.jobsMapByNodeId[job.nodeId] = job.result;
     });
   }
-
-  private async getTransaction() {
+  async getTransaction() {
     if (!this.execution.useTransaction) {
       return;
     }
-
     const { options } = this;
-
-    // @ts-ignore
-    return options.transaction && !options.transaction.finished
-      ? options.transaction
-      : await options.plugin.db.sequelize.transaction();
+    return options.transaction && !options.transaction.finished ? options.transaction : await options.plugin.db.sequelize.transaction();
   }
-
-  public async prepare() {
+  async prepare() {
     const transaction = await this.getTransaction();
     this.transaction = transaction;
-
     const { execution } = this;
     if (!execution.workflow) {
       execution.workflow = await execution.getWorkflow({ transaction });
     }
-
     const nodes = await execution.workflow.getNodes({ transaction });
-
     this.makeNodes(nodes);
-
     const jobs = await execution.getJobs({
-      order: [['id', 'ASC']],
-      transaction,
+      order: [["id", "ASC"]],
+      transaction
     });
-
     this.makeJobs(jobs);
   }
-
-  public async start() {
+  async start() {
     const { execution } = this;
-    if (execution.status !== EXECUTION_STATUS.STARTED) {
+    if (execution.status !== constants.EXECUTION_STATUS.STARTED) {
       throw new Error(`execution was ended with status ${execution.status}`);
     }
     await this.prepare();
@@ -106,31 +79,26 @@ export default class Processor {
       const head = this.nodes.find((item) => !item.upstream);
       await this.run(head, { result: execution.context });
     } else {
-      await this.exit(JOB_STATUS.RESOLVED);
+      await this.exit(constants.JOB_STATUS.RESOLVED);
     }
   }
-
-  public async resume(job: JobModel) {
+  async resume(job) {
     const { execution } = this;
-    if (execution.status !== EXECUTION_STATUS.STARTED) {
+    if (execution.status !== constants.EXECUTION_STATUS.STARTED) {
       throw new Error(`execution was ended with status ${execution.status}`);
     }
     await this.prepare();
     const node = this.nodesMap.get(job.nodeId);
     await this.recall(node, job);
   }
-
-  private async commit() {
-    // @ts-ignore
+  async commit() {
     if (this.transaction && (!this.options.transaction || this.options.transaction.finished)) {
       await this.transaction.commit();
     }
   }
-
-  private async exec(instruction: Runner, node: FlowNodeModel, prevJob) {
+  async exec(instruction, node, prevJob) {
     let job;
     try {
-      // call instruction to get result and status
       this.logger.info(`execution (${this.execution.id}) run instruction [${node.type}] for node (${node.id})`);
       this.logger.debug(`config of node`, { data: node.config });
       job = await instruction(node, prevJob, this);
@@ -138,129 +106,102 @@ export default class Processor {
         return null;
       }
     } catch (err) {
-      // for uncaught error, set to error
       this.logger.error(
         `execution (${this.execution.id}) run instruction [${node.type}] for node (${node.id}) failed: `,
-        { error: err },
+        { error: err }
       );
       job = {
-        result:
-          err instanceof Error
-            ? { message: err.message, stack: process.env.NODE_ENV === 'production' ? [] : err.stack }
-            : err,
-        status: JOB_STATUS.ERROR,
+        result: err instanceof Error ? { message: err.message, stack: process.env.NODE_ENV === "production" ? [] : err.stack } : err,
+        status: constants.JOB_STATUS.ERROR
       };
-      // if previous job is from resuming
       if (prevJob && prevJob.nodeId === node.id) {
         prevJob.set(job);
         job = prevJob;
       }
     }
-
-    if (!(job instanceof Model)) {
-      job.upstreamId = prevJob instanceof Model ? prevJob.get('id') : null;
+    if (!(job instanceof database.Model)) {
+      job.upstreamId = prevJob instanceof database.Model ? prevJob.get("id") : null;
       job.nodeId = node.id;
     }
     const savedJob = await this.saveJob(job);
-
     this.logger.info(
-      `execution (${this.execution.id}) run instruction [${node.type}] for node (${node.id}) finished as status: ${savedJob.status}`,
+      `execution (${this.execution.id}) run instruction [${node.type}] for node (${node.id}) finished as status: ${savedJob.status}`
     );
     this.logger.debug(`result of node`, { data: savedJob.result });
-
-    if (savedJob.status === JOB_STATUS.RESOLVED && node.downstream) {
-      // run next node
+    if (savedJob.status === constants.JOB_STATUS.RESOLVED && node.downstream) {
       this.logger.debug(`run next node (${node.downstreamId})`);
       return this.run(node.downstream, savedJob);
     }
-
-    // all nodes in scope have been executed
     return this.end(node, savedJob);
   }
-
-  public async run(node, input?) {
+  async run(node, input) {
     const { instructions } = this.options.plugin;
     const instruction = instructions.get(node.type);
-    if (typeof instruction.run !== 'function') {
-      return Promise.reject(new Error('`run` should be implemented for customized execution of the node'));
+    if (typeof instruction.run !== "function") {
+      return Promise.reject(new Error("`run` should be implemented for customized execution of the node"));
     }
-
     return this.exec(instruction.run.bind(instruction), node, input);
   }
-
   // parent node should take over the control
-  public async end(node, job: JobModel) {
+  async end(node, job) {
     this.logger.debug(`branch ended at node (${node.id})`);
     const parentNode = this.findBranchParentNode(node);
-    // no parent, means on main flow
     if (parentNode) {
       this.logger.debug(`not on main, recall to parent entry node (${node.id})})`);
       await this.recall(parentNode, job);
       return job;
     }
-
-    // really done for all nodes
-    // * should mark execution as done with last job status
     return this.exit(job.status);
   }
-
   async recall(node, job) {
     const { instructions } = this.options.plugin;
     const instruction = instructions.get(node.type);
-    if (typeof instruction.resume !== 'function') {
-      return Promise.reject(new Error('`resume` should be implemented'));
+    if (typeof instruction.resume !== "function") {
+      return Promise.reject(new Error("`resume` should be implemented"));
     }
-
     return this.exec(instruction.resume.bind(instruction), node, job);
   }
-
-  async exit(s?: number) {
-    if (typeof s === 'number') {
-      const status = (<typeof Processor>this.constructor).StatusMap[s] ?? Math.sign(s);
+  async exit(s) {
+    if (typeof s === "number") {
+      const status = this.constructor.StatusMap[s] ?? Math.sign(s);
       await this.execution.update({ status }, { transaction: this.transaction });
     }
     this.logger.info(`execution (${this.execution.id}) exiting with status ${this.execution.status}`);
     await this.commit();
     return null;
   }
-
   // TODO(optimize)
   async saveJob(payload) {
-    const { database } = <typeof ExecutionModel>this.execution.constructor;
-    const { model } = database.getCollection('jobs');
+    const { database } = this.execution.constructor;
+    const { model } = database.getCollection("jobs");
     let job;
     if (payload instanceof model) {
       job = await payload.save({ transaction: this.transaction });
     } else if (payload.id) {
       job = await model.findByPk(payload.id);
       await job.update(payload, {
-        transaction: this.transaction,
+        transaction: this.transaction
       });
     } else {
       job = await model.create(
         {
           ...payload,
-          executionId: this.execution.id,
+          executionId: this.execution.id
         },
         {
-          transaction: this.transaction,
-        },
+          transaction: this.transaction
+        }
       );
     }
     this.jobsMap.set(job.id, job);
     this.jobsMapByNodeId[job.nodeId] = job.result;
-
     return job;
   }
-
-  getBranches(node: FlowNodeModel): FlowNodeModel[] {
-    return this.nodes
-      .filter((item) => item.upstream === node && item.branchIndex !== null)
-      .sort((a, b) => Number(a.branchIndex) - Number(b.branchIndex));
+  getBranches(node) {
+    return this.nodes.filter((item) => item.upstream === node && item.branchIndex !== null).sort((a, b) => Number(a.branchIndex) - Number(b.branchIndex));
   }
-
   // find the first node in current branch
-  findBranchStartNode(node: FlowNodeModel, parent?: FlowNodeModel): FlowNodeModel | null {
+  findBranchStartNode(node, parent) {
     for (let n = node; n; n = n.upstream) {
       if (!parent) {
         if (n.branchIndex !== null) {
@@ -274,9 +215,8 @@ export default class Processor {
     }
     return null;
   }
-
   // find the node start current branch
-  findBranchParentNode(node: FlowNodeModel): FlowNodeModel | null {
+  findBranchParentNode(node) {
     for (let n = node; n; n = n.upstream) {
       if (n.branchIndex !== null) {
         return n.upstream;
@@ -284,8 +224,7 @@ export default class Processor {
     }
     return null;
   }
-
-  findBranchEndNode(node: FlowNodeModel): FlowNodeModel | null {
+  findBranchEndNode(node) {
     for (let n = node; n; n = n.downstream) {
       if (!n.downstream) {
         return n;
@@ -293,62 +232,56 @@ export default class Processor {
     }
     return null;
   }
-
-  findBranchParentJob(job: JobModel, node: FlowNodeModel): JobModel | null {
-    for (let j: JobModel | undefined = job; j; j = this.jobsMap.get(j.upstreamId)) {
+  findBranchParentJob(job, node) {
+    for (let j = job; j; j = this.jobsMap.get(j.upstreamId)) {
       if (j.nodeId === node.id) {
         return j;
       }
     }
     return null;
   }
-
-  findBranchLastJob(node: FlowNodeModel): JobModel | null {
+  findBranchLastJob(node) {
     for (let n = this.findBranchEndNode(node); n && n !== node.upstream; n = n.upstream) {
-      const jobs = Array.from(this.jobsMap.values())
-        .filter((item) => item.nodeId === n.id)
-        .sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+      const jobs = Array.from(this.jobsMap.values()).filter((item) => item.nodeId === n.id).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
       if (jobs.length) {
         return jobs[jobs.length - 1];
       }
     }
     return null;
   }
-
-  public getScope(node?) {
+  getScope(node) {
     const systemFns = {};
     const scope = {
       execution: this.execution,
-      node,
+      node
     };
     for (const [name, fn] of this.options.plugin.functions.getEntities()) {
       systemFns[name] = fn.bind(scope);
     }
-
     const $scopes = {};
     if (node) {
       for (let n = this.findBranchParentNode(node); n; n = this.findBranchParentNode(n)) {
         const instruction = this.options.plugin.instructions.get(n.type);
-        if (typeof instruction.getScope === 'function') {
+        if (typeof instruction.getScope === "function") {
           $scopes[n.id] = instruction.getScope(n, this.jobsMapByNodeId[n.id], this);
         }
       }
     }
-
     return {
       $context: this.execution.context,
       $jobsMapByNodeId: this.jobsMapByNodeId,
       $system: systemFns,
-      $scopes,
+      $scopes
     };
   }
-
-  public getParsedValue(value, node?, additionalScope?: object) {
-    const template = parse(value);
+  getParsedValue(value, node, additionalScope) {
+    const template = utils.parse(value);
     const scope = Object.assign(this.getScope(node), additionalScope);
     template.parameters.forEach(({ key }) => {
-      appendArrayColumn(scope, key);
+      evaluators.appendArrayColumn(scope, key);
     });
     return template(scope);
   }
 }
+
+module.exports = Processor;

package/dist/server/actions/index.js

@@ -0,0 +1,49 @@
+'use strict';
+
+var workflows = require('./workflows');
+var nodes = require('./nodes');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var workflows__namespace = /*#__PURE__*/_interopNamespace(workflows);
+var nodes__namespace = /*#__PURE__*/_interopNamespace(nodes);
+
+function make(name, mod) {
+  return Object.keys(mod).reduce(
+    (result, key) => ({
+      ...result,
+      [`${name}:${key}`]: mod[key]
+    }),
+    {}
+  );
+}
+function actions_default({ app }) {
+  app.actions({
+    ...make("workflows", workflows__namespace),
+    ...make("workflows.nodes", {
+      create: nodes__namespace.create,
+      destroy: nodes__namespace.destroy
+    }),
+    ...make("flow_nodes", {
+      update: nodes__namespace.update
+    })
+  });
+}
+
+module.exports = actions_default;