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

package/src/server/instructions/condition.ts

@@ -0,0 +1,172 @@
+import { evaluators } from '@nocobase/evaluators';
+import { Registry } from '@nocobase/utils';
+import { Instruction } from '.';
+import { Processor } from '..';
+import { JOB_STATUS } from '../constants';
+import type { FlowNodeModel } from '../types';
+
+type Comparer = (a: any, b: any) => boolean;
+
+export const calculators = new Registry<Comparer>();
+
+// built-in functions
+function equal(a, b) {
+  return a === b;
+}
+
+function notEqual(a, b) {
+  return a !== b;
+}
+
+function gt(a, b) {
+  return a > b;
+}
+
+function gte(a, b) {
+  return a >= b;
+}
+
+function lt(a, b) {
+  return a < b;
+}
+
+function lte(a, b) {
+  return a <= b;
+}
+
+calculators.register('equal', equal);
+calculators.register('notEqual', notEqual);
+calculators.register('gt', gt);
+calculators.register('gte', gte);
+calculators.register('lt', lt);
+calculators.register('lte', lte);
+
+calculators.register('===', equal);
+calculators.register('!==', notEqual);
+calculators.register('>', gt);
+calculators.register('>=', gte);
+calculators.register('<', lt);
+calculators.register('<=', lte);
+
+function includes(a, b) {
+  return a.includes(b);
+}
+
+function notIncludes(a, b) {
+  return !a.includes(b);
+}
+
+function startsWith(a: string, b: string) {
+  return a.startsWith(b);
+}
+
+function notStartsWith(a: string, b: string) {
+  return !a.startsWith(b);
+}
+
+function endsWith(a: string, b: string) {
+  return a.endsWith(b);
+}
+
+function notEndsWith(a: string, b: string) {
+  return !a.endsWith(b);
+}
+
+calculators.register('includes', includes);
+calculators.register('notIncludes', notIncludes);
+calculators.register('startsWith', startsWith);
+calculators.register('notStartsWith', notStartsWith);
+calculators.register('endsWith', endsWith);
+calculators.register('notEndsWith', notEndsWith);
+
+type CalculationItem = {
+  calculator?: string;
+  operands?: [any?, any?];
+};
+
+type CalculationGroup = {
+  group: {
+    type: 'and' | 'or';
+    calculations?: Calculation[];
+  };
+};
+
+type Calculation = CalculationItem | CalculationGroup;
+
+function calculate(calculation: CalculationItem = {}) {
+  type NewType = Comparer;
+
+  let fn: NewType;
+  if (!(calculation.calculator && (fn = calculators.get(calculation.calculator)))) {
+    throw new Error(`no calculator function registered for "${calculation.calculator}"`);
+  }
+  return Boolean(fn(...(calculation.operands ?? [])));
+}
+
+function logicCalculate(calculation?: Calculation) {
+  if (!calculation) {
+    return true;
+  }
+
+  if (typeof calculation['group'] === 'object') {
+    const method = calculation['group'].type === 'and' ? 'every' : 'some';
+    return (calculation['group'].calculations ?? [])[method]((item: Calculation) => logicCalculate(item));
+  }
+
+  return calculate(calculation as CalculationItem);
+}
+
+export default {
+  async run(node: FlowNodeModel, prevJob, processor: Processor) {
+    const { engine, calculation, expression, rejectOnFalse } = node.config || {};
+    const evaluator = evaluators.get(engine);
+
+    let result = true;
+
+    try {
+      result = evaluator
+        ? evaluator(expression, processor.getScope())
+        : logicCalculate(processor.getParsedValue(calculation, node));
+    } catch (e) {
+      return {
+        result: e.toString(),
+        status: JOB_STATUS.ERROR,
+      };
+    }
+
+    if (!result && rejectOnFalse) {
+      return {
+        status: JOB_STATUS.FAILED,
+        result,
+      };
+    }
+
+    const job = {
+      status: JOB_STATUS.RESOLVED,
+      result,
+      // TODO(optimize): try unify the building of job
+      nodeId: node.id,
+      upstreamId: (prevJob && prevJob.id) || null,
+    };
+
+    const branchNode = processor.nodes.find((item) => item.upstream === node && Boolean(item.branchIndex) === result);
+
+    if (!branchNode) {
+      return job;
+    }
+
+    const savedJob = await processor.saveJob(job);
+
+    return processor.run(branchNode, savedJob);
+  },
+
+  async resume(node: FlowNodeModel, branchJob, processor: Processor) {
+    if (branchJob.status === JOB_STATUS.RESOLVED) {
+      // return to continue node.downstream
+      return branchJob;
+    }
+
+    // pass control to upper scope by ending current scope
+    return processor.end(node, branchJob);
+  },
+} as Instruction;

package/src/server/instructions/create.ts

