@nocobase/plugin-workflow-dynamic-calculation 0.17.0-alpha.4

package/src/client/Provider.tsx

@@ -0,0 +1,22 @@
+import React from 'react';
+
+import { CollectionManagerContext, useCollectionManager } from '@nocobase/client';
+
+import expression from './expression';
+
+export function Provider(props) {
+  const cmCtx = useCollectionManager();
+  return (
+    <CollectionManagerContext.Provider
+      value={{
+        ...cmCtx,
+        interfaces: {
+          ...cmCtx.interfaces,
+          expression,
+        },
+      }}
+    >
+      {props.children}
+    </CollectionManagerContext.Provider>
+  );
+}

package/src/client/expression.tsx

@@ -0,0 +1,24 @@
+import { IField, interfacesProperties } from '@nocobase/client';
+
+import { NAMESPACE } from '../locale';
+
+const { defaultProps } = interfacesProperties;
+
+export default {
+  name: 'expression',
+  type: 'string',
+  group: 'advanced',
+  order: 1,
+  title: `{{t("Expression", { ns: "${NAMESPACE}" })}}`,
+  description: `{{t("An expression for calculation in each rows", { ns: "${NAMESPACE}" })}}`,
+  sortable: true,
+  default: {
+    type: 'text',
+    uiSchema: {
+      'x-component': 'DynamicExpression',
+    },
+  },
+  properties: {
+    ...defaultProps,
+  },
+} as IField;

package/src/client/index.ts

