@nocobase/plugin-workflow 0.10.1-alpha.1 → 0.11.1-alpha.1

package/src/server/instructions/manual/forms/index.ts

@@ -0,0 +1,12 @@
+import { Processor } from '../../..';
+import ManualInstruction from '..';
+
+import create from './create';
+import update from './update';
+
+export type FormHandler = (this: ManualInstruction, instance, formConfig, processor: Processor) => Promise<void>;
+
+export default function ({ formTypes }) {
+  formTypes.register('create', create);
+  formTypes.register('update', update);
+}

package/src/server/instructions/manual/forms/update.ts

@@ -0,0 +1,23 @@
+import { Processor } from '../../..';
+import ManualInstruction from '..';
+
+export default async function (this: ManualInstruction, instance, { collection, filter = {} }, processor: 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,
+    },
+    context: {
+      executionId: processor.execution.id,
+    },
+    transaction: processor.transaction,
+  });
+}

package/src/server/instructions/manual/index.ts

@@ -0,0 +1,184 @@
+import actions from '@nocobase/actions';
+import { HandlerType } from '@nocobase/resourcer';
+import { Registry } from '@nocobase/utils';
+
+import Plugin from '../..';
+import { JOB_STATUS } from '../../constants';
+import { Instruction } from '..';
+import jobsCollection from './collecions/jobs';
+import usersCollection from './collecions/users';
+import usersJobsCollection from './collecions/users_jobs';
+import { submit } from './actions';
+import initFormTypes, { FormHandler } from './forms';
+
+type FormType = {
+  type: 'custom' | 'create' | 'update';
+  actions: number[];
+  options: {
+    [key: string]: any;
+  };
+};
+
+export interface ManualConfig {
+  schema: { [key: string]: any };
+  forms: { [key: string]: FormType };
+  assignees?: (number | string)[];
+  mode?: number;
+}
+
+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 !== 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 === JOB_STATUS.RESOLVED);
+      if (resolved && resolved.count === assignees.length) {
+        return JOB_STATUS.RESOLVED;
+      }
+      const rejected = distribution.find((item) => item.status < 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 === JOB_STATUS.RESOLVED);
+      if (resolved && resolved.count) {
+        return JOB_STATUS.RESOLVED;
+      }
+      const rejectedCount = distribution.reduce(
+        (count, item) => (item.status < JOB_STATUS.PENDING ? count + item.count : count),
+        0,
+      );
+      // NOTE: all failures are considered as rejected for now
+      if (rejectedCount === assignees.length) {
+        return 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];
+  }
+}
+
+export default class implements Instruction {
+  formTypes = new Registry<FormHandler>();
+
+  constructor(protected plugin: Plugin) {
+    plugin.db.collection(usersJobsCollection);
+    plugin.db.extendCollection(usersCollection);
+    plugin.db.extendCollection(jobsCollection);
+
+    plugin.app.resource({
+      name: 'users_jobs',
+      actions: {
+        list: {
+          filter: {
+            $or: [
+              {
+                'workflow.enabled': true,
+              },
+              {
+                'workflow.enabled': false,
+                status: {
+                  $ne: JOB_STATUS.PENDING,
+                },
+              },
+            ],
+          },
+          handler: actions.list as HandlerType,
+        },
+        submit,
+      },
+    });
+
+    initFormTypes(this);
+  }
+
+  async run(node, prevJob, processor) {
+    const { mode, ...config } = node.config as ManualConfig;
+    const assignees = [...new Set(processor.getParsedValue(config.assignees) || [])];
+
+    const job = await processor.saveJob({
+      status: JOB_STATUS.PENDING,
+      result: mode ? [] : null,
+      nodeId: node.id,
+      upstreamId: prevJob?.id ?? null,
+    });
+
+    // NOTE: batch create users jobs
+    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: JOB_STATUS.PENDING,
+      })),
+      {
+        transaction: processor.transaction,
+      },
+    );
+
+    return job;
+  }
+
+  async resume(node, job, processor) {
+    // NOTE: check all users jobs related if all done then continue as parallel
+    const { assignees = [], mode } = node.config as ManualConfig;
+
+    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 !== JOB_STATUS.PENDING ? count + item.count : count),
+      0,
+    );
+    const status = job.status || (getMode(mode).getStatus(distribution, assignees) ?? JOB_STATUS.PENDING);
+    const result = mode ? (submitted || 0) / assignees.length : job.latestUserJob?.result ?? job.result;
+    processor.logger.debug(`manual resume job and next status: ${status}`);
+    job.set({
+      status,
+      result,
+    });
+
+    return job;
+  }
+}

