@nocobase/plugin-workflow 0.11.1-alpha.4 → 0.12.0-alpha.1

package/src/client/components/ValueBlock.tsx

@@ -1,67 +0,0 @@
-import { useFieldSchema } from '@formily/react';
-import { css, SchemaInitializer } from '@nocobase/client';
-import { parse } from '@nocobase/utils/client';
-import React from 'react';
-import { useFlowContext } from '../FlowContext';
-
-export const ValueBlock: (() => JSX.Element) & {
-  Initializer: (props) => JSX.Element;
-  Result: (props) => JSX.Element;
-} = () => {
-  return null;
-};
-
-function Initializer({ node, resultTitle, insert, ...props }) {
-  return (
-    <SchemaInitializer.Item
-      {...props}
-      onClick={() => {
-        insert({
-          type: 'void',
-          name: node.id,
-          title: node.title,
-          'x-component': 'CardItem',
-          'x-component-props': {
-            title: node.title ?? `#${node.id}`,
-          },
-          'x-designer': 'SimpleDesigner',
-          properties: {
-            result: {
-              type: 'void',
-              title: resultTitle,
-              'x-component': 'ValueBlock.Result',
-              'x-component-props': {
-                // NOTE: as same format as other reference for migration of revision
-                dataSource: `{{$jobsMapByNodeId.${node.id}}}`,
-              },
-            },
-          },
-        });
-      }}
-    />
-  );
-}
-
-function Result({ dataSource }) {
-  const field = useFieldSchema();
-  const { execution } = useFlowContext();
-  if (!execution) {
-    return field.title;
-  }
-  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>
-  );
-}
-
-ValueBlock.Initializer = Initializer;
-ValueBlock.Result = Result;

package/src/client/components/renderEngineReference.tsx

@@ -1,30 +0,0 @@
-import { css, i18n } from '@nocobase/client';
-import { evaluators } from '@nocobase/evaluators/client';
-import React from 'react';
-
-export const renderEngineReference = (key: string) => {
-  const engine = evaluators.get(key);
-  if (!engine) {
-    return null;
-  }
-
-  return engine.link ? (
-    <>
-      <span
-        className={css`
-          &:after {
-            content: ':';
-          }
-          & + a {
-            margin-left: 0.25em;
-          }
-        `}
-      >
-        {i18n.t('Syntax references')}
-      </span>
-      <a href={engine.link} target="_blank" rel="noreferrer">
-        {engine.label}
-      </a>
-    </>
-  ) : null;
-};

package/src/client/constants.tsx

@@ -1,91 +0,0 @@
-import React from 'react';
-import {
-  CloseOutlined,
-  ClockCircleOutlined,
-  CheckOutlined,
-  MinusOutlined,
-  ExclamationOutlined,
-} from '@ant-design/icons';
-import { NAMESPACE } from './locale';
-
-export const EXECUTION_STATUS = {
-  QUEUEING: null,
-  STARTED: 0,
-  RESOLVED: 1,
-  FAILED: -1,
-  ERROR: -2,
-  ABORTED: -3,
-  CANCELED: -4,
-  REJECTED: -5,
-};
-
-export const ExecutionStatusOptions = [
-  { value: EXECUTION_STATUS.QUEUEING, label: `{{t("Queueing", { ns: "${NAMESPACE}" })}}`, color: 'blue' },
-  { value: EXECUTION_STATUS.STARTED, label: `{{t("On going", { ns: "${NAMESPACE}" })}}`, color: 'gold' },
-  { value: EXECUTION_STATUS.RESOLVED, label: `{{t("Resolved", { ns: "${NAMESPACE}" })}}`, color: 'green' },
-  { value: EXECUTION_STATUS.FAILED, label: `{{t("Failed", { ns: "${NAMESPACE}" })}}`, color: 'red' },
-  { value: EXECUTION_STATUS.ERROR, label: `{{t("Error", { ns: "${NAMESPACE}" })}}`, color: 'red' },
-  { value: EXECUTION_STATUS.ABORTED, label: `{{t("Aborted", { ns: "${NAMESPACE}" })}}`, color: 'red' },
-  { value: EXECUTION_STATUS.CANCELED, label: `{{t("Canceled", { ns: "${NAMESPACE}" })}}`, color: 'volcano' },
-  { value: EXECUTION_STATUS.REJECTED, label: `{{t("Rejected", { ns: "${NAMESPACE}" })}}`, color: 'volcano' },
-];
-
-export const ExecutionStatusOptionsMap = ExecutionStatusOptions.reduce(
-  (map, option) => Object.assign(map, { [option.value as number]: option }),
-  {},
-);
-
-export const JOB_STATUS = {
-  PENDING: 0,
-  RESOLVED: 1,
-  FAILED: -1,
-  ERROR: -2,
-  ABORTED: -3,
-  CANCELED: -4,
-  REJECTED: -5,
-};
-
-export const JobStatusOptions = [
-  {
-    value: JOB_STATUS.PENDING,
-    label: `{{t("Pending", { ns: "${NAMESPACE}" })}}`,
-    color: 'gold',
-    icon: <ClockCircleOutlined />,
-  },
-  {
-    value: JOB_STATUS.RESOLVED,
-    label: `{{t("Resolved", { ns: "${NAMESPACE}" })}}`,
-    color: 'green',
-    icon: <CheckOutlined />,
-  },
-  {
-    value: JOB_STATUS.FAILED,
-    label: `{{t("Failed", { ns: "${NAMESPACE}" })}}`,
-    color: 'red',
-    icon: <ExclamationOutlined />,
-  },
-  { value: JOB_STATUS.ERROR, label: `{{t("Error", { ns: "${NAMESPACE}" })}}`, color: 'red', icon: <CloseOutlined /> },
-  {
-    value: JOB_STATUS.ABORTED,
-    label: `{{t("Aborted", { ns: "${NAMESPACE}" })}}`,
-    color: 'red',
-    icon: <MinusOutlined rotate={90} />,
-  },
-  {
-    value: JOB_STATUS.CANCELED,
-    label: `{{t("Canceled", { ns: "${NAMESPACE}" })}}`,
-    color: 'volcano',
-    icon: <MinusOutlined rotate={45} />,
-  },
-  {
-    value: JOB_STATUS.REJECTED,
-    label: `{{t("Rejected", { ns: "${NAMESPACE}" })}}`,
-    color: 'volcano',
-    icon: <MinusOutlined />,
-  },
-];
-
-export const JobStatusOptionsMap = JobStatusOptions.reduce(
-  (map, option) => Object.assign(map, { [option.value]: option }),
-  {},
-);

