@nocobase/client-v2 2.1.0-beta.24 → 2.1.0-beta.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/client-v2",
-  "version": "2.1.0-beta.24",
+  "version": "2.1.0-beta.25",
   "license": "Apache-2.0",
   "main": "lib/index.js",
   "module": "es/index.mjs",
@@ -24,9 +24,10 @@
     "@formily/antd-v5": "1.2.3",
     "@formily/react": "^2.2.27",
     "@formily/shared": "^2.2.27",
-    "@nocobase/flow-engine": "2.1.0-beta.24",
-    "@nocobase/sdk": "2.1.0-beta.24",
-    "@nocobase/shared": "2.1.0-beta.24",
+    "@nocobase/flow-engine": "2.1.0-beta.25",
+    "@nocobase/sdk": "2.1.0-beta.25",
+    "@nocobase/shared": "2.1.0-beta.25",
+    "ahooks": "^3.7.2",
     "antd": "5.24.2",
     "classnames": "^2.3.1",
     "dayjs": "^1.11.10",
@@ -35,5 +36,5 @@
     "react-i18next": "^11.15.1",
     "react-router-dom": "^6.30.1"
   },
-  "gitHead": "f77b85530a2d127d9bfe4dca3a26fbb02c1139ba"
+  "gitHead": "824f8b8200e9fe086135768934d3ef427b212446"
 }

package/src/BaseApplication.tsx

@@ -189,6 +189,7 @@ export abstract class BaseApplication<
     this.configureContext();
     this.addBaseProviders();
     this.addCustomProviders();
+    this.addFinalProviders();
     this.addReactRouterComponents();
     this.addProviders(options.providers || []);
     this.ws = this.createWebSocketClient(options);
@@ -338,6 +339,9 @@ export abstract class BaseApplication<
     this.use(FlowEngineProvider, { engine: this.flowEngine });
     this.use(GlobalThemeProvider);
     this.use(AntdAppProvider);
+  }
+
+  protected addFinalProviders() {
     this.use(FlowEngineGlobalsContextProvider);
   }
 

package/src/__tests__/globalDeps.test.ts

@@ -23,5 +23,6 @@ describe('client-v2 defineGlobalDeps', () => {
     expect(define).toHaveBeenCalledWith('@nocobase/utils/client', expect.any(Function));
     expect(define).toHaveBeenCalledWith('@nocobase/client-v2', expect.any(Function));
     expect(define).toHaveBeenCalledWith('@nocobase/flow-engine', expect.any(Function));
+    expect(define).toHaveBeenCalledWith('ahooks', expect.any(Function));
   });
 });

package/src/__tests__/remotePlugins.test.ts

@@ -8,6 +8,7 @@
  */
 
 import { Plugin } from '../Plugin';
+import { getRequireJs } from '../utils/requirejs';
 import { defineDevPlugins, definePluginClient, getPlugins } from '../utils/remotePlugins';
 
 describe('client-v2 remotePlugins', () => {
@@ -69,4 +70,30 @@ describe('client-v2 remotePlugins', () => {
     expect(mockDefine).toHaveBeenCalledWith('@nocobase/demo/client-v2', expect.any(Function));
     expect(mockDefine).not.toHaveBeenCalledWith('@nocobase/demo/client', expect.any(Function));
   });
+
+  it('should not append duplicate .js for plugin URLs without query strings', () => {
+    const requirejs = getRequireJs();
+
+    requirejs.requirejs.config({
+      paths: {
+        '@nocobase/demo': '/static/plugins/@nocobase/demo/dist/client-v2/index.js',
+      },
+    });
+
+    expect(requirejs.requirejs.toUrl('@nocobase/demo')).toBe('/static/plugins/@nocobase/demo/dist/client-v2/index.js');
+  });
+
+  it('should keep hashed plugin URLs unchanged', () => {
+    const requirejs = getRequireJs();
+
+    requirejs.requirejs.config({
+      paths: {
+        '@nocobase/demo': '/static/plugins/@nocobase/demo/dist/client-v2/index.js?hash=12345678',
+      },
+    });
+
+    expect(requirejs.requirejs.toUrl('@nocobase/demo')).toBe(
+      '/static/plugins/@nocobase/demo/dist/client-v2/index.js?hash=12345678',
+    );
+  });
 });

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

