@nocobase/client-v2 2.1.0-alpha.46 → 2.1.0-alpha.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/client-v2",
-  "version": "2.1.0-alpha.46",
+  "version": "2.1.0-alpha.47",
   "license": "Apache-2.0",
   "main": "lib/index.js",
   "module": "es/index.mjs",
@@ -27,11 +27,11 @@
     "@formily/antd-v5": "1.2.3",
     "@formily/react": "^2.2.27",
     "@formily/shared": "^2.2.27",
-    "@nocobase/evaluators": "2.1.0-alpha.46",
-    "@nocobase/flow-engine": "2.1.0-alpha.46",
-    "@nocobase/sdk": "2.1.0-alpha.46",
-    "@nocobase/shared": "2.1.0-alpha.46",
-    "@nocobase/utils": "2.1.0-alpha.46",
+    "@nocobase/evaluators": "2.1.0-alpha.47",
+    "@nocobase/flow-engine": "2.1.0-alpha.47",
+    "@nocobase/sdk": "2.1.0-alpha.47",
+    "@nocobase/shared": "2.1.0-alpha.47",
+    "@nocobase/utils": "2.1.0-alpha.47",
     "ahooks": "^3.7.2",
     "antd": "5.24.2",
     "antd-style": "3.7.1",
@@ -45,5 +45,5 @@
     "react-i18next": "^11.15.1",
     "react-router-dom": "^6.30.1"
   },
-  "gitHead": "42b269944cdd1908d7a848c0af4936fe94c03bb7"
+  "gitHead": "66196b57f9043ea0ac6ebdafbc732bfb98af1396"
 }

package/src/__tests__/browserChecker.test.ts