@@ -0,0 +1,28 @@
+import { Plugin } from '@nocobase/client';
+import WorkflowPlugin from '@nocobase/plugin-workflow/client';
+
+import { Provider } from './Provider';
+import DynamicCalculation from './DynamicCalculation';
+import { DynamicExpression } from './DynamicExpression';
+
+export default class extends Plugin {
+  async afterAdd() {
+    // await this.app.pm.add()
+  }
+
+  async beforeLoad() {}
+
+  // You can get and modify the app instance here
+  async load() {
+    this.app.addProvider(Provider);
+    const workflow = this.app.pm.get('workflow') as WorkflowPlugin;
+    const dynamicCalculation = new DynamicCalculation();
+    workflow.instructions.register(dynamicCalculation.type, dynamicCalculation);
+  }
+
+  addComponents() {
+    this.app.addComponents({
+      DynamicExpression,
+    });
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './server';
+export { default } from './server';

package/src/locale/en-US.json

@@ -0,0 +1,11 @@
+{
+  "Dynamic Calculation": "Dynamic Calculation",
+  "Calculate an expression based on a calculation engine and obtain a value as the result. Variables in the upstream nodes can be used in the expression. The expression is dynamic one from an expression collections.": "Calculate an expression based on a calculation engine and obtain a value as the result. Variables in the upstream nodes can be used in the expression. The expression is dynamic one from an expression collections.",
+  "Select dynamic expression": "Select dynamic expression",
+  "Select the dynamic expression queried from the upstream node. You need to query it from an expression collection.": "Select the dynamic expression queried from the upstream node. You need to query it from an expression collection.",
+  "Variable datasource": "Variable datasource",
+  "Dynamic expression": "Dynamic expression",
+  "An expression for calculation in each rows": "An expression for calculation in each rows",
+  "Unconfigured": "Unconfigured",
+  "Calculation result": "Calculation result"
+}

package/src/locale/index.ts

@@ -0,0 +1,12 @@
+import { useTranslation } from 'react-i18next';
+
+export const NAMESPACE = 'workflow-dynamic-calculation';
+
+export function useLang(key: string, options = {}) {
+  const { t } = usePluginTranslation(options);
+  return t(key);
+}
+
+export function usePluginTranslation(options) {
+  return useTranslation(NAMESPACE, options);
+}

package/src/locale/zh-CN.json

@@ -0,0 +1,11 @@
+{
+  "Dynamic Calculation": "动态表达式计算",
+  "Calculate an expression based on a calculation engine and obtain a value as the result. Variables in the upstream nodes can be used in the expression. The expression is dynamic one from an expression collections.": "基于计算引擎计算表达式并获取值作为结果。可以在表达式中使用上游节点的变量。表达式是从表达式表中动态获取的。",
+  "Select dynamic expression": "选择动态表达式",
+  "Select the dynamic expression queried from the upstream node. You need to query it from an expression collection.": "从上游节点中选择查询出来的动态表达式。你需要从动态表达式类型的数据表中查询。",
+  "Variable datasource": "变量数据源",
+  "Dynamic expression": "动态表达式",
+  "An expression for calculation in each rows": "每行数据计算规则不同时使用",
+  "Unconfigured": "未配置",
+  "Calculation result": "运算结果"
+}

package/src/server/DynamicCalculation.ts

@@ -0,0 +1,29 @@
+import { parse } from '@nocobase/utils';
+import { FlowNodeModel, Instruction, JOB_STATUS, Processor } from '@nocobase/plugin-workflow';
+import evaluators, { Evaluator } from '@nocobase/evaluators';
+
+export class DynamicCalculation extends Instruction {
+  async run(node: FlowNodeModel, prevJob, processor: Processor) {
+    let { engine = 'math.js', expression = '' } = node.config;
+    let scope = processor.getScope(node.id);
+    const parsed = parse(expression)(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,
+      };
+    }
+  }
+}

package/src/server/Plugin.ts

@@ -0,0 +1,19 @@
+import { Plugin } from '@nocobase/server';
+import WorkflowPlugin from '@nocobase/plugin-workflow';
+
+import { ExpressionField } from './expression-field';
+import { DynamicCalculation } from './DynamicCalculation';
+
+export default class extends Plugin {
+  workflow: WorkflowPlugin;
+
+  async load() {
+    this.db.registerFieldTypes({
+      expression: ExpressionField,
+    });
+
+    const workflowPlugin = this.app.getPlugin('workflow') as WorkflowPlugin;
+    this.workflow = workflowPlugin;
+    workflowPlugin.instructions.register('dynamic-calculation', new DynamicCalculation(workflowPlugin));
+  }
+}

package/src/server/__tests__/collections/categories.ts

@@ -0,0 +1,19 @@
+import { extendCollection } from '@nocobase/database';
+
+export default extendCollection({
+  name: 'categories',
+  fields: [
+    {
+      type: 'string',
+      name: 'engine',
+    },
+    {
+      type: 'string',
+      name: 'collection',
+    },
+    {
+      type: 'text',
+      name: 'expression',
+    },
+  ],
+});

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

@@ -0,0 +1,115 @@
+import path from 'path';
+
+import { MockServer } from '@nocobase/test';
+import { MockDatabase } from '@nocobase/database';
+import { getApp, sleep } from '@nocobase/plugin-workflow-test';
+
+import Plugin from '..';
+
+describe('workflow > instructions > calculation', () => {
+  let app: MockServer;
+  let db: MockDatabase;
+  let PostRepo;
+  let CategoryRepo;
+  let WorkflowModel;
+  let workflow;
+
+  beforeEach(async () => {
+    app = await getApp({
+      plugins: [Plugin],
+      collectionsPath: path.join(__dirname, 'collections'),
+    });
+
+    db = app.db;
+    WorkflowModel = db.getCollection('workflows').model;
+    PostRepo = db.getCollection('posts').repository;
+    CategoryRepo = db.getCollection('categories').repository;
+
+    workflow = await WorkflowModel.create({
+      title: 'test workflow',
+      enabled: true,
+      type: 'collection',
+      config: {
+        mode: 1,
+        collection: 'posts',
+      },
+    });
+  });
+
+  afterEach(() => app.destroy());
+
+  describe('dynamic expression', () => {
+    it('dynamic expression field in current table', async () => {
+      const n1 = await workflow.createNode({
+        type: 'dynamic-calculation',
+        config: {
+          expression: '{{$context.data.category}}',
+          scope: '{{$context.data}}',
+        },
+      });
+
+      const post = await PostRepo.create({
+        values: {
+          title: 't1',
+          category: {
+            engine: 'math.js',
+            expression: '1 + {{read}}',
+          },
+        },
+      });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const [job] = await execution.getJobs();
+      expect(job.result).toBe(1);
+    });
+
+    it('dynamic expression field in association table', async () => {
+      const n1 = await workflow.createNode({
+        type: 'query',
+        config: {
+          collection: 'categories',
+          params: {
+            filter: {
+              $and: [{ id: '{{$context.data.categoryId}}' }],
+            },
+          },
+        },
+      });
+
+      const n2 = await workflow.createNode({
+        type: 'dynamic-calculation',
+        config: {
+          expression: `{{$jobsMapByNodeKey.${n1.key}}}`,
+          scope: '{{$context.data}}',
+        },
+        upstreamId: n1.id,
+      });
+
+      await n1.setDownstream(n2);
+
+      const category = await CategoryRepo.create({
+        values: {
+          title: 'c1',
+          engine: 'math.js',
+          expression: '1 + {{read}}',
+        },
+      });
+
+      const post = await PostRepo.create({
+        values: {
+          title: 't1',
+          categoryId: category.id,
+        },
+      });
+
+      await sleep(500);
+
+      const [execution] = await workflow.getExecutions();
+      const jobs = await execution.getJobs({ order: [['id', 'ASC']] });
+      expect(jobs.length).toBe(2);
+      expect(jobs[1].result).toBe(1);
+    });
+  });
+});

package/src/server/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/index.ts

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