package/src/server/instructions/parallel.ts

@@ -0,0 +1,121 @@
+import Processor from '../Processor';
+import { JOB_STATUS } from '../constants';
+import type { FlowNodeModel, JobModel } from '../types';
+
+export const PARALLEL_MODE = {
+  ALL: 'all',
+  ANY: 'any',
+  RACE: 'race',
+} as const;
+
+const Modes = {
+  [PARALLEL_MODE.ALL]: {
+    next(previous) {
+      return previous.status >= JOB_STATUS.PENDING;
+    },
+    getStatus(result) {
+      const failedStatus = result.find((status) => status != null && status < JOB_STATUS.PENDING);
+      if (typeof failedStatus !== 'undefined') {
+        return failedStatus;
+      }
+      if (result.every((status) => status != null && status === JOB_STATUS.RESOLVED)) {
+        return JOB_STATUS.RESOLVED;
+      }
+      return JOB_STATUS.PENDING;
+    },
+  },
+  [PARALLEL_MODE.ANY]: {
+    next(previous) {
+      return previous.status <= JOB_STATUS.PENDING;
+    },
+    getStatus(result) {
+      if (result.some((status) => status != null && status === JOB_STATUS.RESOLVED)) {
+        return JOB_STATUS.RESOLVED;
+      }
+      if (result.some((status) => (status != null ? status === JOB_STATUS.PENDING : true))) {
+        return JOB_STATUS.PENDING;
+      }
+      return JOB_STATUS.FAILED;
+    },
+  },
+  [PARALLEL_MODE.RACE]: {
+    next(previous) {
+      return previous.status === JOB_STATUS.PENDING;
+    },
+    getStatus(result) {
+      if (result.some((status) => status != null && status === JOB_STATUS.RESOLVED)) {
+        return JOB_STATUS.RESOLVED;
+      }
+      const failedStatus = result.find((status) => status != null && status < JOB_STATUS.PENDING);
+      if (typeof failedStatus !== 'undefined') {
+        return failedStatus;
+      }
+      return JOB_STATUS.PENDING;
+    },
+  },
+};
+
+export default {
+  async run(node: FlowNodeModel, prevJob: JobModel, processor: Processor) {
+    const branches = processor.getBranches(node);
+
+    const job = await processor.saveJob({
+      status: JOB_STATUS.PENDING,
+      result: Array(branches.length).fill(null),
+      nodeId: node.id,
+      upstreamId: prevJob?.id ?? null,
+    });
+
+    // NOTE:
+    // use `reduce` but not `Promise.all` here to avoid racing manupulating db.
+    // for users, this is almost equivalent to `Promise.all`,
+    // because of the delay is not significant sensible.
+    // another benifit of this is, it could handle sequenced branches in future.
+    const { mode = PARALLEL_MODE.ALL } = node.config;
+    await branches.reduce(
+      (promise: Promise<any>, branch, i) =>
+        promise.then(async (previous) => {
+          if (i && !Modes[mode].next(previous)) {
+            return previous;
+          }
+          await processor.run(branch, job);
+
+          // find last job of the branch
+          return processor.findBranchLastJob(branch);
+        }),
+      Promise.resolve(),
+    );
+
+    return null;
+  },
+
+  async resume(node: FlowNodeModel, branchJob, processor: Processor) {
+    const job = processor.findBranchParentJob(branchJob, node) as JobModel;
+
+    const { result, status } = job;
+    // if parallel has been done (resolved / rejected), do not care newly executed branch jobs.
+    if (status !== JOB_STATUS.PENDING) {
+      return processor.exit();
+    }
+
+    // find the index of the node which start the branch
+    const jobNode = processor.nodesMap.get(branchJob.nodeId) as FlowNodeModel;
+    const branchStartNode = processor.findBranchStartNode(jobNode, node) as FlowNodeModel;
+    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 === JOB_STATUS.PENDING) {
+      await job.save({ transaction: processor.transaction });
+      return processor.exit();
+    }
+
+    return job;
+  },
+};

package/src/server/instructions/query.ts

