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

package/src/flow/models/blocks/assign-form/assignFieldValuesFlow.tsx

@@ -15,7 +15,7 @@ import {
   useFlowEngine,
   useFlowSettingsContext,
 } from '@nocobase/flow-engine';
-import React, { useEffect, useRef } from 'react';
+import React, { useEffect } from 'react';
 import { CollectionActionModel } from '../../base/CollectionActionModel';
 import { RecordActionModel } from '../../base/RecordActionModel';
 import { AssignFormModel } from './AssignFormModel';
@@ -38,6 +38,9 @@ type AssignFieldValuesModel = {
   uid: string;
   assignFormUid?: string;
   context?: AssignFieldValuesContext;
+  subModels?: {
+    assignForm?: AssignFormModel;
+  };
   getStepParams?: (flowKey: string, stepKey: string) => { assignedValues?: AssignedValues } | undefined;
   setStepParams?: (flowKey: string, stepKey: string, params: { assignedValues: AssignedValues }) => void;
 };
@@ -62,6 +65,81 @@ function getResourceInit(ctx: AssignFieldValuesContext): { dataSourceKey: string
   return dsKey && collName ? { dataSourceKey: dsKey, collectionName: collName } : undefined;
 }
 
+function resolveInitFromFlowSettings(
+  blockModel: unknown,
+  actionContext: AssignFieldValuesContext | undefined,
+): { dataSourceKey: string; collectionName: string } | undefined {
+  const maybeBlockCollection = (blockModel as { collection?: { dataSourceKey?: string; name?: string } } | undefined)
+    ?.collection;
+  const collection = maybeBlockCollection || getContextCollection(actionContext);
+  const dsKey = collection?.dataSourceKey;
+  const collName = collection?.name;
+  return dsKey && collName ? { dataSourceKey: dsKey, collectionName: collName } : undefined;
+}
+
+function isValidResourceInit(init: unknown): init is {
+  dataSourceKey: string;
+  collectionName: string;
+} {
+  if (!init || typeof init !== 'object') return false;
+  const obj = init as { dataSourceKey?: unknown; collectionName?: unknown };
+  return (
+    typeof obj.dataSourceKey === 'string' &&
+    !!obj.dataSourceKey &&
+    typeof obj.collectionName === 'string' &&
+    !!obj.collectionName
+  );
+}
+
+type LocalCacheContext = {
+  _observableCache?: Record<string, unknown>;
+  _cache?: Record<string, unknown>;
+  _pending?: Record<string, unknown>;
+};
+
+function toLocalCacheContext(context: unknown): LocalCacheContext | undefined {
+  return context && typeof context === 'object' ? (context as LocalCacheContext) : undefined;
+}
+
+function clearOwnContextCache(context: unknown, key: string) {
+  const localContext = toLocalCacheContext(context);
+  if (!localContext) {
+    return;
+  }
+  delete localContext._observableCache?.[key];
+  delete localContext._cache?.[key];
+  delete localContext._pending?.[key];
+}
+
+function clearResourceContextCache(model: { context?: unknown } | undefined) {
+  clearOwnContextCache(model?.context, 'dataSource');
+  clearOwnContextCache(model?.context, 'collection');
+  clearOwnContextCache(model?.context, 'resource');
+  clearOwnContextCache(model?.context, 'association');
+}
+
+function resolveAssignFormModel(ctx: {
+  model: AssignFieldValuesModel;
+  engine: {
+    getModel?: (uid: string, fromRoot?: boolean) => AssignFormModel | undefined;
+    findModelByParentId?: (parentId: string, subKey: string) => AssignFormModel | undefined | null;
+  };
+}) {
+  if (ctx.model.assignFormUid) {
+    const form = ctx.engine.getModel?.(ctx.model.assignFormUid, true);
+    if (form) {
+      return form;
+    }
+  }
+
+  const localForm = ctx.model.subModels?.assignForm;
+  if (localForm) {
+    return localForm;
+  }
+
+  return ctx.engine.findModelByParentId?.(ctx.model.uid, 'assignForm') || undefined;
+}
+
 export function createAssignFormSubModelOptions(ctx: AssignFieldValuesContext) {
   return {
     async: true,
@@ -114,21 +192,52 @@ function AssignFieldsEditor(props: { settingsFlowKey: string; clearRecordContext
   const { model, blockModel } = useFlowSettingsContext();
   const action = model as AssignFieldValuesModel;
   const engine = useFlowEngine();
-  const initializedRef = useRef(false);
   const [formModel, setFormModel] = React.useState<AssignFormModel | null>(null);
 
   useEffect(() => {
     let cancelled = false;
     const loadAssignForm = async () => {
+      const init = resolveInitFromFlowSettings(blockModel, action?.context);
       const loaded = (await engine.loadOrCreateModel(
-        {
-          parentId: action.uid,
-          subKey: 'assignForm',
-          use: 'AssignFormModel',
-        },
+        init
+          ? {
+              parentId: action.uid,
+              subKey: 'assignForm',
+              use: 'AssignFormModel',
+              stepParams: { resourceSettings: { init } },
+            }
+          : {
+              parentId: action.uid,
+              subKey: 'assignForm',
+              use: 'AssignFormModel',
+            },
         { skipSave: !model.context.flowSettingsEnabled },
       )) as AssignFormModel;
       if (cancelled) return;
+
+      if (isValidResourceInit(init)) {
+        const existingInit = loaded.getStepParams?.('resourceSettings', 'init');
+        // Ensure `resourceSettings.init` is available before first render to avoid cached undefined `collection`
+        if (
+          !isValidResourceInit(existingInit) ||
+          existingInit.dataSourceKey !== init.dataSourceKey ||
+          existingInit.collectionName !== init.collectionName
+        ) {
+          loaded.setStepParams?.('resourceSettings', 'init', init);
+        }
+        clearResourceContextCache(loaded);
+        clearResourceContextCache(loaded.subModels?.grid);
+      }
+
+      const prev = action.getStepParams?.(props.settingsFlowKey, ASSIGN_FIELD_VALUES_STEP_KEY) || {};
+      loaded.setInitialAssignedValues(prev?.assignedValues || {});
+
+      const isBulkCollectionAction = model instanceof CollectionActionModel && !(model instanceof RecordActionModel);
+      const isBulk = props.clearRecordContext || isBulkCollectionAction;
+      if (isBulk && loaded.context?.defineProperty) {
+        loaded.context.defineProperty('record', { get: () => undefined, cache: false });
+      }
+
       setFormModel(loaded);
       action.assignFormUid = loaded?.uid || action.assignFormUid;
     };
@@ -136,31 +245,15 @@ function AssignFieldsEditor(props: { settingsFlowKey: string; clearRecordContext
     return () => {
       cancelled = true;
     };
-  }, [action, engine, model.context.flowSettingsEnabled]);
-
-  useEffect(() => {
-    if (initializedRef.current) return;
-    if (!formModel) return;
-
-    const prev = action.getStepParams?.(props.settingsFlowKey, ASSIGN_FIELD_VALUES_STEP_KEY) || {};
-    const coll = blockModel?.collection || getContextCollection(action?.context);
-    const dsKey = coll?.dataSourceKey;
-    const collName = coll?.name;
-    if (dsKey && collName) {
-      formModel.setStepParams('resourceSettings', 'init', {
-        dataSourceKey: dsKey,
-        collectionName: collName,
-      });
-    }
-    formModel.setInitialAssignedValues(prev?.assignedValues || {});
-
-    const isBulk =
-      props.clearRecordContext || (action instanceof CollectionActionModel && !(action instanceof RecordActionModel));
-    if (isBulk && formModel.context?.defineProperty) {
-      formModel.context.defineProperty('record', { get: () => undefined, cache: false });
-    }
-    initializedRef.current = true;
-  }, [action, blockModel?.collection, formModel, props.clearRecordContext, props.settingsFlowKey]);
+  }, [
+    action,
+    blockModel,
+    engine,
+    model,
+    model.context.flowSettingsEnabled,
+    props.clearRecordContext,
+    props.settingsFlowKey,
+  ]);
 
   return formModel ? <FlowModelRenderer model={formModel} showFlowSettings={false} /> : null;
 }
@@ -187,14 +280,23 @@ export function createAssignFieldValuesStep(options: AssignFieldValuesStepOption
         },
       };
     },
-    async beforeParamsSave(ctx: {
-      model: AssignFieldValuesModel;
-      engine: {
-        getModel?: (uid: string, fromRoot?: boolean) => AssignFormModel | undefined;
-      };
-    }) {
-      const form = ctx.model.assignFormUid ? ctx.engine.getModel?.(ctx.model.assignFormUid, true) : undefined;
-      if (!form) return;
+    async beforeParamsSave(
+      ctx: {
+        model: AssignFieldValuesModel;
+        engine: {
+          getModel?: (uid: string, fromRoot?: boolean) => AssignFormModel | undefined;
+          findModelByParentId?: (parentId: string, subKey: string) => AssignFormModel | undefined | null;
+        };
+      },
+      params?: { assignedValues?: AssignedValues },
+      previousParams?: { assignedValues?: AssignedValues },
+    ) {
+      const form = resolveAssignFormModel(ctx);
+      if (!form) {
+        const assignedValues = params?.assignedValues || previousParams?.assignedValues || {};
+        ctx.model.setStepParams?.(options.settingsFlowKey, ASSIGN_FIELD_VALUES_STEP_KEY, { assignedValues });
+        return;
+      }
       if (options.validateBeforeSave) {
         await form.form?.validateFields?.();
       }

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

@@ -22,7 +22,12 @@ import { CollectionBlockModel, FieldModel } from '../../base';
 import { RecordSelectFieldModel } from '../../fields/AssociationFieldModel/RecordSelectFieldModel';
 import { normalizeAssociationFieldNames } from '../../fields/AssociationFieldModel/recordSelectShared';
 import { FilterManager } from '../filter-manager';
-import { getAllDataModels, getDefaultOperator, isFilterValueEmpty } from '../filter-manager/utils';
+import {
+  getAllDataModels,
+  getDefaultOperator,
+  getFilterFormOperatorMeta,
+  isFilterValueEmpty,
+} from '../filter-manager/utils';
 import { FilterFormFieldModel } from './fields';
 import { normalizeFilterValueByOperator } from './valueNormalization';
 
@@ -51,7 +56,11 @@ const getTargetFilterableFields = (field: any, collection?: Collection, model?:
   return (targetCollection.getFields() || []).filter((childField: any) => childField?.filterable);
 };
 
-const MAX_ASSOCIATION_DEPTH = 5;
+const MAX_ASSOCIATION_DEPTH = 2;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
 
 const normalizeAssociationDefaultFilterValue = (value: any, fieldModel: any) => {
   const collectionField = fieldModel?.context?.collectionField;
@@ -449,15 +458,7 @@ export class FilterFormItemModel extends FilterableItemModel<{
 
   private getCurrentOperatorMeta() {
     const operator = getDefaultOperator(this);
-    if (!operator) return null;
-
-    const operatorList = this.collectionField?.filterable?.operators;
-
-    if (!Array.isArray(operatorList)) {
-      return null;
-    }
-
-    return operatorList.find((op) => op.value === operator) || null;
+    return getFilterFormOperatorMeta(this, operator);
   }
 
   onInit(options: any) {
@@ -530,7 +531,8 @@ export class FilterFormItemModel extends FilterableItemModel<{
     rawValue = this.normalizeAssociationFilterValue(rawValue, fieldModel);
     const operatorMeta = this.getCurrentOperatorMeta();
     if (operatorMeta?.noValue) {
-      const options = operatorMeta?.schema?.['x-component-props']?.options;
+      const componentProps = operatorMeta?.schema?.['x-component-props'];
+      const options = isRecord(componentProps) ? componentProps.options : undefined;
       if (Array.isArray(options)) {
         return rawValue;
       }

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

@@ -136,9 +136,13 @@ describe('FilterFormItemModel defineChildren association fields', () => {
     );
     const managerGroups = await managerAssociation.children();
     const managerFieldsGroup = managerGroups.find((group: any) => group.key === 'department.manager-fields');
+    const managerAssociationGroup = managerGroups.find(
+      (group: any) => group.key === 'department.manager-relation-fields',
+    );
 
     const managerFieldKeys = (managerFieldsGroup?.children || []).map((item: any) => item.key);
     expect(managerFieldKeys).toContain('department.manager.name');
+    expect(managerAssociationGroup).toBeUndefined();
 
     const targetItem = managerFieldsGroup?.children?.find((item: any) => item.key === 'department.manager.name');
     const createOptions = await targetItem.createModelOptions();
@@ -200,7 +204,8 @@ describe('FilterFormItemModel defineChildren association fields', () => {
     });
 
     const ds = engine.dataSourceManager.getDataSource('main');
-    ds!.addCollection({
+    expect(ds).toBeTruthy();
+    ds?.addCollection({
       name: 'users',
       filterTargetKey: 'id',
       fields: [{ name: 'id', type: 'integer', interface: 'number', filterable: { operators: [] } }],

package/src/flow/models/blocks/filter-manager/__tests__/getDefaultOperator.test.ts

@@ -9,7 +9,7 @@
 
 import { describe, expect, it, vi } from 'vitest';
 
-import { getDefaultOperator } from '../utils';
+import { getDefaultOperator, getFilterFormOperatorList } from '../utils';
 
 describe('getDefaultOperator', () => {
   it('returns model.operator when it exists', () => {
@@ -66,4 +66,38 @@ describe('getDefaultOperator', () => {
     expect(result).toBe('$includes');
     expect(getStepParams).toHaveBeenCalledWith('filterFormItemSettings', 'defaultOperator');
   });
+
+  it('falls back to field interface operators when field operators are empty', () => {
+    const getStepParams = vi.fn().mockReturnValue(undefined);
+    const model = {
+      getStepParams,
+      subModels: {},
+      collectionField: {
+        interface: 'id',
+        type: 'bigInt',
+        filterable: { operators: [] },
+      },
+      context: {
+        dataSourceManager: {
+          collectionFieldInterfaceManager: {
+            getFieldInterface: vi.fn(() => ({
+              filterable: {
+                operators: [
+                  { label: 'is', value: '$eq', selected: true },
+                  {
+                    label: 'is any of',
+                    value: '$in',
+                    schema: { 'x-component': 'MultipleKeywordsInput' },
+                  },
+                ],
+              },
+            })),
+          },
+        },
+      },
+    } as any;
+
+    expect(getDefaultOperator(model)).toBe('$eq');
+    expect(getFilterFormOperatorList(model).map((item) => item.value)).toEqual(['$eq', '$in']);
+  });
 });

package/src/flow/models/blocks/filter-manager/flow-actions/__tests__/customizeFilterRender.test.tsx

@@ -0,0 +1,148 @@
+/**
+ * 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 { FilterFormItemModel } from '../../../filter-form/FilterFormItemModel';
+import { customizeFilterRender } from '../customizeFilterRender';
+
+type TestFieldModel = {
+  props: Record<string, unknown>;
+  render: () => React.ReactNode;
+  setupReactiveRender: ReturnType<typeof vi.fn>;
+  _reactiveWrapperCache?: unknown;
+  __originalRender?: () => React.ReactNode;
+};
+
+const MultipleKeywordsInput = (props: Record<string, unknown>) => {
+  return <div data-testid="multiple-keywords-input" {...props} />;
+};
+
+function createFieldModel() {
+  return {
+    props: {
+      value: ['1', '2'],
+      placeholder: 'runtime placeholder',
+      onCompositionStart: vi.fn(),
+      onCompositionEnd: vi.fn(),
+    },
+    render: () => <span data-testid="original-field" />,
+    setupReactiveRender: vi.fn(),
+  };
+}
+
+function createFilterItemModel({
+  fieldModel,
+  operator = '$in',
+  collectionField,
+}: {
+  fieldModel: TestFieldModel;
+  operator?: string;
+  collectionField: Record<string, unknown>;
+}) {
+  return {
+    uid: 'filter-item',
+    operator,
+    collectionField,
+    context: {
+      app: {
+        getComponent: (name: string) => (name === 'MultipleKeywordsInput' ? MultipleKeywordsInput : undefined),
+      },
+      collectionField,
+    },
+    subModels: {
+      field: fieldModel,
+    },
+    setProps: vi.fn(),
+  } as unknown as FilterFormItemModel;
+}
+
+describe('customizeFilterRender action', () => {
+  it('uses operator schema components for number filter fields', () => {
+    const fieldModel = createFieldModel();
+    const model = createFilterItemModel({
+      fieldModel,
+      collectionField: {
+        interface: 'number',
+        type: 'integer',
+        filterable: {
+          operators: [
+            { label: 'equals', value: '$eq' },
+            {
+              label: 'is any of',
+              value: '$in',
+              schema: {
+                'x-component': 'MultipleKeywordsInput',
+                'x-component-props': {
+                  fieldInterface: 'number',
+                  placeholder: 'schema placeholder',
+                },
+              },
+            },
+          ],
+        },
+      },
+    });
+
+    customizeFilterRender.handler?.({ model } as any);
+
+    const element = fieldModel.render();
+    expect(React.isValidElement(element)).toBe(true);
+    expect((element as React.ReactElement).type).toBe(MultipleKeywordsInput);
+    expect((element as React.ReactElement).props.fieldInterface).toBe('number');
+    expect((element as React.ReactElement).props.placeholder).toBe('runtime placeholder');
+    expect((element as React.ReactElement).props.onCompositionStart).toBeNull();
+    expect((element as React.ReactElement).props.onCompositionEnd).toBeNull();
+    expect(fieldModel.setupReactiveRender).toHaveBeenCalled();
+    expect(model.setProps).toHaveBeenCalledWith({ key: 'filter-item-$in' });
+
+    fieldModel.props = {
+      ...fieldModel.props,
+      value: ['3'],
+      placeholder: 'updated runtime placeholder',
+    };
+    const rerenderedElement = fieldModel.render();
+    expect((rerenderedElement as React.ReactElement).props.value).toEqual(['3']);
+    expect((rerenderedElement as React.ReactElement).props.placeholder).toBe('updated runtime placeholder');
+  });
+
+  it('restores original render when switching to an operator without a schema component', () => {
+    const fieldModel = createFieldModel();
+    const originalRender = fieldModel.render;
+    const model = createFilterItemModel({
+      fieldModel,
+      collectionField: {
+        interface: 'number',
+        type: 'integer',
+        filterable: {
+          operators: [
+            { label: 'equals', value: '$eq' },
+            {
+              label: 'is any of',
+              value: '$in',
+              schema: {
+                'x-component': 'MultipleKeywordsInput',
+                'x-component-props': {
+                  fieldInterface: 'number',
+                },
+              },
+            },
+          ],
+        },
+      },
+    });
+
+    customizeFilterRender.handler?.({ model } as any);
+    model.operator = '$eq';
+    customizeFilterRender.handler?.({ model } as any);
+
+    expect(fieldModel.render).toBe(originalRender);
+    expect(fieldModel.render()).toEqual(<span data-testid="original-field" />);
+  });
+});

package/src/flow/models/blocks/filter-manager/flow-actions/__tests__/defaultOperator.test.tsx

@@ -9,6 +9,8 @@
 
 import { describe, it, expect, beforeEach } from 'vitest';
 import { FlowEngine, FlowModel } from '@nocobase/flow-engine';
+import { createMockClient, IdFieldInterface, InputFieldInterface } from '@nocobase/client-v2';
+import React from 'react';
 import { defaultOperator } from '../defaultOperator';
 
 function createModel() {
@@ -17,6 +19,12 @@ function createModel() {
   return model;
 }
 
+type OperatorOption = {
+  value: string;
+  label?: unknown;
+  schema?: Record<string, unknown>;
+};
+
 describe('defaultOperator action', () => {
   beforeEach(() => {
     document.body.innerHTML = '';
@@ -55,4 +63,81 @@ describe('defaultOperator action', () => {
     expect(options2.find((o: any) => o.value === '$a')).toBeTruthy();
     expect(options2.find((o: any) => o.value === '$b')).toBeTruthy();
   });
+
+  it('resolves default operator options from field interfaces when collection field metadata is absent', () => {
+    const app = createMockClient();
+    app.addFieldInterfaces([InputFieldInterface]);
+    app.addFieldInterfaceOperator('input', {
+      label: 'plugin in',
+      value: '$in',
+      schema: { 'x-component': 'MultipleKeywordsInput' },
+    });
+    app.addFieldInterfaceOperator('input', {
+      label: 'plugin not in',
+      value: '$notIn',
+      schema: { 'x-component': 'MultipleKeywordsInput' },
+    });
+
+    const model = new FlowModel({ uid: 'm-default-operator-interface', flowEngine: app.flowEngine });
+    model.context.defineProperty('filterField', {
+      value: { name: 'name', title: 'Name', interface: 'input', type: 'string' },
+    });
+
+    const ui = defaultOperator.uiMode?.({ model } as any);
+    const options = (ui?.props?.options || []) as OperatorOption[];
+    expect(options.find((item) => item.value === '$in')?.schema?.['x-component']).toBe('MultipleKeywordsInput');
+    expect(options.find((item) => item.value === '$notIn')?.schema?.['x-component']).toBe('MultipleKeywordsInput');
+  });
+
+  it('preserves React operator labels', () => {
+    const model = createModel();
+    const label = <span data-testid="operator-label">plugin label</span>;
+
+    model.context.defineProperty('collectionField', {
+      value: {
+        filterable: {
+          operators: [{ value: '$in', label, schema: { 'x-component': 'MultipleKeywordsInput' } }],
+        },
+      },
+    });
+
+    const ui = defaultOperator.uiMode?.({ model } as any);
+    const options = (ui?.props?.options || []) as OperatorOption[];
+    expect(options.find((item) => item.value === '$in')?.label).toBe(label);
+  });
+
+  it('falls back to id field interface operators when collection field operators are empty', () => {
+    const app = createMockClient();
+    app.addFieldInterfaces([IdFieldInterface]);
+    app.addFieldInterfaceOperator('id', {
+      label: 'plugin in',
+      value: '$in',
+      schema: { 'x-component': 'MultipleKeywordsInput' },
+    });
+    app.addFieldInterfaceOperator('id', {
+      label: 'plugin not in',
+      value: '$notIn',
+      schema: { 'x-component': 'MultipleKeywordsInput' },
+    });
+
+    const model = new FlowModel({ uid: 'm-default-operator-id-interface', flowEngine: app.flowEngine });
+    model.context.defineProperty('collectionField', {
+      value: {
+        name: 'id',
+        title: 'ID',
+        interface: 'id',
+        type: 'bigInt',
+        filterable: { operators: [] },
+      },
+    });
+    model.context.defineProperty('filterField', {
+      value: { name: 'id', title: 'ID', interface: 'id', type: 'bigInt' },
+    });
+
+    const ui = defaultOperator.uiMode?.({ model } as any);
+    const options = (ui?.props?.options || []) as OperatorOption[];
+    expect(options.find((item) => item.value === '$eq')).toBeTruthy();
+    expect(options.find((item) => item.value === '$in')?.schema?.['x-component']).toBe('MultipleKeywordsInput');
+    expect(options.find((item) => item.value === '$notIn')?.schema?.['x-component']).toBe('MultipleKeywordsInput');
+  });
 });