@nocobase/plugin-workflow-loop 0.17.0-alpha.4

package/src/server/LoopInstruction.ts

@@ -0,0 +1,97 @@
+import { Processor, Instruction, JOB_STATUS, FlowNodeModel, JobModel } from '@nocobase/plugin-workflow';
+
+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 class extends Instruction {
+  async run(node: FlowNodeModel, prevJob: JobModel, processor: Processor) {
+    const [branch] = processor.getBranches(node);
+    const target = processor.getParsedValue(node.config.target, node.id);
+    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.id);
+    // 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.id);
+    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/Plugin.ts

@@ -0,0 +1,14 @@
+import { Plugin } from '@nocobase/server';
+import { default as WorkflowPlugin } from '@nocobase/plugin-workflow';
+
+import LoopInstruction from './LoopInstruction';
+
+export default class extends Plugin {
+  workflow: WorkflowPlugin;
+
+  async load() {
+    const workflowPlugin = this.app.getPlugin('workflow') as WorkflowPlugin;
+    this.workflow = workflowPlugin;
+    workflowPlugin.instructions.register('loop', new LoopInstruction(workflowPlugin));
+  }
+}

package/src/server/__tests__/instruction.test.ts

@@ -0,0 +1,476 @@
+import Database from '@nocobase/database';
+import { Application } from '@nocobase/server';
+import { BRANCH_INDEX, EXECUTION_STATUS, JOB_STATUS } from '@nocobase/plugin-workflow';
+import { getApp, sleep } from '@nocobase/plugin-workflow-test';
+
+import Plugin from '..';
+
+describe('workflow > instructions > loop', () => {
+  let app: Application;
+  let db: Database;
+  let PostRepo;
+  let WorkflowModel;
+  let workflow;
+  let plugin;
+
+  beforeEach(async () => {
+    app = await getApp({
+      plugins: [Plugin],
+    });
+    plugin = app.pm.get('workflow');
+
+    db = app.db;
+    WorkflowModel = db.getCollection('workflows').model;
+    PostRepo = db.getCollection('posts').repository;
+
+    workflow = await WorkflowModel.create({
+      enabled: true,
+      type: 'collection',
+      config: {
+        mode: 1,
+        collection: 'posts',
+      },
+    });
+  });
+
+  afterEach(() => app.destroy());
+
+  describe('branch', () => {
+    it('no branch just pass', async () => {
+      const n1 = await workflow.createNode({
+        type: 'loop',
+      });
+
+      const n2 = await workflow.createNode({
+        type: 'echo',
+        upstreamId: n1.id,
+      });
+
+      await n1.setDownstream(n2);
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toBe(EXECUTION_STATUS.RESOLVED);
+      const jobs = await execution.getJobs({ order: [['id', 'ASC']] });
+      expect(jobs.length).toBe(2);
+      expect(jobs[0].status).toBe(JOB_STATUS.RESOLVED);
+      expect(jobs[0].result).toBe(0);
+    });
+
+    it('should exit when branch meets error', async () => {
+      const n1 = await workflow.createNode({
+        type: 'loop',
+        config: {
+          target: 2,
+        },
+      });
+
+      const n2 = await workflow.createNode({
+        type: 'error',
+        upstreamId: n1.id,
+        branchIndex: 0,
+      });
+
+      const n3 = await workflow.createNode({
+        type: 'echo',
+        upstreamId: n1.id,
+      });
+
+      await n1.setDownstream(n3);
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toBe(EXECUTION_STATUS.ERROR);
+      const jobs = await execution.getJobs({ order: [['id', 'ASC']] });
+      expect(jobs.length).toBe(2);
+      expect(jobs[0].status).toBe(JOB_STATUS.ERROR);
+      expect(jobs[0].result).toBe(0);
+      expect(jobs[1].status).toBe(JOB_STATUS.ERROR);
+    });
+  });
+
+  describe('config', () => {
+    it('no target just pass', async () => {
+      const n1 = await workflow.createNode({
+        type: 'loop',
+      });
+
+      const n2 = await workflow.createNode({
+        type: 'echo',
+        upstreamId: n1.id,
+        branchIndex: 0,
+      });
+
+      const n3 = await workflow.createNode({
+        type: 'echo',
+        upstreamId: n1.id,
+      });
+
+      await n1.setDownstream(n3);
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toBe(EXECUTION_STATUS.RESOLVED);
+      const jobs = await execution.getJobs({ order: [['id', 'ASC']] });
+      expect(jobs.length).toBe(2);
+      expect(jobs[0].status).toBe(JOB_STATUS.RESOLVED);
+      expect(jobs[0].result).toBe(0);
+    });
+
+    it('null target just pass', async () => {
+      const n1 = await workflow.createNode({
+        type: 'loop',
+        config: {
+          target: null,
+        },
+      });
+
+      const n2 = await workflow.createNode({
+        type: 'echo',
+        upstreamId: n1.id,
+        branchIndex: 0,
+      });
+
+      const n3 = await workflow.createNode({
+        type: 'echo',
+        upstreamId: n1.id,
+      });
+
+      await n1.setDownstream(n3);
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toBe(EXECUTION_STATUS.RESOLVED);
+      const jobs = await execution.getJobs({ order: [['id', 'ASC']] });
+      expect(jobs.length).toBe(2);
+      expect(jobs[0].status).toBe(JOB_STATUS.RESOLVED);
+      expect(jobs[0].result).toBe(0);
+    });
+
+    it('empty array just pass', async () => {
+      const n1 = await workflow.createNode({
+        type: 'loop',
+        config: {
+          target: [],
+        },
+      });
+
+      const n2 = await workflow.createNode({
+        type: 'echo',
+        upstreamId: n1.id,
+        branchIndex: 0,
+      });
+
+      const n3 = await workflow.createNode({
+        type: 'echo',
+        upstreamId: n1.id,
+      });
+
+      await n1.setDownstream(n3);
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toBe(EXECUTION_STATUS.RESOLVED);
+      const jobs = await execution.getJobs({ order: [['id', 'ASC']] });
+      expect(jobs.length).toBe(2);
+      expect(jobs[0].status).toBe(JOB_STATUS.RESOLVED);
+      expect(jobs[0].result).toBe(0);
+    });
+
+    it('target is number, cycle number times', async () => {
+      const n1 = await workflow.createNode({
+        type: 'loop',
+        config: {
+          target: 2.5,
+        },
+      });
+
+      const n2 = await workflow.createNode({
+        type: 'echo',
+        upstreamId: n1.id,
+        branchIndex: 0,
+      });
+
+      const n3 = await workflow.createNode({
+        type: 'echo',
+        upstreamId: n1.id,
+      });
+
+      await n1.setDownstream(n3);
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toBe(EXECUTION_STATUS.RESOLVED);
+      const jobs = await execution.getJobs({ order: [['id', 'ASC']] });
+
+      expect(jobs.length).toBe(4);
+      expect(jobs[0].status).toBe(JOB_STATUS.RESOLVED);
+      expect(jobs[0].result).toBe(2);
+    });
+
+    it('target is no array, set as an array', async () => {
+      const n1 = await workflow.createNode({
+        type: 'loop',
+        config: {
+          target: {},
+        },
+      });
+
+      const n2 = await workflow.createNode({
+        type: 'echo',
+        upstreamId: n1.id,
+        branchIndex: 0,
+      });
+
+      const n3 = await workflow.createNode({
+        type: 'echo',
+        upstreamId: n1.id,
+      });
+
+      await n1.setDownstream(n3);
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toBe(EXECUTION_STATUS.RESOLVED);
+      const jobs = await execution.getJobs({ order: [['id', 'ASC']] });
+
+      expect(jobs.length).toBe(3);
+      expect(jobs[0].status).toBe(JOB_STATUS.RESOLVED);
+      expect(jobs[0].result).toBe(1);
+    });
+
+    it('multiple targets', async () => {
+      const n1 = await workflow.createNode({
+        type: 'loop',
+        config: {
+          target: [1, 2],
+        },
+      });
+
+      const n2 = await workflow.createNode({
+        type: 'echo',
+        upstreamId: n1.id,
+        branchIndex: 0,
+      });
+
+      const n3 = await workflow.createNode({
+        type: 'echo',
+        upstreamId: n1.id,
+      });
+
+      await n1.setDownstream(n3);
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toBe(EXECUTION_STATUS.RESOLVED);
+      const jobs = await execution.getJobs({ order: [['id', 'ASC']] });
+
+      expect(jobs.length).toBe(4);
+      expect(jobs[0].status).toBe(JOB_STATUS.RESOLVED);
+      expect(jobs[0].result).toBe(2);
+      expect(jobs.filter((j) => j.nodeId === n2.id).length).toBe(2);
+    });
+  });
+
+  describe('scope variable', () => {
+    it('item.key', async () => {
+      const n1 = await workflow.createNode({
+        type: 'loop',
+        config: {
+          target: '{{$context.data.comments}}',
+        },
+      });
+
+      const n2 = await workflow.createNode({
+        type: 'calculation',
+        config: {
+          engine: 'formula.js',
+          expression: `{{$scopes.${n1.id}.item.content}}`,
+        },
+        upstreamId: n1.id,
+        branchIndex: 0,
+      });
+
+      const post = await PostRepo.create({
+        values: {
+          title: 't1',
+          comments: [{ content: 'c1' }, { content: 'c2' }],
+        },
+      });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toBe(EXECUTION_STATUS.RESOLVED);
+      const jobs = await execution.getJobs({ order: [['id', 'ASC']] });
+      expect(jobs.length).toBe(3);
+      expect(jobs[1].result).toBe('c1');
+      expect(jobs[2].result).toBe('c2');
+    });
+  });
+
+  describe('mixed', () => {
+    it.skip('loop branch contains parallel branches', async () => {
+      const n1 = await workflow.createNode({
+        type: 'loop',
+        config: {
+          target: 2,
+        },
+      });
+
+      const n2 = await workflow.createNode({
+        type: 'parallel',
+        branchIndex: 0,
+        upstreamId: n1.id,
+        config: {
+          mode: 'any',
+        },
+      });
+
+      const n3 = await workflow.createNode({
+        type: 'condition',
+        config: {
+          rejectOnFalse: true,
+          calculation: {
+            calculator: '<',
+            operands: [`{{$scopes.${n1.id}.item}}`, 1],
+          },
+        },
+        branchIndex: 0,
+        upstreamId: n2.id,
+      });
+      const n4 = await workflow.createNode({
+        type: 'echo',
+        upstreamId: n3.id,
+      });
+      await n3.setDownstream(n4);
+
+      const n5 = await workflow.createNode({
+        type: 'condition',
+        config: {
+          rejectOnFalse: true,
+          calculation: {
+            calculator: '<',
+            operands: [`{{$scopes.${n1.id}.item}}`, 1],
+          },
+        },
+        branchIndex: 1,
+        upstreamId: n2.id,
+      });
+      const n6 = await workflow.createNode({
+        type: 'echo',
+        upstreamId: n5.id,
+      });
+      await n5.setDownstream(n6);
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(1000);
+
+      const [e1] = await workflow.getExecutions();
+      expect(e1.status).toEqual(EXECUTION_STATUS.FAILED);
+      const e1jobs = await e1.getJobs();
+      expect(e1jobs.length).toBe(7);
+    });
+
+    it('condition contains loop (target as 0)', async () => {
+      const n1 = await workflow.createNode({
+        type: 'condition',
+      });
+
+      const n2 = await workflow.createNode({
+        type: 'loop',
+        branchIndex: BRANCH_INDEX.ON_TRUE,
+        upstreamId: n1.id,
+        config: {
+          target: 0,
+        },
+      });
+
+      const n3 = await workflow.createNode({
+        type: 'echo',
+        branchIndex: 0,
+        upstreamId: n2.id,
+      });
+
+      const n4 = await workflow.createNode({
+        type: 'echo',
+        upstreamId: n1.id,
+      });
+
+      await n1.setDownstream(n4);
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [e1] = await workflow.getExecutions();
+      expect(e1.status).toEqual(EXECUTION_STATUS.RESOLVED);
+      const jobs = await e1.getJobs({ order: [['id', 'ASC']] });
+      expect(jobs.length).toBe(3);
+      expect(jobs[0].status).toBe(JOB_STATUS.RESOLVED);
+    });
+
+    it('condition contains loop (target as 2)', async () => {
+      const n1 = await workflow.createNode({
+        type: 'condition',
+      });
+
+      const n2 = await workflow.createNode({
+        type: 'loop',
+        branchIndex: BRANCH_INDEX.ON_TRUE,
+        upstreamId: n1.id,
+        config: {
+          target: 2,
+        },
+      });
+
+      const n3 = await workflow.createNode({
+        type: 'echo',
+        branchIndex: 0,
+        upstreamId: n2.id,
+      });
+
+      const n4 = await workflow.createNode({
+        type: 'echo',
+        upstreamId: n1.id,
+      });
+
+      await n1.setDownstream(n4);
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [e1] = await workflow.getExecutions();
+      expect(e1.status).toEqual(EXECUTION_STATUS.RESOLVED);
+      const jobs = await e1.getJobs({ order: [['id', 'ASC']] });
+      expect(jobs.length).toBe(5);
+      expect(jobs[0].status).toBe(JOB_STATUS.RESOLVED);
+    });
+  });
+});

package/src/server/index.ts

@@ -0,0 +1 @@
+export { default } from './Plugin';