@nocobase/plugin-workflow-delay 0.17.0-alpha.4

package/src/server/DelayInstruction.ts

@@ -0,0 +1,109 @@
+import WorkflowPlugin, {
+  Processor,
+  Instruction,
+  JOB_STATUS,
+  JobModel,
+  EXECUTION_STATUS,
+} from '@nocobase/plugin-workflow';
+
+type ValueOf<T> = T[keyof T];
+
+interface DelayConfig {
+  endStatus: ValueOf<typeof JOB_STATUS>;
+  duration: number;
+}
+
+export default class extends Instruction {
+  timers: Map<number, NodeJS.Timeout> = new Map();
+
+  constructor(public plugin: WorkflowPlugin) {
+    super(plugin);
+
+    plugin.app.on('afterStart', this.load);
+    plugin.app.on('beforeStop', this.unload);
+  }
+
+  load = async () => {
+    const { model } = this.plugin.db.getCollection('jobs');
+    const jobs = (await model.findAll({
+      where: {
+        status: JOB_STATUS.PENDING,
+      },
+      include: [
+        {
+          association: 'execution',
+          attributes: [],
+          where: {
+            status: EXECUTION_STATUS.STARTED,
+          },
+          required: true,
+        },
+        {
+          association: 'node',
+          attributes: ['config'],
+          where: {
+            type: 'delay',
+          },
+          required: true,
+        },
+      ],
+    })) as JobModel[];
+
+    jobs.forEach((job) => {
+      this.schedule(job);
+    });
+  };
+
+  unload = () => {
+    for (const timer of this.timers.values()) {
+      clearTimeout(timer);
+    }
+
+    this.timers = new Map();
+  };
+
+  schedule(job) {
+    const now = new Date();
+    const createdAt = Date.parse(job.createdAt);
+    const delay = createdAt + job.node.config.duration - now.getTime();
+    if (delay > 0) {
+      const trigger = this.trigger.bind(this, job);
+      this.timers.set(job.id, setTimeout(trigger, delay));
+    } else {
+      this.trigger(job);
+    }
+  }
+
+  async trigger(job) {
+    if (!job.execution) {
+      job.execution = await job.getExecution();
+    }
+    if (job.execution.status === EXECUTION_STATUS.STARTED) {
+      this.plugin.resume(job);
+    }
+    if (this.timers.get(job.id)) {
+      this.timers.delete(job.id);
+    }
+  }
+
+  async run(node, prevJob, processor: Processor) {
+    const job = await processor.saveJob({
+      status: JOB_STATUS.PENDING,
+      result: null,
+      nodeId: node.id,
+      upstreamId: prevJob?.id ?? null,
+    });
+    job.node = node;
+
+    // add to schedule
+    this.schedule(job);
+
+    return processor.exit();
+  }
+
+  async resume(node, prevJob, processor: Processor) {
+    const { endStatus } = node.config as DelayConfig;
+    prevJob.set('status', endStatus);
+    return prevJob;
+  }
+}

package/src/server/Plugin.ts

@@ -0,0 +1,14 @@
+import { Plugin } from '@nocobase/server';
+import WorkflowPlugin from '@nocobase/plugin-workflow';
+
+import DelayInstruction from './DelayInstruction';
+
+export default class extends Plugin {
+  workflow: WorkflowPlugin;
+
+  async load() {
+    const workflowPlugin = this.app.getPlugin('workflow') as WorkflowPlugin;
+    this.workflow = workflowPlugin;
+    workflowPlugin.instructions.register('delay', new DelayInstruction(workflowPlugin));
+  }
+}

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