@@ -0,0 +1,103 @@
+/**
+ * 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 { readFileSync } from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+type BrowserCheckerCase = {
+  pathname: string;
+  publicPath: string;
+  expectedRedirect?: string;
+};
+
+const testDir = path.dirname(fileURLToPath(import.meta.url));
+const browserCheckerCases = [
+  {
+    label: 'v2 public browser-checker',
+    scriptPath: path.resolve(testDir, '../../../app/client-v2/public/browser-checker.js'),
+  },
+  {
+    label: 'v1 public browser-checker',
+    scriptPath: path.resolve(testDir, '../../../app/client/public/browser-checker.js'),
+  },
+] as const;
+
+function executeBrowserChecker(scriptPath: string, input: BrowserCheckerCase) {
+  const replace = vi.fn();
+  const consoleMock = {
+    debug: vi.fn(),
+    log: vi.fn(),
+  };
+  const context = {
+    showLog: false,
+    window: {
+      __nocobase_public_path__: input.publicPath,
+      location: {
+        origin: 'http://c.local.nocobase.com',
+        pathname: input.pathname,
+        search: '',
+        hash: '',
+        replace,
+      },
+      console: consoleMock,
+      outerWidth: 1280,
+      outerHeight: 720,
+      devicePixelRatio: 1,
+      onresize: undefined,
+    },
+    document: {
+      documentElement: {
+        className: '',
+        clientWidth: 1280,
+        clientHeight: 720,
+      },
+    },
+    navigator: {
+      userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 14_0) AppleWebKit/537.36 Chrome/126.0 Safari/537.36',
+    },
+    console: consoleMock,
+  };
+
+  vm.runInNewContext(readFileSync(scriptPath, 'utf8'), context, {
+    filename: scriptPath,
+  });
+
+  return replace;
+}
+
+describe.each(browserCheckerCases)('$label', ({ scriptPath }) => {
+  it('normalizes a relative public path before redirecting to the trailing-slash entry', () => {
+    const replace = executeBrowserChecker(scriptPath, {
+      pathname: '/nocobase/v',
+      publicPath: 'nocobase/v/',
+    });
+
+    expect(replace).toHaveBeenCalledWith('http://c.local.nocobase.com/nocobase/v/');
+  });
+
+  it('prefixes outside paths with a root-relative basename instead of duplicating a relative segment', () => {
+    const replace = executeBrowserChecker(scriptPath, {
+      pathname: '/foo',
+      publicPath: 'nocobase/v/',
+    });
+
+    expect(replace).toHaveBeenCalledWith('http://c.local.nocobase.com/nocobase/v/foo');
+  });
+
+  it('does not redirect when the current path is already under the normalized basename', () => {
+    const replace = executeBrowserChecker(scriptPath, {
+      pathname: '/nocobase/v/',
+      publicPath: 'nocobase/v/',
+    });
+
+    expect(replace).not.toHaveBeenCalled();
+  });
+});

package/src/__tests__/dataSourceRuntime.test.tsx

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { createMockClient } from '@nocobase/client-v2';
+import { CollectionFieldInterface, createMockClient } from '@nocobase/client-v2';
 import { describe, expect, it } from 'vitest';
 
 class InputInterface {
@@ -16,6 +16,12 @@ class InputInterface {
   titleUsable = true;
 }
 
+class OperatorOnlyInterface extends CollectionFieldInterface {
+  name = 'operatorOnly';
+  group = 'basic';
+  filterable = {};
+}
+
 describe('data source runtime', () => {
   it('shares one dataSourceManager instance between app and flow context', () => {
     const app = createMockClient();
@@ -31,4 +37,19 @@ describe('data source runtime', () => {
 
     expect(app.dataSourceManager.collectionFieldInterfaceManager.getFieldInterface('input')?.titleUsable).toBe(true);
   });
+
+  it('exposes operators registered on interfaces without predefined operator lists', () => {
+    const app = createMockClient();
+    const operator = {
+      label: 'plugin operator',
+      value: '$plugin',
+      schema: { 'x-component': 'PluginInput' },
+    };
+
+    app.addFieldInterfaces([OperatorOnlyInterface as any]);
+    app.addFieldInterfaceOperator('operatorOnly', operator);
+
+    const fieldInterface = app.dataSourceManager.collectionFieldInterfaceManager.getFieldInterface('operatorOnly');
+    expect(fieldInterface?.filterable?.operators).toEqual([operator]);
+  });
 });

package/src/collection-field-interface/CollectionFieldInterface.ts

@@ -14,7 +14,6 @@ import type { ComponentType, ReactNode } from 'react';
 
 import {
   normalizeFilterableOperators,
-  resolveFilterOperators,
   type FieldFilterable,
   type FieldFilterOperator,
 } from '../collection-manager/filter-operators';
@@ -181,14 +180,22 @@ export abstract class CollectionFieldInterface {
   }
 
   addOperator(operatorOption: FieldFilterOperator) {
-    normalizeFilterableOperators(this.filterable);
-    const operators = [...resolveFilterOperators(this.filterable?.operators)];
-    set(this, 'filterable.operators', operators);
+    if (!this.filterable) {
+      set(this, 'filterable', {});
+    }
 
-    if (operators.find((item) => item.value === operatorOption.value)) {
-      return;
+    const operatorOverrides = Array.isArray(this.filterable.operatorOverrides)
+      ? [...this.filterable.operatorOverrides]
+      : [];
+
+    const existingIndex = operatorOverrides.findIndex((item) => item.value === operatorOption.value);
+    if (existingIndex !== -1) {
+      operatorOverrides[existingIndex] = operatorOption;
+    } else {
+      operatorOverrides.push(operatorOption);
     }
 
-    operators.push(operatorOption);
+    set(this, 'filterable.operatorOverrides', operatorOverrides);
+    normalizeFilterableOperators(this.filterable);
   }
 }

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

@@ -23,6 +23,7 @@ export type FieldFilterOperatorList<TMeta = unknown> = FieldFilterOperator<TMeta
 export type FieldFilterable<TMeta = unknown> = {
   operators?: FieldFilterOperatorList<TMeta>;
   operatorGroup?: string;
+  operatorOverrides?: FieldFilterOperator<TMeta>[];
   children?: unknown[];
   nested?: boolean;
   [key: string]: unknown;
@@ -120,14 +121,20 @@ export function normalizeFilterableOperators<TMeta = unknown>(filterable?: Field
     return filterable;
   }
 
+  const operatorOverrides = Array.isArray(filterable.operatorOverrides) ? filterable.operatorOverrides : [];
+
   if (filterable.operatorGroup) {
-    filterable.operators = resolveFilterOperators(filterable.operatorGroup);
+    filterable.operators = mergeOperatorOverrides(resolveFilterOperators(filterable.operatorGroup), operatorOverrides);
   }
 
   const rawOperators = (filterable as { operators?: unknown }).operators;
   if (typeof rawOperators === 'string') {
     filterable.operatorGroup = rawOperators;
-    filterable.operators = resolveFilterOperators(rawOperators);
+    filterable.operators = mergeOperatorOverrides(resolveFilterOperators(rawOperators), operatorOverrides);
+  } else if (Array.isArray(rawOperators)) {
+    filterable.operators = mergeOperatorOverrides(rawOperators, operatorOverrides);
+  } else if (operatorOverrides.length > 0) {
+    filterable.operators = [...operatorOverrides];
   }
 
   if (Array.isArray(filterable.children)) {
@@ -141,6 +148,26 @@ export function normalizeFilterableOperators<TMeta = unknown>(filterable?: Field
   return filterable;
 }
 
+function mergeOperatorOverrides<TMeta = unknown>(
+  operators: FieldFilterOperator<TMeta>[] = [],
+  operatorOverrides: FieldFilterOperator<TMeta>[] = [],
+) {
+  if (operatorOverrides.length === 0) {
+    return operators;
+  }
+
+  const result = [...operators];
+  operatorOverrides.forEach((operatorOverride) => {
+    const existingIndex = result.findIndex((item) => item.value === operatorOverride.value);
+    if (existingIndex === -1) {
+      result.push(operatorOverride);
+    } else {
+      result[existingIndex] = operatorOverride;
+    }
+  });
+  return result;
+}
+
 export function createFilterable<TPreset extends FieldFilterOperatorGroupName>(
   preset: TPreset,
   options: Omit<FieldFilterable, 'operators'> = {},

package/src/components/form/filter/CollectionFilterItem.tsx

@@ -8,7 +8,7 @@
  */
 
 import { css } from '@emotion/css';
