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

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

@@ -0,0 +1,294 @@
+import { Application } from '@nocobase/server';
+import Database from '@nocobase/database';
+import { getApp, sleep } from '..';
+
+describe('workflow > instructions > aggregate', () => {
+  let app: Application;
+  let db: Database;
+  let PostRepo;
+  let CommentRepo;
+  let TagRepo;
+  let WorkflowModel;
+  let workflow;
+
+  beforeEach(async () => {
+    app = await getApp();
+
+    db = app.db;
+    WorkflowModel = db.getCollection('workflows').model;
+    PostRepo = db.getCollection('posts').repository;
+    CommentRepo = db.getCollection('comments').repository;
+    TagRepo = db.getCollection('tags').repository;
+
+    workflow = await WorkflowModel.create({
+      title: 'test workflow',
+      enabled: true,
+      type: 'collection',
+      config: {
+        mode: 1,
+        collection: 'posts',
+      },
+    });
+  });
+
+  afterEach(() => db.close());
+
+  describe('based on collection', () => {
+    it('count', async () => {
+      const n1 = await workflow.createNode({
+        type: 'aggregate',
+        config: {
+          aggregator: 'count',
+          collection: 'posts',
+          params: {
+            field: '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);
+    });
+
+    it('sum', async () => {
+      const n1 = await workflow.createNode({
+        type: 'aggregate',
+        config: {
+          aggregator: 'sum',
+          collection: 'posts',
+          params: {
+            field: 'read',
+          },
+        },
+      });
+
+      const p1 = await PostRepo.create({ values: { title: 't1', read: 1 } });
+
+      await sleep(500);
+
+      const [e1] = await workflow.getExecutions();
+      const [j1] = await e1.getJobs();
+      expect(j1.result).toBe(1);
+
+      const p2 = await PostRepo.create({ values: { title: 't2', read: 2 } });
+
+      await sleep(500);
+
+      const [e2] = await workflow.getExecutions({ order: [['id', 'desc']] });
+      const [j2] = await e2.getJobs();
+      expect(j2.result).toBe(3);
+    });
+
+    it('avg', async () => {
+      const n1 = await workflow.createNode({
+        type: 'aggregate',
+        config: {
+          aggregator: 'avg',
+          collection: 'posts',
+          params: {
+            field: 'read',
+          },
+        },
+      });
+
+      const p1 = await PostRepo.create({ values: { title: 't1', read: 1 } });
+
+      await sleep(500);
+
+      const [e1] = await workflow.getExecutions();
+      const [j1] = await e1.getJobs();
+      expect(j1.result).toBe(1);
+
+      const p2 = await PostRepo.create({ values: { title: 't2', read: 2 } });
+
+      await sleep(500);
+
+      const [e2] = await workflow.getExecutions({ order: [['id', 'desc']] });
+      const [j2] = await e2.getJobs();
+      expect(j2.result).toBe(1.5);
+    });
+
+    it('min', async () => {
+      const n1 = await workflow.createNode({
+        type: 'aggregate',
+        config: {
+          aggregator: 'min',
+          collection: 'posts',
+          params: {
+            field: 'read',
+          },
+        },
+      });
+
+      const p1 = await PostRepo.create({ values: { title: 't1', read: 1 } });
+
+      await sleep(500);
+
+      const [e1] = await workflow.getExecutions();
+      const [j1] = await e1.getJobs();
+      expect(j1.result).toBe(1);
+
+      const p2 = await PostRepo.create({ values: { title: 't2', read: 2 } });
+
+      await sleep(500);
+
+      const [e2] = await workflow.getExecutions({ order: [['id', 'desc']] });
+      const [j2] = await e2.getJobs();
+      expect(j2.result).toBe(1);
+    });
+
+    it('max', async () => {
+      const n1 = await workflow.createNode({
+        type: 'aggregate',
+        config: {
+          aggregator: 'max',
+          collection: 'posts',
+          params: {
+            field: 'read',
+          },
+        },
+      });
+
+      const p1 = await PostRepo.create({ values: { title: 't1', read: 1 } });
+
+      await sleep(500);
+
+      const [e1] = await workflow.getExecutions();
+      const [j1] = await e1.getJobs();
+      expect(j1.result).toBe(1);
+
+      const p2 = await PostRepo.create({ values: { title: 't2', read: 2 } });
+
+      await sleep(500);
+
+      const [e2] = await workflow.getExecutions({ order: [['id', 'desc']] });
+      const [j2] = await e2.getJobs();
+      expect(j2.result).toBe(2);
+    });
+  });
+
+  describe('based on data associated collection', () => {
+    it('count', async () => {
+      const n1 = await workflow.createNode({
+        type: 'aggregate',
+        config: {
+          aggregator: 'count',
+          collection: 'comments',
+          associated: true,
+          association: {
+            name: 'comments',
+            associatedKey: '{{$context.data.id}}',
+            associatedCollection: 'posts',
+          },
+          params: {
+            field: 'id',
+          },
+        },
+      });
+      const n2 = await workflow.createNode({
+        upstreamId: n1.id,
+        type: 'aggregate',
+        config: {
+          aggregator: 'count',
+          collection: 'comments',
+          associated: true,
+          association: {
+            name: 'comments',
+            associatedKey: '{{$context.data.id}}',
+            associatedCollection: 'posts',
+          },
+          params: {
+            field: 'id',
+            filter: {
+              $and: [{ status: 1 }],
+            },
+          },
+        },
+      });
+      await n1.setDownstream(n2);
+
+      await CommentRepo.create({ values: [{}, {}] });
+
+      const p1 = await PostRepo.create({ values: { title: 't1', comments: [{}, { status: 1 }] } });
+
+      await sleep(500);
+
+      const [e1] = await workflow.getExecutions();
+      const [j1, j2] = await e1.getJobs({ order: [['id', 'ASC']] });
+      expect(j1.result).toBe(2);
+      expect(j2.result).toBe(1);
+    });
+
+    it('sum', async () => {
+      const PostModel = db.getCollection('posts').model;
+      const p1 = await PostModel.create({ title: 't1', read: 1 });
+
+      const n1 = await workflow.createNode({
+        type: 'create',
+        config: {
+          collection: 'tags',
+          params: {
+            values: {
+              posts: [p1.id, '{{$context.data.id}}'],
+            },
+          },
+        },
+      });
+      const n2 = await workflow.createNode({
+        upstreamId: n1.id,
+        type: 'aggregate',
+        config: {
+          aggregator: 'sum',
+          collection: 'posts',
+          associated: true,
+          association: {
+            name: 'posts',
+            associatedKey: `{{$jobsMapByNodeId.${n1.id}.id}}`,
+            associatedCollection: 'tags',
+          },
+          params: {
+            field: 'read',
+          },
+        },
+      });
+      await n1.setDownstream(n2);
+      const n3 = await workflow.createNode({
+        upstreamId: n2.id,
+        type: 'aggregate',
+        config: {
+          aggregator: 'sum',
+          collection: 'posts',
+          associated: true,
+          association: {
+            name: 'posts',
+            associatedKey: `{{$jobsMapByNodeId.${n1.id}.id}}`,
+            associatedCollection: 'tags',
+          },
+          params: {
+            field: 'read',
+            filter: {
+              $and: [{ title: 't1' }],
+            },
+          },
+        },
+      });
+      await n2.setDownstream(n3);
+
+      await TagRepo.create({ values: [{}, {}] });
+
+      const p2 = await PostRepo.create({ values: { title: 't2', read: 2 } });
+
+      await sleep(500);
+
+      const [e1] = await workflow.getExecutions();
+      const [j1, j2, j3] = await e1.getJobs({ order: [['id', 'ASC']] });
+      expect(j2.result).toBe(3);
+      expect(j3.result).toBe(1);
+    });
+  });
+});

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

@@ -0,0 +1,265 @@
+import { Application } from '@nocobase/server';
+import Database from '@nocobase/database';
+import { getApp, sleep } from '..';
+import { JOB_STATUS } from '../../constants';
+
+describe('workflow > instructions > calculation', () => {
+  let app: Application;
+  let db: Database;
+  let PostRepo;
+  let CategoryRepo;
+  let WorkflowModel;
+  let workflow;
+
+  beforeEach(async () => {
+    app = await getApp();
+
+    db = app.db;
+    WorkflowModel = db.getCollection('workflows').model;
+    PostRepo = db.getCollection('posts').repository;
+    CategoryRepo = db.getCollection('categories').repository;
+
+    workflow = await WorkflowModel.create({
+      title: 'test workflow',
+      enabled: true,
+      type: 'collection',
+      config: {
+        mode: 1,
+        collection: 'posts',
+      },
+    });
+  });
+
+  afterEach(() => db.close());
+
+  describe('math.js', () => {
+    it('syntax error', async () => {
+      const n1 = await workflow.createNode({
+        type: 'calculation',
+        config: {
+          engine: 'math.js',
+          expression: '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.status).toBe(JOB_STATUS.ERROR);
+      expect(job.result.startsWith('SyntaxError: ')).toBe(true);
+    });
+
+    it('constant', async () => {
+      const n1 = await workflow.createNode({
+        type: 'calculation',
+        config: {
+          engine: 'math.js',
+          expression: ' 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(2);
+    });
+
+    it('$context', async () => {
+      const n1 = await workflow.createNode({
+        type: 'calculation',
+        config: {
+          engine: 'math.js',
+          expression: '{{$context.data.read}} + 1',
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1', read: 1 } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.result).toBe(2);
+    });
+
+    it('$jobsMapByNodeId', async () => {
+      const n1 = await workflow.createNode({
+        type: 'echo',
+      });
+
+      const n2 = await workflow.createNode({
+        type: 'calculation',
+        config: {
+          engine: 'math.js',
+          expression: `{{$jobsMapByNodeId.${n1.id}.data.read}} + 1`,
+        },
+        upstreamId: n1.id,
+      });
+
+      await n1.setDownstream(n2);
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [n1Job, n2Job] = await execution.getJobs({ order: [['id', 'ASC']] });
+      expect(n2Job.result).toBe(1);
+    });
+
+    it('$system', async () => {
+      const n1 = await workflow.createNode({
+        type: 'calculation',
+        config: {
+          engine: 'math.js',
+          expression: '1 + {{$system.no1}}',
+        },
+      });
+
+      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(2);
+    });
+
+    it('$system.now()', async () => {
+      const n1 = await workflow.createNode({
+        type: 'calculation',
+        config: {
+          engine: 'math.js',
+          expression: '{{$system.now}}',
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.result).toMatch(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,3})?Z/);
+    });
+  });
+
+  describe('formula.js', () => {
+    it('string variable with quote should be wrong result', async () => {
+      const n1 = await workflow.createNode({
+        type: 'calculation',
+        config: {
+          engine: 'formula.js',
+          expression: `CONCATENATE('a', '{{$context.data.title}}')`,
+        },
+      });
+
+      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('a $context.data.title ');
+    });
+
+    it('text', async () => {
+      const n1 = await workflow.createNode({
+        type: 'calculation',
+        config: {
+          engine: 'formula.js',
+          expression: `CONCATENATE('a', {{$context.data.title}})`,
+        },
+      });
+
+      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('at1');
+    });
+  });
+
+  describe('dynamic expression', () => {
+    it('dynamic expression field in current table', async () => {
+      const n1 = await workflow.createNode({
+        type: 'calculation',
+        config: {
+          dynamic: '{{$context.data.category}}',
+          scope: '{{$context.data}}',
+        },
+      });
+
+      const post = await PostRepo.create({
+        values: {
+          title: 't1',
+          category: {
+            engine: 'math.js',
+            expression: '1 + {{read}}',
+          },
+        },
+      });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.result).toBe(1);
+    });
+
+    it('dynamic expression field in association table', async () => {
+      const n1 = await workflow.createNode({
+        type: 'query',
+        config: {
+          collection: 'categories',
+          params: {
+            filter: {
+              $and: [{ id: '{{$context.data.categoryId}}' }],
+            },
+          },
+        },
+      });
+
+      const n2 = await workflow.createNode({
+        type: 'calculation',
+        config: {
+          dynamic: `{{$jobsMapByNodeId.${n1.id}}}`,
+          scope: '{{$context.data}}',
+        },
+        upstreamId: n1.id,
+      });
+
+      await n1.setDownstream(n2);
+
+      const category = await CategoryRepo.create({
+        values: {
+          title: 'c1',
+          engine: 'math.js',
+          expression: '1 + {{read}}',
+        },
+      });
+
+      const post = await PostRepo.create({
+        values: {
+          title: 't1',
+          categoryId: category.id,
+        },
+      });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const jobs = await execution.getJobs({ order: [['id', 'ASC']] });
+      expect(jobs.length).toBe(2);
+      expect(jobs[1].result).toBe(1);
+    });
+  });
+});