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

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

@@ -0,0 +1,369 @@
+import { Application } from '@nocobase/server';
+import Database from '@nocobase/database';
+import { getApp, sleep } from '..';
+
+describe.skip('workflow > triggers > schedule', () => {
+  let app: Application;
+  let db: Database;
+  let PostRepo;
+  let CategoryRepo;
+  let WorkflowModel;
+  let WorkflowRepo;
+
+  beforeEach(async () => {
+    app = await getApp();
+
+    db = app.db;
+    const workflow = db.getCollection('workflows');
+    WorkflowModel = workflow.model;
+    WorkflowRepo = workflow.repository;
+    PostRepo = db.getCollection('posts').repository;
+    CategoryRepo = db.getCollection('categories').repository;
+  });
+
+  afterEach(() => app.destroy());
+
+  describe('constant mode', () => {
+    it('neither startsOn nor repeat configurated', async () => {
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'schedule',
+        config: {
+          mode: 0,
+        },
+      });
+
+      await sleep(3000);
+
+      const executions = await workflow.getExecutions();
+      expect(executions.length).toBe(0);
+    });
+
+    it('on every 2 seconds', async () => {
+      const now = new Date();
+      // NOTE: align to even(0, 2, ...) + 0.5 seconds to start
+      await sleep((2.5 - (now.getSeconds() % 2)) * 1000 - now.getMilliseconds());
+
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'schedule',
+        config: {
+          mode: 0,
+          startsOn: now.toISOString(),
+          repeat: '*/2 * * * * *',
+        },
+      });
+
+      await sleep(4000);
+      // sleep 1.5s at 2s trigger 1st time
+      // sleep 3.5s at 4s trigger 2nd time
+
+      const executions = await workflow.getExecutions();
+      expect(executions.length).toBe(2);
+    });
+
+    it('on every even seconds and limit 1', async () => {
+      const now = new Date();
+      // NOTE: align to even(0, 2, ...) + 0.5 seconds to start
+      await sleep((2.5 - (now.getSeconds() % 2)) * 1000 - now.getMilliseconds());
+
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'schedule',
+        config: {
+          mode: 0,
+          startsOn: now.toISOString(),
+          repeat: '*/2 * * * * *',
+          limit: 1,
+        },
+      });
+
+      await sleep(5000);
+
+      const executions = await workflow.getExecutions();
+      expect(executions.length).toBe(1);
+    });
+
+    it('on every 2 seconds after created and limit 1', async () => {
+      const now = new Date();
+      // NOTE: align to even(0, 2, ...) + 0.5 seconds to start
+      await sleep((2.5 - (now.getSeconds() % 2)) * 1000 - now.getMilliseconds());
+
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'schedule',
+        config: {
+          mode: 0,
+          startsOn: now.toISOString(),
+          repeat: 2000,
+          limit: 1,
+        },
+      });
+
+      await sleep(5000);
+
+      const executions = await workflow.getExecutions();
+      expect(executions.length).toBe(1);
+    });
+
+    it('on certain second', async () => {
+      const now = new Date();
+      const startsOn = now.toISOString();
+      now.setSeconds(now.getSeconds() + 3);
+      now.setMilliseconds(0);
+
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'schedule',
+        config: {
+          mode: 0,
+          startsOn,
+          repeat: `${now.getSeconds()} * * * * *`,
+        },
+      });
+
+      await sleep(5000);
+
+      const executions = await workflow.getExecutions();
+      expect(executions.length).toBe(1);
+      expect(executions[0].context.date).toBe(now.toISOString());
+    });
+
+    it('multiple workflows trigger at same time', async () => {
+      const now = new Date();
+      const startsOn = now.toISOString();
+      now.setSeconds(now.getSeconds() + 2);
+      now.setMilliseconds(0);
+
+      let w1, w2;
+      await db.sequelize.transaction(async (transaction) => {
+        w1 = await WorkflowRepo.create({
+          values: {
+            enabled: true,
+            type: 'schedule',
+            config: {
+              mode: 0,
+              startsOn,
+              repeat: `${now.getSeconds()} * * * * *`,
+            },
+          },
+          transaction,
+        });
+      });
+
+      await db.sequelize.transaction(async (transaction) => {
+        w2 = await WorkflowRepo.create({
+          values: {
+            enabled: true,
+            type: 'schedule',
+            config: {
+              mode: 0,
+              startsOn,
+              repeat: `${now.getSeconds()} * * * * *`,
+            },
+          },
+          transaction,
+        });
+      });
+
+      await sleep(3000);
+      await WorkflowModel.update({ enabled: false }, { where: { enabled: true } });
+
+      const [e1] = await w1.getExecutions();
+      expect(e1).toBeDefined();
+      expect(e1.context.date).toBe(now.toISOString());
+
+      const [e2] = await w2.getExecutions();
+      expect(e2).toBeDefined();
+      expect(e2.context.date).toBe(now.toISOString());
+    });
+  });
+
+  describe('collection field mode', () => {
+    it('starts on post.createdAt with offset', async () => {
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'schedule',
+        config: {
+          mode: 1,
+          collection: 'posts',
+          startsOn: {
+            field: 'createdAt',
+            offset: 2,
+          },
+        },
+      });
+
+      const now = new Date();
+      await sleep((2.5 - (now.getSeconds() % 2)) * 1000 - now.getMilliseconds());
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(1000);
+      const executions = await workflow.getExecutions();
+      expect(executions.length).toBe(0);
+
+      await sleep(2000);
+      const [execution] = await workflow.getExecutions();
+      expect(execution).toBeDefined();
+      expect(execution.context.data.id).toBe(post.id);
+
+      const triggerTime = new Date(post.createdAt.getTime() + 2000);
+      triggerTime.setMilliseconds(0);
+      expect(execution.context.date).toBe(triggerTime.toISOString());
+    });
+
+    it('starts on post.createdAt and repeat by cron', async () => {
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'schedule',
+        config: {
+          mode: 1,
+          collection: 'posts',
+          startsOn: {
+            field: 'createdAt',
+          },
+          repeat: '*/2 * * * * *',
+        },
+      });
+
+      const now = new Date();
+      await sleep((2.5 - (now.getSeconds() % 2)) * 1000 - now.getMilliseconds());
+      const startTime = new Date();
+      startTime.setMilliseconds(500);
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(5000);
+      // sleep 1.5s at 2s trigger 1st time
+      // sleep 3.5s at 4s trigger 2nd time
+
+      const executions = await workflow.getExecutions({ order: [['createdAt', 'ASC']] });
+      expect(executions.length).toBe(2);
+      const d1 = Date.parse(executions[0].context.date);
+      expect(d1 - 1500).toBe(startTime.getTime());
+      const d2 = Date.parse(executions[1].context.date);
+      expect(d2 - 3500).toBe(startTime.getTime());
+    });
+
+    it('starts on post.createdAt and repeat with endsOn at certain time', async () => {
+      const now = new Date();
+      await sleep((2.5 - (now.getSeconds() % 2)) * 1000 - now.getMilliseconds());
+      const startTime = new Date();
+      startTime.setMilliseconds(500);
+
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'schedule',
+        config: {
+          mode: 1,
+          collection: 'posts',
+          startsOn: {
+            field: 'createdAt',
+          },
+          repeat: '*/2 * * * * *',
+          endsOn: new Date(startTime.getTime() + 2500).toISOString(),
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(5000);
+
+      const executions = await workflow.getExecutions();
+      expect(executions.length).toBe(1);
+      const d1 = Date.parse(executions[0].context.date);
+      expect(d1 - 1500).toBe(startTime.getTime());
+    });
+
+    it('starts on post.createdAt and repeat with endsOn by offset', async () => {
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'schedule',
+        config: {
+          mode: 1,
+          collection: 'posts',
+          startsOn: {
+            field: 'createdAt',
+          },
+          repeat: '*/2 * * * * *',
+          endsOn: {
+            field: 'createdAt',
+            offset: 3,
+          },
+        },
+      });
+
+      const now = new Date();
+      await sleep((2.5 - (now.getSeconds() % 2)) * 1000 - now.getMilliseconds());
+      const startTime = new Date();
+      startTime.setMilliseconds(500);
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(5000);
+      const executions = await workflow.getExecutions();
+      expect(executions.length).toBe(1);
+      const d1 = Date.parse(executions[0].context.date);
+      expect(d1 - 1500).toBe(startTime.getTime());
+    });
+
+    it('starts on post.createdAt and repeat by number', async () => {
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'schedule',
+        config: {
+          mode: 1,
+          collection: 'posts',
+          startsOn: {
+            field: 'createdAt',
+          },
+          repeat: 2000,
+          endsOn: {
+            field: 'createdAt',
+            offset: 3,
+          },
+        },
+      });
+
+      const now = new Date();
+      await sleep((2.5 - (now.getSeconds() % 2)) * 1000 - now.getMilliseconds());
+      const startTime = new Date();
+      startTime.setMilliseconds(500);
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(5000);
+      const executions = await workflow.getExecutions();
+      expect(executions.length).toBe(1);
+      const d1 = Date.parse(executions[0].context.date);
+      expect(d1 - 1500).toBe(startTime.getTime());
+    });
+
+    it('appends', async () => {
+      const category = await CategoryRepo.create({ values: { name: 'c1' } });
+
+      const workflow = await WorkflowModel.create({
+        enabled: true,
+        type: 'schedule',
+        config: {
+          mode: 1,
+          collection: 'posts',
+          startsOn: {
+            field: 'createdAt',
+            offset: 2,
+          },
+          appends: ['category'],
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1', categoryId: category.id } });
+
+      await sleep(5000);
+
+      const executions = await workflow.getExecutions();
+      expect(executions.length).toBe(1);
+      expect(executions[0].context.data.category.id).toBe(category.id);
+    });
+  });
+});

