@nocobase/plugin-workflow-manual 0.20.0-alpha.9 → 0.21.0-alpha.2

package/src/server/__tests__/mode.test.ts

@@ -0,0 +1,561 @@
+import Database from '@nocobase/database';
+import { EXECUTION_STATUS, JOB_STATUS } from '@nocobase/plugin-workflow';
+import { getApp, sleep } from '@nocobase/plugin-workflow-test';
+import { MockServer } from '@nocobase/test';
+
+// NOTE: skipped because time is not stable on github ci, but should work in local
+describe('workflow > instructions > manual', () => {
+  let app: MockServer;
+  let agent;
+  let userAgents;
+  let db: Database;
+  let PostRepo;
+  let CommentRepo;
+  let WorkflowModel;
+  let workflow;
+  let UserModel;
+  let users;
+  let UserJobModel;
+
+  beforeEach(async () => {
+    app = await getApp({
+      plugins: ['users', 'auth', 'workflow-manual'],
+    });
+    // await app.getPlugin('auth').install();
+    agent = app.agent();
+    db = app.db;
+    WorkflowModel = db.getCollection('workflows').model;
+    PostRepo = db.getCollection('posts').repository;
+    CommentRepo = db.getCollection('comments').repository;
+    UserModel = db.getCollection('users').model;
+    UserJobModel = db.getModel('users_jobs');
+
+    users = await UserModel.bulkCreate([
+      { id: 2, nickname: 'a' },
+      { id: 3, nickname: 'b' },
+    ]);
+
+    userAgents = users.map((user) => app.agent().login(user));
+
+    workflow = await WorkflowModel.create({
+      enabled: true,
+      type: 'collection',
+      config: {
+        mode: 1,
+        collection: 'posts',
+      },
+    });
+  });
+
+  afterEach(() => app.destroy());
+
+  describe('mode: 0 (single record)', () => {
+    it('the only user assigned could submit', async () => {
+      const n1 = await workflow.createNode({
+        type: 'manual',
+        config: {
+          assignees: [users[0].id],
+          forms: {
+            f1: {
+              actions: [{ status: JOB_STATUS.RESOLVED, key: 'resolve' }],
+            },
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [pending] = await workflow.getExecutions();
+      expect(pending.status).toBe(EXECUTION_STATUS.STARTED);
+      const [j1] = await pending.getJobs();
+      expect(j1.status).toBe(JOB_STATUS.PENDING);
+
+      const usersJobs = await UserJobModel.findAll();
+      expect(usersJobs.length).toBe(1);
+      expect(usersJobs[0].status).toBe(JOB_STATUS.PENDING);
+      expect(usersJobs[0].userId).toBe(users[0].id);
+      expect(usersJobs[0].jobId).toBe(j1.id);
+
+      const res1 = await agent.resource('users_jobs').submit({
+        filterByTk: usersJobs[0].id,
+        values: { result: { f1: {}, _: 'resolve' } },
+      });
+      expect(res1.status).toBe(401);
+
+      const res2 = await userAgents[1].resource('users_jobs').submit({
+        filterByTk: usersJobs[0].id,
+        values: {
+          result: { f1: {}, _: 'resolve' },
+        },
+      });
+      expect(res2.status).toBe(403);
+
+      const res3 = await userAgents[0].resource('users_jobs').submit({
+        filterByTk: usersJobs[0].id,
+        values: {
+          result: { f1: { a: 1 }, _: 'resolve' },
+        },
+      });
+      expect(res3.status).toBe(202);
+
+      await sleep(1000);
+
+      const [j2] = await pending.getJobs();
+      expect(j2.status).toBe(JOB_STATUS.RESOLVED);
+      expect(j2.result).toEqual({ f1: { a: 1 }, _: 'resolve' });
+
+      const usersJobsAfter = await UserJobModel.findAll();
+      expect(usersJobsAfter.length).toBe(1);
+      expect(usersJobsAfter[0].status).toBe(JOB_STATUS.RESOLVED);
+      expect(usersJobsAfter[0].result).toEqual({ f1: { a: 1 }, _: 'resolve' });
+
+      const res4 = await userAgents[0].resource('users_jobs').submit({
+        filterByTk: usersJobs[0].id,
+        values: {
+          result: { f1: { a: 2 }, _: 'resolve' },
+        },
+      });
+      expect(res4.status).toBe(400);
+    });
+
+    it('any user assigned could submit', async () => {
+      const n1 = await workflow.createNode({
+        type: 'manual',
+        config: {
+          assignees: [users[0].id, users[1].id],
+          forms: {
+            f1: {
+              actions: [{ status: JOB_STATUS.RESOLVED, key: 'resolve' }],
+            },
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [pending] = await workflow.getExecutions();
+      expect(pending.status).toBe(EXECUTION_STATUS.STARTED);
+      const [j1] = await pending.getJobs();
+      expect(j1.status).toBe(JOB_STATUS.PENDING);
+
+      const usersJobs = await j1.getUsersJobs();
+
+      const res1 = await userAgents[1].resource('users_jobs').submit({
+        filterByTk: usersJobs.find((item) => item.userId === users[1].id).id,
+        values: {
+          result: { f1: { a: 1 }, _: 'resolve' },
+        },
+      });
+      expect(res1.status).toBe(202);
+
+      await sleep(1000);
+
+      const [j2] = await pending.getJobs();
+      expect(j2.status).toBe(JOB_STATUS.RESOLVED);
+      expect(j2.result).toEqual({ f1: { a: 1 }, _: 'resolve' });
+
+      const res2 = await userAgents[0].resource('users_jobs').submit({
+        filterByTk: usersJobs.find((item) => item.userId === users[0].id).id,
+        values: {
+          result: { f1: { a: 1 }, _: 'resolve' },
+        },
+      });
+      expect(res2.status).toBe(400);
+    });
+
+    it('also could submit to users_jobs api', async () => {
+      const n1 = await workflow.createNode({
+        type: 'manual',
+        config: {
+          assignees: [users[0].id],
+          forms: {
+            f1: {
+              actions: [{ status: JOB_STATUS.RESOLVED, key: 'resolve' }],
+            },
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const UserJobModel = db.getModel('users_jobs');
+      const usersJobs = await UserJobModel.findAll();
+      expect(usersJobs.length).toBe(1);
+      expect(usersJobs[0].get('status')).toBe(JOB_STATUS.PENDING);
+      expect(usersJobs[0].get('userId')).toBe(users[0].id);
+
+      const res = await userAgents[0].resource('users_jobs').submit({
+        filterByTk: usersJobs[0].get('id'),
+        values: {
+          result: { f1: { a: 1 }, _: 'resolve' },
+        },
+      });
+      expect(res.status).toBe(202);
+
+      await sleep(1000);
+
+      const [execution] = await workflow.getExecutions();
+      expect(execution.status).toBe(EXECUTION_STATUS.RESOLVED);
+      const [job] = await execution.getJobs();
+      expect(job.status).toBe(JOB_STATUS.RESOLVED);
+      expect(job.result).toEqual({ f1: { a: 1 }, _: 'resolve' });
+    });
+  });
+
+  describe('mode: 1 (multiple record, all)', () => {
+    it('all resolved', async () => {
+      const n1 = await workflow.createNode({
+        type: 'manual',
+        config: {
+          assignees: [users[0].id, users[1].id],
+          mode: 1,
+          forms: {
+            f1: {
+              actions: [{ status: JOB_STATUS.RESOLVED, key: 'resolve' }],
+            },
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const UserJobModel = db.getModel('users_jobs');
+      const pendingJobs = await UserJobModel.findAll({
+        order: [['userId', 'ASC']],
+      });
+      expect(pendingJobs.length).toBe(2);
+
+      const res1 = await userAgents[0].resource('users_jobs').submit({
+        filterByTk: pendingJobs[0].get('id'),
+        values: {
+          result: { f1: { a: 1 }, _: 'resolve' },
+        },
+      });
+      expect(res1.status).toBe(202);
+
+      await sleep(1000);
+
+      const [e1] = await workflow.getExecutions();
+      expect(e1.status).toBe(EXECUTION_STATUS.STARTED);
+      const [j1] = await e1.getJobs();
+      expect(j1.status).toBe(JOB_STATUS.PENDING);
+      expect(j1.result).toBe(0.5);
+      const usersJobs1 = await UserJobModel.findAll({
+        order: [['userId', 'ASC']],
+      });
+      expect(usersJobs1.length).toBe(2);
+
+      const res2 = await userAgents[1].resource('users_jobs').submit({
+        filterByTk: pendingJobs[1].get('id'),
+        values: {
+          result: { f1: { a: 2 }, _: 'resolve' },
+        },
+      });
+      expect(res2.status).toBe(202);
+
+      await sleep(1000);
+
+      const [e2] = await workflow.getExecutions();
+      expect(e2.status).toBe(EXECUTION_STATUS.RESOLVED);
+      const [j2] = await e2.getJobs();
+      expect(j2.status).toBe(JOB_STATUS.RESOLVED);
+      expect(j2.result).toBe(1);
+    });
+
+    it('first rejected', async () => {
+      const n1 = await workflow.createNode({
+        type: 'manual',
+        config: {
+          assignees: [users[0].id, users[1].id],
+          mode: 1,
+          forms: {
+            f1: {
+              actions: [{ status: JOB_STATUS.REJECTED, key: 'reject' }],
+            },
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const UserJobModel = db.getModel('users_jobs');
+      const pendingJobs = await UserJobModel.findAll({
+        order: [['userId', 'ASC']],
+      });
+      expect(pendingJobs.length).toBe(2);
+
+      const res1 = await userAgents[0].resource('users_jobs').submit({
+        filterByTk: pendingJobs[0].get('id'),
+        values: {
+          result: { f1: { a: 0 }, _: 'reject' },
+        },
+      });
+      expect(res1.status).toBe(202);
+
+      await sleep(1000);
+
+      const [e1] = await workflow.getExecutions();
+      expect(e1.status).toBe(EXECUTION_STATUS.REJECTED);
+      const [j1] = await e1.getJobs();
+      expect(j1.status).toBe(JOB_STATUS.REJECTED);
+      expect(j1.result).toBe(0.5);
+      const usersJobs1 = await UserJobModel.findAll({
+        order: [['userId', 'ASC']],
+      });
+      expect(usersJobs1.length).toBe(2);
+
+      const res2 = await userAgents[1].resource('users_jobs').submit({
+        filterByTk: pendingJobs[1].get('id'),
+        values: {
+          result: { f1: { a: 0 }, _: 'reject' },
+        },
+      });
+      expect(res2.status).toBe(400);
+    });
+
+    it('last rejected', async () => {
+      const n1 = await workflow.createNode({
+        type: 'manual',
+        config: {
+          assignees: [users[0].id, users[1].id],
+          mode: 1,
+          forms: {
+            f1: {
+              actions: [
+                { status: JOB_STATUS.RESOLVED, key: 'resolve' },
+                { status: JOB_STATUS.REJECTED, key: 'reject' },
+              ],
+            },
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const UserJobModel = db.getModel('users_jobs');
+      const pendingJobs = await UserJobModel.findAll({
+        order: [['userId', 'ASC']],
+      });
+      expect(pendingJobs.length).toBe(2);
+
+      const res1 = await userAgents[0].resource('users_jobs').submit({
+        filterByTk: pendingJobs[0].get('id'),
+        values: {
+          result: { f1: { a: 1 }, _: 'resolve' },
+        },
+      });
+      expect(res1.status).toBe(202);
+
+      await sleep(1000);
+
+      const [e1] = await workflow.getExecutions();
+      expect(e1.status).toBe(EXECUTION_STATUS.STARTED);
+      const [j1] = await e1.getJobs();
+      expect(j1.status).toBe(JOB_STATUS.PENDING);
+      expect(j1.result).toBe(0.5);
+      const usersJobs1 = await UserJobModel.findAll({
+        order: [['userId', 'ASC']],
+      });
+      expect(usersJobs1.length).toBe(2);
+
+      const res2 = await userAgents[1].resource('users_jobs').submit({
+        filterByTk: pendingJobs[1].get('id'),
+        values: {
+          result: { f1: { a: 0 }, _: 'reject' },
+        },
+      });
+      expect(res2.status).toBe(202);
+
+      await sleep(1000);
+
+      const [e2] = await workflow.getExecutions();
+      expect(e2.status).toBe(EXECUTION_STATUS.REJECTED);
+      const [j2] = await e2.getJobs();
+      expect(j2.status).toBe(JOB_STATUS.REJECTED);
+      expect(j2.result).toBe(1);
+    });
+  });
+
+  describe('mode: -1 (multiple record, any)', () => {
+    it('first resolved', async () => {
+      const n1 = await workflow.createNode({
+        type: 'manual',
+        config: {
+          assignees: [users[0].id, users[1].id],
+          mode: -1,
+          forms: {
+            f1: {
+              actions: [
+                { status: JOB_STATUS.RESOLVED, key: 'resolve' },
+                { status: JOB_STATUS.REJECTED, key: 'reject' },
+              ],
+            },
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const UserJobModel = db.getModel('users_jobs');
+      const pendingJobs = await UserJobModel.findAll({
+        order: [['userId', 'ASC']],
+      });
+      expect(pendingJobs.length).toBe(2);
+
+      const res1 = await userAgents[0].resource('users_jobs').submit({
+        filterByTk: pendingJobs[0].get('id'),
+        values: {
+          result: { f1: { a: 1 }, _: 'resolve' },
+        },
+      });
+      expect(res1.status).toBe(202);
+
+      await sleep(1000);
+
+      const [e1] = await workflow.getExecutions();
+      expect(e1.status).toBe(EXECUTION_STATUS.RESOLVED);
+      const [j1] = await e1.getJobs();
+      expect(j1.status).toBe(JOB_STATUS.RESOLVED);
+      expect(j1.result).toBe(0.5);
+
+      const res2 = await userAgents[1].resource('users_jobs').submit({
+        filterByTk: pendingJobs[1].get('id'),
+        values: {
+          result: { f1: { a: 0 }, _: 'reject' },
+        },
+      });
+      expect(res2.status).toBe(400);
+    });
+
+    it('any resolved', async () => {
+      const n1 = await workflow.createNode({
+        type: 'manual',
+        config: {
+          assignees: [users[0].id, users[1].id],
+          mode: -1,
+          forms: {
+            f1: {
+              actions: [
+                { status: JOB_STATUS.RESOLVED, key: 'resolve' },
+                { status: JOB_STATUS.REJECTED, key: 'reject' },
+              ],
+            },
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const UserJobModel = db.getModel('users_jobs');
+      const pendingJobs = await UserJobModel.findAll({
+        order: [['userId', 'ASC']],
+      });
+      expect(pendingJobs.length).toBe(2);
+
+      const res1 = await userAgents[0].resource('users_jobs').submit({
+        filterByTk: pendingJobs[0].get('id'),
+        values: {
+          result: { f1: { a: 0 }, _: 'reject' },
+        },
+      });
+      expect(res1.status).toBe(202);
+
+      await sleep(1000);
+
+      const [e1] = await workflow.getExecutions();
+      expect(e1.status).toBe(EXECUTION_STATUS.STARTED);
+      const [j1] = await e1.getJobs();
+      expect(j1.status).toBe(JOB_STATUS.PENDING);
+      expect(j1.result).toBe(0.5);
+
+      const res2 = await userAgents[1].resource('users_jobs').submit({
+        filterByTk: pendingJobs[1].get('id'),
+        values: {
+          result: { f1: { a: 1 }, _: 'resolve' },
+        },
+      });
+      expect(res2.status).toBe(202);
+
+      await sleep(1000);
+
+      const [e2] = await workflow.getExecutions();
+      expect(e2.status).toBe(EXECUTION_STATUS.RESOLVED);
+      const [j2] = await e2.getJobs();
+      expect(j2.status).toBe(JOB_STATUS.RESOLVED);
+      expect(j2.result).toBe(1);
+    });
+
+    it('all rejected', async () => {
+      const n1 = await workflow.createNode({
+        type: 'manual',
+        config: {
+          assignees: [users[0].id, users[1].id],
+          mode: -1,
+          forms: {
+            f1: {
+              actions: [{ status: JOB_STATUS.REJECTED, key: 'reject' }],
+            },
+          },
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const UserJobModel = db.getModel('users_jobs');
+      const pendingJobs = await UserJobModel.findAll({
+        order: [['userId', 'ASC']],
+      });
+      expect(pendingJobs.length).toBe(2);
+
+      const res1 = await userAgents[0].resource('users_jobs').submit({
+        filterByTk: pendingJobs[0].get('id'),
+        values: {
+          result: { f1: { a: 0 }, _: 'reject' },
+        },
+      });
+      expect(res1.status).toBe(202);
+
+      await sleep(1000);
+
+      const [e1] = await workflow.getExecutions();
+      expect(e1.status).toBe(EXECUTION_STATUS.STARTED);
+      const [j1] = await e1.getJobs();
+      expect(j1.status).toBe(JOB_STATUS.PENDING);
+      expect(j1.result).toBe(0.5);
+
+      const res2 = await userAgents[1].resource('users_jobs').submit({
+        filterByTk: pendingJobs[1].get('id'),
+        values: {
+          result: { f1: { a: 0 }, _: 'reject' },
+        },
+      });
+      expect(res2.status).toBe(202);
+
+      await sleep(1000);
+
+      const [e2] = await workflow.getExecutions();
+      expect(e2.status).toBe(EXECUTION_STATUS.REJECTED);
+      const [j2] = await e2.getJobs();
+      expect(j2.status).toBe(JOB_STATUS.REJECTED);
+      expect(j2.result).toBe(1);
+    });
+  });
+});

package/src/server/forms/create.ts

@@ -1,8 +1,15 @@
 import { Processor } from '@nocobase/plugin-workflow';
 import ManualInstruction from '../ManualInstruction';
 
-export default async function (this: ManualInstruction, instance, { collection }, processor: Processor) {
-  const repo = this.workflow.db.getRepository(collection);
+export default async function (
+  this: ManualInstruction,
+  instance,
+  { dataSource = 'main', collection },
+  processor: Processor,
+) {
+  const repo = this.workflow.app.dataSourceManager.dataSources
+    .get(dataSource)
+    .collectionManager.getRepository(collection);
   if (!repo) {
     throw new Error(`collection ${collection} for create data on manual node not found`);
   }
@@ -18,6 +25,6 @@ export default async function (this: ManualInstruction, instance, { collection }
     context: {
       executionId: processor.execution.id,
     },
-    // transaction: processor.transaction,
+    transaction: processor.transaction,
   });
 }

package/src/server/forms/update.ts

@@ -1,8 +1,15 @@
 import { Processor } from '@nocobase/plugin-workflow';
 import ManualInstruction from '../ManualInstruction';
 
-export default async function (this: ManualInstruction, instance, { collection, filter = {} }, processor: Processor) {
-  const repo = this.workflow.db.getRepository(collection);
+export default async function (
+  this: ManualInstruction,
+  instance,
+  { dataSource = 'main', collection, filter = {} },
+  processor: Processor,
+) {
+  const repo = this.workflow.app.dataSourceManager.dataSources
+    .get(dataSource)
+    .collectionManager.getRepository(collection);
   if (!repo) {
     throw new Error(`collection ${collection} for update data on manual node not found`);
   }
@@ -18,6 +25,6 @@ export default async function (this: ManualInstruction, instance, { collection,
     context: {
       executionId: processor.execution.id,
     },
-    // transaction: processor.transaction,
+    transaction: processor.transaction,
   });
 }

package/src/server/migrations/20240325213145-fix-schema.ts

@@ -0,0 +1,81 @@
+import { Migration } from '@nocobase/server';
+
+function findSchema(root, filter, onlyLeaf = false) {
+  const result = [];
+
+  if (!root) {
+    return result;
+  }
+
+  if (filter(root) && (!onlyLeaf || !root.properties)) {
+    result.push(root);
+    return result;
+  }
+
+  if (root.properties) {
+    Object.keys(root.properties).forEach((key) => {
+      result.push(...findSchema(root.properties[key], filter));
+    });
+  }
+  return result;
+}
+
+function changeToDataPath(item) {
+  if (item && item['x-decorator-props']?.dataSource) {
+    item['x-decorator-props'].dataPath = item['x-decorator-props'].dataSource.replace(/^{{|}}$/g, '');
+    delete item['x-decorator-props'].dataSource;
+  }
+}
+
+function migrateSchema(schema) {
+  const root = { properties: schema };
+
+  const detailNodes = findSchema(root, (item) => {
+    return (
+      item['x-decorator'] === 'DetailsBlockProvider' &&
+      item['x-component'] === 'CardItem' &&
+      item['x-designer'] === 'SimpleDesigner'
+    );
+  });
+
+  detailNodes.forEach(changeToDataPath);
+
+  return schema;
+}
+
+export default class extends Migration {
+  async up() {
+    const { db } = this.context;
+    const NodeRepo = db.getRepository('flow_nodes');
+    await db.sequelize.transaction(async (transaction) => {
+      const nodes = await NodeRepo.find({
+        filter: {
+          type: 'manual',
+        },
+        transaction,
+      });
+      console.log('%d nodes need to be migrated.', nodes.length);
+
+      await nodes.reduce(
+        (promise, node) =>
+          promise.then(() => {
+            const { assignees, forms, schema = {}, ...tabs } = node.config;
+            return node.update(
+              {
+                config: {
+                  assignees,
+                  forms,
+                  schema: migrateSchema({ ...tabs, ...schema }),
+                },
+              },
+              {
+                silent: true,
+                transaction,
+              },
+            );
+          }),
+        Promise.resolve(),
+      );
+    });
+  }
+}

package/dist/client/instruction/DetailsBlockProvider.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare function DetailsBlockProvider(props: any): React.JSX.Element;