package/src/client/index.tsx

@@ -1,51 +0,0 @@
-export * from './Branch';
-export * from './FlowContext';
-export * from './nodes';
-export { triggers } from './triggers';
-export { useWorkflowVariableOptions } from './variable';
-
-import { Plugin, useCollectionDataSource } from '@nocobase/client';
-import React from 'react';
-import { ExecutionPage } from './ExecutionPage';
-import { WorkflowPage } from './WorkflowPage';
-import { WorkflowProvider } from './WorkflowProvider';
-import { DynamicExpression } from './components/DynamicExpression';
-import { WorkflowTodo } from './nodes/manual/WorkflowTodo';
-import { WorkflowTodoBlockInitializer } from './nodes/manual/WorkflowTodoBlockInitializer';
-
-export class WorkflowPlugin extends Plugin {
-  async load() {
-    this.addRoutes();
-    this.addComponents();
-    this.app.use(WorkflowProvider);
-  }
-
-  addScopes() {
-    this.app.addScopes({
-      useCollectionDataSource,
-    });
-  }
-
-  addComponents() {
-    this.app.addComponents({
-      WorkflowPage,
-      ExecutionPage,
-      WorkflowTodo,
-      WorkflowTodoBlockInitializer,
-      DynamicExpression,
-    });
-  }
-
-  addRoutes() {
-    this.app.router.add('admin.settings.workflow.workflows.id', {
-      path: '/admin/settings/workflow/workflows/:id',
-      element: <WorkflowPage />,
-    });
-    this.app.router.add('admin.settings.workflow.executions.id', {
-      path: '/admin/settings/workflow/executions/:id',
-      element: <ExecutionPage />,
-    });
-  }
-}
-
-export default WorkflowPlugin;

package/src/client/interfaces/expression.tsx

@@ -1,25 +0,0 @@
-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,
-  },
-  invariable: true,
-} as IField;

package/src/client/locale/index.ts

@@ -1,18 +0,0 @@
-import { i18n } from '@nocobase/client';
-import { useTranslation } from 'react-i18next';
-
-export const NAMESPACE = 'workflow';
-
-// i18n.addResources('zh-CN', NAMESPACE, zhCN);
-// i18n.addResources('en-US', NAMESPACE, enUS);
-// i18n.addResources('ja-JP', NAMESPACE, jaJP);
-// i18n.addResources('ru-RU', NAMESPACE, ruRU);
-// i18n.addResources('tr-TR', NAMESPACE, trTR);
-
-export function lang(key: string, options = {}) {
-  return i18n.t(key, { ...options, ns: NAMESPACE });
-}
-
-export function useWorkflowTranslation() {
-  return useTranslation(NAMESPACE);
-}

package/src/client/nodes/aggregate.tsx

@@ -1,327 +0,0 @@
-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'),
-    };
-  },
-};