@@ -0,0 +1,42 @@
+import Processor from '../Processor';
+import { JOB_STATUS } from '../constants';
+import { toJSON } from '../utils';
+import type { FlowNodeModel } from '../types';
+
+export default {
+  async run(node: FlowNodeModel, input, processor: Processor) {
+    const { collection, multiple, params = {}, failOnEmpty = false } = node.config;
+
+    const repo = (<typeof FlowNodeModel>node.constructor).database.getRepository(collection);
+    const options = processor.getParsedValue(params, node);
+    const appends = options.appends
+      ? Array.from(
+          options.appends.reduce((set, field) => {
+            set.add(field.split('.')[0]);
+            set.add(field);
+            return set;
+          }, new Set()),
+        )
+      : options.appends;
+    const result = await (multiple ? repo.find : repo.findOne).call(repo, {
+      ...options,
+      appends: appends,
+      transaction: processor.transaction,
+    });
+
+    if (failOnEmpty && (multiple ? !result.length : !result)) {
+      return {
+        result,
+        status: JOB_STATUS.FAILED,
+      };
+    }
+
+    // NOTE: `toJSON()` to avoid getting undefined value from Proxied model instance (#380)
+    // e.g. Object.prototype.hasOwnProperty.call(result, 'id') // false
+    // so the properties can not be get by json-templates(object-path)
+    return {
+      result: toJSON(result),
+      status: JOB_STATUS.RESOLVED,
+    };
+  },
+};

package/src/server/instructions/request.ts

@@ -0,0 +1,88 @@
+import axios, { AxiosRequestConfig } from 'axios';
+
+import { Instruction } from './index';
+import { JOB_STATUS } from '../constants';
+import Processor from '../Processor';
+import type { FlowNodeModel } from '../types';
+
+export interface Header {
+  name: string;
+  value: string;
+}
+
+export type RequestConfig = Pick<AxiosRequestConfig, 'url' | 'method' | 'params' | 'data' | 'timeout'> & {
+  headers: Array<Header>;
+  ignoreFail: boolean;
+};
+
+async function request(config) {
+  // default headers
+  const { url, method = 'POST', data, timeout = 5000 } = config;
+  const headers = (config.headers ?? []).reduce((result, header) => {
+    if (header.name.toLowerCase() === 'content-type') {
+      return result;
+    }
+    return Object.assign(result, { [header.name]: header.value });
+  }, {});
+  const params = (config.params ?? []).reduce(
+    (result, param) => Object.assign(result, { [param.name]: param.value }),
+    {},
+  );
+
+  // TODO(feat): only support JSON type for now, should support others in future
+  headers['Content-Type'] = 'application/json';
+
+  return axios.request({
+    url,
+    method,
+    headers,
+    params,
+    data,
+    timeout,
+  });
+}
+
+export default class implements Instruction {
+  constructor(public plugin) {}
+
+  async run(node: FlowNodeModel, prevJob, processor: Processor) {
+    const job = await processor.saveJob({
+      status: JOB_STATUS.PENDING,
+      nodeId: node.id,
+      upstreamId: prevJob?.id ?? null,
+    });
+
+    const config = processor.getParsedValue(node.config, node) as RequestConfig;
+
+    // eslint-disable-next-line promise/catch-or-return
+    request(config)
+      .then((response) => {
+        job.set({
+          status: JOB_STATUS.RESOLVED,
+          result: response.data,
+        });
+      })
+      .catch((error) => {
+        job.set({
+          status: JOB_STATUS.FAILED,
+          result: error.isAxiosError ? error.toJSON() : error.message,
+        });
+      })
+      .finally(() => {
+        processor.logger.info(`request (#${node.id}) response received, status: ${job.get('status')}`);
+        this.plugin.resume(job);
+      });
+
+    processor.logger.info(`request (#${node.id}) sent to "${config.url}", waiting for response...`);
+
+    return processor.exit();
+  }
+
+  async resume(node: FlowNodeModel, job, processor: Processor) {
+    const { ignoreFail } = node.config as RequestConfig;
+    if (ignoreFail) {
+      job.set('status', JOB_STATUS.RESOLVED);
+    }
+    return job;
+  }
+}

package/src/server/instructions/sql.ts

@@ -0,0 +1,25 @@
+import { Processor, JOB_STATUS } from '..';
+import type { FlowNodeModel } from '../types';
+
+export default {
+  async run(node: FlowNodeModel, input, processor: Processor) {
+    const { sequelize } = (<typeof FlowNodeModel>node.constructor).database;
+    const sql = processor.getParsedValue(node.config.sql ?? '', node).trim();
+    if (!sql) {
+      return {
+        status: JOB_STATUS.RESOLVED,
+      }
+    }
+
+    const result = await sequelize.query(sql, {
+      transaction: processor.transaction,
+      // plain: true,
+      // model: db.getCollection(node.config.collection).model
+    });
+
+    return {
+      result,
+      status: JOB_STATUS.RESOLVED,
+    };
+  },
+};

package/src/server/instructions/update.ts

