@nocobase/client-v2 2.1.0-alpha.40 → 2.1.0-alpha.45

package/src/collection-manager/field-validation.ts

@@ -0,0 +1,195 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { cloneDeep } from 'lodash';
+import type { ReactNode } from 'react';
+
+export interface FieldValidationConfigureParam {
+  key: string;
+  label: ReactNode;
+  componentType?: 'checkbox' | 'datePicker' | 'inputNumber' | 'multipleSelect' | 'radio' | 'singleSelect' | 'text';
+  defaultValue?: unknown;
+  options?: Array<{ label: ReactNode; value: string | number | boolean }>;
+  required?: boolean;
+}
+
+export interface FieldValidationConfigureItem {
+  key: string;
+  label: ReactNode;
+  hasValue?: boolean;
+  params?: FieldValidationConfigureParam[];
+  paramsType?: string;
+}
+
+export type FieldValidationConfigureInput = FieldValidationConfigureItem | string;
+
+const requiredValidationItem: FieldValidationConfigureItem = {
+  key: 'required',
+  label: 'Required',
+  hasValue: false,
+  params: [],
+};
+
+export function RangeValidationItems(valueKind: 'date' | 'number'): FieldValidationConfigureItem[] {
+  const componentType = valueKind === 'date' ? 'datePicker' : 'inputNumber';
+  const valueKey = valueKind === 'date' ? 'date' : 'limit';
+
+  return [
+    {
+      key: 'greater',
+      label: 'Greater than',
+      hasValue: true,
+      params: [{ key: valueKey, label: valueKind === 'date' ? 'Date' : 'Limit', componentType, required: true }],
+    },
+    {
+      key: 'less',
+      label: 'Less than',
+      hasValue: true,
+      params: [{ key: valueKey, label: valueKind === 'date' ? 'Date' : 'Limit', componentType, required: true }],
+    },
+    {
+      key: 'max',
+      label: valueKind === 'date' ? 'Max value' : 'Max value',
+      hasValue: true,
+      params: [{ key: valueKey, label: valueKind === 'date' ? 'Date' : 'Limit', componentType, required: true }],
+    },
+    {
+      key: 'min',
+      label: valueKind === 'date' ? 'Min value' : 'Min value',
+      hasValue: true,
+      params: [{ key: valueKey, label: valueKind === 'date' ? 'Date' : 'Limit', componentType, required: true }],
+    },
+  ];
+}
+
+export class FieldValidationConfigureRegistry {
+  protected items = new Map<string, FieldValidationConfigureItem>();
+  protected groups = new Map<string, FieldValidationConfigureInput[]>();
+
+  register(item: FieldValidationConfigureItem) {
+    this.items.set(item.key, cloneDeep(item));
+  }
+
+  registerMany(items: FieldValidationConfigureItem[] = []) {
+    items.forEach((item) => this.register(item));
+  }
+
+  registerGroup(name: string, items: FieldValidationConfigureInput[] = []) {
+    this.groups.set(name, items);
+  }
+
+  addToGroup(name: string, items: FieldValidationConfigureInput[] = []) {
+    this.groups.set(name, [...(this.groups.get(name) || []), ...items]);
+  }
+
+  get(name: string) {
+    return cloneDeep(this.items.get(name));
+  }
+
+  getGroup(name: string) {
+    return (this.groups.get(name) || [])
+      .map((item) => (typeof item === 'string' ? this.get(item) : cloneDeep(item)))
+      .filter(Boolean) as FieldValidationConfigureItem[];
+  }
+}
+
+export const fieldValidationConfigureRegistry = new FieldValidationConfigureRegistry();
+
+export function registerFieldValidationConfigure(item: FieldValidationConfigureItem) {
+  fieldValidationConfigureRegistry.register(item);
+}
+
+export function registerFieldValidationConfigureGroup(name: string, items: FieldValidationConfigureInput[] = []) {
+  fieldValidationConfigureRegistry.registerGroup(name, items);
+}
+
+export function addFieldValidationConfiguresToGroup(name: string, items: FieldValidationConfigureInput[] = []) {
+  fieldValidationConfigureRegistry.addToGroup(name, items);
+}
+
+fieldValidationConfigureRegistry.registerMany([
+  requiredValidationItem,
+  {
+    key: 'pattern',
+    label: 'Pattern',
+    hasValue: true,
+    params: [{ key: 'regex', label: 'Regular Expression', componentType: 'text', required: true }],
+  },
+  { key: 'email', label: 'Email', hasValue: false, params: [], paramsType: 'object' },
+  { key: 'uuid', label: 'UUID', hasValue: false, params: [], paramsType: 'object' },
+  {
+    key: 'length',
+    label: 'Length',
+    hasValue: true,
+    params: [{ key: 'limit', label: 'Limit', componentType: 'inputNumber', required: true }],
+  },
+  { key: 'uri', label: 'URI', hasValue: false, params: [], paramsType: 'object' },
+  {
+    key: 'multiple',
+    label: 'Multiple',
+    hasValue: true,
+    params: [{ key: 'base', label: 'Base', componentType: 'inputNumber', required: true }],
+  },
+  { key: 'integer', label: 'Integer', hasValue: false, params: [] },
+  {
+    key: 'precision',
+    label: 'Precision',
+    hasValue: true,
+    params: [{ key: 'limit', label: 'Limit', componentType: 'inputNumber', required: true }],
+  },
+  { key: 'unsafe', label: 'Unsafe integer', hasValue: false, params: [] },
+  {
+    key: 'timestamp',
+    label: 'Timestamp',
+    hasValue: true,
+    params: [
+      {
+        key: 'type',
+        label: 'Type',
+        componentType: 'singleSelect',
+        options: [
+          { label: 'JavaScript', value: 'javascript' },
+          { label: 'Unix', value: 'unix' },
+        ],
+        defaultValue: 'javascript',
+      },
+    ],
+  },
+]);
+
+fieldValidationConfigureRegistry.registerGroup('string', [
+  'required',
+  {
+    key: 'max',
+    label: 'Max length',
+    hasValue: true,
+    params: [{ key: 'limit', label: 'Limit', componentType: 'inputNumber', required: true }],
+  },
+  {
+    key: 'min',
+    label: 'Min length',
+    hasValue: true,
+    params: [{ key: 'limit', label: 'Limit', componentType: 'inputNumber', required: true }],
+  },
+  'pattern',
+  'email',
+  'uuid',
+  'length',
+  'uri',
+]);
+fieldValidationConfigureRegistry.registerGroup('number', [
+  'required',
+  ...RangeValidationItems('number'),
+  'multiple',
+  'integer',
+  'precision',
+  'unsafe',
+]);
+fieldValidationConfigureRegistry.registerGroup('date', ['required', ...RangeValidationItems('date'), 'timestamp']);
+fieldValidationConfigureRegistry.registerGroup('object', ['required']);

