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

package/src/server/actions/workflows.ts

@@ -0,0 +1,178 @@
+import actions, { Context, utils } from '@nocobase/actions';
+import { Op, Repository } from '@nocobase/database';
+
+export async function update(context: Context, next) {
+  const repository = utils.getRepositoryFromParams(context) as Repository;
+  const { filterByTk, values } = context.action.params;
+  context.action.mergeParams({
+    whitelist: ['title', 'description', 'enabled', 'config'],
+  });
+  // only enable/disable
+  if (Object.keys(values).includes('config')) {
+    const workflow = await repository.findById(filterByTk);
+    if (workflow.get('executed')) {
+      return context.throw(400, 'config of executed workflow can not be updated');
+    }
+  }
+  return actions.update(context, next);
+}
+
+export async function destroy(context: Context, next) {
+  const repository = utils.getRepositoryFromParams(context) as Repository;
+  const { filterByTk, filter } = context.action.params;
+
+  await context.db.sequelize.transaction(async (transaction) => {
+    const items = await repository.find({
+      filterByTk,
+      filter,
+      fields: ['id', 'key', 'current'],
+      transaction,
+    });
+    const ids = new Set<number>(items.map((item) => item.id));
+    const keysSet = new Set<string>(items.filter((item) => item.current).map((item) => item.key));
+    const revisions = await repository.find({
+      filter: {
+        key: Array.from(keysSet),
+        current: { [Op.not]: true },
+      },
+      fields: ['id'],
+      transaction,
+    });
+
+    revisions.forEach((item) => ids.add(item.id));
+
+    context.body = await repository.destroy({
+      filterByTk: Array.from(ids),
+      individualHooks: true,
+      transaction,
+    });
+  });
+
+  next();
+}
+
+function typeOf(value) {
+  if (Array.isArray(value)) {
+    return 'array';
+  } else if (value instanceof Date) {
+    return 'date';
+  } else if (value === null) {
+    return 'null';
+  }
+
+  return typeof value;
+}
+
+function migrateConfig(config, oldToNew) {
+  function migrate(value) {
+    switch (typeOf(value)) {
+      case 'object':
+        if (value.type === '$jobsMapByNodeId') {
+          return {
+            ...value,
+            options: {
+              ...value.options,
+              nodeId: oldToNew.get(value.options?.nodeId)?.id,
+            },
+          };
+        }
+        return Object.keys(value).reduce((result, key) => ({ ...result, [key]: migrate(value[key]) }), {});
+      case 'array':
+        return value.map((item) => migrate(item));
+      case 'string':
+        return value.replace(/({{\$jobsMapByNodeId|{{\$scopes)\.([\w-]+)/g, (_, jobVar, oldNodeId) => {
+          const newNode = oldToNew.get(Number.parseInt(oldNodeId, 10));
+          if (!newNode) {
+            throw new Error('node configurated for result is not existed');
+          }
+          return `${jobVar}.${newNode.id}`;
+        });
+      default:
+        return value;
+    }
+  }
+
+  return migrate(config);
+}
+
+export async function revision(context: Context, next) {
+  const { db } = context;
+  const repository = utils.getRepositoryFromParams(context);
+  const { filterByTk, filter = {} } = context.action.params;
+
+  context.body = await db.sequelize.transaction(async (transaction) => {
+    const origin = await repository.findOne({
+      filterByTk,
+      filter,
+      appends: ['nodes'],
+      context,
+      transaction,
+    });
+
+    const revisionData = filter.key
+      ? {
+          key: filter.key,
+          title: origin.title,
+          allExecuted: origin.allExecuted,
+        }
+      : {};
+
+    const instance = await repository.create({
+      values: {
+        title: `${origin.title} copy`,
+        description: origin.description,
+        type: origin.type,
+        config: origin.config,
+        ...revisionData,
+      },
+      transaction,
+    });
+
+    const originalNodesMap = new Map();
+    origin.nodes.forEach((node) => {
+      originalNodesMap.set(node.id, node);
+    });
+
+    const oldToNew = new Map();
+    const newToOld = new Map();
+    for await (const node of origin.nodes) {
+      const newNode = await instance.createNode(
+        {
+          type: node.type,
+          config: node.config,
+          title: node.title,
+          branchIndex: node.branchIndex,
+        },
+        { transaction },
+      );
+      // NOTE: keep original node references for later replacement
+      oldToNew.set(node.id, newNode);
+      newToOld.set(newNode.id, node);
+    }
+
+    for await (const [oldId, newNode] of oldToNew.entries()) {
+      const oldNode = originalNodesMap.get(oldId);
+      const newUpstream = oldNode.upstreamId ? oldToNew.get(oldNode.upstreamId) : null;
+      const newDownstream = oldNode.downstreamId ? oldToNew.get(oldNode.downstreamId) : null;
+      let migratedConfig;
+      try {
+        migratedConfig = migrateConfig(oldNode.config, oldToNew);
+      } catch (err) {
+        return context.throw(400, err.message);
+      }
+
+      await newNode.update(
+        {
+          upstreamId: newUpstream?.id ?? null,
+          downstreamId: newDownstream?.id ?? null,
+          config: migratedConfig,
+        },
+        { transaction },
+      );
+    }
+
+    return instance;
+  });
+
+  await next();
+}

package/src/server/collections/executions.ts

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

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

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

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

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

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

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

package/src/server/functions/index.ts

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

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

package/src/server/instructions/aggregate.ts

@@ -0,0 +1,42 @@
+import { BelongsToManyRepository, DataTypes, HasManyRepository } from '@nocobase/database';
+
+import Processor from '../Processor';
+import { JOB_STATUS } from '../constants';
+import type { FlowNodeModel } from '../types';
+
+const aggregators = {
+  count: 'count',
+  sum: 'sum',
+  avg: 'avg',
+  min: 'min',
+  max: 'max',
+};
+
+export default {
+  async run(node: FlowNodeModel, input, processor: Processor) {
+    const { aggregator, associated, collection, association = {}, params = {} } = node.config;
+    const options = processor.getParsedValue(params);
+    const { database } = <typeof FlowNodeModel>node.constructor;
+    const repo = associated
+      ? database.getRepository<HasManyRepository | BelongsToManyRepository>(
+          `${association?.associatedCollection}.${association.name}`,
+          processor.getParsedValue(association?.associatedKey),
+        )
+      : database.getRepository(collection);
+
+    if (!options.dataType && aggregator === 'avg') {
+      options.dataType = DataTypes.DOUBLE;
+    }
+
+    const result = await repo.aggregate({
+      ...options,
+      method: aggregators[aggregator],
+      transaction: processor.transaction,
+    });
+
+    return {
+      result: options.dataType === DataTypes.DOUBLE ? Number(result) : result,
+      status: JOB_STATUS.RESOLVED,
+    };
+  },
+};

package/src/server/instructions/calculation.ts

@@ -0,0 +1,41 @@
+import { Evaluator, evaluators } from '@nocobase/evaluators';
+import { parse } from '@nocobase/utils';
+import { Instruction } from '.';
+import { Processor } from '..';
+import { JOB_STATUS } from '../constants';
+import type { FlowNodeModel } from '../types';
+
+interface CalculationConfig {
+  dynamic?: boolean | string;
+  engine?: string;
+  expression?: string;
+}
+
+export default {
+  async run(node: FlowNodeModel, prevJob, processor: Processor) {
+    const { dynamic = false } = <CalculationConfig>node.config || {};
+    let { engine = 'math.js', expression = '' } = node.config;
+    let scope = processor.getScope(node);
+    if (dynamic) {
+      const parsed = parse(dynamic)(scope) ?? {};
+      engine = parsed.engine;
+      expression = parsed.expression;
+      scope = parse(node.config.scope ?? '')(scope) ?? {};
+    }
+
+    const evaluator = <Evaluator | undefined>evaluators.get(engine);
+
+    try {
+      const result = evaluator && expression ? evaluator(expression, scope) : null;
+      return {
+        result,
+        status: JOB_STATUS.RESOLVED,
+      };
+    } catch (e) {
+      return {
+        result: e.toString(),
+        status: JOB_STATUS.ERROR,
+      };
+    }
+  },
+} as Instruction;