package/src/server/actions/index.ts

@@ -0,0 +1,25 @@
+import * as workflows from './workflows';
+import * as nodes from './nodes';
+
+function make(name, mod) {
+  return Object.keys(mod).reduce(
+    (result, key) => ({
+      ...result,
+      [`${name}:${key}`]: mod[key],
+    }),
+    {},
+  );
+}
+
+export default function ({ app }) {
+  app.actions({
+    ...make('workflows', workflows),
+    ...make('workflows.nodes', {
+      create: nodes.create,
+      destroy: nodes.destroy,
+    }),
+    ...make('flow_nodes', {
+      update: nodes.update,
+    }),
+  });
+}

package/src/server/actions/nodes.ts

@@ -0,0 +1,214 @@
+import { Context, utils } from '@nocobase/actions';
+import { MultipleRelationRepository, Op } from '@nocobase/database';
+import type { WorkflowModel } from '../types';
+
+export async function create(context: Context, next) {
+  const { db } = context;
+  const repository = utils.getRepositoryFromParams(context) as MultipleRelationRepository;
+  const { whitelist, blacklist, updateAssociationValues, values, associatedIndex: workflowId } = context.action.params;
+
+  context.body = await db.sequelize.transaction(async (transaction) => {
+    const workflow = (await repository.getSourceModel(transaction)) as WorkflowModel;
+    if (workflow.executed) {
+      context.throw(400, 'Node could not be created in executed workflow');
+    }
+
+    const instance = await repository.create({
+      values,
+      whitelist,
+      blacklist,
+      updateAssociationValues,
+      context,
+      transaction,
+    });
+
+    if (!instance.upstreamId) {
+      const previousHead = await repository.findOne({
+        filter: {
+          id: {
+            $ne: instance.id,
+          },
+          upstreamId: null,
+        },
+        transaction,
+      });
+      if (previousHead) {
+        await previousHead.setUpstream(instance, { transaction });
+        await instance.setDownstream(previousHead, { transaction });
+        instance.set('downstream', previousHead);
+      }
+      return instance;
+    }
+
+    const upstream = await instance.getUpstream({ transaction });
+
+    if (instance.branchIndex == null) {
+      const downstream = await upstream.getDownstream({ transaction });
+
+      if (downstream) {
+        await downstream.setUpstream(instance, { transaction });
+        await instance.setDownstream(downstream, { transaction });
+        instance.set('downstream', downstream);
+      }
+
+      await upstream.update(
+        {
+          downstreamId: instance.id,
+        },
+        { transaction },
+      );
+
+      upstream.set('downstream', instance);
+    } else {
+      const [downstream] = await upstream.getBranches({
+        where: {
+          id: {
+            [Op.ne]: instance.id,
+          },
+          branchIndex: instance.branchIndex,
+        },
+        transaction,
+      });
+
+      if (downstream) {
+        await downstream.update(
+          {
+            upstreamId: instance.id,
+            branchIndex: null,
+          },
+          { transaction },
+        );
+        await instance.setDownstream(downstream, { transaction });
+        instance.set('downstream', downstream);
+      }
+    }
+
+    instance.set('upstream', upstream);
+
+    return instance;
+  });
+
+  await next();
+}
+
+function searchBranchNodes(nodes, from): any[] {
+  const branchHeads = nodes.filter((item: any) => item.upstreamId === from.id && item.branchIndex != null);
+  return branchHeads.reduce(
+    (flatten: any[], head) => flatten.concat(searchBranchDownstreams(nodes, head)),
+    [],
+  ) as any[];
+}
+
+function searchBranchDownstreams(nodes, from) {
+  let result = [];
+  for (let search = from; search; search = search.downstream) {
+    result = [...result, search, ...searchBranchNodes(nodes, search)];
+  }
+  return result;
+}
+
+export async function destroy(context: Context, next) {
+  const { db } = context;
+  const repository = utils.getRepositoryFromParams(context) as MultipleRelationRepository;
+  const { filterByTk } = context.action.params;
+
+  context.body = await db.sequelize.transaction(async (transaction) => {
+    const workflow = (await repository.getSourceModel(transaction)) as WorkflowModel;
+    if (workflow.executed) {
+      context.throw(400, 'Nodes in executed workflow could not be deleted');
+    }
+
+    const fields = ['id', 'upstreamId', 'downstreamId', 'branchIndex'];
+    const instance = await repository.findOne({
+      filterByTk,
+      fields: [...fields, 'workflowId'],
+      appends: ['upstream', 'downstream'],
+      transaction,
+    });
+    const { upstream, downstream } = instance.get();
+
+    if (upstream && upstream.downstreamId === instance.id) {
+      await upstream.update(
+        {
+          downstreamId: instance.downstreamId,
+        },
+        { transaction },
+      );
+    }
+
+    if (downstream) {
+      await downstream.update(
+        {
+          upstreamId: instance.upstreamId,
+          branchIndex: instance.branchIndex,
+        },
+        { transaction },
+      );
+    }
+
+    const nodes = await repository.find({
+      filter: {
+        workflowId: instance.workflowId,
+      },
+      fields,
+      transaction,
+    });
+    const nodesMap = new Map();
+    // make map
+    nodes.forEach((item) => {
+      nodesMap.set(item.id, item);
+    });
+    // overwrite
+    nodesMap.set(instance.id, instance);
+    // make linked list
+    nodes.forEach((item) => {
+      if (item.upstreamId) {
+        item.upstream = nodesMap.get(item.upstreamId);
+      }
+      if (item.downstreamId) {
+        item.downstream = nodesMap.get(item.downstreamId);
+      }
+    });
+
+    const branchNodes = searchBranchNodes(nodes, instance);
+
+    await repository.destroy({
+      filterByTk: [instance.id, ...branchNodes.map((item) => item.id)],
+      transaction,
+    });
+
+    return instance;
+  });
+
+  await next();
+}
+
+export async function update(context: Context, next) {
+  const { db } = context;
+  const repository = utils.getRepositoryFromParams(context);
+  const { filterByTk, values, whitelist, blacklist, filter, updateAssociationValues } = context.action.params;
+  context.body = await db.sequelize.transaction(async (transaction) => {
+    // TODO(optimize): duplicated instance query
+    const { workflow } = await repository.findOne({
+      filterByTk,
+      appends: ['workflow.executed'],
+      transaction,
+    });
+    if (workflow.executed) {
+      context.throw(400, 'Nodes in executed workflow could not be reconfigured');
+    }
+
+    return repository.update({
+      filterByTk,
+      values,
+      whitelist,
+      blacklist,
+      filter,
+      updateAssociationValues,
+      context,
+      transaction,
+    });
+  });
+
+  await next();
+}