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

package/src/server/__tests__/actions/workflows.test.ts

@@ -0,0 +1,419 @@
+import { MockServer } from '@nocobase/test';
+import Database from '@nocobase/database';
+import { getApp, sleep } from '..';
+
+describe('workflow > actions > workflows', () => {
+  let app: MockServer;
+  let agent;
+  let db: Database;
+  let PostModel;
+  let PostRepo;
+  let WorkflowModel;
+
+  beforeEach(async () => {
+    app = await getApp();
+    agent = app.agent();
+    db = app.db;
+    WorkflowModel = db.getCollection('workflows').model;
+    PostModel = db.getCollection('posts').model;
+    PostRepo = db.getCollection('posts').repository;
+  });
+
+  afterEach(() => app.destroy());
+
+  // describe('create', () => {
+  // });
+
+  describe('update', () => {
+    it('update unexecuted workflow should be ok', async () => {
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'collection',
+        config: {
+          mode: 1,
+          collection: 'posts',
+        },
+      });
+
+      const { status } = await agent.resource('workflows').update({
+        filterByTk: workflow.id,
+        values: {
+          config: {
+            mode: 1,
+            collection: 'tags',
+          },
+        },
+      });
+
+      expect(status).toBe(200);
+    });
+
+    it('update executed workflow should not be ok', async () => {
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'collection',
+        config: {
+          mode: 1,
+          collection: 'posts',
+        },
+      });
+
+      const p1 = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const c1 = await workflow.countExecutions();
+      expect(c1).toBe(1);
+
+      const { status } = await agent.resource('workflows').update({
+        filterByTk: workflow.id,
+        values: {
+          config: {
+            mode: 1,
+            collection: 'tags',
+          },
+        },
+      });
+      expect(status).toBe(400);
+    });
+
+    it('only update executed workflow with "enabled" should be ok', async () => {
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'collection',
+        config: {
+          mode: 1,
+          collection: 'posts',
+        },
+      });
+
+      const p1 = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const c1 = await workflow.countExecutions();
+      expect(c1).toBe(1);
+
+      const { status } = await agent.resource('workflows').update({
+        filterByTk: workflow.id,
+        values: {
+          enabled: false,
+          key: workflow.key,
+        },
+      });
+      expect(status).toBe(200);
+
+      const p2 = await PostRepo.create({ values: { title: 't2' } });
+
+      await sleep(500);
+
+      const c2 = await workflow.countExecutions();
+      expect(c2).toBe(1);
+    });
+  });
+
+  describe('destroy', () => {
+    it('cascading destroy all revisions, nodes, executions and jobs', async () => {
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'collection',
+        config: {
+          mode: 1,
+          collection: 'posts',
+        },
+      });
+
+      const n1 = await workflow.createNode({
+        type: 'update',
+        config: {
+          collection: 'posts',
+          params: {
+            filter: {
+              id: '{{$context.data.id}}',
+            },
+            values: {
+              title: 't2',
+            },
+          },
+        },
+      });
+
+      await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const { model: JobModel } = db.getCollection('jobs');
+
+      const e1c = await workflow.countExecutions();
+      expect(e1c).toBe(1);
+      const j1c = await JobModel.count();
+      expect(j1c).toBe(1);
+      const p1 = await PostRepo.findOne();
+      expect(p1.title).toBe('t2');
+
+      const { id, ...w1 } = workflow.get();
+      const w2 = await WorkflowModel.create(w1);
+      const { id: n1Id, ...n1Data } = n1.get();
+      const n2 = await w2.createNode(n1Data);
+
+      await agent.resource(`workflows`).destroy({
+        filterByTk: w2.id,
+      });
+
+      await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const w2c = await WorkflowModel.count();
+      expect(w2c).toBe(0);
+      const e2c = await workflow.countExecutions();
+      expect(e2c).toBe(0);
+      const n1c = await workflow.countNodes();
+      expect(n1c).toBe(0);
+      const n2c = await w2.countNodes();
+      expect(n2c).toBe(0);
+      const p2c = await PostRepo.count({ filter: { title: 't1' } });
+      expect(p2c).toBe(1);
+
+      const j2c = await JobModel.count();
+      expect(j2c).toBe(0);
+    });
+  });
+
+  describe('revision', () => {
+    it('create revision', async () => {
+      const w1 = await WorkflowModel.create({
+        enabled: true,
+        type: 'collection',
+        config: {
+          mode: 1,
+          collection: 'posts',
+        },
+      });
+
+      const p1 = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const { body, status } = await agent.resource(`workflows`).revision({
+        filterByTk: w1.id,
+        filter: {
+          key: w1.key,
+        },
+      });
+
+      expect(status).toBe(200);
+      const { data: w2 } = body;
+      expect(w2.config).toMatchObject(w1.config);
+      expect(w2.key).toBe(w1.key);
+      expect(w2.current).toBeFalsy();
+      expect(w2.enabled).toBe(false);
+      expect(w2.executed).toBe(0);
+      expect(w2.allExecuted).toBe(1);
+
+      await WorkflowModel.update(
+        {
+          enabled: true,
+        },
+        {
+          where: {
+            id: w2.id,
+          },
+          individualHooks: true,
+        },
+      );
+
+      const p2 = await PostRepo.create({ values: { title: 't2' } });
+
+      await sleep(500);
+
+      const [w1next, w2next] = await WorkflowModel.findAll({
+        order: [['id', 'ASC']],
+      });
+
+      expect(w1next.enabled).toBe(false);
+      expect(w1next.current).toBe(null);
+      expect(w1next.allExecuted).toBe(2);
+      expect(w2next.enabled).toBe(true);
+      expect(w2next.current).toBe(true);
+      expect(w2next.executed).toBe(1);
+      expect(w2next.allExecuted).toBe(2);
+
+      const [e1] = await w1next.getExecutions();
+      const [e2] = await w2next.getExecutions();
+      expect(e1.key).toBe(e2.key);
+      expect(e1.workflowId).toBe(w1.id);
+      expect(e2.workflowId).toBe(w2.id);
+    });
+
+    it('revision with nodes', async () => {
+      const w1 = await WorkflowModel.create({
+        enabled: true,
+        type: 'collection',
+        config: {
+          mode: 1,
+          collection: 'posts',
+        },
+      });
+
+      const n1 = await w1.createNode({
+        type: 'echo',
+      });
+      const n2 = await w1.createNode({
+        type: 'calculation',
+        config: {
+          engine: 'math.js',
+          expression: `{{$jobsMapByNodeId.${n1.id}.data.read}} + {{$jobsMapByNodeId.${n1.id}.data.read}}`,
+        },
+        upstreamId: n1.id,
+      });
+      await n1.setDownstream(n2);
+
+      const { body } = await agent.resource(`workflows`).revision({
+        filterByTk: w1.id,
+        filter: {
+          key: w1.key,
+        },
+      });
+      const w2 = await WorkflowModel.findByPk(body.data.id, {
+        include: ['nodes'],
+      });
+
+      const n1_2 = w2.nodes.find((n) => !n.upstreamId);
+      const n2_2 = w2.nodes.find((n) => !n.downstreamId);
+
+      expect(n1_2.type).toBe('echo');
+      expect(n2_2.type).toBe('calculation');
+      expect(n2_2.config).toMatchObject({
+        engine: 'math.js',
+        expression: `{{$jobsMapByNodeId.${n1_2.id}.data.read}} + {{$jobsMapByNodeId.${n1_2.id}.data.read}}`,
+      });
+
+      await w2.update({ enabled: true });
+
+      await PostRepo.create({
+        values: { title: 't1', read: 1 },
+      });
+
+      await sleep(500);
+
+      const [execution] = await w2.getExecutions();
+      const [echo, calculation] = await execution.getJobs({ order: [['id', 'ASC']] });
+      expect(calculation.result).toBe(2);
+    });
+
+    it('revision with using of deleted nodes', async () => {
+      const w1 = await WorkflowModel.create({
+        enabled: true,
+        type: 'collection',
+        config: {
+          mode: 1,
+          collection: 'posts',
+        },
+      });
+
+      const n2 = await w1.createNode({
+        type: 'calculation',
+        config: {
+          calculation: {
+            calculator: 'add',
+            operands: [
+              {
+                type: '$jobsMapByNodeId',
+                options: {
+                  nodeId: 0,
+                  path: 'data.read',
+                },
+              },
+              {
+                value: `{{$jobsMapByNodeId.0.data.read}}`,
+              },
+            ],
+          },
+        },
+      });
+
+      const { status } = await agent.resource(`workflows`).revision({
+        filterByTk: w1.id,
+        filter: {
+          key: w1.key,
+        },
+      });
+
+      expect(status).toBe(400);
+    });
+
+    it('duplicate workflow', async () => {
+      const w1 = await WorkflowModel.create({
+        enabled: true,
+        type: 'collection',
+        config: {
+          mode: 1,
+          collection: 'posts',
+        },
+      });
+
+      const p1 = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const { body, status } = await agent.resource(`workflows`).revision({
+        filterByTk: w1.id,
+      });
+
+      expect(status).toBe(200);
+      const { data: w2 } = body;
+      expect(w2.config).toMatchObject(w1.config);
+      expect(w2.key).not.toBe(w1.key);
+      expect(w2.current).toBeTruthy();
+      expect(w2.enabled).toBe(false);
+      expect(w2.allExecuted).toBe(0);
+
+      // stop w1
+      await WorkflowModel.update(
+        {
+          enabled: false,
+        },
+        {
+          where: {
+            id: w1.id,
+          },
+          individualHooks: true,
+        },
+      );
+
+      await WorkflowModel.update(
+        {
+          enabled: true,
+        },
+        {
+          where: {
+            id: w2.id,
+          },
+          individualHooks: true,
+        },
+      );
+
+      const p2 = await PostRepo.create({ values: { title: 't2' } });
+
+      await sleep(500);
+
+      const [w1next, w2next] = await WorkflowModel.findAll({
+        order: [['id', 'ASC']],
+      });
+
+      expect(w1next.enabled).toBe(false);
+      expect(w1next.current).toBe(true);
+      expect(w1next.executed).toBe(1);
+      expect(w1next.allExecuted).toBe(1);
+      expect(w2next.enabled).toBe(true);
+      expect(w2next.executed).toBe(1);
+      expect(w2next.allExecuted).toBe(1);
+
+      const [e1] = await w1next.getExecutions();
+      const [e2] = await w2next.getExecutions();
+      expect(e1.key).not.toBe(e2.key);
+      expect(e2.workflowId).toBe(w2.id);
+    });
+  });
+});