@@ -0,0 +1,39 @@
+import { JOB_STATUS } from '../constants';
+import { toJSON } from '../utils';
+import type { FlowNodeModel } from '../types';
+
+export default {
+  async run(node: FlowNodeModel, input, processor) {
+    const { collection, params: { appends = [], ...params } = {} } = node.config;
+
+    const { repository, model } = (<typeof FlowNodeModel>node.constructor).database.getCollection(collection);
+    const options = processor.getParsedValue(params, node);
+    const created = await repository.create({
+      ...options,
+      context: {
+        executionId: processor.execution.id,
+      },
+      transaction: processor.transaction,
+    });
+
+    let result = created;
+    if (created && appends.length) {
+      const includeFields = appends.reduce((set, field) => {
+        set.add(field.split('.')[0]);
+        set.add(field);
+        return set;
+      }, new Set());
+      result = await repository.findOne({
+        filterByTk: created[model.primaryKeyAttribute],
+        appends: Array.from(includeFields),
+        transaction: processor.transaction,
+      });
+    }
+
+    return {
+      // NOTE: get() for non-proxied instance (#380)
+      result: toJSON(result),
+      status: JOB_STATUS.RESOLVED,
+    };
+  },
+};

package/src/server/instructions/delay.ts

@@ -0,0 +1,105 @@
+import Plugin from '..';
+import { EXECUTION_STATUS, JOB_STATUS } from '../constants';
+import Processor from '../Processor';
+import { Instruction } from '.';
+import type { ExecutionModel, JobModel } from '../types';
+
+type ValueOf<T> = T[keyof T];
+
+interface DelayConfig {
+  endStatus: ValueOf<typeof JOB_STATUS>;
+  duration: number;
+}
+
+export default class implements Instruction {
+  timers: Map<number, NodeJS.Timeout> = new Map();
+
+  constructor(protected plugin: Plugin) {
+    plugin.app.on('beforeStart', this.load);
+    plugin.app.on('beforeStop', this.unload);
+  }
+
+  load = async () => {
+    const { model } = this.plugin.db.getCollection('jobs');
+    const jobs = (await model.findAll({
+      where: {
+        status: JOB_STATUS.PENDING,
+      },
+      include: [
+        {
+          association: 'execution',
+          attributes: [],
+          where: {
+            status: EXECUTION_STATUS.STARTED,
+          },
+          required: true,
+        },
+        {
+          association: 'node',
+          attributes: ['config'],
+          where: {
+            type: 'delay',
+          },
+          required: true,
+        },
+      ],
+    })) as JobModel[];
+
+    jobs.forEach((job) => {
+      this.schedule(job);
+    });
+  };
+
+  unload = () => {
+    for (const timer of this.timers.values()) {
+      clearTimeout(timer);
+    }
+
+    this.timers = new Map();
+  };
+
+  schedule(job) {
+    const now = new Date();
+    const createdAt = Date.parse(job.createdAt);
+    const delay = createdAt + job.node.config.duration - now.getTime();
+    if (delay > 0) {
+      const trigger = this.trigger.bind(this, job);
+      this.timers.set(job.id, setTimeout(trigger, delay));
+    } else {
+      this.trigger(job);
+    }
+  }
+
+  async trigger(job) {
+    if (!job.execution) {
+      job.execution = await job.getExecution();
+    }
+    if (job.execution.status === EXECUTION_STATUS.STARTED) {
+      this.plugin.resume(job);
+    }
+    if (this.timers.get(job.id)) {
+      this.timers.delete(job.id);
+    }
+  }
+
+  run = async (node, prevJob, processor: Processor) => {
+    const job = await processor.saveJob({
+      status: JOB_STATUS.PENDING,
+      result: null,
+      nodeId: node.id,
+      upstreamId: prevJob?.id ?? null,
+    });
+    job.node = node;
+
+    // add to schedule
+    this.schedule(job);
+
+    return processor.exit();
+  };
+
+  resume = async (node, prevJob, processor: Processor) => {
+    const { endStatus } = node.config as DelayConfig;
+    prevJob.set('status', endStatus);
+    return prevJob;
+  };
+}

package/src/server/instructions/destroy.ts

@@ -0,0 +1,23 @@
+import { JOB_STATUS } from '../constants';
+import type { FlowNodeModel } from '../types';
+
+export default {
+  async run(node: FlowNodeModel, input, 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.destroy({
+      ...options,
+      context: {
+        executionId: processor.execution.id,
+      },
+      transaction: processor.transaction,
+    });
+
+    return {
+      result,
+      status: JOB_STATUS.RESOLVED,
+    };
+  },
+};

package/src/server/instructions/index.ts

