@nocobase/client-v2 2.1.0-beta.36 → 2.1.0-beta.37

package/src/components/form/filter/__tests__/compileFilterGroup.test.ts

@@ -0,0 +1,146 @@
+/**
+ * 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 { describe, expect, it } from 'vitest';
+import { compileFilterGroup } from '../useFilterActionProps';
+
+describe('compileFilterGroup', () => {
+  it('returns undefined for an empty group so callers can drop the filter param', () => {
+    expect(compileFilterGroup(undefined)).toBeUndefined();
+    expect(compileFilterGroup({ logic: '$and', items: [] })).toBeUndefined();
+  });
+
+  it('compiles a single condition into the NocoBase {path: {op: val}} envelope', () => {
+    const out = compileFilterGroup({
+      logic: '$and',
+      items: [{ path: 'lockReason', operator: '$includes', value: 'abuse' }],
+    });
+    expect(out).toEqual({ $and: [{ lockReason: { $includes: 'abuse' } }] });
+  });
+
+  it('preserves the parent logic ($and / $or)', () => {
+    const out = compileFilterGroup({
+      logic: '$or',
+      items: [
+        { path: 'lockReason', operator: '$eq', value: 'abuse' },
+        { path: 'lockReason', operator: '$eq', value: 'spam' },
+      ],
+    });
+    expect(out).toEqual({
+      $or: [{ lockReason: { $eq: 'abuse' } }, { lockReason: { $eq: 'spam' } }],
+    });
+  });
+
+  it('compiles nested groups recursively', () => {
+    const out = compileFilterGroup({
+      logic: '$and',
+      items: [
+        { path: 'lockReason', operator: '$eq', value: 'abuse' },
+        {
+          logic: '$or',
+          items: [
+            { path: 'lockedTs', operator: '$dateAfter', value: '2026-01-01' },
+            { path: 'lockedTs', operator: '$dateBefore', value: '2026-12-31' },
+          ],
+        },
+      ],
+    });
+    expect(out).toEqual({
+      $and: [
+        { lockReason: { $eq: 'abuse' } },
+        {
+          $or: [{ lockedTs: { $dateAfter: '2026-01-01' } }, { lockedTs: { $dateBefore: '2026-12-31' } }],
+        },
+      ],
+    });
+  });
+
+  it('drops items with empty values (undefined / "" / [] / {}) so half-edited rows do not 500 the server', () => {
+    // Mirrors v1's `removeNullCondition` behaviour. A user who selected a field + operator but hasn't typed a value yet must NOT cause `{path:{operator:undefined}}` to fly out — the server rejects empty operator bodies on `$dateOn` etc.
+    const out = compileFilterGroup({
+      logic: '$and',
+      items: [
+        { path: 'lockedTs', operator: '$dateOn', value: undefined },
+        { path: 'lockReason', operator: '$eq', value: '' },
+        { path: 'lockReason', operator: '$in', value: [] },
+        { path: 'lockedTs', operator: '$dateOn', value: {} },
+        { path: 'lockReason', operator: '$eq', value: 'kept' },
+      ],
+    });
+    expect(out).toEqual({ $and: [{ lockReason: { $eq: 'kept' } }] });
+  });
+
+  it('expands dotted association paths into nested objects (matches v1 payload shape)', () => {
+    // `user.createdBy.password` must reach the server as a nested object so the filter resolver walks the association chain. Flattened-key form (`{ "user.createdBy.password": ... }`) leaves the server treating the whole string as one column name.
+    const out = compileFilterGroup({
+      logic: '$and',
+      items: [{ path: 'user.createdBy.password', operator: '$includes', value: '123' }],
+    });
+    expect(out).toEqual({
+      $and: [{ user: { createdBy: { password: { $includes: '123' } } } }],
+    });
+  });
+
+  it('keeps relative date descriptors (non-empty plain objects) intact', () => {
+    // `{ type: 'today' }` is an empty-keys-only check away from being pruned by accident. Confirm it survives — that's the server-readable shape for relative-date filters.
+    const out = compileFilterGroup({
+      logic: '$and',
+      items: [{ path: 'lockedTs', operator: '$dateOn', value: { type: 'today' } }],
+    });
+    expect(out).toEqual({ $and: [{ lockedTs: { $dateOn: { type: 'today' } } }] });
+  });
+
+  it('drops items missing path or operator so half-typed rows do not break the query', () => {
+    const out = compileFilterGroup({
+      logic: '$and',
+      items: [
+        { path: '', operator: '$eq', value: 'orphan' },
+        { path: 'lockReason', operator: '', value: 'orphan' },
+        { path: 'lockReason', operator: '$eq', value: 'kept' },
+      ],
+    });
+    expect(out).toEqual({ $and: [{ lockReason: { $eq: 'kept' } }] });
+  });
+
+  it('drops empty nested groups so a half-built sub-group does not produce { $or: [] }', () => {
+    const out = compileFilterGroup({
+      logic: '$and',
+      items: [
+        { path: 'lockReason', operator: '$eq', value: 'abuse' },
+        { logic: '$or', items: [] },
+      ],
+    });
+    expect(out).toEqual({ $and: [{ lockReason: { $eq: 'abuse' } }] });
+  });
+
+  it('returns undefined when every item drops out', () => {
+    const out = compileFilterGroup({
+      logic: '$and',
+      items: [
+        { path: '', operator: '', value: '' },
+        { logic: '$or', items: [] },
+      ],
+    });
+    expect(out).toBeUndefined();
+  });
+
+  it('passes complex value shapes (date descriptors, arrays) through unchanged', () => {
+    const dateDescriptor = { type: 'past', number: 3, unit: 'day' };
+    const out = compileFilterGroup({
+      logic: '$and',
+      items: [
+        { path: 'lockedTs', operator: '$dateOn', value: dateDescriptor },
+        { path: 'lockReason', operator: '$in', value: ['abuse', 'spam'] },
+      ],
+    });
+    expect(out).toEqual({
+      $and: [{ lockedTs: { $dateOn: dateDescriptor } }, { lockReason: { $in: ['abuse', 'spam'] } }],
+    });
+  });
+});

package/src/components/form/filter/index.ts

@@ -0,0 +1,13 @@
+/**
+ * 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.
+ */
+
+// Higher-level filter compositions for non-schema surfaces (settings pages, panels, side drawers). The low-level primitives — `FilterContainer`, `FilterGroup`, `FilterItem`, `fieldsToOptions`, `useFilterOptions` — live under `src/flow/components/filter/`; this layer composes them with a `Collection` binding and exposes the hook/component pair callers actually reach for. The dependency direction is form/filter → flow/components/filter only.
+export { CollectionFilter } from './CollectionFilter';
+export type { CollectionFilterProps } from './CollectionFilter';
+export type { CompiledFilter } from './useFilterActionProps';