@@ -0,0 +1,24 @@
+import Processor from '../Processor';
+import { JOB_STATUS } from '../constants';
+import type { FlowNodeModel } from '../types';
+
+export default {
+  async run(node: FlowNodeModel, input, processor: Processor) {
+    const { collection, params = {} } = node.config;
+
+    const repo = (<typeof FlowNodeModel>node.constructor).database.getRepository(collection);
+    const options = processor.getParsedValue(params, node);
+    const result = await repo.update({
+      ...options,
+      context: {
+        executionId: processor.execution.id,
+      },
+      transaction: processor.transaction,
+    });
+
+    return {
+      result: result.length ?? result,
+      status: JOB_STATUS.RESOLVED,
+    };
+  },
+};

package/src/server/migrations/20221129153547-calculation-variables.ts

@@ -0,0 +1,64 @@
+import { Migration } from '@nocobase/server';
+
+const VTypes = {
+  constant(operand) {
+    return operand.value;
+  },
+  $jobsMapByNodeId({ options }) {
+    const paths = [options.nodeId, options.path].filter(Boolean);
+    return paths ? `{{$jobsMapByNodeId.${paths.join('.')}}}` : null;
+  },
+  $context({ options }) {
+    return `{{$context.${options.path}}}`;
+  },
+};
+
+function migrateConfig(config) {
+  if (Array.isArray(config)) {
+    return config.map((item) => migrateConfig(item));
+  }
+  if (typeof config !== 'object') {
+    return config;
+  }
+  if (!config) {
+    return config;
+  }
+  if (config.type && VTypes[config.type] && (config.options || config.value)) {
+    return VTypes[config.type](config);
+  }
+  return Object.keys(config).reduce((memo, key) => ({ ...memo, [key]: migrateConfig(config[key]) }), {});
+}
+
+export default class extends Migration {
+  async up() {
+    const match = await this.app.version.satisfies('<=0.8.0-alpha.13');
+    if (!match) {
+      return;
+    }
+    const NodeRepo = this.context.db.getRepository('flow_nodes');
+    await this.context.db.sequelize.transaction(async (transaction) => {
+      const nodes = await NodeRepo.find({
+        filter: {
+          type: {
+            $or: ['calculation', 'condition'],
+          },
+        },
+        transaction,
+      });
+      console.log('%d nodes need to be migrated.', nodes.length);
+
+      await nodes.reduce((promise, node) => {
+        return node.update(
+          {
+            config: migrateConfig(node.config),
+          },
+          {
+            transaction,
+          },
+        );
+      }, Promise.resolve());
+    });
+  }
+
+  async down() {}
+}

package/src/server/migrations/20230221032941-change-request-body-type.ts

@@ -0,0 +1,76 @@
+import { Migration } from '@nocobase/server';
+
+const EJS_RE = /"?<%=\s*(ctx|node)([\w\.\[\]-]+)\s*.*%>"?/;
+
+function migrateData(input) {
+  if (typeof input !== 'string') {
+    return input;
+  }
+  if (!input) {
+    return null;
+  }
+  const typeMap = {
+    ctx: '$context',
+    node: '$jobsMapByNodeId',
+  };
+  return input.replace(EJS_RE, (_, type, path) => {
+    if (type === 'ctx') {
+      return `"{{$context${path}}}"`;
+    }
+    if (type === 'node') {
+      return `"{{$jobsMapByNodeId${path.replace('[', '.').replace(']', '.').replace(/\.$/, '')}}}"`;
+    }
+    return _;
+  });
+}
+
+export default class extends Migration {
+  async up() {
+    const match = await this.app.version.satisfies('<0.9.0-alpha.3');
+    if (!match) {
+      return;
+    }
+
+    const NodeRepo = this.context.db.getRepository('flow_nodes');
+
+    await this.context.db.sequelize.transaction(async (transaction) => {
+      const nodes = await NodeRepo.find({
+        filter: {
+          type: 'request',
+        },
+        transaction,
+      });
+      console.log('%d nodes need to be migrated.', nodes.length);
+
+      await nodes.reduce(
+        (promise, node) =>
+          promise.then(async () => {
+            if (typeof node.config.data !== 'string') {
+              return;
+            }
+            let data = migrateData(node.config.data);
+            try {
+              data = JSON.parse(node.config.data);
+              return node.update(
+                {
+                  config: {
+                    ...node.config,
+                    data,
+                  },
+                },
+                {
+                  transaction,
+                },
+              );
+            } catch (error) {
+              console.error(
+                `flow_node #${node.id} config migrating failed! you should migrate its format from ejs to json-templates manually in your db.`,
+              );
+            }
+          }),
+        Promise.resolve(),
+      );
+    });
+  }
+  async down() {}
+}