-import { Collection, observer } from '@nocobase/flow-engine';
+import { Collection, observer, useFlowEngine } from '@nocobase/flow-engine';
 import { Cascader, Select, Space } from 'antd';
 import React, { FC, useMemo } from 'react';
 import { FilterOption, useFilterOptions } from '../../../flow/components/filter/useFilterOptions';
@@ -56,6 +56,8 @@ export interface CollectionFilterItemProps {
   noIgnore?: boolean;
   /** Translator; defaults to identity so callers can omit it. */
   t?: (key: string) => string;
+  /** Optional v2 app registry used to resolve plugin-provided operator components. */
+  app?: { getComponent?: (name: string) => React.ComponentType<any> | undefined };
 }
 
 const identity = (s: string) => s;
@@ -94,6 +96,8 @@ export const CollectionFilterItem: FC<CollectionFilterItemProps> = observer(
   (props) => {
     const { collection, filterableFieldNames, nonfilterableFieldNames, noIgnore = false, t = identity } = props;
     const { path: leftValue, operator, value: rightValue } = props.value;
+    const flowEngine = useFlowEngine({ throwError: false }) as any;
+    const app = props.app || flowEngine?.context?.app;
 
     const options = useFilterOptions(collection, { filterableFieldNames, nonfilterableFieldNames, noIgnore, t });
 
@@ -160,6 +164,7 @@ export const CollectionFilterItem: FC<CollectionFilterItemProps> = observer(
           onChange={handleValueChange}
           placeholder={t('Enter value')}
           t={t}
+          app={app}
         />
       </Space>
     );
@@ -172,7 +177,10 @@ export const CollectionFilterItem: FC<CollectionFilterItemProps> = observer(
  */
 export function createCollectionFilterItem(
   collection: Collection,
-  bound?: Pick<CollectionFilterItemProps, 'filterableFieldNames' | 'nonfilterableFieldNames' | 'noIgnore' | 't'>,
+  bound?: Pick<
+    CollectionFilterItemProps,
+    'filterableFieldNames' | 'nonfilterableFieldNames' | 'noIgnore' | 't' | 'app'
+  >,
 ) {
   const Component: FC<{ value: CollectionFilterItemValue }> = (props) => (
     <CollectionFilterItem {...bound} value={props.value} collection={collection} />

package/src/components/form/filter/FilterValueInput.tsx

@@ -13,6 +13,10 @@ import type { FilterOperator, FilterOption } from '../../../flow/components/filt
 import { PasswordInput } from '../PasswordInput';
 import { DateFilterDynamicComponent } from './DateFilterDynamicComponent';
 
+type ComponentRegistryApp = {
+  getComponent?: (name: string) => React.ComponentType<any> | undefined;
+};
+
 export interface FilterValueInputProps {
   /** The currently selected leaf field option from the field picker. */
   field?: FilterOption;
@@ -26,17 +30,20 @@ export interface FilterValueInputProps {
   t?: (key: string) => string;
   /** Optional placeholder for the fallback `Input`. */
   placeholder?: string;
+  /** Optional v2 app registry used to resolve plugin-provided operator components. */
+  app?: ComponentRegistryApp;
 }
 
 const identity = (s: string) => s;
 
 type EffectiveSchema = {
-  'x-component'?: string;
+  'x-component'?: string | React.ComponentType<any>;
   'x-component-props'?: Record<string, any>;
   enum?: Array<{ value: any; label: string }> | any[];
 };
 
 const baseStyle = { minWidth: 200 } as const;
+const fallbackInputComponents = new Set(['Input', 'Input.URL', 'NanoIDInput']);
 
 /** Resolve operator-level schema → field uiSchema → fallback Input. */
 const resolveSchema = (field?: FilterOption, operator?: FilterOperator): EffectiveSchema => {
@@ -54,7 +61,7 @@ const resolveSchema = (field?: FilterOption, operator?: FilterOperator): Effecti
  * Interface-aware value renderer for filter rows. Returns `null` for `noValue` operators (`$empty`, `$notEmpty`). Otherwise dispatches the effective `x-component` (operator schema > field uiSchema > Input) to a small registry of antd controls.
  */
 export const FilterValueInput: React.FC<FilterValueInputProps> = (props) => {
-  const { field, operator, value, onChange, t = identity, placeholder } = props;
+  const { field, operator, value, onChange, t = identity, placeholder, app } = props;
 
   if (operator?.noValue) {
     return null;
@@ -64,6 +71,12 @@ export const FilterValueInput: React.FC<FilterValueInputProps> = (props) => {
   const componentName = schema['x-component'];
   const componentProps = schema['x-component-props'] || {};
   const enumOptions = (schema as any).enum || (field?.schema as any)?.enum;
+  const customComponentProps = {
+    value,
+    onChange,
+    ...componentProps,
+    style: { ...baseStyle, ...(componentProps.style || {}) },
+  };
 
   switch (componentName) {
     case 'DateFilterDynamicComponent':
@@ -183,6 +196,18 @@ export const FilterValueInput: React.FC<FilterValueInputProps> = (props) => {
     case 'Input.URL':
     case 'NanoIDInput':
     default:
+      if (typeof componentName === 'function') {
+        const Component = componentName;
+        return <Component {...customComponentProps} />;
+      }
+
+      if (typeof componentName === 'string' && !fallbackInputComponents.has(componentName)) {
+        const Component = app?.getComponent?.(componentName);
+        if (Component) {
+          return <Component {...customComponentProps} />;
+        }
+      }
+
       return (
         <Input
           value={value}

package/src/components/form/filter/__tests__/FilterValueInput.test.tsx

@@ -222,6 +222,45 @@ describe('FilterValueInput schema precedence', () => {
     expect(document.querySelector('.ant-select')).not.toBeNull();
   });
 
+  it('operator schema can render an app-registered custom component', () => {
+    const onChange = vi.fn();
+    const CustomFilterInput = (props: any) => (
+      <button
+        type="button"
+        data-testid="custom-filter-input"
+        data-field-interface={props.fieldInterface}
+        data-value={JSON.stringify(props.value)}
+        onClick={() => props.onChange?.(['alpha', 'beta'])}
+      >
+        custom-filter-input
+      </button>
+    );
+
+    render(
+      <FilterValueInput
+        operator={opOf({
+          value: '$in',
+          schema: {
+            'x-component': 'MultipleKeywordsInput',
+            'x-component-props': { fieldInterface: 'input' },
+          },
+        })}
+        value={['foo', 'bar']}
+        onChange={onChange}
+        app={{
+          getComponent: (name) => (name === 'MultipleKeywordsInput' ? CustomFilterInput : undefined),
+        }}
+      />,
+    );
+
+    const input = screen.getByTestId('custom-filter-input');
+    expect(input.getAttribute('data-field-interface')).toBe('input');
+    expect(input.getAttribute('data-value')).toBe(JSON.stringify(['foo', 'bar']));
+
+    fireEvent.click(input);
+    expect(onChange).toHaveBeenCalledWith(['alpha', 'beta']);
+  });
+
   it('field uiSchema is used when operator has none', () => {
     const { container } = render(
       <FilterValueInput