package/src/server/__tests__/collections/categories.ts

@@ -0,0 +1,27 @@
+import { CollectionOptions } from '@nocobase/database';
+
+export default {
+  name: 'categories',
+  fields: [
+    {
+      type: 'string',
+      name: 'title',
+    },
+    {
+      type: 'string',
+      name: 'engine',
+    },
+    {
+      type: 'string',
+      name: 'collection',
+    },
+    {
+      type: 'text',
+      name: 'expression',
+    },
+    {
+      type: 'hasMany',
+      name: 'posts',
+    },
+  ],
+} as CollectionOptions;

package/src/server/__tests__/collections/comments.ts

@@ -0,0 +1,24 @@
+import { CollectionOptions } from '@nocobase/database';
+
+export default {
+  name: 'comments',
+  fields: [
+    {
+      type: 'belongsTo',
+      name: 'post',
+    },
+    {
+      type: 'text',
+      name: 'content',
+    },
+    {
+      type: 'integer',
+      name: 'status',
+      defaultValue: 0,
+    },
+    {
+      type: 'hasMany',
+      name: 'replies',
+    },
+  ],
+} as CollectionOptions;

package/src/server/__tests__/collections/posts.ts

@@ -0,0 +1,42 @@
+import { CollectionOptions } from '@nocobase/database';
+
+export default {
+  name: 'posts',
+  fields: [
+    {
+      type: 'string',
+      name: 'title',
+    },
+    {
+      type: 'boolean',
+      name: 'published',
+      defaultValue: false,
+    },
+    {
+      type: 'integer',
+      name: 'read',
+      defaultValue: 0,
+    },
+    {
+      type: 'belongsTo',
+      name: 'category',
+    },
+    {
+      type: 'hasMany',
+      name: 'comments',
+    },
+    {
+      type: 'belongsToMany',
+      name: 'tags',
+    },
+    {
+      type: 'integer',
+      name: 'read',
+      defaultValue: 0,
+    },
+    {
+      type: 'expression',
+      name: 'dexp',
+    },
+  ],
+} as CollectionOptions;

