@nocobase/client-v2 2.3.0-alpha.1 → 2.3.0-beta.11

package/src/flow/models/base/__tests__/BlockGridModel.selectSceneActivation.test.ts

@@ -0,0 +1,124 @@
+/**
+ * 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 { FlowEngine, type FlowModelContext, MultiRecordResource, VIEW_ACTIVATED_EVENT } from '@nocobase/flow-engine';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { BlockGridModel } from '../BlockGridModel';
+import { CollectionBlockModel } from '../CollectionBlockModel';
+
+class TestBlockGridModel extends BlockGridModel {
+  mountForTest() {
+    super.onMount();
+  }
+
+  unmountForTest() {
+    super.onUnmount();
+  }
+}
+
+class TestMultiRecordResource extends MultiRecordResource<Record<string, unknown>> {
+  refreshCalls = 0;
+
+  override async refresh(): Promise<void> {
+    this.refreshCalls += 1;
+    this.emit('refresh');
+  }
+}
+
+class TestCollectionBlockModel extends CollectionBlockModel {
+  createResource(ctx: FlowModelContext) {
+    return ctx.createResource(TestMultiRecordResource);
+  }
+
+  mountForTest() {
+    super.onMount();
+  }
+}
+
+describe('BlockGridModel - select scene activation', () => {
+  let engine: FlowEngine;
+
+  beforeEach(() => {
+    engine = new FlowEngine();
+    engine.context.defineProperty('location', { value: { search: '' } });
+    engine.registerModels({ TestBlockGridModel, TestCollectionBlockModel });
+
+    engine.dataSourceManager.getDataSource('main').addCollection({
+      name: 'roles',
+      filterTargetKey: 'id',
+      fields: [
+        { name: 'id', type: 'integer', interface: 'number' },
+        { name: 'name', type: 'string', interface: 'input' },
+      ],
+    });
+  });
+
+  function createModels(scene = 'select') {
+    engine.context.defineProperty('view', { value: { inputArgs: { scene } } });
+    const grid = engine.createModel<TestBlockGridModel>({ use: 'TestBlockGridModel' });
+    const block = grid.addSubModel<TestCollectionBlockModel>('items', {
+      use: 'TestCollectionBlockModel',
+      stepParams: {
+        resourceSettings: {
+          init: {
+            dataSourceKey: 'main',
+            collectionName: 'roles',
+          },
+        },
+      },
+    });
+    const resource = block.context.resource as TestMultiRecordResource;
+
+    block.mountForTest();
+    grid.mountForTest();
+    return { grid, resource };
+  }
+
+  it('refreshes dirty collection blocks once when a nested view closes', async () => {
+    const { grid, resource } = createModels();
+
+    engine.markDataSourceDirty('main', 'roles');
+    engine.emitter.emit(VIEW_ACTIVATED_EVENT);
+    await Promise.resolve();
+
+    expect(resource.refreshCalls).toBe(1);
+
+    engine.emitter.emit(VIEW_ACTIVATED_EVENT);
+    await Promise.resolve();
+
+    expect(resource.refreshCalls).toBe(1);
+    grid.unmountForTest();
+  });
+
+  it('does not refresh without dirty data or after the grid unmounts', async () => {
+    const { grid, resource } = createModels();
+
+    engine.emitter.emit(VIEW_ACTIVATED_EVENT);
+    await Promise.resolve();
+    expect(resource.refreshCalls).toBe(0);
+
+    grid.unmountForTest();
+    engine.markDataSourceDirty('main', 'roles');
+    engine.emitter.emit(VIEW_ACTIVATED_EVENT);
+    await Promise.resolve();
+
+    expect(resource.refreshCalls).toBe(0);
+  });
+
+  it('does not handle activation outside the select scene', async () => {
+    const { grid, resource } = createModels('list');
+
+    engine.markDataSourceDirty('main', 'roles');
+    engine.emitter.emit(VIEW_ACTIVATED_EVENT);
+    await Promise.resolve();
+
+    expect(resource.refreshCalls).toBe(0);
+    grid.unmountForTest();
+  });
+});

package/src/flow/models/base/__tests__/CollectionBlockModel.addAppends.test.ts

@@ -0,0 +1,41 @@
+/**
+ * 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 { FlowEngine, FlowModelContext, MultiRecordResource } from '@nocobase/flow-engine';
+import { describe, expect, it } from 'vitest';
+import { CollectionBlockModel } from '../CollectionBlockModel';
+
+class AddAppendsCollectionBlockModel extends CollectionBlockModel {
+  createResource(ctx: FlowModelContext) {
+    return ctx.createResource(MultiRecordResource);
+  }
+}
+
+describe('CollectionBlockModel addAppends', () => {
+  it('does not throw for a nested field path when the collection is unavailable', () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ AddAppendsCollectionBlockModel });
+
+    const model = engine.createModel<AddAppendsCollectionBlockModel>({
+      uid: 'missing-collection-add-appends-block',
+      use: 'AddAppendsCollectionBlockModel',
+      stepParams: {
+        resourceSettings: {
+          init: {
+            dataSourceKey: 'main',
+            collectionName: 'missing_collection',
+          },
+        },
+      },
+    });
+
+    expect(model.collection).toBeUndefined();
+    expect(() => model.addAppends('createdBy.departments')).not.toThrow();
+  });
+});

package/src/flow/models/base/__tests__/CollectionBlockModel.initialBeforeRenderRefresh.test.ts

@@ -7,9 +7,10 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { FlowEngine, MultiRecordResource } from '@nocobase/flow-engine';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { FlowEngine, FlowRuntimeContext, MultiRecordResource, ResourceError } from '@nocobase/flow-engine';
 import '../../../index';
+import { BlockResourceErrorPlaceholder } from '../../../components/placeholders/BlockPlaceholder';
 import { CollectionBlockModel } from '../CollectionBlockModel';
 import { dataLoadingMode } from '../../../actions/dataLoadingMode';
 
@@ -19,13 +20,16 @@ class InitialBeforeRenderTestBlockModel extends CollectionBlockModel {
   }
 }
 
-function setupModel() {
+function setupModel(dataSourceKey = 'main') {
   const engine = new FlowEngine();
   engine.context.defineProperty('location', { value: { search: '' } as any });
   engine.registerActions({ dataLoadingMode });
   engine.registerModels({ InitialBeforeRenderTestBlockModel });
 
-  const ds = engine.dataSourceManager.getDataSource('main');
+  if (!engine.dataSourceManager.getDataSource(dataSourceKey)) {
+    engine.dataSourceManager.addDataSource({ key: dataSourceKey });
+  }
+  const ds = engine.dataSourceManager.getDataSource(dataSourceKey);
   ds.addCollection({
     name: 'users',
     filterTargetKey: 'id',
@@ -41,7 +45,7 @@ function setupModel() {
     stepParams: {
       resourceSettings: {
         init: {
-          dataSourceKey: 'main',
+          dataSourceKey,
           collectionName: 'users',
         },
       },
@@ -88,16 +92,21 @@ function setupModelWithManualMode() {
   return { model, resource: model.resource as MultiRecordResource };
 }
 
-describe('CollectionBlockModel initial beforeRender refresh', () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
+async function runRefreshStep(model: InitialBeforeRenderTestBlockModel) {
+  const handler = model.getFlow('refreshSettings')?.getStep('refresh')?.serialize().handler;
+  if (!handler) {
+    throw new Error('refreshSettings.refresh handler is not registered');
+  }
+  await handler(new FlowRuntimeContext(model, 'refreshSettings'), {});
+}
 
+describe('CollectionBlockModel initial beforeRender refresh', () => {
   afterEach(() => {
     vi.useRealTimers();
   });
 
   it('only performs one actual data request on first beforeRender', async () => {
+    vi.useFakeTimers();
     const { model, resource } = setupModel();
     const runActionSpy = vi.spyOn(resource, 'runAction').mockResolvedValue({
       data: [{ id: 1, name: 'Alice' }],
@@ -112,7 +121,54 @@ describe('CollectionBlockModel initial beforeRender refresh', () => {
     expect(runActionSpy).toHaveBeenCalledTimes(1);
   });
 
+  it('keeps resource request failures in the block error state', async () => {
+    const { model, resource } = setupModel('external');
+    const resourceError = new ResourceError({
+      response: {
+        data: {
+          errors: [{ code: 'DATA_SOURCE_UNAVAILABLE', message: 'Data source unavailable' }],
+        },
+      },
+    });
+    vi.spyOn(resource, 'refresh').mockImplementation(async () => {
+      resource.setError(resourceError);
+      throw resourceError;
+    });
+
+    await runRefreshStep(model);
+
+    expect(resource.getError()).toBe(resourceError);
+    expect(CollectionBlockModel.prototype.render.call(model)).toMatchObject({
+      type: BlockResourceErrorPlaceholder,
+    });
+  });
+
+  it('continues to throw resource request failures from the main data source', async () => {
+    const { model, resource } = setupModel();
+    const resourceError = new ResourceError({
+      response: {
+        data: {
+          errors: [{ code: 'UNKNOWN_ERROR', message: 'Main data source failed' }],
+        },
+      },
+    });
+    vi.spyOn(resource, 'refresh').mockImplementation(async () => {
+      resource.setError(resourceError);
+      throw resourceError;
+    });
+
+    await expect(runRefreshStep(model)).rejects.toBe(resourceError);
+  });
+
+  it('continues to throw non-resource errors from beforeRender', async () => {
+    const { model, resource } = setupModel('external');
+    vi.spyOn(resource, 'refresh').mockRejectedValue(new Error('beforeRender bug'));
+
+    await expect(runRefreshStep(model)).rejects.toThrow('beforeRender bug');
+  });
+
   it('respects saved manual mode and skips initial request when filters are empty', async () => {
+    vi.useFakeTimers();
     const { model, resource } = setupModelWithManualMode();
     const runActionSpy = vi.spyOn(resource, 'runAction').mockResolvedValue({
       data: [{ id: 1, name: 'Alice' }],
@@ -128,4 +184,64 @@ describe('CollectionBlockModel initial beforeRender refresh', () => {
     expect(resource.getData()).toEqual([]);
     expect(resource.getMeta('count')).toBe(0);
   });
+
+  it('skips forced active refresh in manual mode when filters are empty', async () => {
+    const { model, resource } = setupModelWithManualMode();
+    const refreshSpy = vi.spyOn(resource, 'refresh');
+
+    resource.setData([{ id: 2, name: 'Stale' }]);
+    resource.setMeta({ count: 1, hasNext: true });
+    resource.setPage(2);
+    resource.loading = true;
+
+    model.onActive(true);
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(refreshSpy).not.toHaveBeenCalled();
+    expect(resource.getData()).toEqual([]);
+    expect(resource.getMeta('count')).toBe(0);
+    expect(resource.getMeta('hasNext')).toBe(false);
+    expect(resource.getMeta('page')).toBe(1);
+    expect(resource.getRequestParameter('page')).toBe(1);
+    expect(resource.loading).toBe(false);
+  });
+
+  it('keeps forced active refresh in manual mode when filters are active', async () => {
+    const { model, resource } = setupModelWithManualMode();
+    const refreshSpy = vi.spyOn(resource, 'refresh').mockResolvedValue();
+
+    resource.setData([{ id: 2, name: 'Stale' }]);
+    resource.setMeta({ count: 1, hasNext: true, page: 2 });
+    model.setFilterActive('filter-form-item', true);
+
+    model.onActive(true);
+    await Promise.resolve();
+
+    expect(refreshSpy).toHaveBeenCalledTimes(1);
+    expect(resource.getData()).toEqual([{ id: 2, name: 'Stale' }]);
+    expect(resource.getMeta('count')).toBe(1);
+  });
+
+  it('skips forced active refresh in manual mode when only resource filters are active', async () => {
+    const { model, resource } = setupModelWithManualMode();
+    const refreshSpy = vi.spyOn(resource, 'refresh');
+
+    resource.setData([{ id: 2, name: 'Stale' }]);
+    resource.setMeta({ count: 1, hasNext: true });
+    resource.setPage(2);
+    resource.loading = true;
+    resource.addFilterGroup('data-scope', { status: { $eq: 'active' } });
+
+    model.onActive(true);
+    await Promise.resolve();
+
+    expect(refreshSpy).not.toHaveBeenCalled();
+    expect(resource.getData()).toEqual([]);
+    expect(resource.getMeta('count')).toBe(0);
+    expect(resource.getMeta('hasNext')).toBe(false);
+    expect(resource.getMeta('page')).toBe(1);
+    expect(resource.getRequestParameter('page')).toBe(1);
+    expect(resource.loading).toBe(false);
+  });
 });

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

@@ -115,7 +115,28 @@ export class AssignFormGridModel extends FormGridModel {
       (existing as any).assignValue = value;
       return;
     }
-    const field = (collection?.getFields?.() || []).find((f: any) => f.name === fieldName);
+    if (!collection) {
+      return;
+    }
+    const field = (collection.getFields?.() || []).find((f: any) => f.name === fieldName);
+
+    if (!field) {
+      const created = this.addSubModel('items', {
+        use: 'AssignFormItemModel',
+        stepParams: {
+          fieldSettings: {
+            init: {
+              dataSourceKey: collection?.dataSourceKey,
+              collectionName: collection?.name,
+              fieldPath: fieldName,
+            },
+            assignValue: { value },
+          },
+        },
+      });
+      created['assignValue'] = value;
+      return;
+    }
 
     const binding = EditableItemModel.getDefaultBindingByField(this.context, field);
     if (!binding) {

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

@@ -11,15 +11,12 @@ import React from 'react';
 import { Input } from 'antd';
 import { define, observable } from '@formily/reactive';
 import {
+  EditableItemModel,
+  FieldDeletePlaceholder,
   FlowModelRenderer,
   FormItem,
-  VariableInput,
-  tExpr,
-  isVariableExpression,
-  parseValueToPath,
-  isRunJSValue,
-  EditableItemModel,
   jioToJoiSchema,
+  tExpr,
 } from '@nocobase/flow-engine';
 // 无需类型导入（避免未使用的类型）
 import { FormItemModel } from '../form/FormItemModel';
@@ -27,6 +24,13 @@ import { EditFormModel } from '../form/EditFormModel';
 import { customAlphabet as Alphabet } from 'nanoid';
 import { ensureOptionsFromUiSchemaEnumIfAbsent } from '../../../internal/utils/enumOptionsUtils';
 import { RunJSValueEditor } from '../../../components/RunJSValueEditor';
+import {
+  DEFAULT_DATE_VARIABLE_COMPONENT_PROPS,
+  FieldValueVariableInput,
+  getFieldInterface,
+  isDateLikeField,
+  resolveDateVariableComponentProps,
+} from '../../../components/field-value-variable';
 
 type AssignFormTempOriginField = {
   uid?: string;
@@ -163,11 +167,15 @@ export class AssignFormItemModel extends FormItemModel {
 
   getAssignedEntry(): [string, any] | null {
     const name = this.fieldPath;
-    if (!name) return null;
+    if (!name || !this.collectionField) return null;
     return [name, this.assignValue];
   }
 
   render() {
+    if (!this.collectionField) {
+      return <FieldDeletePlaceholder />;
+    }
+
     // 与 FormItemModel.render 结构保持一致，仅替换内部渲染为 VariableInput + 常量编辑器
     const ctx: any = this.context;
     const collection = ctx.collection;
@@ -285,7 +293,9 @@ export class AssignFormItemModel extends FormItemModel {
         ) : null;
       };
 
-      const NullComponent: React.FC = () => <Input placeholder={'<Null>'} readOnly style={{ width: '100%' }} />;
+      const NullComponent: React.FC = () => (
+        <Input placeholder={`<${this.context.t?.('Null') ?? 'Null'}>`} readOnly style={{ width: '100%' }} />
+      );
 
       const RunJSComponent: React.FC<any> = (inputProps: any) => {
         return (
@@ -298,46 +308,18 @@ export class AssignFormItemModel extends FormItemModel {
         );
       };
 
-      const converters = {
-        renderInputComponent: (meta: any) => {
-          const firstPath = meta?.paths?.[0];
-          if (firstPath === 'constant') return ConstantValueEditor as any;
-          if (firstPath === 'null') return NullComponent as any;
-          if (firstPath === 'runjs') return RunJSComponent as any;
-          return undefined;
-        },
-        resolveValueFromPath: (item: any) => {
-          const firstPath = item?.paths?.[0];
-          if (firstPath === 'constant') return '';
-          if (firstPath === 'null') return null;
-          if (firstPath === 'runjs') return { code: '', version: 'v2' };
-          return undefined;
-        },
-        resolvePathFromValue: (currentValue: any) => {
-          if (currentValue === null) return ['null'];
-          if (isRunJSValue(currentValue)) return ['runjs'];
-          return isVariableExpression(currentValue) ? parseValueToPath(currentValue) : ['constant'];
-        },
-      } as any;
-
-      // 合并变量树：在最前面追加“常量/空值”两个选项
-      const mergedMetaTree = async () => {
+      const baseMetaTree = async () => {
         const getTree = (this.context as any)?.getPropertyMetaTree;
-        const base: any[] = typeof getTree === 'function' ? await getTree() : [];
-        return [
-          {
-            title: tExpr('Constant'),
-            name: 'constant',
-            type: 'string',
-            paths: ['constant'],
-            render: ConstantValueEditor,
-          },
-          { title: tExpr('Null'), name: 'null', type: 'object', paths: ['null'], render: NullComponent },
-          { title: tExpr('RunJS'), name: 'runjs', type: 'object', paths: ['runjs'], render: RunJSComponent },
-          ...base,
-        ];
+        return typeof getTree === 'function' ? await getTree() : [];
       };
 
+      const targetCollectionField = collection?.getField?.(this.fieldPath);
+      const targetFieldInterface = getFieldInterface(targetCollectionField);
+      const dateLike = isDateLikeField(targetCollectionField, this.fieldPath?.split('.').slice(-1)[0]);
+      const dateComponentProps = dateLike
+        ? resolveDateVariableComponentProps(targetCollectionField, targetFieldInterface)
+        : DEFAULT_DATE_VARIABLE_COMPONENT_PROPS;
+
       // 计算 label：优先使用配置中的 label，其次集合字段标题，最后回退字段路径
       let labelText = this.props?.label ?? this.fieldPath ?? '';
       const cf = collection?.getField?.(this.fieldPath);
@@ -357,14 +339,18 @@ export class AssignFormItemModel extends FormItemModel {
             const formValue = formBindingProps?.__assign_value__;
             const mergedValue = typeof formValue === 'undefined' ? this.assignValue : formValue;
             return (
-              <VariableInput
+              <FieldValueVariableInput
                 value={mergedValue}
-                onChange={(v: any) => {
+                onChange={(v) => {
                   this.assignValue = v;
                   formBindingProps?.__assign_trigger__?.(v);
                 }}
-                metaTree={mergedMetaTree}
-                converters={converters}
+                baseMetaTree={baseMetaTree}
+                constantComponent={ConstantValueEditor}
+                nullComponent={NullComponent}
+                runJSComponent={RunJSComponent}
+                isDateLikeField={dateLike}
+                dateComponentProps={dateComponentProps}
                 clearValue={''}
               />
             );
@@ -417,7 +403,7 @@ AssignFormItemModel.registerFlow({
       },
       defaultParams: (ctx) => {
         return {
-          label: (ctx.model as any).collectionField.title,
+          label: (ctx.model as any).collectionField?.title || (ctx.model as any).fieldPath,
         };
       },
       handler(ctx, params) {

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

@@ -47,6 +47,146 @@ class MockFlowModelRepository implements IFlowModelRepository {
 }
 
 describe('assignFieldValuesFlow (editor)', () => {
+  it('shows the deleted-field placeholder for a stale assigned value', async () => {
+    const engine = new FlowEngine();
+    engine.setModelRepository(new MockFlowModelRepository());
+    engine.registerModels({
+      AssignFormModel,
+      AssignFormGridModel,
+      AssignFormItemModel,
+      InputFieldModel,
+      VariableFieldFormModel,
+    });
+    engine.context.defineProperty('location', { value: { search: '' } });
+    engine.context.defineProperty('themeToken', { value: { marginLG: 24 } });
+    engine.context.defineProperty('flowSettingsEnabled', { value: true });
+
+    const main = engine.context.dataSourceManager.getDataSource('main');
+    main.addCollection({
+      name: 'users',
+      fields: [{ name: 'nickname', type: 'string', interface: 'input' }],
+    });
+    const users = engine.context.dataSourceManager.getCollection('main', 'users');
+
+    const action = engine.createModel({
+      use: 'FlowModel',
+      uid: 'act-assign-deleted-field',
+    });
+    action.setStepParams('assignSettings', 'assignFieldValues', {
+      assignedValues: { deletedField: 'stale value' },
+    });
+    action.context.defineProperty('blockModel', { value: { collection: users } });
+
+    const step = createAssignFieldValuesStep({ settingsFlowKey: 'assignSettings' });
+    const Editor = step.uiSchema().editor?.['x-component'] as React.ComponentType;
+    const flowSettingsCtx = new FlowRuntimeContext(action, 'assignSettings', 'settings');
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <ConfigProvider>
+          <App>
+            <FlowSettingsContextProvider value={flowSettingsCtx}>
+              <Editor />
+            </FlowSettingsContextProvider>
+          </App>
+        </ConfigProvider>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByRole('button', { name: /Fields/ })).toBeInTheDocument();
+      expect(screen.getByText(/deletedField.*may have been deleted/)).toBeInTheDocument();
+      const form = engine.findModelByParentId<AssignFormModel>(action.uid, 'assignForm');
+      expect(form).toBeDefined();
+      expect(form?.subModels.grid.subModels.items || []).toHaveLength(1);
+      expect(form?.getAssignedValues()).toEqual({});
+    });
+  });
+
+  it('shows the standard deleted-field placeholder for a persisted assigned field model', async () => {
+    const engine = new FlowEngine();
+    engine.setModelRepository(new MockFlowModelRepository());
+    engine.registerModels({
+      AssignFormModel,
+      AssignFormGridModel,
+      AssignFormItemModel,
+      InputFieldModel,
+      VariableFieldFormModel,
+    });
+    engine.context.defineProperty('location', { value: { search: '' } });
+    engine.context.defineProperty('themeToken', { value: { marginLG: 24 } });
+    engine.context.defineProperty('flowSettingsEnabled', { value: true });
+
+    const main = engine.context.dataSourceManager.getDataSource('main');
+    main.addCollection({
+      name: 'users',
+      fields: [{ name: 'nickname', type: 'string', interface: 'input' }],
+    });
+    const users = engine.context.dataSourceManager.getCollection('main', 'users');
+
+    const action = engine.createModel({
+      use: 'FlowModel',
+      uid: 'act-assign-persisted-deleted-field',
+    });
+    action.setStepParams('assignSettings', 'assignFieldValues', {
+      assignedValues: { deletedField: 'stale value' },
+    });
+    action.context.defineProperty('blockModel', { value: { collection: users } });
+
+    const form = engine.createModel<AssignFormModel>({
+      use: 'AssignFormModel',
+      uid: 'form-assign-persisted-deleted-field',
+      parentId: action.uid,
+      subKey: 'assignForm',
+      stepParams: {
+        resourceSettings: {
+          init: {
+            dataSourceKey: 'main',
+            collectionName: 'users',
+          },
+        },
+      },
+    });
+    action.setSubModel('assignForm', form);
+    form.subModels.grid.addSubModel('items', {
+      use: 'AssignFormItemModel',
+      uid: 'item-assign-persisted-deleted-field',
+      stepParams: {
+        fieldSettings: {
+          init: {
+            dataSourceKey: 'main',
+            collectionName: 'users',
+            fieldPath: 'deletedField',
+          },
+          assignValue: { value: 'stale value' },
+        },
+      },
+    });
+    form.subModels.grid.resetRows(true);
+
+    const step = createAssignFieldValuesStep({ settingsFlowKey: 'assignSettings' });
+    const Editor = step.uiSchema().editor?.['x-component'] as React.ComponentType;
+    const flowSettingsCtx = new FlowRuntimeContext(action, 'assignSettings', 'settings');
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <ConfigProvider>
+          <App>
+            <FlowSettingsContextProvider value={flowSettingsCtx}>
+              <Editor />
+            </FlowSettingsContextProvider>
+          </App>
+        </ConfigProvider>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByText(/deletedField.*may have been deleted/)).toBeInTheDocument();
+      expect(form.subModels.grid.subModels.items).toHaveLength(1);
+      expect(form.getAssignedValues()).toEqual({});
+    });
+  });
+
   it('repairs AssignFormModel resource init and clears cached collection', async () => {
     const engine = new FlowEngine();
     engine.setModelRepository(new MockFlowModelRepository());