@nocobase/client-v2 2.1.20 → 2.1.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/client-v2",
-  "version": "2.1.20",
+  "version": "2.1.22",
   "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.20",
-    "@nocobase/flow-engine": "2.1.20",
-    "@nocobase/sdk": "2.1.20",
-    "@nocobase/shared": "2.1.20",
-    "@nocobase/utils": "2.1.20",
+    "@nocobase/evaluators": "2.1.22",
+    "@nocobase/flow-engine": "2.1.22",
+    "@nocobase/sdk": "2.1.22",
+    "@nocobase/shared": "2.1.22",
+    "@nocobase/utils": "2.1.22",
     "ahooks": "^3.7.2",
     "antd": "5.24.2",
     "antd-style": "3.7.1",
@@ -46,5 +46,5 @@
     "react-i18next": "^11.15.1",
     "react-router-dom": "^6.30.1"
   },
-  "gitHead": "ca646ba28bb11da083e3436866552932ed780b6f"
+  "gitHead": "811fc3d272389739babdfa4338faf843d5bf04ff"
 }

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

@@ -115,6 +115,7 @@ export abstract class CollectionFieldInterface {
   titleUsable?: boolean;
   usePathOptions?(field: any): any;
   hidden?: boolean;
+  creatable?: boolean;
 
   addComponentOption(componentOption: CollectionFieldInterfaceComponentOption) {
     if (!this.componentOptions) {

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

@@ -31,6 +31,7 @@ interface FieldInterfaceLike {
   title?: ReactNode;
   group?: string;
   order?: number;
+  creatable?: boolean;
   isAssociation?: boolean;
   supportDataSourceType?: string[];
   notSupportDataSourceType?: string[];

package/src/flow/FlowPage.tsx

@@ -60,7 +60,9 @@ type FlowPageProps = {
 type FlowPageViewContext = FlowEngineContext & {
   view?: {
     inputArgs?: {
+      filterByTk?: unknown;
       isMobileLayout?: unknown;
+      sourceId?: unknown;
     };
   };
 };
@@ -102,6 +104,10 @@ export const FlowPage = React.memo((props: FlowPageProps & Record<string, unknow
         subType: 'object',
         use: pageModelClass,
       };
+      const isRuntimeRecordScopedPage =
+        !flowEngine.context.flowSettingsEnabled &&
+        (typeof ctx?.view?.inputArgs?.filterByTk !== 'undefined' ||
+          typeof ctx?.view?.inputArgs?.sourceId !== 'undefined');
       if (shouldInjectDefaultChildTab) {
         const tabTitle = defaultTabTitle || flowEngine.translate?.('Details');
         options['subModels'] = {
@@ -128,7 +134,9 @@ export const FlowPage = React.memo((props: FlowPageProps & Record<string, unknow
           },
         };
       }
-      const data = await flowEngine.loadOrCreateModel(options, { skipSave: !flowEngine.context.flowSettingsEnabled });
+      const data =
+        (isRuntimeRecordScopedPage && (await flowEngine.loadModel({ ...options, refresh: true }))) ||
+        (await flowEngine.loadOrCreateModel(options, { skipSave: !flowEngine.context.flowSettingsEnabled }));
       if (data?.uid && onModelLoaded) {
         data.context.addDelegate(ctx);
         bindViewLayoutState(data, ctx);

package/src/flow/__tests__/FlowPage.test.tsx

@@ -9,7 +9,7 @@
 
 import { render, waitFor } from '@testing-library/react';
 import React from 'react';
-import { afterEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { FlowPage } from '../FlowPage';
 
 type TestContextProperty = {
@@ -71,10 +71,15 @@ const createPageModel = (): TestPageModel => {
 };
 
 const mocks = vi.hoisted(() => ({
+  flowSettingsEnabled: false,
+  loadModel: vi.fn(),
+  loadOrCreateModel: vi.fn(),
   rendererMobileStates: [] as boolean[],
   rendererProps: undefined as RendererProps | undefined,
   model: undefined as TestPageModel | undefined,
+  viewFilterByTk: undefined as unknown,
   viewInputMobileLayout: true as boolean | undefined,
+  viewSourceId: undefined as unknown,
   contextMobileLayout: undefined as boolean | undefined,
 }));
 
@@ -94,15 +99,20 @@ vi.mock('@nocobase/flow-engine', async () => {
     }),
     useFlowEngine: vi.fn(() => ({
       getModelClassAsync: vi.fn(async () => TestPageModelClass),
-      loadOrCreateModel: vi.fn(async () => mocks.model),
-      context: {},
+      loadModel: mocks.loadModel,
+      loadOrCreateModel: mocks.loadOrCreateModel,
+      context: {
+        flowSettingsEnabled: mocks.flowSettingsEnabled,
+      },
       translate: vi.fn((value: string) => value),
     })),
     useFlowModelById: vi.fn(() => mocks.model),
     useFlowViewContext: vi.fn(() => ({
       view: {
         inputArgs: {
+          ...(typeof mocks.viewFilterByTk !== 'undefined' ? { filterByTk: mocks.viewFilterByTk } : {}),
           ...(typeof mocks.viewInputMobileLayout === 'boolean' ? { isMobileLayout: mocks.viewInputMobileLayout } : {}),
+          ...(typeof mocks.viewSourceId !== 'undefined' ? { sourceId: mocks.viewSourceId } : {}),
         },
       },
       ...(typeof mocks.contextMobileLayout === 'boolean' ? { isMobileLayout: mocks.contextMobileLayout } : {}),
@@ -154,11 +164,21 @@ vi.mock('ahooks', async () => {
 });
 
 describe('FlowPage', () => {
+  beforeEach(() => {
+    mocks.loadModel.mockImplementation(async () => null);
+    mocks.loadOrCreateModel.mockImplementation(async () => mocks.model);
+  });
+
   afterEach(() => {
+    mocks.flowSettingsEnabled = false;
+    mocks.loadModel.mockReset();
+    mocks.loadOrCreateModel.mockReset();
     mocks.rendererMobileStates = [];
     mocks.rendererProps = undefined;
     mocks.model = undefined;
+    mocks.viewFilterByTk = undefined;
     mocks.viewInputMobileLayout = true;
+    mocks.viewSourceId = undefined;
     mocks.contextMobileLayout = undefined;
   });
 
@@ -203,4 +223,31 @@ describe('FlowPage', () => {
       expect(mocks.rendererMobileStates[0]).toBe(expected);
     },
   );
+
+  it('reloads runtime page models for record scoped views', async () => {
+    mocks.model = createPageModel();
+    mocks.viewFilterByTk = 1;
+    mocks.loadModel.mockImplementation(async () => mocks.model);
+
+    render(<FlowPage onModelLoaded={vi.fn()} />);
+
+    await waitFor(() => {
+      expect(mocks.loadModel).toHaveBeenCalled();
+    });
+    expect(mocks.loadModel.mock.calls[0]?.[0]).toMatchObject({ refresh: true });
+    expect(mocks.loadOrCreateModel).not.toHaveBeenCalled();
+  });
+
+  it('keeps configured page model cache behavior in flow settings mode', async () => {
+    mocks.flowSettingsEnabled = true;
+    mocks.model = createPageModel();
+    mocks.viewFilterByTk = 1;
+
+    render(<FlowPage onModelLoaded={vi.fn()} />);
+
+    await waitFor(() => {
+      expect(mocks.loadOrCreateModel).toHaveBeenCalled();
+    });
+    expect(mocks.loadModel).not.toHaveBeenCalled();
+  });
 });

package/src/flow/components/FieldAssignValueInput.tsx

@@ -1028,18 +1028,22 @@ export const FieldAssignValueInput: React.FC<Props> = ({
       collectionField: effectiveCollectionField,
     });
 
-    const created = engine?.createModel?.({
-      use: 'VariableFieldFormModel',
-      subModels: {
-        fields: [
-          {
-            use: effectiveFieldModelUse,
-            stepParams: tempFieldStepParams,
-            props: tempFieldProps,
-          },
-        ],
+    const sourceContext = resolved?.itemModel?.context || flowCtx.model?.context;
+    const created = engine?.createModel?.(
+      {
+        use: 'VariableFieldFormModel',
+        subModels: {
+          fields: [
+            {
+              use: effectiveFieldModelUse,
+              stepParams: tempFieldStepParams,
+              props: tempFieldProps,
+            },
+          ],
+        },
       },
-    });
+      sourceContext ? { delegate: sourceContext } : undefined,
+    );
     if (!created) return;
 
     // 注入上下文（集合/数据源/字段/区块/资源）

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

@@ -0,0 +1,134 @@
+/**
+ * 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 React from 'react';
+import { describe, expect, it, vi } from 'vitest';
+import { render, waitFor } from '@nocobase/test/client';
+import { FieldAssignValueInput } from '../FieldAssignValueInput';
+
+const { mockUseFlowContext, mockGetDefaultBindingByField } = vi.hoisted(() => ({
+  mockUseFlowContext: vi.fn(),
+  mockGetDefaultBindingByField: vi.fn(),
+}));
+
+vi.mock('@nocobase/flow-engine', async () => {
+  const actual = await vi.importActual<typeof import('@nocobase/flow-engine')>('@nocobase/flow-engine');
+  class MockEditableItemModel extends actual.EditableItemModel {}
+  MockEditableItemModel.getDefaultBindingByField = mockGetDefaultBindingByField;
+
+  return {
+    ...actual,
+    useFlowContext: () => mockUseFlowContext(),
+    VariableInput: () => <div data-testid="variable-input" />,
+    FlowModelRenderer: () => <div data-testid="flow-model-renderer" />,
+    EditableItemModel: MockEditableItemModel,
+  };
+});
+
+describe('FieldAssignValueInput context', () => {
+  it('delegates temporary field model context to the source form context', async () => {
+    type MockContext = {
+      dataSourceManager: { getDataSource: ReturnType<typeof vi.fn> };
+      t: (key: string) => string;
+      engine?: { createModel: ReturnType<typeof vi.fn> };
+      collection?: MockCollection;
+      blockModel?: MockFormModel;
+    };
+    type MockFieldModel = {
+      props: Record<string, unknown>;
+      setProps: ReturnType<typeof vi.fn>;
+      dispatchEvent: ReturnType<typeof vi.fn>;
+      remove: ReturnType<typeof vi.fn>;
+    };
+    type MockCollectionField = {
+      name: string;
+      interface: string;
+      uiSchema: { enum: Array<{ label: string; value: string }> };
+      isAssociationField: () => boolean;
+      getComponentProps: () => Record<string, unknown>;
+    };
+    type MockCollection = {
+      dataSourceKey: string;
+      name: string;
+      getField: (name: string) => MockCollectionField | null;
+      getFields: () => MockCollectionField[];
+    };
+    type MockFormModel = {
+      context: MockContext;
+      collection: MockCollection;
+      subModels: Record<string, unknown>;
+    };
+
+    const sourceContext: MockContext = {
+      dataSourceManager: {
+        getDataSource: vi.fn(() => ({})),
+      },
+      t: (key: string) => key,
+    };
+    const fieldModel: MockFieldModel = {
+      props: {},
+      setProps: vi.fn((props: Record<string, unknown>) => {
+        fieldModel.props = { ...fieldModel.props, ...props };
+      }),
+      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),
+    };
+    sourceContext.engine = engine;
+
+    const collectionField: MockCollectionField = {
+      name: 'status',
+      interface: 'select',
+      uiSchema: {
+        enum: [{ label: 'Open', value: 'open' }],
+      },
+      isAssociationField: () => false,
+      getComponentProps: () => ({}),
+    };
+    const collection: MockCollection = {
+      dataSourceKey: 'main',
+      name: 'tasks',
+      getField: (name: string) => (name === 'status' ? collectionField : null),
+      getFields: () => [collectionField],
+    };
+    const formModel: MockFormModel = {
+      context: sourceContext,
+      collection,
+      subModels: {},
+    };
+    sourceContext.collection = collection;
+    sourceContext.blockModel = formModel;
+
+    mockGetDefaultBindingByField.mockReturnValue({ modelName: 'SelectFieldModel' });
+    mockUseFlowContext.mockReturnValue({
+      model: formModel,
+      t: (key: string) => key,
+      getPropertyMetaTree: vi.fn(async () => []),
+    });
+
+    render(<FieldAssignValueInput targetPath="status" value="" onChange={vi.fn()} />);
+
+    await waitFor(() => {
+      expect(engine.createModel).toHaveBeenCalled();
+    });
+    expect(engine.createModel).toHaveBeenCalledWith(expect.any(Object), { delegate: sourceContext });
+  });
+});

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

@@ -432,6 +432,7 @@ export class FilterFormBlockModel extends FilterBlockModel<{
 
   private canApplyFormDefaultValue(name: string, current: any, force?: boolean) {
     if (force) return true;
+    if (this.userEditedFieldNames.has(name)) return false;
     if (isEmptyValue(current)) return true;
     if (!this.lastDefaultValueByFieldName.has(name)) return false;
     return isEqual(current, this.lastDefaultValueByFieldName.get(name));

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

@@ -62,9 +62,25 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return !!value && typeof value === 'object' && !Array.isArray(value);
 }
 
+interface CollectionFieldWithAssociationMarker {
+  isAssociationField?: () => boolean;
+  target?: unknown;
+}
+
+function hasAssociationMarker(value: unknown): value is CollectionFieldWithAssociationMarker {
+  return isRecord(value) && (typeof value.isAssociationField === 'function' || 'target' in value);
+}
+
+const isAssociationCollectionField = (collectionField: unknown) => {
+  if (!hasAssociationMarker(collectionField)) {
+    return false;
+  }
+  return collectionField.isAssociationField ? collectionField.isAssociationField() : Boolean(collectionField.target);
+};
+
 const normalizeAssociationDefaultFilterValue = (value: any, fieldModel: any) => {
   const collectionField = fieldModel?.context?.collectionField;
-  if (!collectionField?.isAssociationField?.()) {
+  if (!isAssociationCollectionField(collectionField)) {
     return value;
   }
 
@@ -171,8 +187,7 @@ const buildFilterFormFieldItem = ({
   if (!binding) {
     return;
   }
-  const isAssociation =
-    typeof field?.isAssociationField === 'function' ? field.isAssociationField() : Boolean(field?.target);
+  const isAssociation = isAssociationCollectionField(field);
   const fieldModel =
     isAssociation && ctxWithFlags.engine?.getModelClass?.('FilterFormRecordSelectFieldModel')
       ? 'FilterFormRecordSelectFieldModel'
@@ -507,10 +522,7 @@ export class FilterFormItemModel extends FilterableItemModel<{
     const formValue = this.context.form?.getFieldValue(this.props.name);
     const modelValue = fieldModel.getFilterValue ? fieldModel.getFilterValue() : formValue;
     const collectionField = (fieldModel as any)?.context?.collectionField;
-    const isAssociationField =
-      typeof collectionField?.isAssociationField === 'function'
-        ? collectionField.isAssociationField()
-        : !!collectionField?.target;
+    const isAssociationField = isAssociationCollectionField(collectionField);
     const shouldUseFormValue =
       isAssociationField &&
       !this.mounted &&
@@ -547,11 +559,7 @@ export class FilterFormItemModel extends FilterableItemModel<{
       return value;
     }
     const collectionField = (fieldModel as any)?.context?.collectionField;
-    const isAssociation =
-      typeof collectionField?.isAssociationField === 'function'
-        ? collectionField.isAssociationField()
-        : !!collectionField?.target;
-    if (!isAssociation) {
+    if (!isAssociationCollectionField(collectionField)) {
       return value;
     }
     const normalizedFieldNames = normalizeAssociationFieldNames(
@@ -798,6 +806,13 @@ FilterFormItemModel.registerFlow({
     },
     defaultOperator: {
       use: 'defaultOperator',
+      hideInSettings(ctx) {
+        const collectionField =
+          ctx.collectionField ||
+          ctx.model?.context?.collectionField ||
+          ctx.model?.subModels?.field?.context?.collectionField;
+        return isAssociationCollectionField(collectionField);
+      },
     },
     operatorComponentProps: {
       use: 'operatorComponentProps',

package/src/flow/models/blocks/filter-form/__tests__/FilterFormItemModel.defineChildren.test.ts

@@ -33,6 +33,42 @@ class DummyCollectionBlockModel extends CollectionBlockModel {
 }
 
 describe('FilterFormItemModel defineChildren association fields', () => {
+  it('hides default operator setting for association filter fields', () => {
+    const engine = new FlowEngine();
+    engine.registerModels({
+      FilterFormItemModel,
+    });
+
+    const filterItem = engine.createModel<FilterFormItemModel>({
+      uid: 'association-filter-item-settings',
+      use: 'FilterFormItemModel',
+    });
+
+    const defaultOperatorStep = filterItem.getFlow('filterFormItemSettings')?.steps?.defaultOperator as {
+      hideInSettings?: (ctx: {
+        collectionField?: unknown;
+        model?: {
+          subModels?: {
+            field?: {
+              context?: {
+                collectionField?: unknown;
+              };
+            };
+          };
+        };
+      }) => boolean;
+    };
+    expect(defaultOperatorStep?.hideInSettings?.({ collectionField: { isAssociationField: () => true } })).toBe(true);
+    expect(
+      defaultOperatorStep?.hideInSettings?.({
+        model: { subModels: { field: { context: { collectionField: { target: 'departments' } } } } },
+      }),
+    ).toBe(true);
+    expect(defaultOperatorStep?.hideInSettings?.({ collectionField: { interface: 'input', type: 'string' } })).toBe(
+      false,
+    );
+  });
+
   it('groups association target fields and supports recursive paths', async () => {
     const engine = new FlowEngine();
     engine.registerModels({

package/src/flow/models/blocks/filter-form/__tests__/defaultValues.wiring.test.ts

@@ -301,6 +301,40 @@ describe('filter-form defaultValues wiring', () => {
     expect(values.username_user).toBe('Manual');
   });
 
+  it('does not reapply a filter form default value after user clears the field', async () => {
+    const { model, values } = createFilterFormDefaultValuesModel([
+      {
+        key: 'username-default',
+        enable: true,
+        targetPath: 'username',
+        mode: 'default',
+        value: 'admin',
+      },
+    ]);
+
+    await FilterFormBlockModel.prototype.applyFormDefaultValues.call(model as any);
+    expect(values.username_user).toBe('admin');
+
+    values.username_user = undefined;
+    (model as any).handleFilterFormValuesChange({ username_user: undefined }, { username_user: undefined });
+
+    await waitFor(() => {
+      expect(model.dispatchEvent).toHaveBeenCalledWith(
+        'formValuesChange',
+        {
+          changedValues: {
+            username_user: undefined,
+          },
+          allValues: {
+            username_user: undefined,
+          },
+        },
+        { debounce: true },
+      );
+    });
+    expect(values.username_user).toBeUndefined();
+  });
+
   it('applies fixed values even when the target filter field already has a value', async () => {
     const { model, values } = createFilterFormDefaultValuesModel(
       [