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

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

@@ -0,0 +1,162 @@
+import { Application } from '@nocobase/server';
+import Database from '@nocobase/database';
+import { getApp, sleep } from '..';
+import { EXECUTION_STATUS, JOB_STATUS } from '../../constants';
+
+describe('workflow > instructions > sql', () => {
+  let app: Application;
+  let db: Database;
+  let PostRepo;
+  let PostCollection;
+  let ReplyRepo;
+  let WorkflowModel;
+  let workflow;
+
+  beforeEach(async () => {
+    app = await getApp();
+
+    db = app.db;
+    WorkflowModel = db.getCollection('workflows').model;
+    PostCollection = db.getCollection('posts');
+    PostRepo = PostCollection.repository;
+    ReplyRepo = db.getCollection('replies').repository;
+
+    workflow = await WorkflowModel.create({
+      title: 'test workflow',
+      enabled: true,
+      type: 'collection',
+      config: {
+        mode: 1,
+        collection: 'posts',
+      },
+    });
+  });
+
+  afterEach(async () => await app.destroy());
+
+  describe('invalid', () => {
+    it('no sql', async () => {
+      const n1 = await workflow.createNode({
+        type: 'sql',
+        config: {},
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [sqlJob] = await execution.getJobs({ order: [['id', 'ASC']] });
+      expect(execution.status).toBe(EXECUTION_STATUS.RESOLVED);
+      expect(sqlJob.status).toBe(JOB_STATUS.RESOLVED);
+    });
+
+    it('empty sql', async () => {
+      const n1 = await workflow.createNode({
+        type: 'sql',
+        config: {
+          sql: '',
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [sqlJob] = await execution.getJobs({ order: [['id', 'ASC']] });
+      expect(execution.status).toBe(EXECUTION_STATUS.RESOLVED);
+      expect(sqlJob.status).toBe(JOB_STATUS.RESOLVED);
+    });
+
+    it('invalid sql', async () => {
+      const n1 = await workflow.createNode({
+        type: 'sql',
+        config: {
+          sql: '1',
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [sqlJob] = await execution.getJobs({ order: [['id', 'ASC']] });
+      expect(execution.status).toBe(EXECUTION_STATUS.ERROR);
+      expect(sqlJob.status).toBe(JOB_STATUS.ERROR);
+    });
+  });
+
+  describe('sql with variables', () => {
+    it('update', async () => {
+      const queryInterface = db.sequelize.getQueryInterface();
+      const n1 = await workflow.createNode({
+        type: 'sql',
+        config: {
+          sql: `update ${PostCollection.quotedTableName()} set ${queryInterface.quoteIdentifier('read')}={{$context.data.id}} where ${queryInterface.quoteIdentifier('id')}={{$context.data.id}}`,
+        },
+      });
+
+      const n2 = await workflow.createNode({
+        type: 'query',
+        config: {
+          collection: 'posts',
+          params: {
+            filter: {
+              id: '{{ $context.data.id }}',
+            }
+          }
+        },
+        upstreamId: n1.id,
+      });
+
+      await n1.setDownstream(n2);
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [sqlJob, queryJob] = await execution.getJobs({ order: [['id', 'ASC']] });
+      expect(sqlJob.status).toBe(JOB_STATUS.RESOLVED);
+      expect(queryJob.status).toBe(JOB_STATUS.RESOLVED);
+      expect(queryJob.result.read).toBe(post.id);
+    });
+
+    it('delete', async () => {
+      const queryInterface = db.sequelize.getQueryInterface();
+      const n1 = await workflow.createNode({
+        type: 'sql',
+        config: {
+          sql: `delete from ${PostCollection.quotedTableName()} where ${queryInterface.quoteIdentifier('id')}={{$context.data.id}};`,
+        },
+      });
+
+      const n2 = await workflow.createNode({
+        type: 'query',
+        config: {
+          collection: 'posts',
+          params: {
+            filter: {
+              id: '{{ $context.data.id }}',
+            }
+          }
+        },
+        upstreamId: n1.id,
+      });
+
+      await n1.setDownstream(n2);
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [sqlJob, queryJob] = await execution.getJobs({ order: [['id', 'ASC']] });
+      expect(sqlJob.status).toBe(JOB_STATUS.RESOLVED);
+      expect(queryJob.status).toBe(JOB_STATUS.RESOLVED);
+      expect(queryJob.result).toBeNull();
+    });
+  });
+});

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

@@ -0,0 +1,189 @@
+import { Application } from '@nocobase/server';
+import Database from '@nocobase/database';
+import { getApp, sleep } from '..';
+import type { WorkflowModel as WorkflowModelType } from '../../types';
+
+describe('workflow > instructions > update', () => {
+  let app: Application;
+  let db: Database;
+  let PostRepo;
+  let WorkflowModel;
+  let workflow: WorkflowModelType;
+
+  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(() => db.close());
+
+  describe('update one', () => {
+    it('params: from context', async () => {
+      const n1 = await workflow.createNode({
+        type: 'update',
+        config: {
+          collection: 'posts',
+          params: {
+            filter: {
+              id: '{{$context.data.id}}',
+            },
+            values: {
+              published: true,
+            },
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+      expect(post.published).toBe(false);
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.result).toBe(1);
+
+      const updatedPost = await PostRepo.findById(post.id);
+      expect(updatedPost.published).toBe(true);
+    });
+
+    it('params: from job of node', async () => {
+      const n1 = await workflow.createNode({
+        type: 'query',
+        config: {
+          collection: 'posts',
+          params: {
+            filter: {
+              title: 'test',
+            },
+          },
+        },
+      });
+
+      const n2 = await workflow.createNode({
+        type: 'update',
+        config: {
+          collection: 'posts',
+          params: {
+            filter: {
+              id: `{{$jobsMapByNodeId.${n1.id}.id}}`,
+            },
+            values: {
+              title: 'changed',
+            },
+          },
+        },
+        upstreamId: n1.id,
+      });
+
+      await n1.setDownstream(n2);
+
+      // NOTE: the result of post immediately created will not be changed by workflow
+      const { id } = await PostRepo.create({ values: { title: 'test' } });
+
+      await sleep(500);
+
+      // should get from db
+      const post = await PostRepo.findById(id);
+      expect(post.title).toBe('changed');
+    });
+  });
+
+  describe('update batch', () => {
+    it('individualHooks off should not trigger other workflow', async () => {
+      const w2 = await WorkflowModel.create({
+        enabled: true,
+        type: 'collection',
+        config: {
+          mode: 2,
+          collection: 'posts',
+        },
+      });
+
+      const n1 = await workflow.createNode({
+        type: 'update',
+        config: {
+          collection: 'posts',
+          params: {
+            filter: {
+              id: '{{$context.data.id}}',
+            },
+            values: {
+              published: true,
+            },
+            individualHooks: false,
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+      expect(post.published).toBe(false);
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.result).toBe(1);
+
+      const updatedPost = await PostRepo.findById(post.id);
+      expect(updatedPost.published).toBe(true);
+
+      const w2Exes = await w2.getExecutions();
+      expect(w2Exes.length).toBe(0);
+    });
+
+    it('individualHooks on should trigger other workflow', async () => {
+      const w2 = await WorkflowModel.create({
+        enabled: true,
+        type: 'collection',
+        config: {
+          mode: 2,
+          collection: 'posts',
+        },
+      });
+
+      const n1 = await workflow.createNode({
+        type: 'update',
+        config: {
+          collection: 'posts',
+          params: {
+            filter: {
+              id: '{{$context.data.id}}',
+            },
+            values: {
+              published: true,
+            },
+            individualHooks: true,
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+      expect(post.published).toBe(false);
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.result).toBe(1);
+
+      const updatedPost = await PostRepo.findById(post.id);
+      expect(updatedPost.published).toBe(true);
+
+      const w2Exes = await w2.getExecutions();
+      expect(w2Exes.length).toBe(1);
+    });
+  });
+});

package/src/server/__tests__/triggers/collection.test.ts

@@ -0,0 +1,333 @@
+import { Application } from '@nocobase/server';
+import Database from '@nocobase/database';
+import { getApp, sleep } from '..';
+import { EXECUTION_STATUS } from '../../constants';
+
+describe('workflow > triggers > collection', () => {
+  let app: Application;
+  let db: Database;
+  let CategoryRepo;
+  let PostRepo;
+  let CommentRepo;
+  let TagRepo;
+  let WorkflowModel;
+
+  beforeEach(async () => {
+    app = await getApp();
+
+    db = app.db;
+    WorkflowModel = db.getCollection('workflows').model;
+    CategoryRepo = db.getCollection('categories').repository;
+    PostRepo = db.getCollection('posts').repository;
+    CommentRepo = db.getCollection('comments').repository;
+    TagRepo = db.getCollection('tags').repository;
+  });
+
+  afterEach(() => db.close());
+
+  describe('toggle', () => {
+    it('when collection change', async () => {
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'collection',
+        config: {
+          mode: 1,
+          collection: 'posts',
+        },
+      });
+
+      await workflow.update({
+        config: {
+          ...workflow.config,
+          collection: 'comments',
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const executions = await workflow.getExecutions();
+      expect(executions.length).toBe(0);
+    });
+  });
+
+  describe('model context', () => {
+    it('with association', async () => {
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'collection',
+        config: {
+          mode: 1,
+          collection: 'posts',
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1', category: { title: 'c1' } } });
+
+      await sleep(500);
+
+      const executions = await workflow.getExecutions();
+      expect(executions.length).toBe(1);
+      expect(executions[0].context.data.title).toBe('t1');
+      expect(executions[0].context.data.category.title).toBe('c1');
+    });
+  });
+
+  describe('config.changed', () => {
+    it('no changed config', async () => {
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'collection',
+        config: {
+          mode: 2,
+          collection: 'posts',
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+      await PostRepo.update({ filterByTk: post.id, values: { title: 't2' } });
+
+      await sleep(500);
+
+      const executions = await workflow.getExecutions();
+      expect(executions.length).toBe(1);
+      expect(executions[0].context.data.title).toBe('t2');
+    });
+
+    it('field in changed config', async () => {
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'collection',
+        config: {
+          mode: 2,
+          collection: 'posts',
+          changed: ['title'],
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+      await PostRepo.update({ filterByTk: post.id, values: { title: 't2' } });
+
+      await sleep(500);
+
+      const executions = await workflow.getExecutions();
+      expect(executions.length).toBe(1);
+      expect(executions[0].status).toBe(EXECUTION_STATUS.RESOLVED);
+      expect(executions[0].context.data.title).toBe('t2');
+    });
+
+    it('field not in changed config', async () => {
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'collection',
+        config: {
+          mode: 2,
+          collection: 'posts',
+          changed: ['published'],
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+      await PostRepo.update({ filterByTk: post.id, values: { title: 't2' } });
+
+      await sleep(500);
+
+      const executions = await workflow.getExecutions();
+      expect(executions.length).toBe(0);
+    });
+  });
+
+  describe('config.appends', () => {
+    it('non-appended association could not be accessed', async () => {
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'collection',
+        config: {
+          mode: 1,
+          collection: 'posts',
+        },
+      });
+
+      await workflow.createNode({
+        type: 'echo',
+      });
+
+      const category = await CategoryRepo.create({ values: { title: 'c1' } });
+
+      const post = await PostRepo.create({
+        values: {
+          title: 't1',
+          categoryId: category.id,
+        },
+      });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toBe(EXECUTION_STATUS.RESOLVED);
+      const [job] = await execution.getJobs();
+      expect(job.result.data.category).toBeUndefined();
+    });
+
+    it('appends association could be accessed', async () => {
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'collection',
+        config: {
+          mode: 1,
+          collection: 'posts',
+          appends: ['category'],
+        },
+      });
+
+      await workflow.createNode({
+        type: 'echo',
+      });
+
+      const category = await CategoryRepo.create({ values: { title: 'c1' } });
+
+      const post = await PostRepo.create({
+        values: {
+          title: 't1',
+          categoryId: category.id,
+        },
+      });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toBe(EXECUTION_STATUS.RESOLVED);
+      const [job] = await execution.getJobs();
+      expect(job.result.data.category.title).toBe('c1');
+    });
+
+    it('appends belongsTo null', async () => {
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'collection',
+        config: {
+          mode: 1,
+          collection: 'posts',
+          appends: ['category'],
+        },
+      });
+
+      await workflow.createNode({
+        type: 'echo',
+      });
+
+      const post = await PostRepo.create({
+        values: {
+          title: 't1',
+        },
+      });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toBe(EXECUTION_STATUS.RESOLVED);
+      const [job] = await execution.getJobs();
+      expect(job.result.data.category).toBeNull();
+    });
+
+    it('appends hasMany', async () => {
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'collection',
+        config: {
+          mode: 1,
+          collection: 'posts',
+          appends: ['comments'],
+        },
+      });
+
+      await workflow.createNode({
+        type: 'echo',
+      });
+
+      const comments = await CommentRepo.create({ values: [{}] });
+
+      const post = await PostRepo.create({
+        values: {
+          title: 't1',
+          comments: comments.map((item) => item.id),
+        },
+      });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toBe(EXECUTION_STATUS.RESOLVED);
+      const [job] = await execution.getJobs();
+      expect(job.result.data.comments.length).toBe(1);
+    });
+
+    it('appends belongsToMany', async () => {
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'collection',
+        config: {
+          mode: 1,
+          collection: 'posts',
+          appends: ['tags'],
+        },
+      });
+
+      await workflow.createNode({
+        type: 'echo',
+      });
+
+      const tags = await TagRepo.create({ values: [{}] });
+
+      const post = await PostRepo.create({
+        values: {
+          title: 't1',
+          tags: tags.map((item) => item.id),
+        },
+      });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toBe(EXECUTION_STATUS.RESOLVED);
+      const [job] = await execution.getJobs();
+      expect(job.result.data.tags.length).toBe(1);
+    });
+
+    describe('appends depth > 1', () => {
+      it('create with associtions', async () => {
+        const workflow = await WorkflowModel.create({
+          enabled: true,
+          type: 'collection',
+          config: {
+            mode: 1,
+            collection: 'categories',
+            appends: ['posts.tags'],
+          },
+        });
+
+        const tags = await TagRepo.create({ values: [{}] });
+        const tagIds = tags.map((item) => item.id);
+
+        const category = await CategoryRepo.create({
+          values: {
+            title: 't1',
+            posts: [
+              { title: 't1', tags: tagIds },
+              { title: 't2', tags: tagIds },
+            ],
+          },
+        });
+
+        await sleep(500);
+
+        const [execution] = await workflow.getExecutions();
+        expect(execution.status).toBe(EXECUTION_STATUS.RESOLVED);
+        expect(execution.context.data.posts.length).toBe(2);
+        expect(execution.context.data.posts.map((item) => item.title)).toEqual(['t1', 't2']);
+        expect(execution.context.data.posts.map((item) => item.tags.map((tag) => tag.id))).toEqual([tagIds, tagIds]);
+      });
+    });
+  });
+});