@nocobase/plugin-workflow 0.9.2-alpha.4 → 0.9.4-alpha.1

package/lib/client/nodes/aggregate.d.ts

@@ -0,0 +1,186 @@
+import React from 'react';
+import { SchemaInitializerItemOptions, useCollectionDataSource } from '@nocobase/client';
+import { FilterDynamicComponent } from '../components/FilterDynamicComponent';
+declare function AssociatedConfig({ value, onChange, ...props }: {
+    [x: string]: any;
+    value: any;
+    onChange: any;
+}): JSX.Element;
+declare const _default: {
+    title: string;
+    type: string;
+    group: string;
+    description: string;
+    fieldset: {
+        aggregator: {
+            type: string;
+            title: string;
+            'x-decorator': string;
+            'x-component': string;
+            enum: {
+                label: string;
+                value: string;
+            }[];
+            required: boolean;
+            default: string;
+        };
+        associated: {
+            type: string;
+            title: string;
+            'x-decorator': string;
+            'x-component': string;
+            enum: {
+                label: string;
+                value: boolean;
+            }[];
+            required: boolean;
+            default: boolean;
+            'x-reactions': {
+                target: string;
+                effects: string[];
+                fulfill: {
+                    state: {
+                        value: any;
+                    };
+                };
+            }[];
+        };
+        collectionField: {
+            type: string;
+            'x-decorator': string;
+            'x-decorator-props': {
+                value: {
+                    designable: boolean;
+                };
+            };
+            'x-component': string;
+            properties: {
+                row: {
+                    type: string;
+                    'x-component': string;
+                    properties: {
+                        target: {
+                            type: string;
+                            'x-component': string;
+                            properties: {
+                                collection: {
+                                    title: string;
+                                    'x-component-props': {
+                                        className: string;
+                                        dropdownMatchSelectWidth: boolean;
+                                    };
+                                    'x-reactions': any[];
+                                    type: string;
+                                    required: boolean;
+                                    'x-decorator': string;
+                                    'x-component': string;
+                                };
+                                association: {
+                                    type: string;
+                                    title: string;
+                                    'x-decorator': string;
+                                    'x-component': string;
+                                    'x-component-props': {
+                                        className: string;
+                                    };
+                                    'x-reactions': {
+                                        dependencies: string[];
+                                        fulfill: {
+                                            state: {
+                                                visible: string;
+                                            };
+                                        };
+                                    }[];
+                                    required: boolean;
+                                };
+                            };
+                        };
+                        field: {
+                            type: string;
+                            'x-component': string;
+                            properties: {
+                                'params.field': {
+                                    type: string;
+                                    title: string;
+                                    'x-decorator': string;
+                                    'x-component': string;
+                                    'x-component-props': {
+                                        filter(field: any): boolean;
+                                    };
+                                    required: boolean;
+                                    'x-reactions': {
+                                        dependencies: string[];
+                                        fulfill: {
+                                            state: {
+                                                visible: string;
+                                            };
+                                        };
+                                    }[];
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        params: {
+            type: string;
+            properties: {
+                distinct: {
+                    type: string;
+                    title: string;
+                    'x-decorator': string;
+                    'x-component': string;
+                    'x-reactions': {
+                        dependencies: string[];
+                        fulfill: {
+                            state: {
+                                visible: string;
+                            };
+                        };
+                    }[];
+                };
+                filter: {
+                    'x-reactions': {
+                        dependencies: string[];
+                        fulfill: {
+                            state: {
+                                visible: string;
+                            };
+                        };
+                    }[];
+                    type: string;
+                    title: string;
+                    'x-decorator': string;
+                    'x-component': string;
+                    'x-component-props': {
+                        useProps(): {
+                            options: any[];
+                            className: string;
+                        };
+                        dynamicComponent: string;
+                    };
+                };
+            };
+        };
+    };
+    view: {};
+    scope: {
+        useCollectionDataSource: typeof useCollectionDataSource;
+    };
+    components: {
+        SchemaComponentContext: React.Context<import("@nocobase/client").ISchemaComponentContext>;
+        FilterDynamicComponent: typeof FilterDynamicComponent;
+        FieldsSelect: React.MemoExoticComponent<React.FunctionComponent<Pick<any, string | number | symbol>>>;
+        ValueBlock: (() => JSX.Element) & {
+            Initializer: (props: any) => JSX.Element;
+            Result: (props: any) => JSX.Element;
+        };
+        AssociatedConfig: typeof AssociatedConfig;
+    };
+    useVariables(current: any, { types }: {
+        types: any;
+    }): any[];
+    useInitializers(node: any): SchemaInitializerItemOptions | null;
+};
+export default _default;

package/lib/client/nodes/aggregate.js

@@ -0,0 +1,349 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _react() {
+  const data = _interopRequireWildcard(require("react"));
+  _react = function _react() {
+    return data;
+  };
+  return data;
+}
+function _antd() {
+  const data = require("antd");
+  _antd = function _antd() {
+    return data;
+  };
+  return data;
+}
+function _react2() {
+  const data = require("@formily/react");
+  _react2 = function _react2() {
+    return data;
+  };
+  return data;
+}
+function _client() {
+  const data = require("@nocobase/client");
+  _client = function _client() {
+    return data;
+  };
+  return data;
+}
+var _collection = require("../schemas/collection");
+var _locale = require("../locale");
+var _FilterDynamicComponent = require("../components/FilterDynamicComponent");
+var _variable = require("../variable");
+var _FieldsSelect = require("../components/FieldsSelect");
+var _ValueBlock = require("../components/ValueBlock");
+var _ = require(".");
+const _excluded = ["value", "onChange"];
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function matchToManyField(field, depth) {
+  return ['hasMany', 'belongsToMany'].includes(field.type) && depth;
+}
+function AssociatedConfig(_ref) {
+  let value = _ref.value,
+    onChange = _ref.onChange,
+    props = _objectWithoutProperties(_ref, _excluded);
+  const _useForm = (0, _react2().useForm)(),
+    setValuesIn = _useForm.setValuesIn;
+  const compile = (0, _client().useCompile)();
+  const _useCollectionManager = (0, _client().useCollectionManager)(),
+    getCollection = _useCollectionManager.getCollection;
+  const current = (0, _.useNodeContext)();
+  const options = [_variable.nodesOptions, _variable.triggerOptions].map(item => {
+    var _item$useOptions;
+    const children = (_item$useOptions = item.useOptions({
+      types: [matchToManyField]
+    })) === null || _item$useOptions === void 0 ? void 0 : _item$useOptions.filter(Boolean);
+    return {
+      label: compile(item.label),
+      value: item.value,
+      key: item.value,
+      children: compile(children),
+      disabled: children && !children.length
+    };
+  });
+  const _ref2 = value !== null && value !== void 0 ? value : {},
+    _ref2$associatedKey = _ref2.associatedKey,
+    associatedKey = _ref2$associatedKey === void 0 ? '' : _ref2$associatedKey,
+    fieldName = _ref2.name;
+  let p = [];
+  const matched = associatedKey.match(/^{{(.*)}}$/);
+  if (matched) {
+    p = [...matched[1].trim().split('.').slice(0, -1), fieldName];
+  }
+  const onSelectChange = (0, _react().useCallback)((path, option) => {
+    if (!(path === null || path === void 0 ? void 0 : path.length)) {
+      setValuesIn('collection', null);
+      onChange({});
+      return;
+    }
+    // const associationFieldName = path.pop();
+    const _option$pop = option.pop(),
+      field = _option$pop.field;
+    // need to get:
+    // * source collection (from node.config)
+    // * target collection (from field name)
+    const collectionName = field.collectionName,
+      target = field.target,
+      name = field.name;
+    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 _react().default.createElement(_antd().Cascader, _objectSpread(_objectSpread({}, 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
+var _default = {
+  title: `{{t("Aggregate", { ns: "${_locale.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: "${_locale.NAMESPACE}" })}}`,
+  fieldset: {
+    aggregator: {
+      type: 'string',
+      title: `{{t("Aggregator function", { ns: "${_locale.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: "${_locale.NAMESPACE}" })}}`,
+      'x-decorator': 'FormItem',
+      'x-component': 'Radio.Group',
+      enum: [{
+        label: `{{t("Data of collection", { ns: "${_locale.NAMESPACE}" })}}`,
+        value: false
+      }, {
+        label: `{{t("Data of associated collection", { ns: "${_locale.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: _objectSpread(_objectSpread({}, _collection.collection), {}, {
+                  title: `{{t("Data of collection", { ns: "${_locale.NAMESPACE}" })}}`,
+                  'x-component-props': _objectSpread(_objectSpread({}, _collection.collection['x-component-props']), {}, {
+                    className: 'full-width'
+                  }),
+                  'x-reactions': [..._collection.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: "${_locale.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: "${_locale.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: "${_locale.NAMESPACE}" })}}`,
+          'x-decorator': 'FormItem',
+          'x-component': 'Checkbox',
+          'x-reactions': [{
+            dependencies: ['collection', 'aggregator'],
+            fulfill: {
+              state: {
+                visible: '{{!!$deps[0] && ["count"].includes($deps[1])}}'
+              }
+            }
+          }]
+        },
+        filter: _objectSpread(_objectSpread({}, _collection.filter), {}, {
+          'x-reactions': [{
+            dependencies: ['collection'],
+            fulfill: {
+              state: {
+                visible: '{{!!$deps[0]}}'
+              }
+            }
+          }]
+        })
+      }
+    }
+  },
+  view: {},
+  scope: {
+    useCollectionDataSource: _client().useCollectionDataSource
+  },
+  components: {
+    SchemaComponentContext: _client().SchemaComponentContext,
+    FilterDynamicComponent: _FilterDynamicComponent.FilterDynamicComponent,
+    FieldsSelect: _FieldsSelect.FieldsSelect,
+    ValueBlock: _ValueBlock.ValueBlock,
+    AssociatedConfig
+  },
+  useVariables(current, {
+    types
+  }) {
+    if (types && !types.some(type => type in _variable.BaseTypeSets || Object.values(_variable.BaseTypeSets).some(set => set.has(type)))) {
+      return null;
+    }
+    return [
+      // { key: '', value: '', label: lang('Calculation result') }
+    ];
+  },
+  useInitializers(node) {
+    var _node$title;
+    if (!node.config.collection) {
+      return null;
+    }
+    return {
+      type: 'item',
+      title: (_node$title = node.title) !== null && _node$title !== void 0 ? _node$title : `#${node.id}`,
+      component: _ValueBlock.ValueBlock.Initializer,
+      node,
+      resultTitle: (0, _locale.lang)('Query result')
+    };
+  }
+};
+exports.default = _default;

package/lib/client/nodes/calculation.d.ts

@@ -12,6 +12,7 @@ declare const _default: {
     title: string;
     type: string;
     group: string;
+    description: string;
     fieldset: {
         dynamic: {
             type: string;
@@ -101,7 +102,7 @@ declare const _default: {
             onChange: any;
         }) => JSX.Element;
     };
-    getOptions(config: any, types: any): any[];
+    useVariables(current: any, options: any): any[];
     useInitializers(node: any): SchemaInitializerItemOptions;
 };
 export default _default;