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

package/src/client/nodes/aggregate.tsx

@@ -0,0 +1,327 @@
+import React, { useCallback } from 'react';
+import { Cascader } from 'antd';
+import { useForm } from '@formily/react';
+
+import {
+  SchemaInitializerItemOptions,
+  useCollectionDataSource,
+  useCompile,
+  SchemaComponentContext,
+  useCollectionManager,
+} from '@nocobase/client';
+
+import { collection, filter } from '../schemas/collection';
+import { NAMESPACE, lang } from '../locale';
+import { FilterDynamicComponent } from '../components/FilterDynamicComponent';
+import { BaseTypeSets, defaultFieldNames, nodesOptions, triggerOptions, useWorkflowVariableOptions } from '../variable';
+import { FieldsSelect } from '../components/FieldsSelect';
+import { ValueBlock } from '../components/ValueBlock';
+import { useNodeContext } from '.';
+
+function matchToManyField(field, appends): boolean {
+  const fieldPrefix = `${field.name}.`;
+  return (
+    ['hasMany', 'belongsToMany'].includes(field.type) &&
+    (appends.includes(field.name) || appends.some((item) => item.startsWith(fieldPrefix)))
+  );
+}
+
+function AssociatedConfig({ value, onChange, ...props }): JSX.Element {
+  const { setValuesIn } = useForm();
+  const compile = useCompile();
+  const { getCollection } = useCollectionManager();
+  const options = [nodesOptions, triggerOptions].map((item) => {
+    const children = item.useOptions({ types: [matchToManyField] })?.filter(Boolean);
+    return {
+      label: compile(item.label),
+      value: item.value,
+      key: item.value,
+      children: compile(children),
+      disabled: children && !children.length,
+    };
+  });
+
+  const { associatedKey = '', name: fieldName } = value ?? {};
+  let p = [];
+  const matched = associatedKey.match(/^{{(.*)}}$/);
+  if (matched) {
+    p = [...matched[1].trim().split('.').slice(0, -1), fieldName];
+  }
+
+  const onSelectChange = useCallback(
+    (path, option) => {
+      if (!path?.length) {
+        setValuesIn('collection', null);
+        onChange({});
+        return;
+      }
+
+      // const associationFieldName = path.pop();
+      const { field } = option.pop();
+      // need to get:
+      // * source collection (from node.config)
+      // * target collection (from field name)
+      const { collectionName, target, name } = field;
+
+      const collection = getCollection(collectionName);
+      const primaryKeyField = collection.fields.find((f) => f.primaryKey);
+
+      setValuesIn('collection', target);
+
+      onChange({
+        name,
+        // primary key data path
+        associatedKey: `{{${path.slice(0, -1).join('.')}.${primaryKeyField.name}}}`,
+        // data associated collection name
+        associatedCollection: collectionName,
+      });
+    },
+    [onChange],
+  );
+
+  return <Cascader {...props} value={p} options={options} onChange={onSelectChange} />;
+}
+
+// based on collection:
+// { collection, field }
+
+// based on data associated collection
+// { key: '{{$context.data.id}}', collection: "collection.association", field }
+// select data based
+
+export default {
+  title: `{{t("Aggregate", { ns: "${NAMESPACE}" })}}`,
+  type: 'aggregate',
+  group: 'collection',
+  description: `{{t("Counting, summing, finding maximum, minimum, and average values for multiple records of a collection or associated data of a record.", { ns: "${NAMESPACE}" })}}`,
+  fieldset: {
+    aggregator: {
+      type: 'string',
+      title: `{{t("Aggregator function", { ns: "${NAMESPACE}" })}}`,
+      'x-decorator': 'FormItem',
+      'x-component': 'Radio.Group',
+      enum: [
+        { label: 'COUNT', value: 'count' },
+        { label: 'SUM', value: 'sum' },
+        { label: 'AVG', value: 'avg' },
+        { label: 'MIN', value: 'min' },
+        { label: 'MAX', value: 'max' },
+      ],
+      required: true,
+      default: 'count',
+    },
+    associated: {
+      type: 'boolean',
+      title: `{{t("Target type", { ns: "${NAMESPACE}" })}}`,
+      'x-decorator': 'FormItem',
+      'x-component': 'Radio.Group',
+      enum: [
+        { label: `{{t("Data of collection", { ns: "${NAMESPACE}" })}}`, value: false },
+        { label: `{{t("Data of associated collection", { ns: "${NAMESPACE}" })}}`, value: true },
+      ],
+      required: true,
+      default: false,
+      'x-reactions': [
+        {
+          target: 'collection',
+          effects: ['onFieldValueChange'],
+          fulfill: {
+            state: {
+              value: null,
+            },
+          },
+        },
+        {
+          target: 'association',
+          effects: ['onFieldValueChange'],
+          fulfill: {
+            state: {
+              value: null,
+            },
+          },
+        },
+      ],
+    },
+    collectionField: {
+      type: 'void',
+      'x-decorator': 'SchemaComponentContext.Provider',
+      'x-decorator-props': {
+        value: { designable: false },
+      },
+      'x-component': 'Grid',
+      properties: {
+        row: {
+          type: 'void',
+          'x-component': 'Grid.Row',
+          properties: {
+            target: {
+              type: 'void',
+              'x-component': 'Grid.Col',
+              properties: {
+                collection: {
+                  ...collection,
+                  title: `{{t("Data of collection", { ns: "${NAMESPACE}" })}}`,
+                  'x-component-props': {
+                    ...collection['x-component-props'],
+                    className: 'full-width',
+                  },
+                  'x-reactions': [
+                    ...collection['x-reactions'],
+                    {
+                      dependencies: ['associated'],
+                      fulfill: {
+                        state: {
+                          display: '{{$deps[0] ? "hidden" : "visible"}}',
+                        },
+                      },
+                    },
+                    {
+                      target: 'params.field',
+                      effects: ['onFieldValueChange'],
+                      fulfill: {
+                        state: {
+                          value: null,
+                        },
+                      },
+                    },
+                    {
+                      target: 'params.filter',
+                      effects: ['onFieldValueChange'],
+                      fulfill: {
+                        state: {
+                          value: null,
+                        },
+                      },
+                    },
+                  ],
+                },
+                association: {
+                  type: 'object',
+                  title: `{{t("Data of associated collection", { ns: "${NAMESPACE}" })}}`,
+                  'x-decorator': 'FormItem',
+                  'x-component': 'AssociatedConfig',
+                  'x-component-props': {
+                    className: 'full-width',
+                  },
+                  'x-reactions': [
+                    {
+                      dependencies: ['associated'],
+                      fulfill: {
+                        state: {
+                          visible: '{{!!$deps[0]}}',
+                        },
+                      },
+                    },
+                  ],
+                  required: true,
+                },
+              },
+            },
+            field: {
+              type: 'void',
+              'x-component': 'Grid.Col',
+              properties: {
+                'params.field': {
+                  type: 'string',
+                  title: `{{t("Field to aggregate", { ns: "${NAMESPACE}" })}}`,
+                  'x-decorator': 'FormItem',
+                  'x-component': 'FieldsSelect',
+                  'x-component-props': {
+                    filter(field) {
+                      return (
+                        !field.hidden &&
+                        field.interface &&
+                        !['belongsTo', 'hasOne', 'hasMany', 'belongsToMany'].includes(field.type)
+                      );
+                    },
+                  },
+                  required: true,
+                  'x-reactions': [
+                    {
+                      dependencies: ['collection'],
+                      fulfill: {
+                        state: {
+                          visible: '{{!!$deps[0]}}',
+                        },
+                      },
+                    },
+                  ],
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+    params: {
+      type: 'object',
+      properties: {
+        distinct: {
+          type: 'boolean',
+          title: `{{t("Distinct", { ns: "${NAMESPACE}" })}}`,
+          'x-decorator': 'FormItem',
+          'x-component': 'Checkbox',
+          'x-reactions': [
+            {
+              dependencies: ['collection', 'aggregator'],
+              fulfill: {
+                state: {
+                  visible: '{{!!$deps[0] && ["count"].includes($deps[1])}}',
+                },
+              },
+            },
+          ],
+        },
+        filter: {
+          ...filter,
+          'x-reactions': [
+            {
+              dependencies: ['collection'],
+              fulfill: {
+                state: {
+                  visible: '{{!!$deps[0]}}',
+                },
+              },
+            },
+          ],
+        },
+      },
+    },
+  },
+  view: {},
+  scope: {
+    useCollectionDataSource,
+  },
+  components: {
+    SchemaComponentContext,
+    FilterDynamicComponent,
+    FieldsSelect,
+    ValueBlock,
+    AssociatedConfig,
+  },
+  useVariables({ id, title }, { types, fieldNames = defaultFieldNames }) {
+    if (
+      types &&
+      !types.some((type) => type in BaseTypeSets || Object.values(BaseTypeSets).some((set) => set.has(type)))
+    ) {
+      return null;
+    }
+    return {
+      [fieldNames.value]: `${id}`,
+      [fieldNames.label]: title,
+    };
+  },
+  useInitializers(node): SchemaInitializerItemOptions | null {
+    if (!node.config.collection) {
+      return null;
+    }
+
+    return {
+      type: 'item',
+      title: node.title ?? `#${node.id}`,
+      component: ValueBlock.Initializer,
+      node,
+      resultTitle: lang('Query result'),
+    };
+  },
+};

package/src/client/nodes/calculation.tsx

@@ -0,0 +1,216 @@
+import { FormItem, FormLayout } from '@formily/antd-v5';
+import { SchemaInitializerItemOptions, Variable, css, defaultFieldNames, useCollectionManager } from '@nocobase/client';
+import { Evaluator, evaluators, getOptions } from '@nocobase/evaluators/client';
+import { parse } from '@nocobase/utils/client';
+import { Radio } from 'antd';
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+import { useFlowContext } from '../FlowContext';
+import { RadioWithTooltip } from '../components/RadioWithTooltip';
+import { ValueBlock } from '../components/ValueBlock';
+import { renderEngineReference } from '../components/renderEngineReference';
+import { NAMESPACE, lang } from '../locale';
+import { BaseTypeSets, useWorkflowVariableOptions } from '../variable';
+
+function useDynamicExpressionCollectionFieldMatcher(field): boolean {
+  if (!['belongsTo', 'hasOne'].includes(field.type)) {
+    return false;
+  }
+
+  if (this.getCollection(field.collectionName)?.template === 'expression') {
+    return true;
+  }
+
+  const fields = this.getCollectionFields(field.target);
+  return fields.some((f) => f.interface === 'expression');
+}
+
+const DynamicConfig = ({ value, onChange }) => {
+  const { t } = useTranslation();
+  const { getCollectionFields, getCollection } = useCollectionManager();
+  const scope = useWorkflowVariableOptions({
+    types: [useDynamicExpressionCollectionFieldMatcher.bind({ getCollectionFields, getCollection })],
+  });
+
+  return (
+    <FormLayout layout="vertical">
+      <FormItem colon label={t('Expression type', { ns: NAMESPACE })}>
+        <Radio.Group
+          value={value === false ? false : value || ''}
+          onChange={(ev) => {
+            onChange(ev.target.value);
+          }}
+        >
+          <Radio value={false}>{t('Static', { ns: NAMESPACE })}</Radio>
+          <Radio value={value || ''}>{t('Dynamic', { ns: NAMESPACE })}</Radio>
+        </Radio.Group>
+      </FormItem>
+      {value !== false ? (
+        <FormItem
+          label={t('Select dynamic expression', { ns: NAMESPACE })}
+          extra={t(
+            'Select the dynamic expression queried from the upstream node. You need to query it from an expression collection.',
+            { ns: NAMESPACE },
+          )}
+        >
+          <Variable.Input value={value || ''} onChange={(v) => onChange(v)} scope={scope} />
+        </FormItem>
+      ) : null}
+    </FormLayout>
+  );
+};
+
+export default {
+  title: `{{t("Calculation", { ns: "${NAMESPACE}" })}}`,
+  type: 'calculation',
+  group: 'control',
+  description: `{{t("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 can be static or dynamic one from an expression collections.", { ns: "${NAMESPACE}" })}}`,
+  fieldset: {
+    dynamic: {
+      type: 'string',
+      'x-component': 'DynamicConfig',
+      // description: `{{t("Select the dynamic expression queried from the upstream node. You need to query it from an expression collection.", { ns: "${NAMESPACE}" })}}`,
+      default: false,
+    },
+    engine: {
+      type: 'string',
+      title: `{{t("Calculation engine", { ns: "${NAMESPACE}" })}}`,
+      'x-decorator': 'FormItem',
+      'x-component': 'RadioWithTooltip',
+      'x-component-props': {
+        options: getOptions(),
+      },
+      required: true,
+      default: 'math.js',
+      'x-reactions': {
+        dependencies: ['dynamic'],
+        fulfill: {
+          state: {
+            visible: '{{$deps[0] === false}}',
+          },
+        },
+      },
+    },
+    expression: {
+      type: 'string',
+      title: `{{t("Calculation expression", { ns: "${NAMESPACE}" })}}`,
+      'x-decorator': 'FormItem',
+      'x-component': 'CalculationExpression',
+      // NOTE: can not use Variable.Input and scope directly as below,
+      //       because the scope will be cached.
+      // 'x-component': 'Variable.Input',
+      // 'x-component-props': {
+      //   scope: '{{useWorkflowVariableOptions()}}',
+      // },
+      ['x-validator'](value, rules, { form }) {
+        const { values } = form;
+        const { evaluate } = evaluators.get(values.engine) as Evaluator;
+        const exp = value.trim().replace(/{{([^{}]+)}}/g, ' 1 ');
+        try {
+          evaluate(exp);
+          return '';
+        } catch (e) {
+          return lang('Expression syntax error');
+        }
+      },
+      'x-reactions': [
+        {
+          dependencies: ['dynamic'],
+          fulfill: {
+            state: {
+              visible: '{{$deps[0] === false}}',
+            },
+          },
+        },
+        {
+          dependencies: ['engine'],
+          fulfill: {
+            schema: {
+              description: '{{renderEngineReference($deps[0])}}',
+            },
+          },
+        },
+      ],
+      required: true,
+    },
+    scope: {
+      type: 'string',
+      title: `{{t("Variable datasource", { ns: "${NAMESPACE}" })}}`,
+      'x-decorator': 'FormItem',
+      'x-component': 'ScopeSelect',
+      'x-component-props': {
+        changeOnSelect: true,
+      },
+      'x-reactions': {
+        dependencies: ['dynamic'],
+        fulfill: {
+          state: {
+            visible: '{{$deps[0]}}',
+          },
+        },
+      },
+    },
+  },
+  view: {},
+  scope: {
+    renderEngineReference,
+  },
+  components: {
+    CalculationExpression(props) {
+      const scope = useWorkflowVariableOptions();
+
+      return <Variable.TextArea scope={scope} {...props} />;
+    },
+    ScopeSelect(props) {
+      const scope = useWorkflowVariableOptions({
+        types: [{ type: 'reference', options: { collection: '*', entity: true } }],
+      });
+      return <Variable.Input scope={scope} {...props} />;
+    },
+    CalculationResult({ dataSource }) {
+      const { execution } = useFlowContext();
+      if (!execution) {
+        return lang('Calculation result');
+      }
+      const result = parse(dataSource)({
+        $jobsMapByNodeId: (execution.jobs ?? []).reduce(
+          (map, job) => Object.assign(map, { [job.nodeId]: job.result }),
+          {},
+        ),
+      });
+
+      return (
+        <pre
+          className={css`
+            margin: 0;
+          `}
+        >
+          {JSON.stringify(result, null, 2)}
+        </pre>
+      );
+    },
+    RadioWithTooltip,
+    DynamicConfig,
+  },
+  useVariables({ id, title }, { types, fieldNames = defaultFieldNames }) {
+    if (
+      types &&
+      !types.some((type) => type in BaseTypeSets || Object.values(BaseTypeSets).some((set) => set.has(type)))
+    ) {
+      return null;
+    }
+    return {
+      [fieldNames.value]: `${id}`,
+      [fieldNames.label]: title,
+    };
+  },
+  useInitializers(node): SchemaInitializerItemOptions {
+    return {
+      type: 'item',
+      title: node.title ?? `#${node.id}`,
+      component: ValueBlock.Initializer,
+      node,
+      resultTitle: lang('Calculation result'),
+    };
+  },
+};