@@ -0,0 +1,158 @@
+/**
+ * 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, vi } from 'vitest';
+import { dataScope } from '../dataScope';
+import { normalizeDataScopeFilter } from '../dataScopeFilter';
+import { setTargetDataScope } from '../setTargetDataScope';
+
+describe('normalizeDataScopeFilter', () => {
+  it('keeps null when a right-side variable resolves to empty', () => {
+    const rawFilter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.formValues.department.id }}' }],
+    };
+    const resolvedFilter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: undefined }],
+    };
+
+    expect(normalizeDataScopeFilter(rawFilter, resolvedFilter)).toEqual({
+      $and: [{ departmentId: { $eq: null } }],
+    });
+  });
+
+  it('keeps null when a right-side variable resolves to an empty string', () => {
+    const rawFilter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.formValues.department.id }}' }],
+    };
+    const resolvedFilter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: '' }],
+    };
+
+    expect(normalizeDataScopeFilter(rawFilter, resolvedFilter)).toEqual({
+      $and: [{ departmentId: { $eq: null } }],
+    });
+  });
+
+  it('still prunes empty constant values', () => {
+    const filter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: undefined }],
+    };
+
+    expect(normalizeDataScopeFilter(filter, filter)).toBeUndefined();
+  });
+
+  it('handles nested groups and keeps non-empty values unchanged', () => {
+    const rawFilter = {
+      logic: '$and',
+      items: [
+        { path: 'status', operator: '$eq', value: 'active' },
+        {
+          logic: '$or',
+          items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.formValues.department.id }}' }],
+        },
+      ],
+    };
+    const resolvedFilter = {
+      logic: '$and',
+      items: [
+        { path: 'status', operator: '$eq', value: 'active' },
+        {
+          logic: '$or',
+          items: [{ path: 'departmentId', operator: '$eq', value: null }],
+        },
+      ],
+    };
+
+    expect(normalizeDataScopeFilter(rawFilter, resolvedFilter)).toEqual({
+      $and: [{ status: { $eq: 'active' } }, { $or: [{ departmentId: { $eq: null } }] }],
+    });
+  });
+
+  it('does not preserve explicit null constants', () => {
+    const filter = {
+      logic: '$and',
+      items: [{ path: 'departmentId', operator: '$eq', value: null }],
+    };
+
+    expect(normalizeDataScopeFilter(filter, filter)).toBeUndefined();
+  });
+
+  it('dataScope handler sends null for empty variable dependencies', async () => {
+    const resource = {
+      addFilterGroup: vi.fn(),
+      removeFilterGroup: vi.fn(),
+    };
+    const ctx = {
+      model: {
+        uid: 'field-1',
+        resource,
+      },
+      resolveJsonTemplate: vi.fn(async (template) => ({
+        ...template,
+        items: [{ ...template.items[0], value: undefined }],
+      })),
+    };
+    const params = {
+      filter: {
+        logic: '$and',
+        items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.formValues.department.id }}' }],
+      },
+    };
+
+    await (dataScope as any).handler(ctx, params);
+
+    expect(resource.addFilterGroup).toHaveBeenCalledWith('field-1', {
+      $and: [{ departmentId: { $eq: null } }],
+    });
+    expect(resource.removeFilterGroup).not.toHaveBeenCalled();
+  });
+
+  it('setTargetDataScope handler sends null for empty variable dependencies', async () => {
+    const resource = {
+      addFilterGroup: vi.fn(),
+      removeFilterGroup: vi.fn(),
+      hasData: vi.fn(() => false),
+      refresh: vi.fn(),
+    };
+    const targetModel = { resource };
+    const ctx = {
+      model: {
+        uid: 'action-1',
+        scheduleModelOperation: vi.fn((_uid, callback) => callback(targetModel)),
+      },
+      resolveJsonTemplate: vi.fn(async (template) => ({
+        ...template,
+        filter: {
+          ...template.filter,
+          items: [{ ...template.filter.items[0], value: undefined }],
+        },
+      })),
+    };
+    const params = {
+      targetBlockUid: 'target-1',
+      filter: {
+        logic: '$and',
+        items: [{ path: 'departmentId', operator: '$eq', value: '{{ ctx.formValues.department.id }}' }],
+      },
+    };
+
+    await (setTargetDataScope as any).handler(ctx, params);
+
+    expect(ctx.model.scheduleModelOperation).toHaveBeenCalledWith('target-1', expect.any(Function));
+    expect(resource.addFilterGroup).toHaveBeenCalledWith('setTargetDataScope_action-1', {
+      $and: [{ departmentId: { $eq: null } }],
+    });
+    expect(resource.removeFilterGroup).not.toHaveBeenCalled();
+  });
+});

package/src/flow/actions/dataScope.tsx

@@ -7,12 +7,12 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { defineAction, MultiRecordResource, pruneFilter, tExpr, useFlowSettingsContext } from '@nocobase/flow-engine';
-import { isEmptyFilter, transformFilter } from '@nocobase/utils/client';
-import _ from 'lodash';
+import { defineAction, MultiRecordResource, tExpr, useFlowSettingsContext } from '@nocobase/flow-engine';
+import { isEmptyFilter } from '@nocobase/utils/client';
 import React from 'react';
 import { FilterGroup, VariableFilterItem } from '../components/filter';
 import { FieldModel } from '../models/base/FieldModel';
+import { normalizeDataScopeFilter } from './dataScopeFilter';
 
 export const dataScope = defineAction({
   name: 'dataScope',
@@ -43,6 +43,7 @@ export const dataScope = defineAction({
       filter: { logic: '$and', items: [] },
     };
   },
+  useRawParams: true,
   async handler(ctx, params) {
     // @ts-ignore
     const resource = ctx.model?.resource as MultiRecordResource;
@@ -50,7 +51,8 @@ export const dataScope = defineAction({
       return;
     }
 
-    const filter = pruneFilter(transformFilter(params.filter));
+    const resolvedFilter = await ctx.resolveJsonTemplate(params.filter);
+    const filter = normalizeDataScopeFilter(params.filter, resolvedFilter);
 
     if (isEmptyFilter(filter)) {
       resource.removeFilterGroup(ctx.model.uid);

package/src/flow/actions/dataScopeFilter.ts

@@ -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 { isVariableExpression, pruneFilter } from '@nocobase/flow-engine';
+import { transformFilter } from '@nocobase/utils/client';
+import _ from 'lodash';
+
+const PRESERVE_NULL = { __nocobaseDataScopeNull__: true };
+
+function isPreserveNull(value: any) {
+  return (
+    value &&
+    typeof value === 'object' &&
+    !Array.isArray(value) &&
+    value.__nocobaseDataScopeNull__ === true &&
+    Object.keys(value).length === 1
+  );
+}
+
+function restorePreservedNull(value: any): any {
+  if (isPreserveNull(value)) {
+    return null;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => restorePreservedNull(item));
+  }
+  if (value && typeof value === 'object') {
+    return Object.keys(value).reduce<Record<string, any>>((result, key) => {
+      result[key] = restorePreservedNull(value[key]);
+      return result;
+    }, {});
+  }
+  return value;
+}
+
+function markEmptyVariableValues(rawNode: any, resolvedNode: any) {
+  if (!rawNode || !resolvedNode || typeof rawNode !== 'object' || typeof resolvedNode !== 'object') {
+    return;
+  }
+
+  if ('path' in rawNode && 'operator' in rawNode) {
+    if (
+      isVariableExpression(rawNode.value) &&
+      (resolvedNode.value === undefined || resolvedNode.value === null || resolvedNode.value === '')
+    ) {
+      resolvedNode.value = PRESERVE_NULL;
+    }
+    return;
+  }
+
+  if (Array.isArray(rawNode.items) && Array.isArray(resolvedNode.items)) {
+    rawNode.items.forEach((rawItem, index) => {
+      markEmptyVariableValues(rawItem, resolvedNode.items[index]);
+    });
+  }
+}
+
+export function normalizeDataScopeFilter(rawFilter: any, resolvedFilter: any) {
+  const filterForTransform = _.cloneDeep(resolvedFilter);
+  markEmptyVariableValues(rawFilter, filterForTransform);
+
+  const filter = pruneFilter(transformFilter(filterForTransform));
+  return restorePreservedNull(filter);
+}

package/src/flow/actions/setTargetDataScope.tsx

@@ -12,14 +12,13 @@ import {
   defineAction,
   FlowModel,
   MultiRecordResource,
-  pruneFilter,
   useFlowContext,
   tExpr,
 } from '@nocobase/flow-engine';
-import { isEmptyFilter, transformFilter } from '@nocobase/utils/client';
-import _ from 'lodash';
+import { isEmptyFilter } from '@nocobase/utils/client';
 import React from 'react';
 import { FilterGroup, VariableFilterItem } from '../components/filter';
+import { normalizeDataScopeFilter } from './dataScopeFilter';
 
 export const setTargetDataScope = defineAction({
   name: 'setTargetDataScope',
@@ -62,8 +61,10 @@ export const setTargetDataScope = defineAction({
       filter: { logic: '$and', items: [] },
     };
   },
+  useRawParams: true,
   async handler(ctx, params) {
-    const targetBlockUid = params.targetBlockUid;
+    const resolvedParams = await ctx.resolveJsonTemplate(params);
+    const targetBlockUid = resolvedParams.targetBlockUid;
     if (!targetBlockUid) {
       return;
     }
@@ -74,7 +75,7 @@ export const setTargetDataScope = defineAction({
         return;
       }
 
-      const filter = pruneFilter(transformFilter(params.filter));
+      const filter = normalizeDataScopeFilter(params.filter, resolvedParams.filter);
 
       if (isEmptyFilter(filter)) {
         resource.removeFilterGroup(`setTargetDataScope_${ctx.model.uid}`);

package/src/flow/internal/utils/__tests__/rebuildFieldSubModel.test.ts

@@ -35,7 +35,7 @@ describe('rebuildFieldSubModel', () => {
     });
   });
 
-  test('rebuilds field with same uid and updates binding use', async () => {
+  test('rebuilds field with same uid and direct target field model use', async () => {
     const staleClickHandler = () => null;
     const parent = engine.createModel<DummyParentModel>({
       use: DummyParentModel,
@@ -66,7 +66,8 @@ describe('rebuildFieldSubModel', () => {
 
     expect(rebuilt).toBeInstanceOf(DummyTargetFieldModel);
     expect(rebuilt.uid).toBe('field-1');
-    expect(getFieldBindingUse(rebuilt)).toBe('DummyTargetFieldModel');
+    expect(getFieldBindingUse(rebuilt)).toBeUndefined();
+    expect(rebuilt.use).toBe('DummyTargetFieldModel');
     expect(rebuilt.props).toMatchObject({ added: 'yes', pattern: 'readPretty' });
     expect((rebuilt.props as any).onClick).toBeUndefined();
 
@@ -106,4 +107,78 @@ describe('rebuildFieldSubModel', () => {
     expect(Array.isArray(cols)).toBe(true);
     expect(cols.map((c) => c.uid)).toEqual(['col-1', 'col-2']);
   });
+
+  test('preserves compatible step params when rebuilding with the same field model use', async () => {
+    const parent = engine.createModel<DummyParentModel>({
+      use: DummyParentModel,
+      uid: 'parent-3',
+      subModels: {
+        field: {
+          use: DummyTargetFieldModel,
+          uid: 'field-3',
+          stepParams: {
+            fieldSettings: { init: { initKey: true } },
+            displayFieldSettings: {
+              overflowMode: {
+                overflowMode: true,
+              },
+            },
+          } as any,
+        },
+      },
+    });
+
+    await rebuildFieldSubModel({
+      parentModel: parent,
+      targetUse: 'DummyTargetFieldModel',
+      fieldSettingsInit: { fieldPath: 'title' },
+    });
+
+    const rebuilt = parent.subModels.field as DummyTargetFieldModel;
+    expect(rebuilt.stepParams).toEqual({
+      fieldSettings: {
+        init: { fieldPath: 'title' },
+      },
+      displayFieldSettings: {
+        overflowMode: {
+          overflowMode: true,
+        },
+      },
+    });
+  });
+
+  test('drops incompatible step params when rebuilding to a different field model use', async () => {
+    const parent = engine.createModel<DummyParentModel>({
+      use: DummyParentModel,
+      uid: 'parent-4',
+      subModels: {
+        field: {
+          use: FieldModel,
+          uid: 'field-4',
+          stepParams: {
+            fieldBinding: { use: 'FieldModel' },
+            fieldSettings: { init: { initKey: true } },
+            numberSettings: {
+              format: {
+                separator: '0,0.00',
+              },
+            },
+          } as any,
+        },
+      },
+    });
+
+    await rebuildFieldSubModel({
+      parentModel: parent,
+      targetUse: 'DummyTargetFieldModel',
+      fieldSettingsInit: { fieldPath: 'title' },
+    });
+
+    const rebuilt = parent.subModels.field as DummyTargetFieldModel;
+    expect(rebuilt.stepParams).toEqual({
+      fieldSettings: {
+        init: { fieldPath: 'title' },
+      },
+    });
+  });
 });

package/src/flow/internal/utils/rebuildFieldSubModel.ts

@@ -10,8 +10,9 @@
 /**
  * 通用的字段子模型重建工具：
  * - 保留原有 uid
- * - 通过 FieldModel 入口 + fieldBinding.use 动态选择目标字段类
+ * - 直接重建为目标字段类，保持与 defineChildren 初始创建逻辑一致
  * - 支持同步父项模式（pattern）
+ * - 同一字段模型类型下保留已有字段设置；切换到其他字段模型类型时丢弃不兼容设置
  * - 重建后触发 beforeRender（useCache: false）
  */
 import { FieldModel } from '../../models/base/FieldModel';
