@nocobase/client-v2 2.1.0-beta.42 → 2.1.0-beta.43

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

@@ -10,7 +10,7 @@
 import React from 'react';
 import { App, ConfigProvider } from 'antd';
 import { describe, expect, it } from 'vitest';
-import { render, screen, waitFor } from '@nocobase/test/client';
+import { render, screen, userEvent, waitFor } from '@nocobase/test/client';
 import {
   FlowEngine,
   FlowEngineProvider,
@@ -24,6 +24,7 @@ import { AssignFormItemModel } from '../AssignFormItemModel';
 import { AssignFormModel } from '../AssignFormModel';
 import { createAssignFieldValuesStep } from '../assignFieldValuesFlow';
 import { InputFieldModel } from '../../../fields/InputFieldModel';
+import { VariableFieldFormModel } from '../../../fields/VariableFieldFormModel';
 
 class MockFlowModelRepository implements IFlowModelRepository {
   async findOne(): Promise<Record<string, any> | null> {
@@ -49,7 +50,13 @@ describe('assignFieldValuesFlow (editor)', () => {
   it('repairs AssignFormModel resource init and clears cached collection', async () => {
     const engine = new FlowEngine();
     engine.setModelRepository(new MockFlowModelRepository());
-    engine.registerModels({ AssignFormModel, AssignFormGridModel, AssignFormItemModel, InputFieldModel });
+    engine.registerModels({
+      AssignFormModel,
+      AssignFormGridModel,
+      AssignFormItemModel,
+      InputFieldModel,
+      VariableFieldFormModel,
+    });
     engine.context.defineProperty('location', { value: { search: '' } });
     engine.context.defineProperty('themeToken', { value: { marginLG: 24 } });
 
@@ -120,5 +127,90 @@ describe('assignFieldValuesFlow (editor)', () => {
       const form = engine.findModelByParentId<AssignFormModel>(action.uid, 'assignForm');
       expect(form?.subModels.grid.subModels.items.length).toBe(1);
     });
+
+    await waitFor(() => {
+      expect(screen.getByDisplayValue('1111')).toBeInTheDocument();
+    });
+
+    const input = screen.getByDisplayValue('1111') as HTMLInputElement;
+    await userEvent.clear(input);
+    await userEvent.type(input, '2222');
+
+    await waitFor(() => {
+      const form = engine.findModelByParentId<AssignFormModel>(action.uid, 'assignForm');
+      expect(form?.getAssignedValues()).toEqual({ nickname: '2222' });
+    });
+  });
+
+  it('does not clear delegated parent resource cache when repairing AssignFormModel init', async () => {
+    const engine = new FlowEngine();
+    engine.setModelRepository(new MockFlowModelRepository());
+    engine.registerModels({ AssignFormModel, AssignFormGridModel, AssignFormItemModel, InputFieldModel });
+    engine.context.defineProperty('location', { value: { search: '' } });
+    engine.context.defineProperty('themeToken', { value: { marginLG: 24 } });
+
+    const dsm = engine.context.dataSourceManager;
+    const main = dsm.getDataSource('main');
+    main.addCollection({
+      name: 'users',
+      fields: [{ name: 'nickname', type: 'string', interface: 'input' }],
+    });
+    const users = dsm.getCollection('main', 'users');
+
+    const action = engine.createModel({
+      use: 'FlowModel',
+      uid: 'act-assign-parent-resource',
+    });
+
+    let resourceCreateCount = 0;
+    action.context.defineProperty('resource', {
+      get: () => ({ id: ++resourceCreateCount }),
+    });
+    const cachedResource = action.context.resource;
+
+    engine.createModel<AssignFormModel>({
+      use: 'AssignFormModel',
+      uid: 'form-assign-parent-resource',
+      parentId: action.uid,
+      subKey: 'assignForm',
+      stepParams: {
+        resourceSettings: {
+          init: {
+            dataSourceKey: 'main',
+            collectionName: 'missing',
+          },
+        },
+      },
+    });
+
+    action.context.defineProperty('blockModel', { value: { collection: users } });
+
+    const step = createAssignFieldValuesStep({ settingsFlowKey: 'assignSettings' });
+    const schema = step.uiSchema();
+    const Editor = schema.editor?.['x-component'] as React.ComponentType;
+    const flowSettingsCtx = new FlowRuntimeContext(action as any, 'assignSettings', 'settings');
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <ConfigProvider>
+          <App>
+            <FlowSettingsContextProvider value={flowSettingsCtx}>
+              <Editor />
+            </FlowSettingsContextProvider>
+          </App>
+        </ConfigProvider>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      const form = engine.findModelByParentId<AssignFormModel>(action.uid, 'assignForm');
+      expect(form?.getStepParams('resourceSettings', 'init')).toEqual({
+        dataSourceKey: 'main',
+        collectionName: 'users',
+      });
+    });
+
+    expect(action.context.resource).toBe(cachedResource);
+    expect(resourceCreateCount).toBe(1);
   });
 });

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

@@ -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;
 };
@@ -88,11 +91,53 @@ function isValidResourceInit(init: unknown): init is {
   );
 }
 
-function clearResourceContextCache(model: { context?: { removeCache?: (key: string) => void } } | undefined) {
-  model?.context?.removeCache?.('dataSource');
-  model?.context?.removeCache?.('collection');
-  model?.context?.removeCache?.('resource');
-  model?.context?.removeCache?.('association');
+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) {
@@ -235,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?.();
       }