package/src/components/form/filter/useFilterActionProps.ts

@@ -0,0 +1,200 @@
+/**
+ * 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 { Collection, observable } from '@nocobase/flow-engine';
+import { useMemoizedFn } from 'ahooks';
+import { useMemo, useRef } from 'react';
+import { FilterOption, useFilterOptions, UseFilterOptionsArgs } from '../../../flow/components/filter/useFilterOptions';
+import { CollectionFilterItemValue, createCollectionFilterItem } from './CollectionFilterItem';
+
+/** A single condition row (`{ path, operator, value }`) or a nested group. */
+export type FilterGroupItem = CollectionFilterItemValue | FilterGroupValue;
+
+/**
+ * Reactive shape consumed by `FilterContainer` / `FilterGroup`. `logic` is the join (`$and` / `$or`) and `items` is a heterogeneous list of leaf conditions and nested groups.
+ */
+export type FilterGroupValue = {
+  logic: '$and' | '$or';
+  items: FilterGroupItem[];
+};
+
+/** Compiled filter param accepted by NocoBase resource `list`. */
+export type CompiledFilter = Record<string, unknown> | undefined;
+
+interface FilterCtxModel {
+  translate: (key: string) => string;
+  dispatchEvent: (event: 'submit' | 'reset' | (string & {})) => void;
+}
+
+export interface FilterCtx {
+  model: FilterCtxModel;
+}
+
+const isGroup = (item: FilterGroupItem): item is FilterGroupValue =>
+  Array.isArray((item as FilterGroupValue).items) && typeof (item as FilterGroupValue).logic === 'string';
+
+const isCondition = (item: FilterGroupItem): item is CollectionFilterItemValue =>
+  typeof (item as CollectionFilterItemValue).path === 'string' &&
+  Object.prototype.hasOwnProperty.call(item, 'operator');
+
+/**
+ * `true` when the rhs of a condition is "no real value yet" — covers `undefined` / `null` / empty string / empty array / empty plain object. Mirrors v1's `removeNullCondition` `isEmpty` predicate so half-filled rows ("Locked time → is → (no date picked yet)") get dropped on Submit instead of being sent to the server as `{lockedTs:{}}` and triggering a 500.
+ */
+const isEmptyFilterValue = (value: unknown): boolean => {
+  if (value === undefined || value === null || value === '') return true;
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === 'object') {
+    // Plain `{}` only — descriptor shapes like `{ type: 'today' }` have own keys and survive this check.
+    return Object.keys(value as Record<string, unknown>).length === 0;
+  }
+  return false;
+};
+
+/**
+ * Build a nested object from a dotted path. `'user.createdBy.password'` + `{ $includes: '123' }` becomes `{ user: { createdBy: { password: { $includes: '123' } } } }`. Matches v1's filter payload shape so server-side filter resolution sees the same association chain whether the request came from a v1 or v2 page.
+ */
+const nestPath = (path: string, leaf: unknown): Record<string, unknown> => {
+  const segments = path.split('.');
+  let result: unknown = leaf;
+  for (let i = segments.length - 1; i >= 0; i--) {
+    result = { [segments[i]]: result };
+  }
+  return result as Record<string, unknown>;
+};
+
+/**
+ * Compile a reactive filter group into the `{ $and: [{ path: { op: val } }] }` envelope accepted by NocoBase's resource `list` filter param. Returns `undefined` when the group is empty so callers can drop the param.
+ *
+ * Mirrors v1's `removeNullCondition` + filter compile path, but works on the v2 `{ logic, items }` group structure rather than v1's Formily-bracketed `$and.0.path.$eq` shape:
+ *
+ * - Rows missing `path` or `operator` are dropped (still mid-edit).
+ * - Rows whose `value` is empty (`undefined`, `''`, `[]`, `{}`) are dropped — matches v1, which sends `filter={}` for a row with only a field/operator picked. Sending `{lockedTs:{}}` would 500.
+ * - Dotted association paths (`user.createdBy.password`) are expanded into nested objects — matches v1's payload shape, which the server resolves along the association chain rather than treating the dotted string as a single key.
+ * - Empty groups (after pruning) propagate as `undefined` so the outermost caller can drop the whole `filter` param.
+ */
+export function compileFilterGroup(group: FilterGroupValue | undefined): CompiledFilter {
+  if (!group?.items?.length) return undefined;
+  const compiled = group.items
+    .map((entry) => {
+      if (isGroup(entry)) return compileFilterGroup(entry);
+      if (!isCondition(entry) || !entry.path || !entry.operator) return undefined;
+      if (isEmptyFilterValue(entry.value)) return undefined;
+      return nestPath(entry.path, { [entry.operator]: entry.value });
+    })
+    .filter((v): v is Record<string, unknown> => !!v);
+  if (!compiled.length) return undefined;
+  return { [group.logic]: compiled };
+}
+
+const createEmptyGroup = (): FilterGroupValue => ({ logic: '$and', items: [] });
+
+/** Which footer button triggered the apply — useful for closing a popover on Submit but keeping it open on Reset. */
+export type FilterApplyAction = 'submit' | 'reset';
+
+export interface UseFilterActionPropsArgs extends UseFilterOptionsArgs {
+  /** Collection whose fields populate the filter row's field picker. */
+  collection: Collection | undefined;
+  /**
+   * Called when the user submits or resets the filter popover. Receives the compiled filter param (`undefined` when cleared) and which footer button triggered the call. Typical implementation: `(filter, action) => { listRequest.run(filter); if (action === 'submit') closePopover(); }`.
+   */
+  onApply: (filter: CompiledFilter, action: FilterApplyAction) => void;
+}
+
+export interface UseFilterActionPropsResult {
+  /**
+   * Reactive filter group state. Pass directly to `<FilterContent value={...}>`. Stable across renders.
+   */
+  value: FilterGroupValue;
+  /** Field-option tree (for inspection or custom badges). */
+  options: FilterOption[];
+  /** Bound `FilterItem` component to plug into `<FilterContent FilterItem={...}>`. */
+  FilterItem: ReturnType<typeof createCollectionFilterItem> | undefined;
+  /**
+   * Ready-to-use `ctx` for `<FilterContent ctx={...}>`. Wires Submit / Reset buttons to `onSubmit` / `onReset` below.
+   */
+  ctx: FilterCtx;
+  /** Imperative trigger — submit current group as a compiled filter. */
+  onSubmit: () => void;
+  /** Imperative trigger — clear the group and emit an empty filter. */
+  onReset: () => void;
+  /**
+   * Count of top-level condition rows. Useful for showing a badge like `Filter (3)` on the trigger button — matches v1's `field.title = t('{{count}} filter items', { count })`.
+   */
+  conditionCount: number;
+}
+
+/**
+ * v2 equivalent of v1's `useFilterActionProps` for non-schema surfaces (settings pages, panels, side drawers). Bundles three things v1's hook returned implicitly through schema:
+ *
+ * - A reactive `{ logic, items }` group state that `<FilterContent>` reads.
+ * - A bound `FilterItem` component (driven by `createCollectionFilterItem`).
+ * - A `ctx` object that turns `<FilterContent>`'s `dispatchEvent('submit' | 'reset')` into a compiled filter param passed to `onApply`.
+ *
+ * Pair with antd `Popover` to recreate the legacy `Filter.Action` UX:
+ *
+ * ```tsx
+ * const { value, ctx, FilterItem, onSubmit, conditionCount } = useFilterActionProps({
+ *   collection,
+ *   onApply: (filter) => listRequest.run(filter),
+ *   t,
+ * });
+ * return (
+ *   <Popover content={<FilterContent value={value} ctx={ctx} FilterItem={FilterItem} />}>
+ *     <Button>{t('Filter')}{conditionCount ? ` (${conditionCount})` : ''}</Button>
+ *   </Popover>
+ * );
+ * ```
+ */
+export function useFilterActionProps(args: UseFilterActionPropsArgs): UseFilterActionPropsResult {
+  const { collection, onApply, filterableFieldNames, noIgnore, t } = args;
+
+  // Held in a ref so the group object identity is stable for the lifetime of the host component — `<FilterContent>` mutates this object directly (push/splice on `items`, swap `logic`), and a fresh observable on every render would reset that internal state.
+  const valueRef = useRef<FilterGroupValue>();
+  if (!valueRef.current) {
+    valueRef.current = observable(createEmptyGroup()) as FilterGroupValue;
+  }
+  const value = valueRef.current;
+
+  const options = useFilterOptions(collection, { filterableFieldNames, noIgnore, t });
+
+  const FilterItem = useMemo(
+    () => (collection ? createCollectionFilterItem(collection, { filterableFieldNames, noIgnore, t }) : undefined),
+    [collection, filterableFieldNames, noIgnore, t],
+  );
+
+  const onSubmit = useMemoizedFn(() => {
+    onApply(compileFilterGroup(value), 'submit');
+  });
+
+  const onReset = useMemoizedFn(() => {
+    value.logic = '$and';
+    value.items = [];
+    onApply(undefined, 'reset');
+  });
+
+  const translate = useMemoizedFn((key: string) => (t ? t(key) : key));
+
+  const ctx = useMemo<FilterCtx>(
+    () => ({
+      model: {
+        translate,
+        dispatchEvent: (event: string) => {
+          if (event === 'submit') onSubmit();
+          else if (event === 'reset') onReset();
+        },
+      },
+    }),
+    [translate, onSubmit, onReset],
+  );
+
+  // Re-read on each render so `observer`-wrapped hosts re-render when the reactive `items` array length changes. No useMemo needed — the `value` object's identity is stable (held in a ref), but its observable `items.length` is what we actually care about, and the eslint exhaustive-deps rule rightly complains about depending on a mutable property of a stable ref.
+  const conditionCount = value.items.length;
+
+  return { value, options, FilterItem, ctx, onSubmit, onReset, conditionCount };
+}

