@nocobase/client-v2 2.1.0-alpha.40 → 2.1.0-alpha.46

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

@@ -0,0 +1,308 @@
+/**
+ * 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 {
+  FlowModelRenderer,
+  resolveRunJSObjectValues,
+  tExpr,
+  type FlowModelContext,
+  useFlowEngine,
+  useFlowSettingsContext,
+} from '@nocobase/flow-engine';
+import React, { useEffect } from 'react';
+import { CollectionActionModel } from '../../base/CollectionActionModel';
+import { RecordActionModel } from '../../base/RecordActionModel';
+import { AssignFormModel } from './AssignFormModel';
+
+export const ASSIGN_FIELD_VALUES_STEP_KEY = 'assignFieldValues';
+
+type AssignedValues = Record<string, unknown>;
+
+type AssignFieldValuesCollection = {
+  dataSourceKey?: string;
+  name?: string;
+};
+
+type AssignFieldValuesContext = FlowModelContext & {
+  collection?: AssignFieldValuesCollection;
+  flowSettingsEnabled?: boolean;
+};
+
+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;
+};
+
+type AssignFieldValuesStepOptions = {
+  settingsFlowKey: string;
+  title?: string;
+  tipComponent?: React.ComponentType;
+  validateBeforeSave?: boolean;
+  clearRecordContext?: boolean;
+};
+
+function getContextCollection(ctx: AssignFieldValuesContext | undefined): AssignFieldValuesCollection | undefined {
+  const collection = ctx?.collection;
+  return collection && typeof collection === 'object' ? collection : undefined;
+}
+
+function getResourceInit(ctx: AssignFieldValuesContext): { dataSourceKey: string; collectionName: string } | undefined {
+  const collection = getContextCollection(ctx);
+  const dsKey = collection?.dataSourceKey;
+  const collName = collection?.name;
+  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,
+    use: 'AssignFormModel',
+    stepParams: { resourceSettings: { init: getResourceInit(ctx) } },
+  };
+}
+
+export function getAssignFieldValuesDefaultParams(
+  ctx: {
+    model: Pick<AssignFieldValuesModel, 'getStepParams'>;
+  },
+  settingsFlowKey: string,
+): { assignedValues: AssignedValues } {
+  const step = ctx.model.getStepParams?.(settingsFlowKey, ASSIGN_FIELD_VALUES_STEP_KEY) || {};
+  return { assignedValues: step?.assignedValues || {} };
+}
+
+export async function resolveAssignFieldValues(
+  ctx: {
+    message?: { error?: (message: string) => void };
+    t?: (message: string) => string;
+  },
+  rawAssignedValues: unknown,
+  logName = 'AssignFieldValues',
+): Promise<AssignedValues | null> {
+  try {
+    return await resolveRunJSObjectValues(ctx, rawAssignedValues);
+  } catch (error) {
+    console.error(`[${logName}] RunJS execution failed`, error);
+    ctx.message?.error?.(ctx.t?.('RunJS execution failed') || 'RunJS execution failed');
+    return null;
+  }
+}
+
+export function mergeAssignFieldValues<T extends Record<string, unknown>>(
+  values: T,
+  assignedValues?: AssignedValues | null,
+): T {
+  if (!assignedValues || typeof assignedValues !== 'object' || !Object.keys(assignedValues).length) {
+    return values;
+  }
+  return {
+    ...values,
+    ...assignedValues,
+  } as T;
+}
+
+function AssignFieldsEditor(props: { settingsFlowKey: string; clearRecordContext?: boolean }) {
+  const { model, blockModel } = useFlowSettingsContext();
+  const action = model as AssignFieldValuesModel;
+  const engine = useFlowEngine();
+  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(
+        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;
+    };
+    loadAssignForm();
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    action,
+    blockModel,
+    engine,
+    model,
+    model.context.flowSettingsEnabled,
+    props.clearRecordContext,
+    props.settingsFlowKey,
+  ]);
+
+  return formModel ? <FlowModelRenderer model={formModel} showFlowSettings={false} /> : null;
+}
+
+export function createAssignFieldValuesStep(options: AssignFieldValuesStepOptions) {
+  return {
+    title: options.title || tExpr('Assign field values'),
+    uiSchema() {
+      return {
+        tip: options.tipComponent
+          ? {
+              'x-decorator': 'FormItem',
+              'x-component': options.tipComponent,
+            }
+          : undefined,
+        editor: {
+          'x-decorator': 'FormItem',
+          'x-component': () => (
+            <AssignFieldsEditor
+              settingsFlowKey={options.settingsFlowKey}
+              clearRecordContext={options.clearRecordContext}
+            />
+          ),
+        },
+      };
+    },
+    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?.();
+      }
+      const assignedValues = form.getAssignedValues?.() || {};
+      ctx.model.setStepParams?.(options.settingsFlowKey, ASSIGN_FIELD_VALUES_STEP_KEY, { assignedValues });
+    },
+    handler() {},
+  };
+}

package/src/flow/models/blocks/assign-form/index.ts

@@ -10,3 +10,4 @@
 export * from './AssignFormModel';
 export * from './AssignFormGridModel';
 export * from './AssignFormItemModel';
+export * from './assignFieldValuesFlow';

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

@@ -51,7 +51,7 @@ 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;
 
 const normalizeAssociationDefaultFilterValue = (value: any, fieldModel: any) => {
   const collectionField = fieldModel?.context?.collectionField;

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/flow-actions/connectFields.tsx

@@ -40,7 +40,20 @@ export const connectFields = defineAction({
 });
 
 // 构建级联选项数据结构
-const buildCascaderOptions = (ctx, fields: any[], prefix = '', selectedPaths: string[] = [], labelPrefix = '') => {
+const MAX_ASSOCIATION_FIELD_DEPTH = 2;
+
+const isAssociationField = (field: any) => {
+  return Boolean(field?.target || field?.targetCollection);
+};
+
+const buildCascaderOptions = (
+  ctx,
+  fields: any[],
+  prefix = '',
+  selectedPaths: string[] = [],
+  labelPrefix = '',
+  associationDepth = 0,
+) => {
   const selectedPathsArray = selectedPaths.filter(Boolean);
 
   return fields
@@ -48,7 +61,13 @@ const buildCascaderOptions = (ctx, fields: any[], prefix = '', selectedPaths: st
       const currentPath = prefix ? `${prefix}.${field.name}` : field.name;
       const label = field.title || field.name;
       const fullLabel = labelPrefix ? `${labelPrefix} / ${label}` : label;
-      const isLeaf = !field.target;
+      const isAssociation = isAssociationField(field);
+      const nextAssociationDepth = associationDepth + (isAssociation ? 1 : 0);
+      if (isAssociation && nextAssociationDepth > MAX_ASSOCIATION_FIELD_DEPTH) {
+        return null;
+      }
+
+      const isLeaf = !isAssociation;
 
       const option: any = {
         label,
@@ -59,6 +78,7 @@ const buildCascaderOptions = (ctx, fields: any[], prefix = '', selectedPaths: st
           field,
           fullPath: currentPath,
           fullLabel,
+          associationDepth: nextAssociationDepth,
         },
       };
 
@@ -68,18 +88,33 @@ const buildCascaderOptions = (ctx, fields: any[], prefix = '', selectedPaths: st
 
       if (shouldLoadChildren) {
         if (field.filterable?.children?.length) {
-          option.children = buildCascaderOptions(ctx, field.filterable.children, currentPath, selectedPaths, fullLabel);
+          option.children = buildCascaderOptions(
+            ctx,
+            field.filterable.children,
+            currentPath,
+            selectedPaths,
+            fullLabel,
+            nextAssociationDepth,
+          );
         } else {
           const targetCollection = field.targetCollection;
           if (targetCollection) {
             const targetFields = targetCollection.getFields?.() || [];
-            option.children = buildCascaderOptions(ctx, targetFields, currentPath, selectedPaths, fullLabel);
+            option.children = buildCascaderOptions(
+              ctx,
+              targetFields,
+              currentPath,
+              selectedPaths,
+              fullLabel,
+              nextAssociationDepth,
+            );
           }
         }
       }
 
       return option;
     })
+    .filter(Boolean)
     .sort((a, b) => {
       // isLeaf 为 true 的节点排在前面
       if (a.isLeaf && !b.isLeaf) return -1;
@@ -259,7 +294,7 @@ function ConnectFields(
           <li>{ctx.t('Available "target blocks" are all data blocks on the current page')}</li>
           <li>
             {ctx.t(
-              'Support filtering multiple blocks simultaneously, support deep selection of relationship fields (e.g.: User/Department/Name)',
+              'Support filtering multiple blocks simultaneously, support selection of relationship fields up to two levels (e.g.: User/Department/Name)',
             )}
           </li>
         </ul>
@@ -469,7 +504,14 @@ function CascaderWrapper(
       return;
     }
 
-    target.children = buildCascaderOptions(ctx, childFields, fullPath, [], meta.fullLabel || target.label);
+    target.children = buildCascaderOptions(
+      ctx,
+      childFields,
+      fullPath,
+      [],
+      meta.fullLabel || target.label,
+      meta.associationDepth || 0,
+    );
     setOptions((prev) => [...prev]);
   };
 

package/src/flow/models/blocks/form/FormActionGroupModel.tsx

@@ -12,4 +12,18 @@ import { FormActionModel } from './FormActionModel';
 
 export class FormActionGroupModel extends ActionGroupModel {
   static baseClass = FormActionModel;
+
+  static async defineChildren(ctx) {
+    const allowedModelNames = ctx.allowedFormActionModelNames;
+
+    if (!Array.isArray(allowedModelNames) || allowedModelNames.length === 0) {
+      return super.defineChildren(ctx);
+    }
+
+    await Promise.all(allowedModelNames.map((name) => ctx.engine?.getModelClassAsync?.(name)));
+
+    const items = await super.defineChildren(ctx);
+    const allowedSet = new Set(allowedModelNames);
+    return items.filter((item) => allowedSet.has(item.useModel || item.key));
+  }
 }

package/src/flow/models/blocks/form/FormActionModel.tsx

@@ -7,15 +7,27 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { tExpr } from '@nocobase/flow-engine';
+import { DefaultStructure, FlowExitAllException, tExpr } from '@nocobase/flow-engine';
 import { ButtonProps } from 'antd';
 import { AxiosRequestConfig } from 'axios';
 import { ActionModel } from '../../base/ActionModelCore';
+import { AssignFormModel } from '../assign-form/AssignFormModel';
+import {
+  createAssignFieldValuesStep,
+  createAssignFormSubModelOptions,
+  getAssignFieldValuesDefaultParams,
+} from '../assign-form/assignFieldValuesFlow';
 import { shouldSkipSubmitValidation, validateSubmitForm } from './submitValues';
 
-export class FormActionModel extends ActionModel {}
+export class FormActionModel<T extends DefaultStructure = DefaultStructure> extends ActionModel<T> {}
+
+export class FormSubmitActionModel extends FormActionModel<{
+  subModels: {
+    assignForm: AssignFormModel;
+  };
+}> {
+  assignFormUid?: string;
 
-export class FormSubmitActionModel extends FormActionModel {
   defaultProps: ButtonProps = {
     title: tExpr('Submit'),
     type: 'primary',
@@ -35,6 +47,11 @@ export class FormSubmitActionModel extends FormActionModel {
 
 FormSubmitActionModel.define({
   label: tExpr('Submit'),
+  createModelOptions: (ctx) => ({
+    subModels: {
+      assignForm: createAssignFormSubModelOptions(ctx),
+    },
+  }),
 });
 
 FormSubmitActionModel.registerFlow({
@@ -82,7 +99,14 @@ FormSubmitActionModel.registerFlow({
       },
       handler() {},
     },
+    assignFieldValues: createAssignFieldValuesStep({
+      settingsFlowKey: 'submitSettings',
+      title: tExpr('Assign field values'),
+    }),
     saveResource: {
+      async defaultParams(ctx) {
+        return getAssignFieldValuesDefaultParams(ctx, 'submitSettings');
+      },
       async handler(ctx, params) {
         if (!ctx?.resource) {
           throw new Error('Resource is not initialized');
@@ -96,6 +120,9 @@ FormSubmitActionModel.registerFlow({
           await submitHandler(ctx, params);
         } catch (error) {
           ctx.model.setProps('loading', false);
+          if (error instanceof FlowExitAllException) {
+            throw error;
+          }
           // 显示保存失败提示
           ctx.message.error(ctx.t('Save failed'));
           console.error('Form submission error:', error);

package/src/flow/models/blocks/form/FormAssociationItemModel.tsx

@@ -22,6 +22,8 @@ import { FieldModel } from '../../base/FieldModel';
 import { rebuildFieldSubModel } from '../../../internal/utils/rebuildFieldSubModel';
 import { useJsonTemplateResolver } from '../../../utils/useJsonTemplateResolver';
 
+const MAX_FORM_ASSOCIATION_FIELD_DEPTH = 2;
+
 function mergeArrays(a, b) {
   if (!b) {
     return a;
@@ -84,10 +86,17 @@ const AssociationItem = (props) => {
 export class FormAssociationItemModel extends DisplayItemModel {
   static defineChildren(ctx: FlowModelContext) {
     const collection = ctx.collection as Collection;
+    const associationDepth = ctx.prefixFieldPath ? ctx.prefixFieldPath.split('.').filter(Boolean).length : 0;
 
     return collection
       .getFields()
       .map((field) => {
+        if (
+          associationDepth >= MAX_FORM_ASSOCIATION_FIELD_DEPTH &&
+          (field.isAssociationField?.() || field.target || field.targetCollection)
+        ) {
+          return null;
+        }
         const binding = this.getDefaultBindingByField(ctx, field, { fallbackToTargetTitleField: true });
         if (!binding) return null;
         const fieldModel = binding.modelName;

package/src/flow/models/blocks/form/FormItemModel.tsx

@@ -42,12 +42,21 @@ const interfacesOfUnsupportedDefaultValue = [
   'formula',
 ];
 
+const MAX_FORM_ASSOCIATION_FIELD_DEPTH = 2;
+
 export class FormItemModel<T extends DefaultStructure = DefaultStructure> extends EditableItemModel<T> {
   static defineChildren(ctx: FlowModelContext) {
     const collection = ctx.collection as Collection;
+    const associationDepth = ctx.prefixFieldPath ? ctx.prefixFieldPath.split('.').filter(Boolean).length : 0;
     return collection
       .getFields()
       .map((field) => {
+        if (
+          associationDepth >= MAX_FORM_ASSOCIATION_FIELD_DEPTH &&
+          (field.isAssociationField?.() || field.target || field.targetCollection)
+        ) {
+          return;
+        }
         const binding = this.getDefaultBindingByField(ctx, field);
         if (!binding) {
           return;
@@ -138,6 +147,10 @@ export class FormItemModel<T extends DefaultStructure = DefaultStructure> extend
                 });
               }
             }
+            fork.context.defineProperty('fieldPathArray', {
+              get: () => this.context.fieldPathArray,
+              cache: false,
+            });
             if (isHiddenReservedValuePreview) {
               fork.setProps({ hidden: false });
             }
@@ -151,7 +164,10 @@ export class FormItemModel<T extends DefaultStructure = DefaultStructure> extend
       : { hidden, ...mergedPropsWithoutInitial };
     const fieldPath = buildDynamicNamePath(this.props.name, idx);
     this.context.defineProperty('fieldPathArray', {
-      value: [...parentFieldPathArray, ..._.castArray(fieldPath)],
+      get: () => {
+        return [...parentFieldPathArray, ..._.castArray(fieldPath)];
+      },
+      cache: false,
     });
     const record = this.context.item?.value || this.context.record;
     const content = (

package/src/flow/models/blocks/form/__tests__/FormActionGroupModel.test.ts

@@ -0,0 +1,46 @@
+/**
+ * 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 } from '@nocobase/flow-engine';
+import { describe, expect, it } from 'vitest';
+import { FormActionGroupModel, FormActionModel } from '../../../..';
+
+describe('FormActionGroupModel', () => {
+  it('filters addable form actions by allowedFormActionModelNames', async () => {
+    class AllowedFormActionModel extends FormActionModel {}
+    class HiddenFormActionModel extends FormActionModel {}
+
+    AllowedFormActionModel.define({
+      label: 'Allowed action',
+      sort: 10,
+    });
+    HiddenFormActionModel.define({
+      label: 'Hidden action',
+      sort: 20,
+    });
+
+    const engine = new FlowEngine();
+    engine.registerModels({
+      FormActionModel,
+      HiddenFormActionModel,
+    });
+    engine.registerModelLoaders({
+      AllowedFormActionModel: {
+        loader: async () => ({ AllowedFormActionModel }),
+      },
+    });
+
+    const items = await FormActionGroupModel.defineChildren({
+      engine,
+      allowedFormActionModelNames: ['AllowedFormActionModel'],
+    } as any);
+
+    expect(items.map((item: any) => item.useModel)).toEqual(['AllowedFormActionModel']);
+  });
+});

package/src/flow/models/blocks/form/__tests__/FormBlockModel.test.tsx

@@ -221,6 +221,23 @@ describe('FlowModel core behaviors (collected)', () => {
     expect(i1).toEqual({ ping: 1 });
   });
 
+  it('unchanged stepParams do not trigger a beforeRender rerun', async () => {
+    vi.useFakeTimers();
+    const spy = vi.fn().mockResolvedValue([]);
+    (engine as any).executor.dispatchEvent = spy;
+    const model = engine.createModel<FlowModel>({
+      use: 'FlowModel',
+      uid: 'm-flow-3-noop',
+      stepParams: { anyFlow: { anyStep: { x: 1 } } },
+    });
+
+    await model.dispatchEvent('beforeRender', { ping: 1 });
+    model.setStepParams('anyFlow', 'anyStep', { x: 1 });
+    await vi.advanceTimersByTimeAsync(150);
+
+    expect(spy).toHaveBeenCalledTimes(1);
+  });
+
   it('applyFlow delegates to executor.runFlow', async () => {
     const spyRun = vi.fn().mockResolvedValue('ok');
     (engine as any).executor.runFlow = spyRun;