package/src/server/__tests__/collections/replies.ts

@@ -0,0 +1,9 @@
+export default {
+  name: 'replies',
+  fields: [
+    {
+      type: 'string',
+      name: 'content',
+    },
+  ],
+};

package/src/server/__tests__/collections/tags.ts

@@ -0,0 +1,15 @@
+import { CollectionOptions } from '@nocobase/database';
+
+export default {
+  name: 'tags',
+  fields: [
+    {
+      type: 'belongsToMany',
+      name: 'posts',
+    },
+    {
+      type: 'string',
+      name: 'name',
+    },
+  ],
+} as CollectionOptions;

package/src/server/__tests__/index.ts

@@ -0,0 +1,89 @@
+import { ApplicationOptions } from '@nocobase/server';
+import { MockServer, mockServer } from '@nocobase/test';
+import { lodash } from '@nocobase/utils';
+import path from 'path';
+import Plugin from '..';
+import { JOB_STATUS } from '../constants';
+import type { FlowNodeModel } from '../types';
+
+export function sleep(ms: number) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+interface MockAppOptions extends ApplicationOptions {
+  manual?: boolean;
+}
+
+export async function getApp({ manual, ...options }: MockAppOptions = {}): Promise<MockServer> {
+  const app = mockServer(options);
+
+  app.plugin(Plugin, {
+    name: 'workflow',
+    instructions: {
+      echo: {
+        run({ config = {} }: FlowNodeModel, { result }, processor) {
+          return {
+            status: JOB_STATUS.RESOLVED,
+            result: config.path == null ? result : lodash.get(result, config.path),
+          };
+        },
+      },
+
+      error: {
+        run(node, input, processor) {
+          throw new Error('definite error');
+        },
+      },
+
+      'prompt->error': {
+        run(node, input, processor) {
+          return {
+            status: JOB_STATUS.PENDING,
+          };
+        },
+        resume(node, input, processor) {
+          throw new Error('input failed');
+        },
+      },
+
+      customizedSuccess: {
+        run(node, input, processor) {
+          return {
+            status: 100,
+          };
+        },
+      },
+
+      customizedError: {
+        run(node, input, processor) {
+          return {
+            status: -100,
+          };
+        },
+      },
+    },
+    functions: {
+      no1: () => 1,
+    },
+  });
+
+  await app.load();
+
+  await app.db.import({
+    directory: path.resolve(__dirname, './collections'),
+  });
+
+  try {
+    await app.db.sync();
+  } catch (error) {
+    console.error(error);
+  }
+
+  if (!manual) {
+    await app.start();
+  }
+
+  return app;
+}