@@ -0,0 +1,190 @@
+import path from 'path';
+
+import Database from '@nocobase/database';
+import { Application } from '@nocobase/server';
+import { EXECUTION_STATUS, JOB_STATUS } from '@nocobase/plugin-workflow';
+import { getApp, sleep } from '@nocobase/plugin-workflow-test';
+
+import Plugin from '..';
+
+describe('workflow > instructions > delay', () => {
+  let app: Application;
+  let db: Database;
+  let PostRepo;
+  let WorkflowModel;
+  let workflow;
+  let plugin;
+
+  beforeEach(async () => {
+    app = await getApp({
+      plugins: [Plugin],
+      collectionPath: path.join(__dirname, './collections'),
+    });
+    plugin = app.pm.get('workflow');
+
+    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(() => app.destroy());
+
+  describe('runtime', () => {
+    it('delay to resolved', async () => {
+      const n1 = await workflow.createNode({
+        type: 'delay',
+        config: {
+          duration: 2000,
+          endStatus: JOB_STATUS.RESOLVED,
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [e1] = await workflow.getExecutions();
+      expect(e1.status).toEqual(EXECUTION_STATUS.STARTED);
+      const [j1] = await e1.getJobs();
+      expect(j1.status).toBe(JOB_STATUS.PENDING);
+
+      await sleep(2000);
+
+      const [e2] = await workflow.getExecutions();
+      expect(e2.status).toEqual(EXECUTION_STATUS.RESOLVED);
+      const [j2] = await e2.getJobs();
+      expect(j2.status).toBe(JOB_STATUS.RESOLVED);
+    });
+
+    it('delay to reject', async () => {
+      const n1 = await workflow.createNode({
+        type: 'delay',
+        config: {
+          duration: 2000,
+          endStatus: JOB_STATUS.FAILED,
+        },
+      });
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [e1] = await workflow.getExecutions();
+      expect(e1.status).toEqual(EXECUTION_STATUS.STARTED);
+      const [j1] = await e1.getJobs();
+      expect(j1.status).toBe(JOB_STATUS.PENDING);
+
+      await sleep(2000);
+
+      const [e2] = await workflow.getExecutions();
+      expect(e2.status).toEqual(EXECUTION_STATUS.FAILED);
+      const [j2] = await e2.getJobs();
+      expect(j2.status).toBe(JOB_STATUS.FAILED);
+    });
+
+    it('delay to resolve and rollback in downstream node', async () => {
+      const n1 = await workflow.createNode({
+        type: 'delay',
+        config: {
+          duration: 2000,
+          endStatus: JOB_STATUS.RESOLVED,
+        },
+      });
+      const n2 = await workflow.createNode({
+        type: 'create',
+        config: {
+          collection: 'comment',
+          params: {
+            values: {
+              status: 'should be number but use string to raise an error',
+            },
+          },
+        },
+        upstreamId: n1.id,
+      });
+      await n1.setDownstream(n2);
+
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [e1] = await workflow.getExecutions();
+      expect(e1.status).toEqual(EXECUTION_STATUS.STARTED);
+      const [j1] = await e1.getJobs();
+      expect(j1.status).toBe(JOB_STATUS.PENDING);
+
+      await sleep(2000);
+
+      const [e2] = await workflow.getExecutions();
+      expect(e2.status).toEqual(EXECUTION_STATUS.ERROR);
+      const [j2, j3] = await e2.getJobs({ order: [['id', 'ASC']] });
+      expect(j2.status).toBe(JOB_STATUS.RESOLVED);
+      expect(j3.status).toBe(JOB_STATUS.ERROR);
+    });
+  });
+
+  describe('app lifecycle', () => {
+    beforeEach(async () => {
+      await workflow.createNode({
+        type: 'delay',
+        config: {
+          duration: 2000,
+          endStatus: JOB_STATUS.RESOLVED,
+        },
+      });
+    });
+
+    it('restart app should trigger delayed job', async () => {
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [e1] = await workflow.getExecutions();
+      expect(e1.status).toEqual(EXECUTION_STATUS.STARTED);
+      const [j1] = await e1.getJobs();
+      expect(j1.status).toBe(JOB_STATUS.PENDING);
+
+      await app.stop();
+      await sleep(500);
+
+      await app.start();
+      await sleep(2000);
+
+      const [e2] = await workflow.getExecutions();
+      expect(e2.status).toEqual(EXECUTION_STATUS.RESOLVED);
+      const [j2] = await e2.getJobs();
+      expect(j2.status).toBe(JOB_STATUS.RESOLVED);
+    });
+
+    it('restart app should trigger missed delayed job', async () => {
+      const post = await PostRepo.create({ values: { title: 't1' } });
+
+      await sleep(500);
+
+      const [e1] = await workflow.getExecutions();
+      expect(e1.status).toEqual(EXECUTION_STATUS.STARTED);
+      const [j1] = await e1.getJobs();
+      expect(j1.status).toBe(JOB_STATUS.PENDING);
+
+      await app.stop();
+      await sleep(2000);
+
+      await app.start();
+      await sleep(1000);
+
+      const [e2] = await workflow.getExecutions();
+      expect(e2.status).toEqual(EXECUTION_STATUS.RESOLVED);
+      const [j2] = await e2.getJobs();
+      expect(j2.status).toBe(JOB_STATUS.RESOLVED);
+    });
+  });
+});

package/src/server/index.ts

@@ -0,0 +1 @@
+export { default } from './Plugin';