package/src/collection-manager/filter-operators/index.ts

@@ -0,0 +1,176 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import * as standardFieldFilterOperatorGroups from './operators';
+import type { FieldFilterOperator } from './operators';
+
+export * from './operators';
+
+export type FieldFilterOperatorPreset = keyof typeof standardFieldFilterOperatorGroups;
+
+export type FieldFilterOperatorGroupName = FieldFilterOperatorPreset | (string & {});
+
+export type FieldFilterOperatorReference<TMeta = unknown> = FieldFilterOperator<TMeta> | string;
+
+export type FieldFilterOperatorList<TMeta = unknown> = FieldFilterOperator<TMeta>[] | FieldFilterOperatorGroupName;
+
+export type FieldFilterable<TMeta = unknown> = {
+  operators?: FieldFilterOperatorList<TMeta>;
+  operatorGroup?: string;
+  children?: unknown[];
+  nested?: boolean;
+  [key: string]: unknown;
+};
+
+export class FieldFilterOperatorRegistry {
+  protected operators: Record<string, FieldFilterOperator> = {};
+  protected groups: Record<string, FieldFilterOperator[]> = {};
+
+  constructor(groups: Record<string, FieldFilterOperator[]> = {}) {
+    Object.entries(groups).forEach(([name, operatorList]) => {
+      this.registerGroup(name, operatorList);
+    });
+  }
+
+  register(operator: FieldFilterOperator) {
+    this.operators[operator.value] = operator;
+    return this;
+  }
+
+  registerMany(operators: FieldFilterOperator[] = []) {
+    operators.forEach((operator) => {
+      this.register(operator);
+    });
+    return this;
+  }
+
+  registerGroup(name: string, operators: FieldFilterOperatorReference[] = []) {
+    const operatorList = this.resolveOperatorReferences(operators);
+    this.registerMany(operatorList);
+    this.groups[name] = operatorList;
+    return this;
+  }
+
+  addToGroup(name: string, operators: FieldFilterOperatorReference[] = []) {
+    const operatorList = this.resolveOperatorReferences(operators);
+    this.registerMany(operatorList);
+    if (!this.groups[name]) {
+      this.groups[name] = [];
+    }
+    operatorList.forEach((operator) => {
+      if (!this.groups[name].some((item) => item.value === operator.value)) {
+        this.groups[name].push(operator);
+      }
+    });
+    return this;
+  }
+
+  get(name: string) {
+    return this.operators[name];
+  }
+
+  getGroup(name: string) {
+    return this.groups[name] || [];
+  }
+
+  getGroups() {
+    return this.groups;
+  }
+
+  resolveOperators<TMeta = unknown>(operators?: FieldFilterOperatorList<TMeta>): FieldFilterOperator<TMeta>[] {
+    if (!operators) {
+      return [];
+    }
+
+    if (typeof operators === 'string') {
+      return this.getGroup(operators) as FieldFilterOperator<TMeta>[];
+    }
+
+    return operators;
+  }
+
+  protected resolveOperatorReferences(operators: FieldFilterOperatorReference[] = []) {
+    return operators
+      .map((operator) => (typeof operator === 'string' ? this.get(operator) : operator))
+      .filter((operator): operator is FieldFilterOperator => Boolean(operator));
+  }
+}
+
+export const filterOperatorRegistry = new FieldFilterOperatorRegistry(standardFieldFilterOperatorGroups);
+
+export const fieldFilterOperators = filterOperatorRegistry.getGroups() as Record<string, FieldFilterOperator[]> &
+  typeof standardFieldFilterOperatorGroups;
+
+export const fieldFilterOperatorPresets = fieldFilterOperators;
+
+export function resolveFilterOperators<TMeta = unknown>(
+  operators?: FieldFilterOperatorList<TMeta>,
+): FieldFilterOperator<TMeta>[] {
+  return filterOperatorRegistry.resolveOperators(operators);
+}
+
+export function normalizeFilterableOperators<TMeta = unknown>(filterable?: FieldFilterable<TMeta>) {
+  if (!filterable) {
+    return filterable;
+  }
+
+  if (filterable.operatorGroup) {
+    filterable.operators = resolveFilterOperators(filterable.operatorGroup);
+  }
+
+  const rawOperators = (filterable as { operators?: unknown }).operators;
+  if (typeof rawOperators === 'string') {
+    filterable.operatorGroup = rawOperators;
+    filterable.operators = resolveFilterOperators(rawOperators);
+  }
+
+  if (Array.isArray(filterable.children)) {
+    filterable.children.forEach((child) => {
+      if (child && typeof child === 'object') {
+        normalizeFilterableOperators(child as FieldFilterable<TMeta>);
+      }
+    });
+  }
+
+  return filterable;
+}
+
+export function createFilterable<TPreset extends FieldFilterOperatorGroupName>(
+  preset: TPreset,
+  options: Omit<FieldFilterable, 'operators'> = {},
+): FieldFilterable {
+  return {
+    ...options,
+    operatorGroup: preset,
+    operators: resolveFilterOperators(preset),
+  };
+}
+
+export function createTypedFilterable<TMeta = unknown>(
+  groups: Array<{
+    types: string[];
+    operators: FieldFilterOperatorList<TMeta>;
+  }>,
+  resolveType: (meta: TMeta) => string,
+): FieldFilterable<TMeta> {
+  return {
+    operators: groups.flatMap(({ types, operators: operatorList }) =>
+      resolveFilterOperators(operatorList).map((operator) => ({
+        ...operator,
+        visible: (meta: TMeta) => {
+          const matches = types.includes(resolveType(meta));
+          if (typeof operator.visible === 'function') {
+            return operator.visible(meta) && matches;
+          }
+          return matches;
+        },
+      })),
+    ),
+  };
+}

