@nocobase/client-v2 2.2.0-alpha.7 → 2.2.0-alpha.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/client-v2",
-  "version": "2.2.0-alpha.7",
+  "version": "2.2.0-alpha.8",
   "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.2.0-alpha.7",
-    "@nocobase/flow-engine": "2.2.0-alpha.7",
-    "@nocobase/sdk": "2.2.0-alpha.7",
-    "@nocobase/shared": "2.2.0-alpha.7",
-    "@nocobase/utils": "2.2.0-alpha.7",
+    "@nocobase/evaluators": "2.2.0-alpha.8",
+    "@nocobase/flow-engine": "2.2.0-alpha.8",
+    "@nocobase/sdk": "2.2.0-alpha.8",
+    "@nocobase/shared": "2.2.0-alpha.8",
+    "@nocobase/utils": "2.2.0-alpha.8",
     "ahooks": "^3.7.2",
     "antd": "5.24.2",
     "antd-style": "3.7.1",
@@ -47,5 +47,5 @@
     "react-i18next": "^11.15.1",
     "react-router-dom": "^6.30.1"
   },
-  "gitHead": "34ba02960fca9ab0b6881d3db7040a8a64067bba"
+  "gitHead": "810c81e5963966bda7ec03b6453a3a80fe60e027"
 }

package/src/BaseApplication.tsx

@@ -35,6 +35,7 @@ import { SystemSettingsSource } from './flow/system-settings';
 import { LayoutManager } from './layout-manager/LayoutManager';
 import type { PluginClass, PluginManager, PluginType } from './PluginManager';
 import { RouteRepository } from './RouteRepository';
+import { stripModernClientPrefix } from './authRedirect';
 import type {
   ComponentTypeAndString,
   RenderableComponentType,
@@ -402,7 +403,7 @@ export abstract class BaseApplication<
       this.favicon = favicon || '';
     }
 
