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

package/src/server/__tests__/instructions/condition.test.ts

@@ -0,0 +1,335 @@
+import { Application } from '@nocobase/server';
+import Database from '@nocobase/database';
+import { getApp, sleep } from '..';
+import { EXECUTION_STATUS, BRANCH_INDEX } from '../../constants';
+
+describe('workflow > instructions > condition', () => {
+  let app: Application;
+  let db: Database;
+  let PostRepo;
+  let WorkflowModel;
+  let workflow;
+
+  beforeEach(async () => {
+    app = await getApp();
+
+    db = app.db;
+    WorkflowModel = db.getCollection('workflows').model;
+    PostRepo = db.getCollection('posts').repository;
+
+    workflow = await WorkflowModel.create({
+      title: 'test workflow',
+      enabled: true,
+      type: 'collection',
+      config: {
+        mode: 1,
+        collection: 'posts',
+      },
+    });
+  });
+
+  afterEach(() => db.close());
+
+  describe('config.rejectOnFalse', () => {});
+
+  describe('single calculation', () => {
+    it('calculation to true downstream', async () => {
+      const n1 = await workflow.createNode({
+        title: 'condition',
+        type: 'condition',
+        config: {
+          engine: 'math.js',
+          expression: '1 == 1',
+        },
+      });
+
+      const n2 = await workflow.createNode({
+        title: 'true to echo',
+        type: 'echo',
+        branchIndex: BRANCH_INDEX.ON_TRUE,
+        upstreamId: n1.id,
+      });
+
+      const n3 = await workflow.createNode({
+        title: 'false to echo',
+        type: 'echo',
+        branchIndex: BRANCH_INDEX.ON_FALSE,
+        upstreamId: n1.id,
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toEqual(EXECUTION_STATUS.RESOLVED);
+
+      const jobs = await execution.getJobs();
+      expect(jobs.length).toEqual(2);
+      expect(jobs[1].result).toEqual(true);
+    });
+
+    it('calculation to false downstream', async () => {
+      const n1 = await workflow.createNode({
+        title: 'condition',
+        type: 'condition',
+        config: {
+          engine: 'math.js',
+          // false
+          expression: '0 == 1',
+        },
+      });
+
+      await workflow.createNode({
+        title: 'true to echo',
+        type: 'echo',
+        branchIndex: BRANCH_INDEX.ON_TRUE,
+        upstreamId: n1.id,
+      });
+
+      await workflow.createNode({
+        title: 'false to echo',
+        type: 'echo',
+        branchIndex: BRANCH_INDEX.ON_FALSE,
+        upstreamId: n1.id,
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toEqual(EXECUTION_STATUS.RESOLVED);
+
+      const jobs = await execution.getJobs();
+      expect(jobs.length).toEqual(2);
+      expect(jobs[1].result).toEqual(false);
+    });
+  });
+
+  describe('group calculation', () => {
+    it('and true', async () => {
+      const n1 = await workflow.createNode({
+        type: 'condition',
+        config: {
+          calculation: {
+            group: {
+              type: 'and',
+              calculations: [
+                { calculator: 'equal', operands: [1, 1] },
+                { calculator: 'equal', operands: [1, 1] },
+              ],
+            },
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.result).toBe(true);
+    });
+
+    it('and false', async () => {
+      const n1 = await workflow.createNode({
+        type: 'condition',
+        config: {
+          calculation: {
+            group: {
+              type: 'and',
+              calculations: [
+                { calculator: 'equal', operands: [1, 1] },
+                { calculator: 'equal', operands: [0, 1] },
+              ],
+            },
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.result).toBe(false);
+    });
+
+    it('or true', async () => {
+      const n1 = await workflow.createNode({
+        type: 'condition',
+        config: {
+          calculation: {
+            group: {
+              type: 'or',
+              calculations: [
+                { calculator: 'equal', operands: [1, 1] },
+                { calculator: 'equal', operands: [0, 1] },
+              ],
+            },
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions({ include: ['jobs'] });
+      const [job] = execution.jobs;
+      expect(job.result).toBe(true);
+    });
+
+    it('or false', async () => {
+      const n1 = await workflow.createNode({
+        type: 'condition',
+        config: {
+          calculation: {
+            group: {
+              type: 'and',
+              calculations: [
+                { calculator: 'equal', operands: [0, 1] },
+                { calculator: 'equal', operands: [0, 1] },
+              ],
+            },
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.result).toBe(false);
+    });
+
+    it('nested', async () => {
+      const n1 = await workflow.createNode({
+        type: 'condition',
+        config: {
+          calculation: {
+            group: {
+              type: 'and',
+              calculations: [
+                { calculator: 'equal', operands: [1, 1] },
+                {
+                  group: {
+                    type: 'or',
+                    calculations: [
+                      { calculator: 'equal', operands: [0, 1] },
+                      { calculator: 'equal', operands: [0, 1] },
+                    ],
+                  },
+                },
+              ],
+            },
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.result).toBe(false);
+    });
+  });
+
+  describe('engines', () => {
+    it('default as basic', async () => {
+      const n1 = await workflow.createNode({
+        title: 'condition',
+        type: 'condition',
+        config: {
+          calculation: {
+            calculator: 'equal',
+            operands: [1, '{{$context.data.read}}'],
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { read: 1 } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toEqual(EXECUTION_STATUS.RESOLVED);
+
+      const [job] = await execution.getJobs();
+      expect(job.result).toEqual(true);
+    });
+
+    it('basic engine', async () => {
+      const n1 = await workflow.createNode({
+        title: 'condition',
+        type: 'condition',
+        config: {
+          engine: 'basic',
+          calculation: {
+            calculator: 'equal',
+            operands: [1, '{{$context.data.read}}'],
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { read: 1 } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toEqual(EXECUTION_STATUS.RESOLVED);
+
+      const [job] = await execution.getJobs();
+      expect(job.result).toEqual(true);
+    });
+
+    it('math.js', async () => {
+      const n1 = await workflow.createNode({
+        title: 'condition',
+        type: 'condition',
+        config: {
+          engine: 'math.js',
+          expression: '1 == 1',
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toEqual(EXECUTION_STATUS.RESOLVED);
+
+      const [job] = await execution.getJobs();
+      expect(job.result).toEqual(true);
+    });
+
+    it('formula.js', async () => {
+      const n1 = await workflow.createNode({
+        title: 'condition',
+        type: 'condition',
+        config: {
+          engine: 'formula.js',
+          expression: '1 == 1',
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toEqual(EXECUTION_STATUS.RESOLVED);
+
+      const [job] = await execution.getJobs();
+      expect(job.result).toEqual(true);
+    });
+  });
+});

package/src/server/__tests__/instructions/create.test.ts

@@ -0,0 +1,129 @@
+import { Application } from '@nocobase/server';
+import Database from '@nocobase/database';
+import { getApp, sleep } from '..';
+
+describe('workflow > instructions > create', () => {
+  let app: Application;
+  let db: Database;
+  let PostRepo;
+  let ReplyRepo;
+  let WorkflowModel;
+  let workflow;
+
+  beforeEach(async () => {
+    app = await getApp();
+
+    db = app.db;
+    WorkflowModel = db.getCollection('workflows').model;
+    PostRepo = db.getCollection('posts').repository;
+    ReplyRepo = db.getCollection('replies').repository;
+
+    workflow = await WorkflowModel.create({
+      title: 'test workflow',
+      enabled: true,
+      type: 'collection',
+      config: {
+        mode: 1,
+        collection: 'posts',
+      },
+    });
+  });
+
+  afterEach(() => db.close());
+
+  describe('create one', () => {
+    it('params: from context', async () => {
+      const n1 = await workflow.createNode({
+        type: 'create',
+        config: {
+          collection: 'comments',
+          params: {
+            values: {
+              postId: '{{$context.data.id}}',
+            },
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.result.postId).toBe(post.id);
+    });
+
+    it('params.values with hasMany', async () => {
+      const replies = await ReplyRepo.create({ values: [{}, {}] });
+
+      const n1 = await workflow.createNode({
+        type: 'create',
+        config: {
+          collection: 'comments',
+          params: {
+            values: {
+              replies: replies.map((item) => item.id),
+            },
+            appends: ['replies'],
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.result.replies.length).toBe(2);
+    });
+
+    it('params.appends: belongsTo', async () => {
+      const n1 = await workflow.createNode({
+        type: 'create',
+        config: {
+          collection: 'comments',
+          params: {
+            values: {
+              postId: '{{$context.data.id}}',
+            },
+            appends: ['post'],
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.result.post.id).toBe(post.id);
+    });
+
+    it('params.appends: belongsToMany', async () => {
+      const n1 = await workflow.createNode({
+        type: 'create',
+        config: {
+          collection: 'tags',
+          params: {
+            values: {
+              posts: ['{{$context.data.id}}'],
+            },
+            appends: ['posts'],
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.result.posts.length).toBe(1);
+      expect(job.result.posts[0].id).toBe(post.id);
+    });
+  });
+});

package/src/server/__tests__/instructions/delay.test.ts

@@ -0,0 +1,182 @@
+import Database from '@nocobase/database';
+import { Application } from '@nocobase/server';
+import { getApp, sleep } from '..';
+import { EXECUTION_STATUS, JOB_STATUS } from '../../constants';
+
+describe('workflow > instructions > delay', () => {
+  let app: Application;
+  let db: Database;
+  let PostRepo;
+  let WorkflowModel;
+  let workflow;
+
+  beforeEach(async () => {
+    app = await getApp();
+
+    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.stop());
+
+  describe('runtime', () => {
+    it('delay to resolved', async () => {
+      const n1 = await workflow.createNode({
+        type: 'delay',
+        config: {
+          duration: 2000,
+          endStatus: JOB_STATUS.RESOLVED,
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [e1] = await workflow.getExecutions();
+      expect(e1.status).toEqual(EXECUTION_STATUS.STARTED);
+      const [j1] = await e1.getJobs();
+      expect(j1.status).toBe(JOB_STATUS.PENDING);
+
+      await sleep(2000);
+
+      const [e2] = await workflow.getExecutions();
+      expect(e2.status).toEqual(EXECUTION_STATUS.RESOLVED);
+      const [j2] = await e2.getJobs();
+      expect(j2.status).toBe(JOB_STATUS.RESOLVED);
+    });
+
+    it('delay to reject', async () => {
+      const n1 = await workflow.createNode({
+        type: 'delay',
+        config: {
+          duration: 2000,
+          endStatus: JOB_STATUS.FAILED,
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [e1] = await workflow.getExecutions();
+      expect(e1.status).toEqual(EXECUTION_STATUS.STARTED);
+      const [j1] = await e1.getJobs();
+      expect(j1.status).toBe(JOB_STATUS.PENDING);
+
+      await sleep(2000);
+
+      const [e2] = await workflow.getExecutions();
+      expect(e2.status).toEqual(EXECUTION_STATUS.FAILED);
+      const [j2] = await e2.getJobs();
+      expect(j2.status).toBe(JOB_STATUS.FAILED);
+    });
+
+    it('delay to resolve and rollback in downstream node', async () => {
+      const n1 = await workflow.createNode({
+        type: 'delay',
+        config: {
+          duration: 2000,
+          endStatus: JOB_STATUS.RESOLVED,
+        },
+      });
+      const n2 = await workflow.createNode({
+        type: 'create',
+        config: {
+          collection: 'comment',
+          params: {
+            values: {
+              status: 'should be number but use string to raise an error',
+            },
+          },
+        },
+        upstreamId: n1.id,
+      });
+      await n1.setDownstream(n2);
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [e1] = await workflow.getExecutions();
+      expect(e1.status).toEqual(EXECUTION_STATUS.STARTED);
+      const [j1] = await e1.getJobs();
+      expect(j1.status).toBe(JOB_STATUS.PENDING);
+
+      await sleep(2000);
+
+      const [e2] = await workflow.getExecutions();
+      expect(e2.status).toEqual(EXECUTION_STATUS.ERROR);
+      const [j2, j3] = await e2.getJobs({ order: [['id', 'ASC']] });
+      expect(j2.status).toBe(JOB_STATUS.RESOLVED);
+      expect(j3.status).toBe(JOB_STATUS.ERROR);
+    });
+  });
+
+  describe('app lifecycle', () => {
+    beforeEach(async () => {
+      await workflow.createNode({
+        type: 'delay',
+        config: {
+          duration: 2000,
+          endStatus: JOB_STATUS.RESOLVED,
+        },
+      });
+    });
+
+    it('restart app should trigger delayed job', async () => {
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [e1] = await workflow.getExecutions();
+      expect(e1.status).toEqual(EXECUTION_STATUS.STARTED);
+      const [j1] = await e1.getJobs();
+      expect(j1.status).toBe(JOB_STATUS.PENDING);
+
+      await app.stop();
+      await sleep(500);
+
+      await app.start();
+      await sleep(2000);
+
+      const [e2] = await workflow.getExecutions();
+      expect(e2.status).toEqual(EXECUTION_STATUS.RESOLVED);
+      const [j2] = await e2.getJobs();
+      expect(j2.status).toBe(JOB_STATUS.RESOLVED);
+    });
+
+    it('restart app should trigger missed delayed job', async () => {
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [e1] = await workflow.getExecutions();
+      expect(e1.status).toEqual(EXECUTION_STATUS.STARTED);
+      const [j1] = await e1.getJobs();
+      expect(j1.status).toBe(JOB_STATUS.PENDING);
+
+      await app.stop();
+      await sleep(2000);
+
+      await app.start();
+      await sleep(500);
+
+      const [e2] = await workflow.getExecutions();
+      expect(e2.status).toEqual(EXECUTION_STATUS.RESOLVED);
+      const [j2] = await e2.getJobs();
+      expect(j2.status).toBe(JOB_STATUS.RESOLVED);
+    });
+  });
+});

package/src/server/__tests__/instructions/destroy.test.ts

@@ -0,0 +1,58 @@
+import { Application } from '@nocobase/server';
+import Database from '@nocobase/database';
+import { getApp, sleep } from '..';
+
+describe('workflow > instructions > destroy', () => {
+  let app: Application;
+  let db: Database;
+  let PostRepo;
+  let WorkflowModel;
+  let workflow;
+
+  beforeEach(async () => {
+    app = await getApp();
+
+    db = app.db;
+    WorkflowModel = db.getCollection('workflows').model;
+    PostRepo = db.getCollection('posts').repository;
+
+    workflow = await WorkflowModel.create({
+      title: 'test workflow',
+      enabled: true,
+      type: 'collection',
+      config: {
+        mode: 1,
+        collection: 'posts',
+      },
+    });
+  });
+
+  afterEach(() => db.close());
+
+  describe('destroy one', () => {
+    it('params: from context', async () => {
+      const n1 = await workflow.createNode({
+        type: 'destroy',
+        config: {
+          collection: 'posts',
+          params: {
+            filter: {
+              id: '{{$context.data.id}}',
+            },
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.result).toBe(1);
+
+      const count = await PostRepo.count();
+      expect(count).toBe(0);
+    });
+  });
+});