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

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

@@ -0,0 +1,359 @@
+import { Application } from '@nocobase/server';
+import Database from '@nocobase/database';
+import { getApp, sleep } from '..';
+import { EXECUTION_STATUS, JOB_STATUS } from '../../constants';
+
+describe('workflow > instructions > query', () => {
+  let app: Application;
+  let db: Database;
+  let PostCollection;
+  let PostRepo;
+  let TagModel;
+  let CommentRepo;
+  let WorkflowModel;
+  let workflow;
+
+  beforeEach(async () => {
+    app = await getApp();
+
+    db = app.db;
+    WorkflowModel = db.getCollection('workflows').model;
+    PostCollection = db.getCollection('posts');
+    PostRepo = PostCollection.repository;
+    CommentRepo = db.getCollection('comments').repository;
+    TagModel = db.getCollection('tags').model;
+
+    workflow = await WorkflowModel.create({
+      title: 'test workflow',
+      enabled: true,
+      type: 'collection',
+      config: {
+        mode: 1,
+        collection: 'posts',
+      },
+    });
+  });
+
+  afterEach(() => db.close());
+
+  describe('query one', () => {
+    it('params: empty', async () => {
+      const n1 = await workflow.createNode({
+        type: 'query',
+        config: {
+          collection: '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.title).toBe(post.title);
+    });
+
+    it('params.filter: match', async () => {
+      const n1 = await workflow.createNode({
+        type: 'query',
+        config: {
+          collection: 'posts',
+          params: {
+            filter: {
+              title: 't1',
+            },
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.result.title).toBe(post.title);
+    });
+
+    it('params.filter: unmatch', async () => {
+      const n1 = await workflow.createNode({
+        type: 'query',
+        config: {
+          collection: 'posts',
+          params: {
+            filter: {
+              title: 't2',
+            },
+          },
+        },
+      });
+
+      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(null);
+    });
+
+    it('params.filter: value from context', async () => {
+      const n1 = await workflow.createNode({
+        type: 'query',
+        config: {
+          collection: 'posts',
+          params: {
+            filter: {
+              title: '{{$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.title).toBe(post.title);
+    });
+
+    it('params.filter: value from job of node', async () => {
+      const n1 = await workflow.createNode({
+        type: 'echo',
+      });
+      const n2 = await workflow.createNode({
+        type: 'query',
+        config: {
+          collection: 'posts',
+          params: {
+            filter: {
+              title: `{{$jobsMapByNodeId.${n1.id}.data.title}}`,
+            },
+          },
+        },
+        upstreamId: n1.id,
+      });
+      await n1.setDownstream(n2);
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const jobs = await execution.getJobs({ order: [['id', 'ASC']] });
+      expect(jobs[1].result.title).toBe(post.title);
+    });
+
+    it('params.filter: by association field', async () => {
+      const n1 = await workflow.createNode({
+        type: 'query',
+        config: {
+          collection: 'tags',
+          params: {
+            filter: {
+              'posts.id': `{{$context.data.id}}`,
+            },
+          },
+        },
+      });
+
+      const tag = await TagModel.create({ name: 'tag1' });
+      const post = await PostRepo.create({
+        values: { title: 't1', tags: [tag.id] },
+      });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.result.id).toBe(tag.id);
+    });
+
+    it('params.appends: hasMany', async () => {
+      const n1 = await workflow.createNode({
+        type: 'query',
+        config: {
+          collection: 'posts',
+          params: {
+            appends: ['comments'],
+          },
+        },
+      });
+
+      const comment = await CommentRepo.create({});
+      const post = await PostRepo.create({
+        values: { title: 't1', comments: [comment.id] },
+      });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.result.comments.length).toBe(1);
+      expect(job.result.comments[0].id).toBe(comment.id);
+    });
+
+    it('params.appends: belongsToMany', async () => {
+      const n1 = await workflow.createNode({
+        type: 'query',
+        config: {
+          collection: 'tags',
+          params: {
+            appends: ['posts'],
+          },
+        },
+      });
+
+      const tag = await TagModel.create({ name: 'tag1' });
+      const post = await PostRepo.create({
+        values: { title: 't1', tags: [tag.id] },
+      });
+
+      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);
+    });
+
+    it('params.sort', async () => {
+      const n1 = await workflow.createNode({
+        type: 'query',
+        config: {
+          collection: 'posts',
+          params: {
+            sort: 'id',
+          },
+        },
+      });
+
+      const p1 = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const p2 = await PostRepo.create({ values: { title: 't2' } });
+
+      await sleep(500);
+
+      // get the 2nd execution
+      const [execution] = await workflow.getExecutions({ order: [['id', 'DESC']] });
+      expect(execution.context.data.title).toBe(p2.title);
+      const [job] = await execution.getJobs();
+      expect(job.result.title).toBe(p1.title);
+    });
+  });
+
+  describe('query all', () => {
+    it('params: empty', async () => {
+      const n1 = await workflow.createNode({
+        type: 'query',
+        config: {
+          collection: 'posts',
+          multiple: true,
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.result.length).toBe(1);
+      expect(job.result[0].title).toBe(post.title);
+    });
+
+    it('params.filter: match', async () => {
+      const n1 = await workflow.createNode({
+        type: 'query',
+        config: {
+          collection: 'posts',
+          multiple: true,
+          params: {
+            filter: {
+              title: 't1',
+            },
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.result.length).toBe(1);
+      expect(job.result[0].title).toBe(post.title);
+    });
+
+    it('params.filter: unmatch', async () => {
+      const n1 = await workflow.createNode({
+        type: 'query',
+        config: {
+          collection: 'posts',
+          multiple: true,
+          params: {
+            filter: {
+              title: 't2',
+            },
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.result.length).toBe(0);
+    });
+  });
+
+  describe('failOnEmpty', () => {
+    it('failOnEmpty', async () => {
+      const n1 = await workflow.createNode({
+        type: 'query',
+        config: {
+          collection: 'categories',
+          failOnEmpty: true,
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toBe(EXECUTION_STATUS.FAILED);
+      const [job] = await execution.getJobs();
+      expect(job.status).toBe(JOB_STATUS.FAILED);
+      expect(job.result).toBe(null);
+    });
+
+    it('failOnEmpty && multiple', async () => {
+      const n1 = await workflow.createNode({
+        type: 'query',
+        config: {
+          collection: 'categories',
+          multiple: true,
+          failOnEmpty: true,
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toBe(EXECUTION_STATUS.FAILED);
+      const [job] = await execution.getJobs();
+      expect(job.result).toMatchObject([]);
+    });
+  });
+});

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

@@ -0,0 +1,247 @@
+import { Application } from '@nocobase/server';
+import Database from '@nocobase/database';
+import { getApp, sleep } from '..';
+import { RequestConfig } from '../../instructions/request';
+import { EXECUTION_STATUS, JOB_STATUS } from '../../constants';
+
+const PORT = 12345;
+
+const URL_DATA = `http://localhost:${PORT}/data`;
+const URL_400 = `http://localhost:${PORT}/api/400`;
+const URL_TIMEOUT = `http://localhost:${PORT}/timeout`;
+
+describe('workflow > instructions > request', () => {
+  let app: Application;
+  let db: Database;
+  let PostRepo;
+  let WorkflowModel;
+  let workflow;
+
+  beforeEach(async () => {
+    app = await getApp({ manual: true });
+
+    app.use(async (ctx, next) => {
+      if (ctx.path === '/api/400') {
+        return ctx.throw(400);
+      }
+      if (ctx.path === '/timeout') {
+        await sleep(2000);
+        return ctx.throw(new Error('timeout'));
+      }
+      if (ctx.path === '/data') {
+        ctx.withoutDataWrapping = true;
+        ctx.body = {
+          meta: { title: ctx.query.title },
+          data: { title: ctx.request.body['title'] },
+        };
+      }
+      next();
+    });
+
+    await app.start({ listen: { port: PORT } });
+
+    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(() => app.stop());
+
+  describe('request', () => {
+    it('request', async () => {
+      await workflow.createNode({
+        type: 'request',
+        config: {
+          url: URL_DATA,
+          method: 'GET',
+        } as RequestConfig,
+      });
+
+      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.status).toEqual(JOB_STATUS.RESOLVED);
+    });
+
+    it('request - timeout', async () => {
+      await workflow.createNode({
+        type: 'request',
+        config: {
+          url: URL_TIMEOUT,
+          method: 'GET',
+          timeout: 250,
+        } as RequestConfig,
+      });
+
+      await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(1000);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.status).toEqual(JOB_STATUS.FAILED);
+
+      expect(job.result).toMatchObject({
+        code: 'ECONNABORTED',
+        name: 'AxiosError',
+        status: null,
+        message: 'timeout of 250ms exceeded',
+      });
+    });
+
+    it('request - ignoreFail', async () => {
+      await workflow.createNode({
+        type: 'request',
+        config: {
+          url: URL_TIMEOUT,
+          method: 'GET',
+          timeout: 250,
+          ignoreFail: true,
+        } as RequestConfig,
+      });
+
+      await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(1000);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.status).toEqual(JOB_STATUS.RESOLVED);
+      expect(job.result).toMatchObject({
+        code: 'ECONNABORTED',
+        name: 'AxiosError',
+        status: null,
+        message: 'timeout of 250ms exceeded',
+      });
+    });
+
+    it('response 400', async () => {
+      await workflow.createNode({
+        type: 'request',
+        config: {
+          url: URL_400,
+          method: 'GET',
+          ignoreFail: false,
+        } as RequestConfig,
+      });
+
+      await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.status).toEqual(JOB_STATUS.FAILED);
+      expect(job.result.status).toBe(400);
+    });
+
+    it('response 400 ignoreFail', async () => {
+      await workflow.createNode({
+        type: 'request',
+        config: {
+          url: URL_400,
+          method: 'GET',
+          timeout: 1000,
+          ignoreFail: true,
+        } as RequestConfig,
+      });
+
+      await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.status).toEqual(JOB_STATUS.RESOLVED);
+      expect(job.result.status).toBe(400);
+    });
+
+    it('request with data', async () => {
+      const n1 = await workflow.createNode({
+        type: 'request',
+        config: {
+          url: URL_DATA,
+          method: 'POST',
+          data: { title: '{{$context.data.title}}' },
+        } as RequestConfig,
+      });
+
+      await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.status).toEqual(JOB_STATUS.RESOLVED);
+      expect(job.result.data).toEqual({ title: 't1' });
+    });
+
+    // TODO(bug): should not use ejs
+    it('request json data with multiple lines', async () => {
+      const n1 = await workflow.createNode({
+        type: 'request',
+        config: {
+          url: URL_DATA,
+          method: 'POST',
+          data: { title: '{{$context.data.title}}' },
+        } as RequestConfig,
+      });
+
+      const title = 't1\n\nline 2';
+      await PostRepo.create({
+        values: { title },
+      });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.status).toEqual(JOB_STATUS.RESOLVED);
+      expect(job.result.data).toEqual({ title });
+    });
+
+    it('request inside loop',async () => {
+      const n1 = await workflow.createNode({
+        type: 'loop',
+        config: {
+          target: 2,
+        },
+      });
+
+      const n2 = await workflow.createNode({
+        type: 'request',
+        upstreamId: n1.id,
+        branchIndex: 0,
+        config: {
+          url: URL_DATA,
+          method: 'GET',
+        }
+      });
+
+      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({ order: [['id', 'ASC']] });
+      expect(jobs.length).toBe(3);
+      expect(jobs.map(item => item.status)).toEqual(Array(3).fill(JOB_STATUS.RESOLVED));
+      expect(jobs[0].result).toBe(2);
+    });
+  });
+});