package/src/collection-manager/{interfaces/properties → filter-operators}/operators.ts

@@ -7,7 +7,18 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-export const string = [
+export type FieldFilterOperator<TMeta = unknown> = {
+  label: string;
+  value: string;
+  selected?: boolean;
+  noValue?: boolean;
+  schema?: Record<string, unknown>;
+  onlyFilterAction?: boolean;
+  visible?: (meta: TMeta) => boolean;
+  [key: string]: unknown;
+};
+
+export const string: FieldFilterOperator[] = [
   { label: '{{t("contains")}}', value: '$includes', selected: true },
   { label: '{{t("does not contain")}}', value: '$notIncludes' },
   { label: '{{t("is")}}', value: '$eq' },
@@ -16,7 +27,7 @@ export const string = [
   { label: '{{t("is not empty")}}', value: '$notEmpty', noValue: true },
 ];
 
-export const array = [
+export const array: FieldFilterOperator[] = [
   {
     label: '{{t("is")}}',
     value: '$match',
@@ -54,12 +65,12 @@ export const array = [
   { label: '{{t("is not empty")}}', value: '$notEmpty', noValue: true },
 ];
 
-export const object = [
+export const object: FieldFilterOperator[] = [
   { label: '{{t("is")}}', value: '$eq', selected: true },
   { label: '{{t("is not")}}', value: '$ne' },
 ];
 
-export const datetime = [
+export const datetime: FieldFilterOperator[] = [
   {
     label: "{{ t('is') }}",
     value: '$dateOn',
@@ -70,7 +81,7 @@ export const datetime = [
         isRange: false,
       },
     },
-    onlyFilterAction: true, //schema 仅在Filter.Action生效，筛选表单中不生效
+    onlyFilterAction: true,
   },
   {
     label: "{{ t('is not') }}",
@@ -141,7 +152,7 @@ export const datetime = [
   { label: "{{ t('is not empty') }}", value: '$notEmpty', noValue: true },
 ];
 
-export const number = [
+export const number: FieldFilterOperator[] = [
   { label: '{{t("=")}}', value: '$eq', selected: true },
   { label: '{{t("≠")}}', value: '$ne' },
   { label: '{{t(">")}}', value: '$gt' },
@@ -152,14 +163,14 @@ export const number = [
   { label: '{{t("is not empty")}}', value: '$notEmpty', noValue: true },
 ];
 
-export const id = [
+export const id: FieldFilterOperator[] = [
   { label: '{{t("is")}}', value: '$eq', selected: true },
   { label: '{{t("is not")}}', value: '$ne' },
   { label: '{{t("exists")}}', value: '$exists', noValue: true },
   { label: '{{t("not exists")}}', value: '$notExists', noValue: true },
 ];
 
-export const enumType = [
+export const enumType: FieldFilterOperator[] = [
   {
     label: '{{t("is")}}',
     value: '$eq',
@@ -191,14 +202,14 @@ export const enumType = [
   { label: '{{t("is not empty")}}', value: '$notEmpty', noValue: true },
 ];
 
-export const time = [
+export const time: FieldFilterOperator[] = [
   { label: '{{t("is")}}', value: '$eq', selected: true },
   { label: '{{t("is not")}}', value: '$neq' },
   { label: '{{t("is empty")}}', value: '$empty', noValue: true },
   { label: '{{t("is not empty")}}', value: '$notEmpty', noValue: true },
 ];
 
-export const boolean = [
+export const boolean: FieldFilterOperator[] = [
   {
     label: '{{t("Yes")}}',
     value: '$isTruly',
@@ -246,7 +257,7 @@ export const boolean = [
   { label: "{{ t('is not empty') }}", value: '$notEmpty', noValue: true },
 ];
 
-export const tableoid = [
+export const tableoid: FieldFilterOperator[] = [
   {
     label: '{{t("is any of")}}',
     value: '$childIn',
@@ -265,7 +276,7 @@ export const tableoid = [
   },
 ];
 
-export const collection = [
+export const collection: FieldFilterOperator[] = [
   {
     label: '{{t("is")}}',
     value: '$eq',
@@ -297,7 +308,7 @@ export const collection = [
   { label: '{{t("is not empty")}}', value: '$notEmpty', noValue: true },
 ];
 
-export const bigField = [
+export const bigField: FieldFilterOperator[] = [
   {
     label: '{{t("contains")}}',
     value: '$includes',

package/src/collection-manager/interfaces/checkbox.ts

@@ -7,8 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { ISchema } from '@formily/react';
-import { defaultProps, operators } from './properties';
+import { defaultProps } from './properties';
 import { CollectionFieldInterface } from '../../collection-field-interface/CollectionFieldInterface';
 
 export class CheckboxFieldInterface extends CollectionFieldInterface {
@@ -30,12 +29,6 @@ export class CheckboxFieldInterface extends CollectionFieldInterface {
     ...defaultProps,
   };
   filterable = {
-    operators: operators.boolean,
+    operators: 'boolean',
   };
-  schemaInitialize(schema: ISchema, { block }: { block: string }): void {
-    if (['Table', 'Kanban'].includes(block)) {
-      schema['x-component-props'] = schema['x-component-props'] || {};
-      schema['x-component-props']['ellipsis'] = true;
-    }
-  }
 }

package/src/collection-manager/interfaces/checkboxGroup.ts

@@ -7,8 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { ISchema } from '@formily/react';
-import { dataSource, defaultProps, operators } from './properties';
+import { dataSource, defaultProps } from './properties';
 import { CollectionFieldInterface } from '../../collection-field-interface/CollectionFieldInterface';
 
 export class CheckboxGroupFieldInterface extends CollectionFieldInterface {
@@ -33,13 +32,6 @@ export class CheckboxGroupFieldInterface extends CollectionFieldInterface {
     'uiSchema.enum': dataSource,
   };
   filterable = {
-    operators: operators.array,
+    operators: 'array',
   };
-
-  schemaInitialize(schema: ISchema, { block }: { block: string }): void {
-    if (['Table', 'Kanban'].includes(block)) {
-      schema['x-component-props'] = schema['x-component-props'] || {};
-      schema['x-component-props']['ellipsis'] = true;
-    }
-  }
 }

package/src/collection-manager/interfaces/collection.ts

@@ -7,8 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { ISchema } from '@formily/react';
-import { collectionDataSource, defaultProps, operators } from './properties';
+import { collectionDataSource, defaultProps } from './properties';
 import { CollectionFieldInterface } from '../../collection-field-interface/CollectionFieldInterface';
 
 export class CollectionSelectFieldInterface extends CollectionFieldInterface {
@@ -36,18 +35,6 @@ export class CollectionSelectFieldInterface extends CollectionFieldInterface {
   };
 
   filterable = {
-    operators: operators.collection,
+    operators: 'collection',
   };
-
-  schemaInitialize(schema: ISchema, { block }): void {
-    const props = (schema['x-component-props'] = schema['x-component-props'] || {});
-    props.style = {
-      ...(props.style || {}),
-      width: '100%',
-    };
-
-    if (['Table', 'Kanban'].includes(block)) {
-      props['ellipsis'] = true;
-    }
-  }
 }

package/src/collection-manager/interfaces/color.ts

@@ -8,7 +8,7 @@
  */
 
 import { CollectionFieldInterface } from '../../collection-field-interface/CollectionFieldInterface';
-import { defaultProps, operators } from './properties';
+import { defaultProps } from './properties';
 
 export class ColorFieldInterface extends CollectionFieldInterface {
   name = 'color';
@@ -29,6 +29,6 @@ export class ColorFieldInterface extends CollectionFieldInterface {
     ...defaultProps,
   };
   filterable = {
-    operators: operators.string,
+    operators: 'string',
   };
 }

package/src/collection-manager/interfaces/createdAt.ts

@@ -8,7 +8,7 @@
  */
 
 import { CollectionFieldInterface } from '../../collection-field-interface/CollectionFieldInterface';
-import { dateTimeProps, defaultProps, operators } from './properties';
+import { dateTimeProps, defaultProps } from './properties';
 
 export class CreatedAtFieldInterface extends CollectionFieldInterface {
   name = 'createdAt';
@@ -35,7 +35,7 @@ export class CreatedAtFieldInterface extends CollectionFieldInterface {
     ...dateTimeProps,
   };
   filterable = {
-    operators: operators.datetime,
+    operators: 'datetime',
   };
   titleUsable = true;
 }

package/src/collection-manager/interfaces/createdBy.ts

@@ -7,10 +7,8 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { ISchema } from '@formily/react';
-import { cloneDeep } from 'lodash';
 import { CollectionFieldInterface } from '../../collection-field-interface/CollectionFieldInterface';
-import { defaultProps, recordPickerViewer } from './properties';
+import { defaultProps } from './properties';
 
 export class CreatedByFieldInterface extends CollectionFieldInterface {
   name = 'createdBy';
@@ -67,14 +65,5 @@ export class CreatedByFieldInterface extends CollectionFieldInterface {
     // ],
   };
 
-  schemaInitialize(schema: ISchema, { block }: { block: string }): void {
-    schema['properties'] = {
-      viewer: cloneDeep(recordPickerViewer),
-    };
-    if (['Table', 'Kanban'].includes(block)) {
-      schema['x-component-props'] = schema['x-component-props'] || {};
-      schema['x-component-props']['ellipsis'] = true;
-    }
-  }
   description = '{{t("Store the creation user of each record")}}';
 }

package/src/collection-manager/interfaces/dateOnly.ts

@@ -8,7 +8,7 @@
  */
 
 import { CollectionFieldInterface } from '../../collection-field-interface/CollectionFieldInterface';
-import { dateTimeProps, defaultProps, operators } from './properties';
+import { dateTimeProps, defaultProps } from './properties';
 
 export class DateFieldInterface extends CollectionFieldInterface {
   name = 'date';
@@ -40,9 +40,15 @@ export class DateFieldInterface extends CollectionFieldInterface {
       'x-component': 'Checkbox',
       'x-visible': false,
     },
+    'uiSchema.x-component-props.timeFormat': {
+      type: 'string',
+      'x-decorator': 'FormItem',
+      'x-component': 'Radio.Group',
+      'x-visible': false,
+    },
   };
   filterable = {
-    operators: operators.datetime,
+    operators: 'datetime',
   };
   titleUsable = true;
 }

package/src/collection-manager/interfaces/datetime.ts

@@ -8,7 +8,7 @@
  */
 
 import { CollectionFieldInterface } from '../../collection-field-interface/CollectionFieldInterface';
-import { dateTimeProps, defaultProps, operators } from './properties';
+import { dateTimeProps, defaultProps } from './properties';
 
 export class DatetimeFieldInterface extends CollectionFieldInterface {
   name = 'datetime';
@@ -60,7 +60,7 @@ export class DatetimeFieldInterface extends CollectionFieldInterface {
     },
   };
   filterable = {
-    operators: operators.datetime,
+    operators: 'datetime',
   };
   titleUsable = true;
 }