package/src/components/form/index.tsx

@@ -8,6 +8,7 @@
  */
 
 export * from './createFormRegistry';
+export * from './filter';
 export * from './DialogFormLayout';
 export * from './DrawerFormLayout';
 export * from './EnvVariableInput';

package/src/data-source/ExtendCollectionsProvider.tsx

@@ -0,0 +1,70 @@
+/**
+ * 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 type { CollectionOptions } from '@nocobase/flow-engine';
+import React, { FC, ReactNode, useEffect, useRef } from 'react';
+import { useApp } from '../hooks';
+
+export interface ExtendCollectionsProviderProps {
+  /** Data source key to extend. Defaults to `'main'`. */
+  dataSource?: string;
+  /** Collections to surface for the lifetime of this provider's subtree. */
+  collections: CollectionOptions[];
+  children?: ReactNode;
+}
+
+/**
+ * Mount-scoped collection injector. Adds the given `collections` to the target data source on mount and removes them on unmount. Survives mid-session reloads via `dataSource:loaded` events.
+ *
+ * Use this for client-only collections — e.g. a `schema-only` server collection that isn't auto-published to the v2 data source, or a pure UI-side mirror — so downstream components (like `<CollectionFilter>`) can resolve the collection by name.
+ */
+export const ExtendCollectionsProvider: FC<ExtendCollectionsProviderProps> = ({
+  dataSource = 'main',
+  collections,
+  children,
+}) => {
+  const app = useApp();
+  const ownedRef = useRef<Set<string>>(new Set());
+
+  const apply = () => {
+    const ds = app.dataSourceManager?.getDataSource?.(dataSource);
+    if (!ds) return;
+    for (const collection of collections) {
+      if (ds.getCollection?.(collection.name)) continue;
+      ds.addCollection?.(collection);
+      ownedRef.current.add(collection.name);
+    }
+  };
+
+  apply();
+
+  useEffect(() => {
+    const onLoaded = (event: Event) => {
+      const key = (event as CustomEvent<{ dataSourceKey: string }>).detail?.dataSourceKey;
+      if (key === dataSource || key === '*') apply();
+    };
+    app.eventBus?.addEventListener('dataSource:loaded', onLoaded);
+
+    return () => {
+      app.eventBus?.removeEventListener('dataSource:loaded', onLoaded);
+      const ds = app.dataSourceManager?.getDataSource?.(dataSource);
+      const owned = ownedRef.current;
+      ownedRef.current = new Set();
+      if (!ds) return;
+      for (const name of owned) {
+        ds.removeCollection?.(name);
+      }
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [app, dataSource, collections]);
+
+  return <>{children}</>;
+};
+
+export default ExtendCollectionsProvider;

package/src/data-source/index.ts

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ */
+
+export * from './ExtendCollectionsProvider';

package/src/flow/components/filter/index.ts

@@ -15,3 +15,6 @@ export { VariableFilterItem } from './VariableFilterItem';
 export type { VariableFilterItemProps, VariableFilterItemValue } from './VariableFilterItem';
 export { LinkageFilterItem } from './LinkageFilterItem';
 export type { LinkageFilterItemProps, LinkageFilterItemValue } from './LinkageFilterItem';
+export { useFilterOptions } from './useFilterOptions';
+export type { FilterOption, UseFilterOptionsArgs } from './useFilterOptions';
+// Higher-level filter compositions (`CollectionFilterItem`, `useFilterActionProps`, `createCollectionFilterItem`) live under `src/components/form/filter/`. They compose these flow primitives on top of a `Collection` binding — the dependency direction is form/filter → flow/components/filter, never the reverse.

package/src/flow/components/filter/useFilterOptions.ts

@@ -0,0 +1,80 @@
+/**
+ * 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 type { Collection } from '@nocobase/flow-engine';
+import { useMemo } from 'react';
+import { fieldsToOptions } from './fieldsToOptions';
+
+/**
+ * One operator entry on a `FilterOption`. Mirrors v1's interface-defined operator shape so the v2 filter value renderer can pick up the same per-operator value-side schema (e.g. datetime operators wanting the smart date picker, array/enum operators wanting a tag-mode Select).
+ */
+export type FilterOperator = {
+  value: string;
+  label: string;
+  /**
+   * Per-operator override for the value-side renderer. Wins over the field's own `uiSchema` when set. The `x-component` string is looked up against the v2 filter component registry.
+   */
+  schema?: { 'x-component'?: string; 'x-component-props'?: Record<string, any> } & Record<string, any>;
+  /** Operator takes no right-hand value (e.g. `$empty`, `$notEmpty`). */
+  noValue?: boolean;
+  [key: string]: any;
+};
+
+/** Single field-tree node returned by `useFilterOptions`. */
+export type FilterOption = {
+  name: string;
+  type?: string;
+  target?: string;
+  title: string;
+  schema?: Record<string, any>;
+  operators?: FilterOperator[];
+  children?: FilterOption[];
+};
+
+export interface UseFilterOptionsArgs {
+  /**
+   * Whitelist of root-level field names to expose. Empty/undefined means "all filterable fields". The whitelist applies only at depth 1 — nested fields under an allowed association field are always included, matching the legacy v1 `Filter.Action` behaviour.
+   */
+  filterableFieldNames?: string[];
+  /** Bypass the `filterableFieldNames` whitelist (mirrors v1 `noIgnore`). */
+  noIgnore?: boolean;
+  /** Translator used for field/operator labels. Defaults to identity. */
+  t?: (key: string) => string;
+}
+
+const identity = (s: string) => s;
+
+/**
+ * v2 equivalent of v1's `useFilterOptions`/`useFilterFieldOptions`. Walks a `Collection`'s fields and returns the nested option tree consumed by antd `Cascader` in `CollectionFilterItem` (and any other v2 filter surface that wants the same field picker).
+ *
+ * Mirrors v1 in two ways that matter:
+ * - association fields (belongsTo / hasMany / m2m / etc.) are kept and recursed into via `fieldsToOptions`'s `nested` branch — so picking `user.username` is a first-class action, just like the legacy cascader.
+ * - the whitelist applies at depth 1 only, so capping the root field list (e.g. to `['lockedTs', 'unlockTs', 'user']`) doesn't accidentally hide the nested `user.username` / `user.nickname` leaves.
+ */
+export function useFilterOptions(collection: Collection | undefined, args: UseFilterOptionsArgs = {}): FilterOption[] {
+  const { filterableFieldNames, noIgnore = false, t = identity } = args;
+
+  const fields = useMemo(() => collection?.getFields() || [], [collection]);
+
+  const ignoreFieldsNames = useMemo(() => {
+    if (noIgnore || !filterableFieldNames?.length) return [];
+    return fields.map((f) => f.name).filter((n) => !filterableFieldNames.includes(n));
+  }, [fields, filterableFieldNames, noIgnore]);
+
+  return useMemo(
+    () =>
+      fieldsToOptions(
+        fields.filter((field) => field.target !== 'attachments' && field.interface !== 'formula'),
+        1,
+        ignoreFieldsNames,
+        t,
+      ).filter(Boolean) as FilterOption[],
+    [fields, ignoreFieldsNames, t],
+  );
+}

package/src/index.ts

@@ -32,6 +32,7 @@ export * from './nocobase-buildin-plugin';
 export * from './collection-field-interface/CollectionFieldInterface';
 export * from './collection-field-interface/CollectionFieldInterfaceManager';
 export * from './collection-manager/interfaces';
+export * from './data-source';
 export * from './flow';
 export { DEFAULT_DATA_SOURCE_KEY, isTitleField, isTitleFieldInterface } from './flow-compat';
 export { default as AntdAppProvider } from './theme/AntdAppProvider';

package/src/nocobase-buildin-plugin/index.tsx

@@ -64,15 +64,9 @@ export function useCurrentUserContext() {
 }
 
 /**
- * 返回当前用户在 v2 应用上下文中可选的角色列表，等价于 v1 `useCurrentRoles`：
- * 从 FlowEngine 全局上下文 `engine.context.user.roles` 派生（CurrentUserProvider 在
- * `/auth:check` 成功后通过 `defineProperty('user', { value })` 写入），按需追加匿名角色，
- * 并去掉合并角色 `__union__`。v2 中角色 title 可能含有 `{{t('...')}}` 模板，因此用
- * flowEngine.context.t 解析。
+ * 返回当前用户在 v2 应用上下文中可选的角色列表，等价于 v1 `useCurrentRoles`：从 FlowEngine 全局上下文 `engine.context.user.roles` 派生（CurrentUserProvider 在 `/auth:check` 成功后通过 `defineProperty('user', { value })` 写入），按需追加匿名角色，并去掉合并角色 `__union__`。v2 中角色 title 可能含有 `{{t('...')}}` 模板，因此用 flowEngine.context.t 解析。
  *
- * 不读 React `CurrentUserContext`：FlowEngine 的 dialog/drawer/popover 内容通过 `ctx.viewer`
- * 渲染到独立的 ElementsHolder，部分场景会脱离原 Provider 树；FlowEngine 全局上下文是同一份
- * 数据但不受 React 树位置影响。
+ * 不读 React `CurrentUserContext`：FlowEngine 的 dialog/drawer/popover 内容通过 `ctx.viewer` 渲染到独立的 ElementsHolder，部分场景会脱离原 Provider 树；FlowEngine 全局上下文是同一份数据但不受 React 树位置影响。
  */
 export function useCurrentRoles(): CurrentRoleOption[] {
   const { allowAnonymous } = useACLRoleContext();
@@ -183,10 +177,7 @@ const CurrentUserProvider: FC = ({ children }) => {
         });
 
         const user = res?.data?.data;
-        // 服务端通过 `{ code: 302, redirect }` 通知客户端先去某个中间页(例如 2FA 验证页)。
-        // 这类响应没有 user.id,但也不能视为未登录——否则会和处理 302 的全局响应拦截器
-        // (例如 plugin-two-factor-authentication 注册的那一个)竞态,而 `window.location.replace`
-        // 会覆盖更早发出的 `window.location.href`,把用户错误地弹回登录页。让响应拦截器接管跳转。
+        // 服务端通过 `{ code: 302, redirect }` 通知客户端先去某个中间页(例如 2FA 验证页)。这类响应没有 user.id,但也不能视为未登录——否则会和处理 302 的全局响应拦截器 (例如 plugin-two-factor-authentication 注册的那一个)竞态,而 `window.location.replace` 会覆盖更早发出的 `window.location.href`,把用户错误地弹回登录页。让响应拦截器接管跳转。
         if (user?.code === 302) {
           if (mounted) {
             setState({ loading: false });
@@ -194,9 +185,7 @@ const CurrentUserProvider: FC = ({ children }) => {
           return;
         }
         if (user?.id == null) {
-          // 用 react-router navigate (虚拟跳转)而不是 location.replace, 这样如果有其他响应拦截器
-          // 已经发起了 window.location.href 整页跳转(例如 2FA 插件接收到服务端 302 重定向),
-          // 真实跳转可以胜出 navigate, 不会被这里的 signin 重定向覆盖。
+          // 用 react-router navigate (虚拟跳转)而不是 location.replace, 这样如果有其他响应拦截器已经发起了 window.location.href 整页跳转(例如 2FA 插件接收到服务端 302 重定向), 真实跳转可以胜出 navigate, 不会被这里的 signin 重定向覆盖。
           navigate(`/signin?redirect=${encodeURIComponent(getCurrentV2RedirectPath(app, locationRef.current))}`, {
             replace: true,
           });
@@ -256,8 +245,7 @@ const RootRedirect: FC = () => {
   const targetPath = getDefaultV2AdminRedirectPath(app);
 
   if (!hasToken) {
-    // 用 react-router <Navigate /> 而非 location.replace, 避免覆盖同时段其它响应拦截器
-    // 触发的 window.location.href (例如 2FA 接收到服务端 302 时设置的整页跳转)。
+    // 用 react-router <Navigate /> 而非 location.replace, 避免覆盖同时段其它响应拦截器触发的 window.location.href (例如 2FA 接收到服务端 302 时设置的整页跳转)。
     return <Navigate replace to={`/signin?redirect=${encodeURIComponent(targetPath)}`} />;
   }
 
@@ -267,8 +255,7 @@ const RootRedirect: FC = () => {
 /**
  * client-v2 使用的内建插件集合。
  *
- * 只迁移当前 v2 运行时仍然需要的部分，显式跳过 schemaInitializerManager
- * 以及用户标注暂不迁移的旧插件注册逻辑。
+ * 只迁移当前 v2 运行时仍然需要的部分，显式跳过 schemaInitializerManager 以及用户标注暂不迁移的旧插件注册逻辑。
  */
 export class NocoBaseBuildInPlugin extends Plugin<any, Application> {
   async afterAdd() {
@@ -317,6 +304,13 @@ export class NocoBaseBuildInPlugin extends Plugin<any, Application> {
       aclSnippet: 'pm.system-settings.system-settings',
       sort: -100,
     });
+    // Parent menu for security-related plugin settings (password policy, locked users, etc.). Registered here in the buildin plugin so any pro plugin can attach page tabs to `menuKey: 'security'` without each one re-registering the same parent.
+    this.app.pluginSettingsManager.addMenuItem({
+      key: 'security',
+      title: this.app.i18n.t('Security'),
+      icon: 'SafetyOutlined',
+      aclSnippet: 'pm.security',
+    });
   }
 
   addRoutes() {

package/src/nocobase-buildin-plugin/plugins/LocalePlugin.ts

@@ -39,6 +39,7 @@ export class LocalePlugin extends Plugin {
 
       if (data.lang) {
         api.auth.setLocale(data.lang);
+        this.app.setDocumentLanguage(data.lang);
         this.app.i18n.changeLanguage(data.lang);
       }