@nocobase/client-v2 3.0.0-alpha.1 → 3.0.0-alpha.11

package/src/flow/components/filter/__tests__/VariableFilterItem.test.tsx

@@ -47,6 +47,10 @@ vi.mock('@nocobase/flow-engine', async () => {
   return { ...actual, VariableInput: MockVariableInput };
 });
 
+vi.mock('../../../models/blocks/filter-form/fields/date-time/components/DateFilterDynamicComponent', () => ({
+  DateFilterDynamicComponent: () => <div data-testid="date-filter-dynamic-component" />,
+}));
+
 const getRenderedSelectTexts = (root: ParentNode = document.body) =>
   Array.from(root.querySelectorAll('.ant-select-selection-item')).map((node) => (node.textContent || '').trim());
 
@@ -158,6 +162,127 @@ describe('VariableFilterItem', () => {
     expect(value.value).toBe('abc');
   });
 
+  it.each([
+    { operator: '$includes', xComponent: 'Input' },
+    { operator: '$eq', xComponent: 'Select' },
+    { operator: '$in', xComponent: 'Select' },
+  ])('uses a silent app registry lookup for the local $xComponent control', async ({ operator, xComponent }) => {
+    const value = observable({ path: '', operator: '', value: '' }) as VariableFilterItemValue;
+    const model = CreateModel();
+    const app = model.context.app as unknown as ReturnType<typeof createMockFlowApp>;
+    const getComponent = vi.spyOn(app, 'getComponent');
+
+    (globalThis as { __TEST_PATH__?: string }).__TEST_PATH__ = 'status';
+    (globalThis as { __TEST_META__?: MetaTreeNode }).__TEST_META__ = {
+      interface: 'input',
+      uiSchema: {
+        'x-component': xComponent,
+        enum: [{ label: 'Draft', value: 'draft' }],
+        'x-filter-operators': [
+          {
+            value: operator,
+            label: 'Operator',
+            selected: true,
+            schema: {
+              'x-component': xComponent,
+              'x-component-props': xComponent === 'Select' ? { mode: operator === '$in' ? 'tags' : null } : {},
+            },
+          },
+        ],
+      },
+      paths: ['collection', 'status'],
+      name: 'status',
+      title: 'Status',
+      type: 'string',
+    };
+
+    render(<VariableFilterItem value={value} model={model} rightAsVariable={false} />);
+    fireEvent.click(screen.getByTestId('variable-input'));
+
+    await waitFor(() => {
+      expect(value.operator).toBe(operator);
+    });
+    if (xComponent === 'Select' && operator === '$eq') {
+      expect(getComponent).not.toHaveBeenCalled();
+    } else {
+      expect(getComponent).toHaveBeenCalledWith(xComponent, false);
+    }
+  });
+
+  it('silently handles the DatePicker field schema before the date operator component takes over', async () => {
+    const value = observable({ path: '', operator: '', value: '' }) as VariableFilterItemValue;
+    const model = CreateModel();
+    const app = model.context.app as unknown as ReturnType<typeof createMockFlowApp>;
+    const getComponent = vi.spyOn(app, 'getComponent');
+
+    (globalThis as { __TEST_PATH__?: string }).__TEST_PATH__ = 'createdAt';
+    (globalThis as { __TEST_META__?: MetaTreeNode }).__TEST_META__ = {
+      interface: 'createdAt',
+      uiSchema: {
+        'x-component': 'DatePicker',
+        'x-filter-operators': [
+          {
+            value: '$dateOn',
+            label: 'Is',
+            selected: true,
+            schema: {
+              'x-component': 'DateFilterDynamicComponent',
+              'x-component-props': { isRange: false },
+            },
+          },
+        ],
+      },
+      paths: ['collection', 'createdAt'],
+      name: 'createdAt',
+      title: 'Created at',
+      type: 'date',
+    };
+
+    render(<VariableFilterItem value={value} model={model} rightAsVariable={false} />);
+    fireEvent.click(screen.getByTestId('variable-input'));
+
+    await waitFor(() => {
+      expect(value.operator).toBe('$dateOn');
+    });
+    expect(getComponent).toHaveBeenCalledWith('DatePicker', false);
+    expect(await screen.findByTestId('date-filter-dynamic-component')).toBeInTheDocument();
+  });
+
+  it('continues resolving plugin-provided keyword controls from the app registry', async () => {
+    const value = observable({ path: '', operator: '', value: '' }) as VariableFilterItemValue;
+    const model = CreateModel();
+    const app = model.context.app as unknown as ReturnType<typeof createMockFlowApp>;
+    const MultipleKeywordsInput: React.FC = () => <div data-testid="multiple-keywords-input" />;
+    app.addComponents({ MultipleKeywordsInput });
+    const getComponent = vi.spyOn(app, 'getComponent');
+
+    (globalThis as { __TEST_PATH__?: string }).__TEST_PATH__ = 'name';
+    (globalThis as { __TEST_META__?: MetaTreeNode }).__TEST_META__ = {
+      interface: 'input',
+      uiSchema: {
+        'x-component': 'Input',
+        'x-filter-operators': [
+          {
+            value: '$in',
+            label: 'Is any of',
+            selected: true,
+            schema: { 'x-component': 'MultipleKeywordsInput' },
+          },
+        ],
+      },
+      paths: ['collection', 'name'],
+      name: 'name',
+      title: 'Name',
+      type: 'string',
+    };
+
+    render(<VariableFilterItem value={value} model={model} rightAsVariable={false} />);
+    fireEvent.click(screen.getByTestId('variable-input'));
+
+    expect(await screen.findByTestId('multiple-keywords-input')).toBeTruthy();
+    expect(getComponent).toHaveBeenCalledWith('MultipleKeywordsInput');
+  });
+
   it('passes disabled through to the left selector, operator select, and right variable input', async () => {
     const value: VariableFilterItemValue = { path: '', operator: '', value: '' };
     const model = CreateModel();

package/src/flow/components/placeholders/BlockPlaceholder.tsx

@@ -8,12 +8,13 @@
  */
 
 import { useFlowModel } from '@nocobase/flow-engine';
-import { Result } from 'antd';
+import { useMemoizedFn } from 'ahooks';
+import { Button, Result } from 'antd';
 import _ from 'lodash';
 import React, { useMemo } from 'react';
 import { useTranslation } from 'react-i18next';
 import { BlockItemCard } from '../BlockItemCard';
-import { BlockModel } from '../../models/base/BlockModel';
+import type { BlockModel } from '../../models/base/BlockModel';
 
 function getResourceSettingsInitParams(model: any) {
   if (typeof model?.getResourceSettingsInitParams === 'function') {
@@ -43,26 +44,46 @@ function getBlockResourceInfo(model: any, t: (key: string) => string) {
   const dataSourceName = dataSource ? t(dataSource.displayName || dataSource.key) : dataSourceKey;
   const collectionLabel = collectionName ? `${t(collectionName) || collectionName}` : '';
   const dataSourceLabel = dataSourceName ? `${t(dataSourceName)} > ` : '';
+  const isDataSourceLoadFailed = ['loading-failed', 'reloading-failed'].includes(dataSource?.status);
 
   return {
     dataSourceName,
     nameValue: `${dataSourceLabel}${collectionLabel}`,
-    isDataSourceUnavailable: Boolean(dataSourceKey && !dataSource),
+    isDataSourceLoadFailed,
+    isDataSourceUnavailable: Boolean(dataSourceKey && (!dataSource || isDataSourceLoadFailed)),
   };
 }
 
-function DataSourceUnavailablePlaceholder({ dataSourceName }: { dataSourceName?: string }) {
+function getTemporarilyUnavailableMessage(t: (key: string, options?: Record<string, string>) => string, name?: string) {
+  return name
+    ? t('The data source "{{name}}" is temporarily unavailable. Please try again later or contact an administrator.', {
+        name,
+      })
+    : t('The data source is temporarily unavailable. Please try again later or contact an administrator.');
+}
+
+function DataSourceUnavailablePlaceholder({
+  dataSourceName,
+  isLoadFailed,
+}: {
+  dataSourceName?: string;
+  isLoadFailed?: boolean;
+}) {
   const { t } = useTranslation();
-  const subTitle = dataSourceName
-    ? t(
-        'The data source "{{name}}" used by this block is disabled or unavailable. Enable the data source to display this block.',
-        { name: dataSourceName },
-      )
-    : t('The data source used by this block is disabled or unavailable. Enable the data source to display this block.');
+  const subTitle = isLoadFailed
+    ? getTemporarilyUnavailableMessage(t, dataSourceName)
+    : dataSourceName
+      ? t(
+          'The data source "{{name}}" used by this block is disabled or unavailable. Enable the data source to display this block.',
+          { name: dataSourceName },
+        )
+      : t(
+          'The data source used by this block is disabled or unavailable. Enable the data source to display this block.',
+        );
 
   return (
-    <BlockItemCard>
-      <Result status="403" subTitle={subTitle}></Result>
+    <BlockItemCard role="alert" aria-live="polite">
+      <Result status={isLoadFailed ? 'warning' : '403'} subTitle={subTitle}></Result>
     </BlockItemCard>
   );
 }
@@ -70,7 +91,7 @@ function DataSourceUnavailablePlaceholder({ dataSourceName }: { dataSourceName?:
 export const BlockPlaceholder = () => {
   const { t } = useTranslation();
   const model: BlockModel = useFlowModel();
-  const { dataSourceName, isDataSourceUnavailable, nameValue } = useMemo(() => {
+  const { dataSourceName, isDataSourceLoadFailed, isDataSourceUnavailable, nameValue } = useMemo(() => {
     return getBlockResourceInfo(model, t);
   }, [model, t]);
 
@@ -86,10 +107,7 @@ export const BlockPlaceholder = () => {
   }, [actionName, nameValue, t]);
 
   if (isDataSourceUnavailable) {
-    if (!model.context.flowSettingsEnabled) {
-      return null;
-    }
-    return <DataSourceUnavailablePlaceholder dataSourceName={dataSourceName} />;
+    return <DataSourceUnavailablePlaceholder dataSourceName={dataSourceName} isLoadFailed={isDataSourceLoadFailed} />;
   }
 
   return (
@@ -101,8 +119,8 @@ export const BlockPlaceholder = () => {
 
 export function BlockDeletePlaceholder() {
   const { t } = useTranslation();
-  const model: any = useFlowModel();
-  const { dataSourceName, isDataSourceUnavailable, nameValue } = useMemo(() => {
+  const model: BlockModel = useFlowModel();
+  const { dataSourceName, isDataSourceLoadFailed, isDataSourceUnavailable, nameValue } = useMemo(() => {
     return getBlockResourceInfo(model, t);
   }, [model, t]);
 
@@ -115,10 +133,7 @@ export function BlockDeletePlaceholder() {
   }, [nameValue, t]);
 
   if (isDataSourceUnavailable) {
-    if (!model.context.flowSettingsEnabled) {
-      return null;
-    }
-    return <DataSourceUnavailablePlaceholder dataSourceName={dataSourceName} />;
+    return <DataSourceUnavailablePlaceholder dataSourceName={dataSourceName} isLoadFailed={isDataSourceLoadFailed} />;
   }
 
   return (
@@ -127,3 +142,35 @@ export function BlockDeletePlaceholder() {
     </BlockItemCard>
   );
 }
+
+type RefreshableBlockModel = BlockModel & {
+  refresh?: () => Promise<unknown> | unknown;
+};
+
+export function BlockResourceErrorPlaceholder() {
+  const { t } = useTranslation();
+  const model = useFlowModel() as RefreshableBlockModel;
+  const { dataSourceName } = useMemo(() => getBlockResourceInfo(model, t), [model, t]);
+  const handleRetry = useMemoizedFn(async () => {
+    try {
+      await model.refresh?.();
+    } catch {
+      // The resource retains the latest error and keeps this placeholder visible.
+    }
+  });
+
+  return (
+    <BlockItemCard ref={model.context.ref} {...model.decoratorProps} role="alert" aria-live="polite">
+      <Result
+        status="warning"
+        title={t('Data loading failed')}
+        subTitle={getTemporarilyUnavailableMessage(t, dataSourceName)}
+        extra={
+          <Button type="primary" onClick={handleRetry}>
+            {t('Try again')}
+          </Button>
+        }
+      />
+    </BlockItemCard>
+  );
+}

package/src/flow/components/placeholders/__tests__/BlockPlaceholder.test.tsx

@@ -8,9 +8,9 @@
  */
 
 import { FlowModelProvider } from '@nocobase/flow-engine';
-import { render, screen } from '@testing-library/react';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
 import React from 'react';
-import { BlockDeletePlaceholder } from '../BlockPlaceholder';
+import { BlockDeletePlaceholder, BlockResourceErrorPlaceholder } from '../BlockPlaceholder';
 
 vi.mock('react-i18next', () => ({
   useTranslation: () => ({
@@ -23,8 +23,9 @@ vi.mock('react-i18next', () => ({
 function createModel(options: {
   dataSourceKey?: string;
   collectionName?: string;
-  dataSource?: { key: string; displayName?: string };
+  dataSource?: { key: string; displayName?: string; status?: string };
   flowSettingsEnabled?: boolean;
+  refresh?: () => Promise<unknown>;
 }) {
   const model: any = {
     context: {
@@ -38,6 +39,7 @@ function createModel(options: {
       dataSourceKey: options.dataSourceKey,
       collectionName: options.collectionName,
     }),
+    refresh: options.refresh,
   };
   model.context.blockModel = model;
   return model;
@@ -64,25 +66,47 @@ describe('BlockPlaceholder', () => {
     ).toBeInTheDocument();
   });
 
-  it('should hide data source unavailable block outside configuration mode', () => {
+  it('should render data source unavailable placeholder outside configuration mode', () => {
     const model = createModel({
       dataSourceKey: 'external-mysql',
       collectionName: 'orders',
       flowSettingsEnabled: false,
     });
 
-    const { container } = render(
+    render(
       <FlowModelProvider model={model}>
         <BlockDeletePlaceholder />
       </FlowModelProvider>,
     );
 
     expect(
-      screen.queryByText(
+      screen.getByText(
         'The data source "external-mysql" used by this block is disabled or unavailable. Enable the data source to display this block.',
       ),
+    ).toBeInTheDocument();
+  });
+
+  it('should treat a failed data source as unavailable', () => {
+    const model = createModel({
+      dataSourceKey: 'external-mysql',
+      collectionName: 'orders',
+      dataSource: { key: 'external-mysql', displayName: 'External MySQL', status: 'loading-failed' },
+    });
+
+    render(
+      <FlowModelProvider model={model}>
+        <BlockDeletePlaceholder />
+      </FlowModelProvider>,
+    );
+
+    expect(
+      screen.getByText(
+        'The data source "External MySQL" is temporarily unavailable. Please try again later or contact an administrator.',
+      ),
+    ).toBeInTheDocument();
+    expect(
+      screen.queryByText('The Collection "External MySQL > orders" may have been deleted. Please remove this Block.'),
     ).not.toBeInTheDocument();
-    expect(container).toBeEmptyDOMElement();
   });
 
   it('should keep collection deleted placeholder when the data source is available', () => {
@@ -102,4 +126,30 @@ describe('BlockPlaceholder', () => {
       screen.getByText('The Collection "External MySQL > orders" may have been deleted. Please remove this Block.'),
     ).toBeInTheDocument();
   });
+
+  it('should render a retryable resource error placeholder', async () => {
+    const refresh = vi.fn().mockRejectedValue(new Error('still unavailable'));
+    const model = createModel({
+      dataSourceKey: 'external-mysql',
+      collectionName: 'orders',
+      dataSource: { key: 'external-mysql', displayName: 'External MySQL' },
+      refresh,
+    });
+
+    render(
+      <FlowModelProvider model={model}>
+        <BlockResourceErrorPlaceholder />
+      </FlowModelProvider>,
+    );
+
+    expect(screen.getByText('Data loading failed')).toBeInTheDocument();
+    expect(
+      screen.getByText(
+        'The data source "External MySQL" is temporarily unavailable. Please try again later or contact an administrator.',
+      ),
+    ).toBeInTheDocument();
+
+    fireEvent.click(screen.getByRole('button', { name: 'Try again' }));
+    await waitFor(() => expect(refresh).toHaveBeenCalledTimes(1));
+  });
 });

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

@@ -20,7 +20,7 @@ type OperatorMeta = {
 };
 
 type ComponentRegistry = {
-  getComponent?: (name: string) => ComponentType<Record<string, unknown>> | undefined;
+  getComponent?: (name: string, isShowError?: boolean) => ComponentType<Record<string, unknown>> | undefined;
 };
 
 type OperatorComponentFieldModel = {
@@ -67,6 +67,7 @@ export function resolveOperatorComponent(
   app: ComponentRegistry | undefined,
   operator: string,
   operators?: OperatorMeta[],
+  isShowError = true,
 ) {
   if (!operators || !Array.isArray(operators)) return null;
   const op = operators.find((item) => item?.value === operator);
@@ -77,7 +78,7 @@ export function resolveOperatorComponent(
   if (xComp === 'DateFilterDynamicComponent') {
     Comp = DateFilterDynamicComponent as ComponentType<Record<string, unknown>>;
   } else {
-    Comp = app?.getComponent?.(xComp);
+    Comp = isShowError ? app?.getComponent?.(xComp) : app?.getComponent?.(xComp, false);
   }
   if (!Comp) return null;
   const props = isRecord(schema?.['x-component-props']) ? schema['x-component-props'] : {};

package/src/flow/models/actions/UpdateRecordActionModel.tsx

@@ -22,6 +22,11 @@ import { applyUpdateRecordAction } from './UpdateRecordActionUtils';
 // import { RemoteFlowModelRenderer } from '../../FlowPage';
 
 const SETTINGS_FLOW_KEY = 'assignSettings';
+const AFTER_SUCCESS_DEFAULT_PARAMS = {
+  successMessage: tExpr('Saved successfully'),
+  manualClose: false,
+  actionAfterSuccess: 'stay',
+};
 
 function Info() {
   const ctx = useFlowSettingsContext();
@@ -101,6 +106,10 @@ UpdateRecordActionModel.registerFlow({
       tipComponent: Info,
       validateBeforeSave: true,
     }),
+    afterSuccess: {
+      use: 'afterSuccess',
+      defaultParams: AFTER_SUCCESS_DEFAULT_PARAMS,
+    },
   },
 });
 
@@ -113,7 +122,15 @@ UpdateRecordActionModel.registerFlow({
         return getAssignFieldValuesDefaultParams(ctx, SETTINGS_FLOW_KEY);
       },
       async handler(ctx, params) {
-        await applyUpdateRecordAction(ctx, params, { settingsFlowKey: SETTINGS_FLOW_KEY });
+        const updated = await applyUpdateRecordAction(ctx, params, { settingsFlowKey: SETTINGS_FLOW_KEY });
+        if (!updated) {
+          return;
+        }
+        const savedAfterSuccess = ctx.model.getStepParams(SETTINGS_FLOW_KEY, 'afterSuccess') || {};
+        await ctx.runAction('afterSuccess', {
+          ...AFTER_SUCCESS_DEFAULT_PARAMS,
+          ...savedAfterSuccess,
+        });
       },
     },
   },

package/src/flow/models/actions/UpdateRecordActionUtils.ts

@@ -8,9 +8,15 @@
  */
 
 import { MultiRecordResource, SingleRecordResource } from '@nocobase/flow-engine';
+import type { AxiosRequestConfig } from 'axios';
 import { dispatchEventDeep } from '../../utils';
 import { resolveAssignFieldValues } from '../blocks/assign-form/assignFieldValuesFlow';
 
+type UpdateRecordActionParams = {
+  assignedValues?: unknown;
+  requestConfig?: AxiosRequestConfig;
+};
+
 export async function refreshLinkageRulesAfterUpdate(ctx: any) {
   const blockModel = ctx?.blockModel || ctx?.model?.context?.blockModel || ctx?.model;
   const actionModel = ctx?.model;
@@ -48,11 +54,11 @@ export async function refreshLinkageRulesAfterUpdate(ctx: any) {
 
 export async function applyUpdateRecordAction(
   ctx: any,
-  params: any,
+  params: UpdateRecordActionParams,
   options?: {
     settingsFlowKey?: string;
   },
-) {
+): Promise<boolean> {
   const settingsFlowKey = options?.settingsFlowKey || 'assignSettings';
 
   // 统一接入二次确认：如果启用则弹窗；未配置时默认不启用
@@ -62,25 +68,31 @@ export async function applyUpdateRecordAction(
 
   const assignedValues = await resolveAssignFieldValues(ctx, params?.assignedValues, 'UpdateRecordAction');
   if (!assignedValues) {
-    return;
+    return false;
   }
 
   if (!assignedValues || typeof assignedValues !== 'object' || !Object.keys(assignedValues).length) {
     ctx.message.warning(ctx.t('No assigned fields configured'));
-    return;
+    return false;
   }
   const collection = ctx.collection?.name;
   const filterByTk = ctx.collection?.getFilterByTK?.(ctx.record);
   if (!collection || typeof filterByTk === 'undefined' || filterByTk === null) {
     ctx.message.error(ctx.t('Record is required to perform this action'));
-    return;
+    return false;
   }
+  let updated = false;
   if (ctx.resource instanceof SingleRecordResource) {
     await ctx.resource.save(assignedValues, params.requestConfig);
+    updated = true;
   } else if (ctx.resource instanceof MultiRecordResource) {
     await ctx.resource.update(filterByTk, assignedValues, params.requestConfig);
+    updated = true;
+  }
+  if (!updated) {
+    return false;
   }
 
   await refreshLinkageRulesAfterUpdate(ctx);
-  ctx.message.success(ctx.t('Saved successfully'));
+  return true;
 }

package/src/flow/models/actions/__tests__/UpdateRecordActionModel.test.ts

@@ -8,8 +8,9 @@
  */
 
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { MultiRecordResource } from '@nocobase/flow-engine';
+import { FlowEngine, MultiRecordResource } from '@nocobase/flow-engine';
 import { applyUpdateRecordAction } from '../UpdateRecordActionUtils';
+import { UpdateRecordActionModel } from '../UpdateRecordActionModel';
 import { dispatchEventDeep } from '../../../utils';
 
 vi.mock('../../../utils', () => ({
@@ -21,7 +22,7 @@ describe('UpdateRecordActionModel apply action', () => {
     vi.clearAllMocks();
   });
 
-  it('dispatches paginationChange for action and block after successful update', async () => {
+  it('dispatches paginationChange and returns success after updating the record', async () => {
     const resource: any = Object.create(MultiRecordResource.prototype);
     resource.update = vi.fn(async () => ({}));
     resource.refresh = vi.fn(async () => {});
@@ -52,12 +53,13 @@ describe('UpdateRecordActionModel apply action', () => {
       t: (value: string) => value,
     };
 
-    await applyUpdateRecordAction(ctx, {
+    const updated = await applyUpdateRecordAction(ctx, {
       assignedValues: {
         marital_status: '已婚',
       },
     });
 
+    expect(updated).toBe(true);
     expect(resource.update).toHaveBeenCalledWith(1, { marital_status: '已婚' }, undefined);
     expect(resource.refresh).not.toHaveBeenCalled();
 
@@ -67,6 +69,76 @@ describe('UpdateRecordActionModel apply action', () => {
     expect(paginationCalls.length).toBeGreaterThan(0);
     expect(paginationCalls.some(([model]: [any]) => model === ctx.model)).toBe(true);
     expect(paginationCalls.some(([model]: [any]) => model === blockModel)).toBe(true);
-    expect(ctx.message.success).toHaveBeenCalledWith('Saved successfully');
+    expect(ctx.message.success).not.toHaveBeenCalled();
+  });
+
+  it('runs the configured after-success action only after a successful update', async () => {
+    const engine = new FlowEngine();
+    const action = new UpdateRecordActionModel({ uid: 'update-record-action', flowEngine: engine } as any);
+    action.setStepParams('assignSettings', 'confirm', { enable: false });
+    action.setStepParams('assignSettings', 'afterSuccess', {
+      successMessage: 'Record updated',
+    });
+
+    const resource: any = Object.create(MultiRecordResource.prototype);
+    resource.update = vi.fn(async () => ({}));
+    const blockModel: any = { uid: 'details-block' };
+    const runAction = vi.fn(async () => {});
+    const ctx: any = {
+      model: action,
+      blockModel,
+      runAction,
+      collection: {
+        name: 'users',
+        getFilterByTK: vi.fn(() => 1),
+      },
+      record: { id: 1 },
+      resource,
+      message: {
+        success: vi.fn(),
+        warning: vi.fn(),
+        error: vi.fn(),
+      },
+      t: (value: string) => value,
+    };
+    const handler = action.getFlow('apply')?.getStep('apply')?.serialize().handler;
+
+    await handler(ctx, { assignedValues: { status: 'active' } });
+
+    expect(runAction).toHaveBeenNthCalledWith(1, 'confirm', { enable: false });
+    expect(runAction).toHaveBeenNthCalledWith(2, 'afterSuccess', {
+      successMessage: 'Record updated',
+      manualClose: false,
+      actionAfterSuccess: 'stay',
+    });
+  });
+
+  it('does not run the after-success action when no fields are assigned', async () => {
+    const engine = new FlowEngine();
+    const action = new UpdateRecordActionModel({ uid: 'update-record-action-empty', flowEngine: engine } as any);
+    const runAction = vi.fn(async () => {});
+    const ctx: any = {
+      model: action,
+      runAction,
+      collection: {
+        name: 'users',
+        getFilterByTK: vi.fn(() => 1),
+      },
+      record: { id: 1 },
+      resource: Object.create(MultiRecordResource.prototype),
+      message: {
+        success: vi.fn(),
+        warning: vi.fn(),
+        error: vi.fn(),
+      },
+      t: (value: string) => value,
+    };
+    const handler = action.getFlow('apply')?.getStep('apply')?.serialize().handler;
+
+    await handler(ctx, { assignedValues: {} });
+
+    expect(runAction).toHaveBeenCalledTimes(1);
+    expect(runAction).toHaveBeenCalledWith('confirm', { enable: false });
+    expect(ctx.message.warning).toHaveBeenCalledWith('No assigned fields configured');
   });
 });