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

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

@@ -1,184 +0,0 @@
-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

@@ -1,121 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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/20230221032941-change-request-body-type.ts

@@ -1,76 +0,0 @@
-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() {}
-}

package/src/server/migrations/20230221071831-calculation-expression.ts

@@ -1,102 +0,0 @@
-import { Migration } from '@nocobase/server';
-
-function addQuote(v) {
-  if (typeof v !== 'string') {
-    return v;
-  }
-
-  if (v.match(/^{{\s*([^{}]+)\s*}}$/)) {
-    return v;
-  }
-
-  return `'${v}'`;
-}
-
-const calculatorsMap = {
-  equal: '==',
-  '===': '==',
-  notEqual: '!=',
-  '!==': '!=',
-  gt: '>',
-  gte: '>=',
-  lt: '<',
-  lte: '<=',
-  add: '+',
-  minus: '-',
-  multiple: '*',
-  divide: '/',
-  mod: '%',
-  includes(a, b) {
-    return `SEARCH(${b}, ${a}) >= 0`;
-  },
-  notIncludes(a, b) {
-    return `SEARCH(${b}, ${a}) < 0`;
-  },
-  startsWith(a, b) {
-    return `SEARCH(${b}, ${a}) == 0`;
-  },
-  endsWith(a, b) {
-    return `RIGHT(${a}, LEN(${b})) == ${b}`;
-  },
-  notStartsWith(a, b) {
-    return `SEARCH(${b}, ${a}) != 0`;
-  },
-  notEndsWith(a, b) {
-    return `RIGHT(${a}, LEN(${b})) != ${b}`;
-  },
-  concat(a, b) {
-    return `CONCATENATE(${a}, ${b})`;
-  },
-};
-
-function migrateConfig({ calculation, ...config }: any = {}) {
-  if (!calculation?.calculator || !calculation?.operands?.length) {
-    return config;
-  }
-
-  const calculator = calculatorsMap[calculation.calculator];
-  const operands = (calculator.operands ?? []).map((operand) => addQuote(operand));
-
-  return {
-    engine: 'formula.js',
-    expression:
-      typeof calculator === 'function'
-        ? calculator(...operands)
-        : operands.join(` ${calculator ?? calculation.calculator} `),
-  };
-}
-
-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: 'calculation',
-        },
-        transaction,
-      });
-      console.log('%d nodes need to be migrated.', nodes.length);
-
-      await nodes.reduce(
-        (promise, node) =>
-          promise.then(() => {
-            return node.update(
-              {
-                config: migrateConfig(node.config),
-              },
-              {
-                transaction,
-              },
-            );
-          }),
-        Promise.resolve(),
-      );
-    });
-  }
-}