@nocobase/plugin-workflow 0.11.1-alpha.5 → 0.12.0-alpha.2

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

@@ -1,369 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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/collections/executions.ts

@@ -1,35 +0,0 @@
-import { CollectionOptions } from '@nocobase/database';
-
-export default {
-  namespace: 'workflow.executionLogs',
-  duplicator: 'optional',
-  name: 'executions',
-  fields: [
-    {
-      type: 'belongsTo',
-      name: 'workflow',
-    },
-    {
-      type: 'uid',
-      name: 'key',
-    },
-    {
-      type: 'boolean',
-      name: 'useTransaction',
-      defaultValue: false,
-    },
-    {
-      type: 'hasMany',
-      name: 'jobs',
-      onDelete: 'CASCADE',
-    },
-    {
-      type: 'json',
-      name: 'context',
-    },
-    {
-      type: 'integer',
-      name: 'status',
-    },
-  ],
-} as CollectionOptions;

package/src/server/collections/flow_nodes.ts

@@ -1,54 +0,0 @@
-import { CollectionOptions } from '@nocobase/database';
-
-export default {
-  namespace: 'workflow.workflowConfig',
-  duplicator: 'required',
-  name: 'flow_nodes',
-  fields: [
-    {
-      type: 'string',
-      name: 'title',
-    },
-    // which workflow belongs to
-    {
-      name: 'workflow',
-      type: 'belongsTo',
-    },
-    {
-      name: 'upstream',
-      type: 'belongsTo',
-      target: 'flow_nodes',
-    },
-    {
-      name: 'branches',
-      type: 'hasMany',
-      target: 'flow_nodes',
-      sourceKey: 'id',
-      foreignKey: 'upstreamId',
-    },
-    // only works when upstream node is branching type, such as condition and parallel.
-    // put here because the design of flow-links model is not really necessary for now.
-    // or it should be put into flow-links model.
-    {
-      name: 'branchIndex',
-      type: 'integer',
-    },
-    // Note: for reasons:
-    // 1. redirect type node to solve cycle flow.
-    // 2. recognize as real next node after branches.
-    {
-      name: 'downstream',
-      type: 'belongsTo',
-      target: 'flow_nodes',
-    },
-    {
-      type: 'string',
-      name: 'type',
-    },
-    {
-      type: 'json',
-      name: 'config',
-      defaultValue: {},
-    },
-  ],
-} as CollectionOptions;

package/src/server/collections/jobs.ts

@@ -1,31 +0,0 @@
-import { CollectionOptions } from '@nocobase/database';
-
-export default {
-  namespace: 'workflow.executionLogs',
-  duplicator: 'optional',
-  name: 'jobs',
-  fields: [
-    {
-      type: 'belongsTo',
-      name: 'execution',
-    },
-    {
-      type: 'belongsTo',
-      name: 'node',
-      target: 'flow_nodes',
-    },
-    {
-      type: 'belongsTo',
-      name: 'upstream',
-      target: 'jobs',
-    },
-    {
-      type: 'integer',
-      name: 'status',
-    },
-    {
-      type: 'json',
-      name: 'result',
-    },
-  ],
-} as CollectionOptions;

package/src/server/collections/workflows.ts

@@ -1,88 +0,0 @@
-import { CollectionOptions } from '@nocobase/database';
-
-export default function () {
-  return {
-    namespace: 'workflow.workflowConfig',
-    duplicator: 'required',
-    name: 'workflows',
-    fields: [
-      {
-        name: 'key',
-        type: 'uid',
-      },
-      {
-        type: 'string',
-        name: 'title',
-        required: true,
-      },
-      {
-        type: 'boolean',
-        name: 'enabled',
-        defaultValue: false,
-      },
-      {
-        type: 'text',
-        name: 'description',
-      },
-      {
-        type: 'string',
-        name: 'type',
-        required: true,
-      },
-      {
-        type: 'json',
-        name: 'config',
-        required: true,
-        defaultValue: {},
-      },
-      {
-        type: 'boolean',
-        name: 'useTransaction',
-        // defaultValue: true,
-      },
-      {
-        type: 'hasMany',
-        name: 'nodes',
-        target: 'flow_nodes',
-        onDelete: 'CASCADE',
-      },
-      {
-        type: 'hasMany',
-        name: 'executions',
-        onDelete: 'CASCADE',
-      },
-      {
-        type: 'integer',
-        name: 'executed',
-        defaultValue: 0,
-      },
-      {
-        type: 'integer',
-        name: 'allExecuted',
-        defaultValue: 0,
-      },
-      {
-        type: 'boolean',
-        name: 'current',
-        defaultValue: false,
-      },
-      {
-        type: 'hasMany',
-        name: 'revisions',
-        target: 'workflows',
-        foreignKey: 'key',
-        sourceKey: 'key',
-        // NOTE: no constraints needed here because tricky self-referencing
-        constraints: false,
-        onDelete: 'NO ACTION',
-      },
-    ],
-    // NOTE: use unique index for avoiding deadlock in mysql when setCurrent
-    indexes: [
-      {
-        unique: true,
-        fields: ['key', 'current'],
-      },
-    ],
-  } as CollectionOptions;
-}

package/src/server/constants.ts

@@ -1,26 +0,0 @@
-export const EXECUTION_STATUS = {
-  QUEUEING: null,
-  STARTED: 0,
-  RESOLVED: 1,
-  FAILED: -1,
-  ERROR: -2,
-  ABORTED: -3,
-  CANCELED: -4,
-  REJECTED: -5,
-};
-
-export const JOB_STATUS = {
-  PENDING: 0,
-  RESOLVED: 1,
-  FAILED: -1,
-  ERROR: -2,
-  ABORTED: -3,
-  CANCELED: -4,
-  REJECTED: -5,
-};
-
-export const BRANCH_INDEX = {
-  DEFAULT: null,
-  ON_TRUE: 1,
-  ON_FALSE: 0,
-};

package/src/server/fields/expression-field.ts

@@ -1,11 +0,0 @@
-import { BaseFieldOptions, DataTypes, Field } from '@nocobase/database';
-
-export interface ExpressionFieldOptions extends BaseFieldOptions {
-  type: 'expression';
-}
-
-export class ExpressionField extends Field {
-  get dataType() {
-    return DataTypes.TEXT;
-  }
-}

package/src/server/fields/index.ts

@@ -1,7 +0,0 @@
-import { ExpressionField } from './expression-field';
-
-export default function (plugin) {
-  plugin.db.registerFieldTypes({
-    expression: ExpressionField,
-  });
-}

package/src/server/functions/index.ts

@@ -1,16 +0,0 @@
-import Plugin from '..';
-import type { ExecutionModel, FlowNodeModel } from '../types';
-
-export type CustomFunction = (this: { execution: ExecutionModel; node?: FlowNodeModel }) => any;
-
-function now() {
-  return new Date();
-}
-
-export default function ({ functions }: Plugin, more: { [key: string]: CustomFunction } = {}) {
-  functions.register('now', now);
-
-  for (const [name, fn] of Object.entries(more)) {
-    functions.register(name, fn);
-  }
-}

package/src/server/index.ts

@@ -1,6 +0,0 @@
-export * from './constants';
-// export * from './instructions';
-export { Trigger } from './triggers';
-export { default as Processor } from './Processor';
-export { default } from './Plugin';
-export * from './types';