@@ -39,6 +40,16 @@ type RebuildOptions = {
   fieldSettingsInit?: unknown;
 };
 
+function normalizeModelUse(value: unknown): string | undefined {
+  if (typeof value === 'string') {
+    return value;
+  }
+  if (typeof value === 'function' && value.name) {
+    return value.name;
+  }
+  return undefined;
+}
+
 export function getFieldBindingUse(fieldModel?: FieldModel): string | undefined {
   const bindingUse = (fieldModel?.stepParams as FieldStepParams | undefined)?.fieldBinding?.use;
   return typeof bindingUse === 'string' ? bindingUse : undefined;
@@ -61,13 +72,18 @@ export async function rebuildFieldSubModel({
       delete prevSubModels[key];
     }
   }
-  const prevStepParams: FieldStepParams = (fieldModel?.stepParams as FieldStepParams) || {};
+  const currentUse = normalizeModelUse(getFieldBindingUse(fieldModel) || fieldModel?.use);
+  const shouldPreserveStepParams = currentUse === targetUse;
+  const prevStepParams: FieldStepParams = shouldPreserveStepParams
+    ? (fieldModel?.stepParams as FieldStepParams) || {}
+    : {};
   const nextFieldSettingsInit = fieldSettingsInit ?? parentModel.getFieldSettingsInitParams?.();
+  const { fieldBinding: _fieldBinding, ...restStepParams } = prevStepParams;
 
   const nextStepParams: FieldStepParams = {
-    ...prevStepParams,
-    fieldBinding: { ...prevStepParams.fieldBinding, use: targetUse },
+    ...restStepParams,
     fieldSettings: {
+      ...(restStepParams.fieldSettings || {}),
       init: nextFieldSettingsInit,
     },
   };
@@ -81,7 +97,7 @@ export async function rebuildFieldSubModel({
 
   const subModel = parentModel.setSubModel('field', {
     uid: fieldUid,
-    use: FieldModel,
+    use: targetUse,
     props: { ...(defaultProps || {}), ...(pattern ? { pattern } : {}) },
     stepParams: nextStepParams as StepParams,
     // Preserve existing subModels (e.g. SubTable columns) so switching field component back and forth

package/src/flow/models/blocks/filter-form/FilterFormBlockModel.tsx

@@ -102,15 +102,19 @@ export class FilterFormBlockModel extends FilterBlockModel<{
     // 首次进入页面：等待子模型 beforeRender 完成（例如 name 初始化），再应用表单级默认值并触发筛选
     void this.applyDefaultsAndInitialFilter();
 
-    // 监听页面区块删除，自动清理已失效的筛选字段
+    // 监听页面区块删除，自动清理已失效的筛选字段。
+    // 这里使用 onSubModelDestroyed 而不是 onSubModelRemoved，避免弹窗关闭时
+    // 的临时模型卸载被误判成“用户删除了目标区块”。
     const blockGridModel = this.context.blockGridModel;
     if (blockGridModel?.emitter) {
-      const handleTargetRemoved = (model) => {
+      const handleTargetDestroyed = (model) => {
         if (!model?.uid || model.uid === this.uid) return;
-        this.handleTargetBlockRemoved(model.uid);
+        void this.handleTargetBlockRemoved(model.uid).catch((error) => {
+          console.error('Failed to handle destroyed target block in FilterFormBlockModel:', error);
+        });
       };
-      blockGridModel.emitter.on('onSubModelRemoved', handleTargetRemoved);
-      this.removeTargetBlockListener = () => blockGridModel.emitter.off('onSubModelRemoved', handleTargetRemoved);
+      blockGridModel.emitter.on('onSubModelDestroyed', handleTargetDestroyed);
+      this.removeTargetBlockListener = () => blockGridModel.emitter.off('onSubModelDestroyed', handleTargetDestroyed);
     }
   }