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

package/src/flow/models/base/PageModel/RootPageModel.tsx

@@ -68,22 +68,15 @@ export class RootPageModel extends PageModel {
     reaction(
       () => this.context.pageActive.value,
       () => {
+        if (this.context.view?.inputArgs?.activationControlledByLayout) {
+          this.mounted = true;
+          return;
+        }
         if (this.context.pageActive.value && this.mounted) {
-          const firstTab = this.subModels.tabs?.[0];
-          if (firstTab) {
-            this.setProps('tabActiveKey', firstTab.uid);
-            this.invokeTabModelLifecycleMethod(firstTab.uid, 'onActive', true);
-          }
+          this.activateCurrentTab(true);
         }
         if (this.context.pageActive.value === false) {
-          if (this.props.tabActiveKey) {
-            this.invokeTabModelLifecycleMethod(this.props.tabActiveKey, 'onInactive');
-          } else {
-            const firstTab = this.subModels.tabs?.[0];
-            if (firstTab) {
-              this.invokeTabModelLifecycleMethod(firstTab.uid, 'onInactive');
-            }
-          }
+          this.deactivateCurrentTab();
         }
         this.mounted = true;
       },

package/src/flow/models/base/PageModel/__tests__/PageModel.test.ts

@@ -47,6 +47,13 @@ vi.mock('@nocobase/flow-engine', () => {
       return [];
     }
 
+    findSubModel(key: string, callback: any) {
+      if (this.subModels[key]) {
+        return this.subModels[key].find(callback) || null;
+      }
+      return null;
+    }
+
     addSubModel() {}
     setSubModel() {}
 
@@ -260,6 +267,44 @@ describe('PageModel', () => {
     });
   });
 
+  describe('tab lifecycle', () => {
+    it('should invoke tab lifecycle on PageModel subModels before engine lookup', () => {
+      const blockOnActive = vi.fn();
+      const blockOnInactive = vi.fn();
+      const tabModel = {
+        uid: 'tab1',
+        context: {
+          tabActive: { value: false },
+        },
+        subModels: {
+          grid: {
+            mapSubModels: vi.fn((_key, callback) => {
+              callback({ onActive: blockOnActive, onInactive: blockOnInactive });
+            }),
+          },
+        },
+      };
+      (pageModel as any).subModels = { tabs: [tabModel] };
+      (pageModel as any).flowEngine = {
+        getModel: vi.fn(() => undefined),
+      };
+      (pageModel as any).context = {
+        pageInfo: {},
+        view: {
+          inputArgs: { pageActive: true },
+        },
+      };
+
+      pageModel.invokeTabModelLifecycleMethod('tab1', 'onActive', true);
+      pageModel.invokeTabModelLifecycleMethod('tab1', 'onInactive');
+
+      expect((pageModel as any).flowEngine.getModel).not.toHaveBeenCalled();
+      expect(tabModel.context.tabActive.value).toBe(false);
+      expect(blockOnActive).toHaveBeenCalledWith(true);
+      expect(blockOnInactive).toHaveBeenCalledWith(false);
+    });
+  });
+
   describe('renderTabs activeKey logic', () => {
     beforeEach(() => {
       // Mock mapTabs to avoid complex rendering logic inside it
@@ -455,6 +500,7 @@ describe('PageModel', () => {
       } as any;
       (pageModel as any).context = {
         currentRoute: {
+          id: 'route-1',
           enableTabs: false,
         },
       };
@@ -479,6 +525,7 @@ describe('PageModel', () => {
       } as any;
       (pageModel as any).context = {
         currentRoute: {
+          id: 'route-1',
           enableTabs: true,
         },
       };
@@ -495,6 +542,59 @@ describe('PageModel', () => {
         paddingBottom: 0,
       });
     });
+
+    it('should ignore stale desktop route enableTabs=false from another route', () => {
+      pageModel.props = {
+        routeId: 'route-1',
+        displayTitle: true,
+        enableTabs: true,
+        title: 'Title',
+        headerStyle: { backgroundColor: 'var(--colorBgLayout)' },
+      } as any;
+      (pageModel as any).context = {
+        currentRoute: {
+          id: 'route-2',
+          enableTabs: false,
+        },
+      };
+      pageModel.renderTabs = vi.fn(() => null);
+      pageModel.renderFirstTab = vi.fn(() => null);
+
+      const result = pageModel.render() as any;
+      const header = result.props.children[0];
+
+      expect(pageModel.renderTabs).toHaveBeenCalled();
+      expect(pageModel.renderFirstTab).not.toHaveBeenCalled();
+      expect(header.props.style).toMatchObject({
+        backgroundColor: 'var(--colorBgLayout)',
+        paddingBottom: 0,
+      });
+    });
+
+    it('should ignore stale desktop route enableTabs=true from another route', () => {
+      pageModel.props = {
+        routeId: 'route-1',
+        displayTitle: true,
+        enableTabs: false,
+        title: 'Title',
+        headerStyle: { backgroundColor: 'var(--colorBgLayout)' },
+      } as any;
+      (pageModel as any).context = {
+        currentRoute: {
+          id: 'route-2',
+          enableTabs: true,
+        },
+      };
+      pageModel.renderTabs = vi.fn(() => null);
+      pageModel.renderFirstTab = vi.fn(() => null);
+
+      const result = pageModel.render() as any;
+      const header = result.props.children[0];
+
+      expect(pageModel.renderTabs).not.toHaveBeenCalled();
+      expect(pageModel.renderFirstTab).toHaveBeenCalled();
+      expect(header.props.style).toEqual({ backgroundColor: 'var(--colorBgLayout)' });
+    });
   });
 
   describe('dirty refresh signal', () => {
@@ -554,7 +654,7 @@ describe('PageModel', () => {
       pageModel.onMount();
 
       expect(typeof listeners['view:activated']).toBe('function');
-      expect(invokeSpy).toHaveBeenCalledWith('tab1', 'onActive');
+      expect(invokeSpy).toHaveBeenCalledWith('tab1', 'onActive', false);
     });
   });
 
@@ -630,6 +730,7 @@ describe('PageModel', () => {
     it('should use page documentTitle when desktop route disables tabs even if flow model enables tabs', async () => {
       pageModel.props = { routeId: 'route-1', enableTabs: true, title: 'Route page title' } as any;
       (pageModel as any).context.currentRoute = {
+        id: 'route-1',
         enableTabs: false,
       };
       (pageModel as any).stepParams = {

package/src/flow/models/base/RouteModel.tsx

@@ -21,7 +21,7 @@ RouteModel.registerFlow({
         return {
           mode: 'embed',
           preventClose: true,
-          pageModelClass: 'RootPageModel',
+          pageModelClass: ctx.layout?.rootPageModelClass || 'RootPageModel',
         };
       },
     },

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

@@ -28,6 +28,64 @@ import { customAlphabet as Alphabet } from 'nanoid';
 import { ensureOptionsFromUiSchemaEnumIfAbsent } from '../../../internal/utils/enumOptionsUtils';
 import { RunJSValueEditor } from '../../../components/RunJSValueEditor';
 
+type AssignFormTempOriginField = {
+  uid?: string;
+  props?: {
+    fieldNames?: unknown;
+    titleField?: unknown;
+  };
+  getStepParams?: (flowKey: string, stepKey: string) => unknown;
+};
+
+function getAssignFormTempFieldOptions(
+  originField: AssignFormTempOriginField | undefined,
+  init: Record<string, unknown>,
+) {
+  const inheritedFieldNames = originField?.props?.fieldNames;
+  const inheritedTitleField = originField?.props?.titleField;
+  const inheritedSelectFieldNamesStep = originField?.getStepParams?.('selectSettings', 'fieldNames');
+
+  return {
+    stepParams: {
+      fieldSettings: {
+        init,
+      },
+      ...(inheritedSelectFieldNamesStep
+        ? {
+            selectSettings: {
+              fieldNames: inheritedSelectFieldNamesStep,
+            },
+          }
+        : {}),
+    },
+    props: {
+      ...(typeof inheritedFieldNames !== 'undefined' ? { fieldNames: inheritedFieldNames } : {}),
+      ...(typeof inheritedTitleField !== 'undefined' ? { titleField: inheritedTitleField } : {}),
+    },
+  };
+}
+
+function stringifyAssignFormTempFieldOption(value: unknown) {
+  try {
+    return JSON.stringify(value) ?? '';
+  } catch {
+    return String(value);
+  }
+}
+
+function getAssignFormTempFieldRefreshKey(originField: AssignFormTempOriginField | undefined) {
+  const inheritedFieldNames = originField?.props?.fieldNames;
+  const inheritedTitleField = originField?.props?.titleField;
+  const inheritedSelectFieldNamesStep = originField?.getStepParams?.('selectSettings', 'fieldNames');
+
+  return [
+    originField?.uid || '',
+    stringifyAssignFormTempFieldOption(inheritedFieldNames),
+    stringifyAssignFormTempFieldOption(inheritedTitleField),
+    stringifyAssignFormTempFieldOption(inheritedSelectFieldNamesStep),
+  ].join('|');
+}
+
 /**
  * 使用 FormItemModel 的“表单项”包装，内部渲染 VariableInput，并将“常量”映射到临时字段模型。
  */
@@ -108,6 +166,8 @@ export class AssignFormItemModel extends FormItemModel {
     const init = this.fieldInit;
     const namePath = this.props?.name || (this.fieldPath ? [this.fieldPath] : undefined);
     const fieldPath = this.fieldPath;
+    const originField = this.subModels?.field as AssignFormTempOriginField | undefined;
+    const tempFieldRefreshKey = getAssignFormTempFieldRefreshKey(originField);
 
     const FieldRow: React.FC = () => {
       const [tempRoot, setTempRoot] = React.useState<any>(null);
@@ -121,13 +181,14 @@ export class AssignFormItemModel extends FormItemModel {
           return;
         }
         const fieldModel = binding.modelName;
+        const tempFieldOptions = getAssignFormTempFieldOptions(originField, init);
         const created = ctx?.engine?.createModel?.({
           use: 'VariableFieldFormModel',
           subModels: {
             fields: [
               {
                 use: fieldModel,
-                stepParams: { fieldSettings: { init } },
+                ...tempFieldOptions,
               },
             ],
           },
@@ -302,7 +363,7 @@ export class AssignFormItemModel extends FormItemModel {
       );
     };
 
-    return <FieldRow />;
+    return <FieldRow key={tempFieldRefreshKey} />;
   }
 }
 

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

@@ -0,0 +1,206 @@
+/**
+ * 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, useRef } 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;
+  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;
+}
+
+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 initializedRef = useRef(false);
+  const [formModel, setFormModel] = React.useState<AssignFormModel | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+    const loadAssignForm = async () => {
+      const loaded = (await engine.loadOrCreateModel(
+        {
+          parentId: action.uid,
+          subKey: 'assignForm',
+          use: 'AssignFormModel',
+        },
+        { skipSave: !model.context.flowSettingsEnabled },
+      )) as AssignFormModel;
+      if (cancelled) return;
+      setFormModel(loaded);
+      action.assignFormUid = loaded?.uid || action.assignFormUid;
+    };
+    loadAssignForm();
+    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]);
+
+  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;
+      };
+    }) {
+      const form = ctx.model.assignFormUid ? ctx.engine.getModel?.(ctx.model.assignFormUid, true) : undefined;
+      if (!form) 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/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/FormItemModel.tsx

@@ -138,6 +138,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 +155,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']);
+  });
+});