@@ -0,0 +1,64 @@
+import path from 'path';
+
+import { requireModule } from '@nocobase/utils';
+
+import Plugin from '..';
+import Processor from '../Processor';
+
+import type { FlowNodeModel } from '../types';
+
+export type Job = {
+  status: number;
+  result?: unknown;
+  [key: string]: unknown;
+} | null;
+
+export type InstructionResult = Job | Promise<Job>;
+
+export type Runner = (node: FlowNodeModel, input: any, processor: Processor) => InstructionResult;
+
+// what should a instruction do?
+// - base on input and context, do any calculations or system call (io), and produce a result or pending.
+export interface Instruction {
+  run: Runner;
+
+  // for start node in main flow (or branch) to resume when manual sub branch triggered
+  resume?: Runner;
+
+  getScope?: (node: FlowNodeModel, job: any, processor: Processor) => any;
+}
+
+type InstructionConstructor<T> = { new (p: Plugin): T };
+
+export default function <T extends Instruction>(plugin, more: { [key: string]: T | InstructionConstructor<T> } = {}) {
+  const { instructions } = plugin;
+
+  const natives = [
+    'calculation',
+    'condition',
+    'parallel',
+    'loop',
+    'delay',
+    'manual',
+    'query',
+    'create',
+    'update',
+    'destroy',
+    'aggregate',
+    'request',
+    'sql',
+  ].reduce(
+    (result, key) =>
+      Object.assign(result, {
+        [key]: requireModule(path.isAbsolute(key) ? key : path.join(__dirname, key)),
+      }),
+    {},
+  );
+
+  for (const [name, instruction] of Object.entries({ ...more, ...natives })) {
+    instructions.register(
+      name,
+      typeof instruction === 'function' ? new (instruction as InstructionConstructor<T>)(plugin) : instruction,
+    );
+  }
+}

package/src/server/instructions/loop.ts

@@ -0,0 +1,99 @@
+import Processor from '../Processor';
+import { JOB_STATUS } from '../constants';
+import type { FlowNodeModel, JobModel } from '../types';
+
+function getTargetLength(target) {
+  let length = 0;
+  if (typeof target === 'number') {
+    if (target < 0) {
+      throw new Error('Loop target in number type must be greater than 0');
+    }
+    length = Math.floor(target);
+  } else {
+    const targets = (Array.isArray(target) ? target : [target]).filter((t) => t != null);
+    length = targets.length;
+  }
+  return length;
+}
+
+export default {
+  async run(node: FlowNodeModel, prevJob: JobModel, processor: 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,
+      };
+    }
+
+    const job = await processor.saveJob({
+      status: JOB_STATUS.PENDING,
+      // save loop index
+      result: 0,
+      nodeId: node.id,
+      upstreamId: 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;
+    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) {
+      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) {
+      job.set({ result: nextIndex });
+
+      const length = getTargetLength(target);
+      if (nextIndex < length) {
+        await processor.saveJob(job);
+        await processor.run(branch, job);
+        return null;
+      }
+    }
+
+    // branchJob.status < JOB_STATUS.PENDING means branchJob is rejected, any rejection should cause loop rejected
+    job.set({
+      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 result = {
+      item,
+      index,
+      length,
+    };
+
+    return result;
+  },
+};

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

@@ -0,0 +1,91 @@
+import { Context, utils } from '@nocobase/actions';
+
+import Plugin from '../..';
+import { EXECUTION_STATUS, JOB_STATUS } from '../../constants';
+import ManualInstruction from '.';
+
+export async function submit(context: Context, next) {
+  const repository = 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 userJob = await repository.findOne({
+    filterByTk,
+    // filter: {
+    //   userId: currentUser?.id
+    // },
+    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
+  ) {
+    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);
+  }
+  const presetValues = processor.getParsedValue(actionItem.values ?? {}, null, {
+    currentUser: currentUser.toJSON(),
+    currentRecord: values.result[formKey],
+    currentTime: 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),
+  });
+
+  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);
+}

package/src/server/instructions/manual/collecions/jobs.ts

@@ -0,0 +1,17 @@
+export default {
+  name: 'jobs',
+  fields: [
+    {
+      type: 'belongsToMany',
+      name: 'users',
+      through: 'users_jobs',
+    },
+    {
+      type: 'hasMany',
+      name: 'usersJobs',
+      target: 'users_jobs',
+      foreignKey: 'jobId',
+      onDelete: 'CASCADE',
+    },
+  ],
+};

package/src/server/instructions/manual/collecions/users.ts

@@ -0,0 +1,15 @@
+export default {
+  name: 'users',
+  fields: [
+    {
+      type: 'belongsToMany',
+      name: 'jobs',
+      through: 'users_jobs',
+    },
+    {
+      type: 'hasMany',
+      name: 'usersJobs',
+      target: 'users_jobs',
+    },
+  ],
+};

package/src/server/instructions/manual/collecions/users_jobs.ts

@@ -0,0 +1,50 @@
+import { CollectionOptions } from '@nocobase/database';
+
+export 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',
+    },
+  ],
+} as CollectionOptions;

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

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