-    const iconHref = this.favicon || '/favicon/favicon.ico';
+    const iconHref = this.favicon || this.getCdnUrl() + 'favicon/favicon.ico';
 
     if (faviconLinkElement) {
       faviconLinkElement.href = iconHref;
@@ -438,7 +439,7 @@ export abstract class BaseApplication<
   }
 
   getCdnUrl() {
-    return ensureTrailingSlash(window['__webpack_public_path__'] || this.getPublicPath());
+    return ensureTrailingSlash(window['__webpack_public_path__'] || stripModernClientPrefix(this.getPublicPath()));
   }
 
   getPublicPath() {

package/src/__tests__/app.test.tsx

@@ -35,6 +35,7 @@ describe('app', () => {
       document.querySelectorAll('link[rel="shortcut icon"]').forEach((node) => node.remove());
       document.documentElement.removeAttribute('lang');
       delete window['__webpack_public_path__'];
+      delete window['__nocobase_modern_client_prefix__'];
       vi.restoreAllMocks();
     });
 
@@ -84,6 +85,34 @@ describe('app', () => {
       expect(app.getCdnUrl()).toBe('/cdn/assets/');
     });
 
+    it('should remove the modern client prefix from the CDN fallback path', () => {
+      const app = new Application({
+        router,
+        publicPath: '/v/',
+      });
+
+      expect(app.getCdnUrl()).toBe('/');
+    });
+
+    it('should preserve APP_PUBLIC_PATH when removing the modern client prefix', () => {
+      const app = new Application({
+        router,
+        publicPath: '/nocobase/v/',
+      });
+
+      expect(app.getCdnUrl()).toBe('/nocobase/');
+    });
+
+    it('should support a custom modern client prefix', () => {
+      window['__nocobase_modern_client_prefix__'] = 'modern';
+      const app = new Application({
+        router,
+        publicPath: '/nocobase/modern/',
+      });
+
+      expect(app.getCdnUrl()).toBe('/nocobase/');
+    });
+
     it('should apply the provided favicon immediately', () => {
       const app = new Application({ router });
 

package/src/components/form/TypedVariableInput.tsx

@@ -121,12 +121,15 @@ function normalizeTypes(types: TypedConstantSpec[]): NormalizedType[] {
   );
 }
 
-function defaultValueFor(type: TypedConstantType): unknown {
+function defaultValueFor(type: TypedConstantType, typedProps: Record<string, unknown> = {}): unknown {
   switch (type) {
     case 'string':
       return '';
-    case 'number':
+    case 'number': {
+      const min = typeof typedProps.min === 'number' ? typedProps.min : undefined;
+      if (min !== undefined && min > 0) return min;
       return 0;
+    }
     case 'boolean':
       return false;
     case 'date': {
@@ -433,7 +436,7 @@ export function TypedVariableInput(props: TypedVariableInputProps) {
       return undefined;
     }
     const firstType = normalizedTypes[0];
-    return firstType ? defaultValueFor(firstType.type) : undefined;
+    return firstType ? defaultValueFor(firstType.type, firstType.props) : undefined;
   }, [defaultToFirstConstantTypeWhenUndefined, normalizedTypes, value, variableOnly]);
   const effectiveValue = value === undefined && defaultedValue !== undefined ? defaultedValue : value;
   const detected = useMemo(() => detectMode(effectiveValue, parseVariablePath), [effectiveValue, parseVariablePath]);
@@ -529,7 +532,8 @@ export function TypedVariableInput(props: TypedVariableInputProps) {
         const targetType = (path[1] as TypedConstantType | undefined) ?? normalizedTypes[0]?.type;
         if (!targetType) return;
         if (detected.mode === targetType) return;
-        onChange?.(defaultValueFor(targetType));
+        const target = normalizedTypes.find(({ type }) => type === targetType);
+        onChange?.(defaultValueFor(targetType, target?.props));
         return;
       }
       const leaf = selectedOptions?.[selectedOptions.length - 1] as SwitcherOption | undefined;
@@ -548,7 +552,7 @@ export function TypedVariableInput(props: TypedVariableInputProps) {
     }
     const first = normalizedTypes[0];
     if (first) {
-      onChange?.(defaultValueFor(first.type));
+      onChange?.(defaultValueFor(first.type, first.props));
       return;
     }
     if (nullable) {
@@ -585,11 +589,11 @@ export function TypedVariableInput(props: TypedVariableInputProps) {
     if (variableOnly) {
       return undefined;
     }
-    if (isNull) {
+    if (isNull && nullable) {
       return [NULL_KEY];
     }
     return [CONST_KEY, constantTypeForRendering];
-  }, [constantTypeForRendering, detected.variablePath, isNull, isVariable, variableOnly]);
+  }, [constantTypeForRendering, detected.variablePath, isNull, isVariable, nullable, variableOnly]);
 
   // Preload a saved variable's label path across lazy levels. `resolveVariableLabels` can only read already-loaded
   // `children`; when a saved reference points below a node whose children are still a lazy thunk (e.g. a relation field
@@ -734,7 +738,7 @@ export function TypedVariableInput(props: TypedVariableInputProps) {
             </div>
           ) : variableOnly ? (
             <Input placeholder={placeholder} readOnly disabled={disabled} style={{ width: '100%' }} />
-          ) : isNull ? (
+          ) : isNull && nullable ? (
             // v1 used the `placeholder` slot (not `value`) so the antd default placeholder colour applies — keeps the
             // field looking visibly empty/inactive rather than holding a real text value.
             <Input placeholder={`<${t('Null')}>`} readOnly disabled={disabled} style={{ width: '100%' }} />

package/src/components/form/__tests__/TypedVariableInput.test.tsx

@@ -81,6 +81,27 @@ describe('TypedVariableInput - constant rendering', () => {
     expect(screen.getByRole('button', { name: 'variable-switcher' }).className).not.toContain('ant-btn-primary');
   });
 
+  it('keeps the number editor usable when value=null and nullable=false', async () => {
+    const ctx = createContextWithEnv();
+    const handleChange = vi.fn();
+    renderWithCtx(
+      ctx,
+      <TypedVariableInput
+        value={null}
+        types={[['number', { min: 1 }]]}
+        namespaces={['$env']}
+        nullable={false}
+        onChange={handleChange}
+      />,
+    );
+
+    const numberInput = await screen.findByRole('spinbutton');
+    expect(screen.queryByPlaceholderText('<Null>')).toBeNull();
+    fireEvent.change(numberInput, { target: { value: '2' } });
+    fireEvent.blur(numberInput);
+    expect(handleChange).toHaveBeenCalledWith(2);
+  });
+
   it('defaults undefined to the first constant type', async () => {
     const ctx = createContextWithEnv();
     const handleChange = vi.fn();
@@ -102,6 +123,26 @@ describe('TypedVariableInput - constant rendering', () => {
     });
   });
 
+  it('uses a positive numeric minimum as the default value', async () => {
+    const ctx = createContextWithEnv();
+    const handleChange = vi.fn();
+    renderWithCtx(
+      ctx,
+      <TypedVariableInput
+        value={undefined}
+        types={[['number', { min: 1 }]]}
+        namespaces={['$env']}
+        nullable={false}
+        onChange={handleChange}
+      />,
+    );
+
+    expect(await screen.findByDisplayValue('1')).toBeInTheDocument();
+    await waitFor(() => {
+      expect(handleChange).toHaveBeenCalledWith(1);
+    });
+  });
+
   it('can still opt out to keep the null placeholder for undefined', async () => {
     const ctx = createContextWithEnv();
     renderWithCtx(
@@ -183,14 +224,14 @@ describe('TypedVariableInput - variable rendering', () => {
     expect(handleChange).toHaveBeenCalledWith(0);
   });
 
-  it('clears back to default-of-first-type when nullable=false', async () => {
+  it('clears back to the valid minimum of the first type when nullable=false', async () => {
     const ctx = createContextWithEnv();
     const handleChange = vi.fn();
     const { container } = renderWithCtx(
       ctx,
       <TypedVariableInput
         value="{{$env.SMTP_PORT}}"
-        types={['number']}
+        types={[['number', { min: 1 }]]}
         namespaces={['$env']}
         nullable={false}
         onChange={handleChange}
@@ -199,7 +240,7 @@ describe('TypedVariableInput - variable rendering', () => {
     const clear = container.querySelector('button.clear-button') as HTMLButtonElement | null;
     expect(clear).not.toBeNull();
     fireEvent.click(clear as HTMLButtonElement);
-    expect(handleChange).toHaveBeenCalledWith(0);
+    expect(handleChange).toHaveBeenCalledWith(1);
   });
 
   it('treats types=[] as variable-only mode with a readonly placeholder before selection', async () => {

package/src/flow/actions/__tests__/linkageRulesRefresh.test.ts

@@ -135,11 +135,15 @@ describe('linkageRulesRefresh action', () => {
     expect(handler).toHaveBeenCalledWith(ctx, { value: ['master-mounted'] });
   });
 
-  it('runs linkage action on master model when forks exist in design mode', async () => {
+  it('skips master model when forks can handle flow in design mode', async () => {
     const handler = vi.fn(async () => {});
     const model: any = {
       isFork: false,
-      forks: new Set([{}]),
+      forks: new Set([
+        {
+          getFlow: vi.fn(() => ({})),
+        },
+      ]),
       getFlow: vi.fn(() => ({})),
       getStepParams: vi.fn(() => ({ value: ['master'] })),
       context: {
@@ -157,7 +161,7 @@ describe('linkageRulesRefresh action', () => {
       flowKey: 'buttonSettings',
     });
 
-    expect(handler).toHaveBeenCalledWith(ctx, { value: ['master'] });
+    expect(handler).not.toHaveBeenCalled();
   });
 
   it('runs linkage action on fork model and resolves params', async () => {

package/src/flow/actions/linkageRulesRefresh.tsx

@@ -35,12 +35,8 @@ export const linkageRulesRefresh = defineAction({
     // Prefer running on the current model; fallback to blockModel when the current model doesn't own the flow.
     if (!hasFlow) return;
 
-    // In runtime, only skip master when there are mounted forks that can handle the same flow.
+    // Skip master when unmounted forks can handle the same flow.
     // Otherwise master is likely the rendered model and still needs refresh.
-    // In design mode, always refresh master so the currently edited model state stays in sync.
-    const flowSettingsEnabled = Boolean(
-      (ctx as any)?.flowSettingsEnabled || (model as any)?.context?.flowSettingsEnabled,
-    );
     const hasForkWithFlow =
       !model?.isFork &&
       !!model?.forks?.size &&
@@ -49,7 +45,7 @@ export const linkageRulesRefresh = defineAction({
         return !!fork?.getFlow?.(flowKey);
       });
     const isMasterMounted = Boolean((model as any)?.context?.ref?.current);
-    if (hasForkWithFlow && !isMasterMounted && !flowSettingsEnabled) {
+    if (hasForkWithFlow && !isMasterMounted) {
       return;
     }
 

package/src/flow/components/FieldAssignValueInput.tsx

@@ -42,6 +42,12 @@ import { normalizeFilterValueByOperator } from '../models/blocks/filter-form/val
 import { FieldAssignExactDatePicker, type ExactDatePickerMode } from './FieldAssignExactDatePicker';
 import { limitAssociationMetaTree } from './filter/metaTreeAssociationDepth';
 
+type VariableInputConverters = {
+  renderInputComponent?: (metaTreeNode: MetaTreeNode | null) => React.ComponentType<any> | null;
+  resolvePathFromValue?: (value: any) => string[] | undefined;
+  resolveValueFromPath?: (metaTreeNode: MetaTreeNode) => any;
+};
+
 const DATE_FIELD_INTERFACES = new Set(['date', 'datetime', 'datetimeNoTz', 'createdAt', 'updatedAt', 'unixTimestamp']);
 
 const TZ_AWARE_DATE_INTERFACES = new Set(['datetime', 'createdAt', 'updatedAt', 'unixTimestamp']);
@@ -345,6 +351,7 @@ interface Props {
   allowRunJS?: boolean;
   maxAssociationFieldDepth?: number;
   disabled?: boolean;
+  variableConverters?: VariableInputConverters;
 }
 
 type ResolvedFieldContext = {
@@ -718,6 +725,7 @@ export const FieldAssignValueInput: React.FC<Props> = ({
   allowRunJS = true,
   maxAssociationFieldDepth = 2,
   disabled = false,
+  variableConverters,
 }) => {
   const flowCtx = useFlowContext<FlowModelContext>();
   const normalizeEventValue = React.useCallback((eventOrValue: unknown) => {
@@ -1511,7 +1519,12 @@ export const FieldAssignValueInput: React.FC<Props> = ({
       clearValue={''}
       disabled={disabled}
       converters={{
+        ...variableConverters,
         renderInputComponent: (meta) => {
+          const external = variableConverters?.renderInputComponent?.(meta ?? null);
+          if (external) {
+            return external;
+          }
           const firstPath = meta?.paths?.[0];
           if (firstPath === 'constant') return ConstantEditor;
           if (firstPath === 'null') return NullComponent;
@@ -1519,6 +1532,10 @@ export const FieldAssignValueInput: React.FC<Props> = ({
           return null;
         },
         resolveValueFromPath: (item) => {
+          const external = variableConverters?.resolveValueFromPath?.(item);
+          if (external !== undefined) {
+            return external;
+          }
           const firstPath = item?.paths?.[0];
           if (firstPath === 'constant') {
             return useDateVariableConstant ? { type: 'today' } : '';
@@ -1528,6 +1545,10 @@ export const FieldAssignValueInput: React.FC<Props> = ({
           return undefined;
         },
         resolvePathFromValue: (currentValue) => {
+          const external = variableConverters?.resolvePathFromValue?.(currentValue);
+          if (external !== undefined) {
+            return external;
+          }
           if (currentValue === null) return ['null'];
           if (allowRunJS && isRunJSValue(currentValue)) return ['runjs'];
           if (useDateVariableConstant && isCtxDateExpression(currentValue)) {

package/src/flow/components/__tests__/FieldAssignValueInput.context.test.tsx

@@ -12,9 +12,10 @@ import { describe, expect, it, vi } from 'vitest';
 import { render, waitFor } from '@nocobase/test/client';
 import { FieldAssignValueInput } from '../FieldAssignValueInput';
 
-const { mockUseFlowContext, mockGetDefaultBindingByField } = vi.hoisted(() => ({
+const { mockUseFlowContext, mockGetDefaultBindingByField, mockVariableInput } = vi.hoisted(() => ({
   mockUseFlowContext: vi.fn(),
   mockGetDefaultBindingByField: vi.fn(),
+  mockVariableInput: vi.fn(() => <div data-testid="variable-input" />),
 }));
 
 vi.mock('@nocobase/flow-engine', async () => {
@@ -25,7 +26,7 @@ vi.mock('@nocobase/flow-engine', async () => {
   return {
     ...actual,
     useFlowContext: () => mockUseFlowContext(),
-    VariableInput: () => <div data-testid="variable-input" />,
+    VariableInput: mockVariableInput,
     FlowModelRenderer: () => <div data-testid="flow-model-renderer" />,
     EditableItemModel: MockEditableItemModel,
   };
@@ -131,4 +132,85 @@ describe('FieldAssignValueInput context', () => {
     });
     expect(engine.createModel).toHaveBeenCalledWith(expect.any(Object), { delegate: sourceContext });
   });
+
+  it('lets callers override variable path parsing for domain-specific stored formats', async () => {
+    mockVariableInput.mockClear();
+    const sourceContext = {
+      dataSourceManager: {
+        getDataSource: vi.fn(() => ({})),
+      },
+      t: (key: string) => key,
+    };
+    const fieldModel = {
+      props: {},
+      setProps: vi.fn(),
+      dispatchEvent: vi.fn(),
+      remove: vi.fn(),
+    };
+    const tempRoot = {
+      context: {
+        defineProperty: vi.fn(),
+      },
+      subModels: {
+        fields: [fieldModel],
+      },
+      setProps: vi.fn(),
+      remove: vi.fn(),
+    };
+    const engine = {
+      createModel: vi.fn(() => tempRoot),
+    };
+    const collectionField = {
+      name: 'status',
+      interface: 'input',
+      uiSchema: { 'x-component': 'Input' },
+      isAssociationField: () => false,
+      getComponentProps: () => ({}),
+    };
+    const collection = {
+      dataSourceKey: 'main',
+      name: 'tasks',
+      getField: (name: string) => (name === 'status' ? collectionField : null),
+      getFields: () => [collectionField],
+    };
+    const formModel = {
+      context: { ...sourceContext, engine, collection, blockModel: null as any },
+      collection,
+      subModels: {},
+    };
+    formModel.context.blockModel = formModel;
+
+    mockGetDefaultBindingByField.mockReturnValue({ modelName: 'InputFieldModel' });
+    mockUseFlowContext.mockReturnValue({
+      model: formModel,
+      t: (key: string) => key,
+      getPropertyMetaTree: vi.fn(async () => []),
+    });
+
+    const variableConverters = {
+      resolvePathFromValue: vi.fn((value: string) =>
+        value === '{{$context.data.updatedAt}}' ? ['$context', 'data', 'updatedAt'] : undefined,
+      ),
+      resolveValueFromPath: vi.fn(() => undefined),
+    };
+
+    render(
+      <FieldAssignValueInput
+        targetPath="status"
+        value="{{$context.data.updatedAt}}"
+        onChange={vi.fn()}
+        variableConverters={variableConverters}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(engine.createModel).toHaveBeenCalled();
+    });
+    const latestVariableInputCall = mockVariableInput.mock.calls.at(-1)?.[0];
+    expect(latestVariableInputCall.converters.resolvePathFromValue('{{$context.data.updatedAt}}')).toEqual([
+      '$context',
+      'data',
+      'updatedAt',
+    ]);
+  });
 });

package/src/flow/components/filter/FilterGroup.tsx

@@ -45,6 +45,7 @@ interface FilterGroupProps {
   value: Record<string, any>;
   /** 自定义筛选项组件 */
   FilterItem?: React.FC<FilterItemProps>;
+  disabled?: boolean;
   closeIcon?: ReactNode;
   /** 是否显示边框 */
   showBorder?: boolean;
@@ -89,6 +90,7 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
     const {
       value = { logic: '$and', items: [] },
       FilterItem,
+      disabled = false,
       showBorder = false,
       onRemove,
       onChange,
@@ -120,11 +122,17 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
         };
 
     const handleLogicChange = (newLogic: '$and' | '$or') => {
+      if (disabled) {
+        return;
+      }
       value.logic = newLogic;
       onChange?.(value);
     };
 
     const handleAddCondition = () => {
+      if (disabled) {
+        return;
+      }
       items.push({
         path: '',
         operator: '',
@@ -134,6 +142,9 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
     };
 
     const handleAddConditionGroup = () => {
+      if (disabled) {
+        return;
+      }
       items.push({
         logic: '$and',
         items: [],
@@ -142,6 +153,9 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
     };
 
     const handleRemoveItem = (index: number) => {
+      if (disabled) {
+        return;
+      }
       items.splice(index, 1);
       onChange?.(value);
     };
@@ -160,11 +174,12 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
           <button
             type="button"
             aria-label="icon-close"
+            disabled={disabled}
             style={{
               position: 'absolute',
               right: 10,
               top: 10,
-              cursor: 'pointer',
+              cursor: disabled ? 'not-allowed' : 'pointer',
               background: 'transparent',
               border: 0,
               padding: 0,
@@ -182,6 +197,7 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
               data-testid="filter-select-all-or-any"
               style={{ width: 'auto' }}
               value={logic}
+              disabled={disabled}
               onChange={handleLogicChange}
             >
               <Select.Option value="$and">{t('All')}</Select.Option>
@@ -200,6 +216,7 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
                   key={getFilterItemKey(item)}
                   value={item}
                   FilterItem={FilterItem}
+                  disabled={disabled}
                   showBorder={true}
                   onRemove={() => handleRemoveItem(index)}
                   onChange={(v) => {
@@ -221,11 +238,12 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
                       <button
                         type="button"
                         aria-label="icon-close"
+                        disabled={disabled}
                         style={{
                           marginLeft: 8,
                           marginRight: 8,
                           flex: '0 0 auto',
-                          cursor: 'pointer',
+                          cursor: disabled ? 'not-allowed' : 'pointer',
                           background: 'transparent',
                           border: 0,
                           padding: 0,
@@ -251,11 +269,12 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
                       <button
                         type="button"
                         aria-label="icon-close"
+                        disabled={disabled}
                         style={{
                           marginLeft: 8,
                           marginRight: 8,
                           flex: '0 0 auto',
-                          cursor: 'pointer',
+                          cursor: disabled ? 'not-allowed' : 'pointer',
                           background: 'transparent',
                           border: 0,
                           padding: 0,
@@ -277,11 +296,12 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
                     <button
                       type="button"
                       aria-label="icon-close"
+                      disabled={disabled}
                       style={{
                         marginLeft: 8,
                         marginRight: 8,
                         flex: '0 0 auto',
-                        cursor: 'pointer',
+                        cursor: disabled ? 'not-allowed' : 'pointer',
                         background: 'transparent',
                         border: 0,
                         padding: 0,
@@ -298,7 +318,14 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
         </div>
 
         <Space size={16} style={{ marginTop: 8, marginBottom: 8 }}>
-          <Button style={{ padding: 0 }} type="link" size="small" icon={<PlusOutlined />} onClick={handleAddCondition}>
+          <Button
+            style={{ padding: 0 }}
+            type="link"
+            size="small"
+            icon={<PlusOutlined />}
+            onClick={handleAddCondition}
+            disabled={disabled}
+          >
             {t('Add condition')}
           </Button>
           <Button
@@ -307,6 +334,7 @@ export const FilterGroup: FC<FilterGroupProps> = observer(
             size="small"
             icon={<PlusOutlined />}
             onClick={handleAddConditionGroup}
+            disabled={disabled}
           >
             {t('Add condition group')}
           </Button>