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

package/src/server/instructions/aggregate.ts

@@ -1,42 +0,0 @@
-import { BelongsToManyRepository, DataTypes, HasManyRepository } from '@nocobase/database';
-
-import Processor from '../Processor';
-import { JOB_STATUS } from '../constants';
-import type { FlowNodeModel } from '../types';
-
-const aggregators = {
-  count: 'count',
-  sum: 'sum',
-  avg: 'avg',
-  min: 'min',
-  max: 'max',
-};
-
-export default {
-  async run(node: FlowNodeModel, input, processor: Processor) {
-    const { aggregator, associated, collection, association = {}, params = {} } = node.config;
-    const options = processor.getParsedValue(params);
-    const { database } = <typeof FlowNodeModel>node.constructor;
-    const repo = associated
-      ? database.getRepository<HasManyRepository | BelongsToManyRepository>(
-          `${association?.associatedCollection}.${association.name}`,
-          processor.getParsedValue(association?.associatedKey),
-        )
-      : database.getRepository(collection);
-
-    if (!options.dataType && aggregator === 'avg') {
-      options.dataType = DataTypes.DOUBLE;
-    }
-
-    const result = await repo.aggregate({
-      ...options,
-      method: aggregators[aggregator],
-      transaction: processor.transaction,
-    });
-
-    return {
-      result: options.dataType === DataTypes.DOUBLE ? Number(result) : result,
-      status: JOB_STATUS.RESOLVED,
-    };
-  },
-};

package/src/server/instructions/calculation.ts

@@ -1,41 +0,0 @@
-import { Evaluator, evaluators } from '@nocobase/evaluators';
-import { parse } from '@nocobase/utils';
-import { Instruction } from '.';
-import { Processor } from '..';
-import { JOB_STATUS } from '../constants';
-import type { FlowNodeModel } from '../types';
-
-interface CalculationConfig {
-  dynamic?: boolean | string;
-  engine?: string;
-  expression?: string;
-}
-
-export default {
-  async run(node: FlowNodeModel, prevJob, processor: Processor) {
-    const { dynamic = false } = <CalculationConfig>node.config || {};
-    let { engine = 'math.js', expression = '' } = node.config;
-    let scope = processor.getScope(node);
-    if (dynamic) {
-      const parsed = parse(dynamic)(scope) ?? {};
-      engine = parsed.engine;
-      expression = parsed.expression;
-      scope = parse(node.config.scope ?? '')(scope) ?? {};
-    }
-
-    const evaluator = <Evaluator | undefined>evaluators.get(engine);
-
-    try {
-      const result = evaluator && expression ? evaluator(expression, scope) : null;
-      return {
-        result,
-        status: JOB_STATUS.RESOLVED,
-      };
-    } catch (e) {
-      return {
-        result: e.toString(),
-        status: JOB_STATUS.ERROR,
-      };
-    }
-  },
-} as Instruction;

package/src/server/instructions/condition.ts

@@ -1,172 +0,0 @@
-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/delay.ts

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

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

@@ -1,64 +0,0 @@
-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/manual/collecions/jobs.ts

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

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

@@ -1,50 +0,0 @@
-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/index.ts

@@ -1,12 +0,0 @@
-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);
-}