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

package/src/components/form/__tests__/TypedVariableInput.test.tsx

@@ -0,0 +1,152 @@
+/**
+ * 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 { FlowContext, FlowContextProvider } from '@nocobase/flow-engine';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import React from 'react';
+import { describe, expect, it, vi } from 'vitest';
+import { TypedVariableInput } from '../TypedVariableInput';
+
+function createContextWithEnv() {
+  const ctx = new FlowContext();
+  (ctx as any).t = (key: string) => key;
+
+  ctx.defineProperty('$env', {
+    value: { SMTP_PORT: 465, SECURE_FLAG: true },
+    meta: {
+      title: 'Env',
+      type: 'object',
+      properties: {
+        SMTP_PORT: { title: 'SMTP Port', type: 'number' },
+        SECURE_FLAG: { title: 'Secure flag', type: 'boolean' },
+      },
+    },
+  });
+
+  return ctx;
+}
+
+function renderWithCtx(ctx: FlowContext, node: React.ReactNode) {
+  return render(<FlowContextProvider context={ctx}>{node}</FlowContextProvider>);
+}
+
+describe('TypedVariableInput - constant rendering', () => {
+  it('renders an InputNumber for a numeric value when types=[number]', async () => {
+    const ctx = createContextWithEnv();
+    renderWithCtx(
+      ctx,
+      <TypedVariableInput
+        value={465}
+        types={[['number', { min: 1, max: 65535 }]]}
+        namespaces={['$env']}
+        onChange={() => undefined}
+      />,
+    );
+    const numberInput = await screen.findByDisplayValue('465');
+    expect(numberInput).toBeInTheDocument();
+    expect(numberInput.getAttribute('role')).toBe('spinbutton');
+  });
+
+  it('renders a boolean Select when value is true and types=[boolean]', async () => {
+    const ctx = createContextWithEnv();
+    renderWithCtx(
+      ctx,
+      <TypedVariableInput value={true} types={['boolean']} namespaces={['$env']} onChange={() => undefined} />,
+    );
+    await waitFor(() => {
+      // antd Select renders the chosen item label via a selection-item span
+      const item = screen.getByText('True');
+      expect(item).toBeInTheDocument();
+    });
+  });
+
+  it('renders the Null placeholder when value=null and nullable=true', async () => {
+    const ctx = createContextWithEnv();
+    renderWithCtx(
+      ctx,
+      <TypedVariableInput value={null} types={['number']} namespaces={['$env']} nullable onChange={() => undefined} />,
+    );
+    // Uses placeholder slot (not value) so antd's grey placeholder colour
+    // applies — see comment in TypedVariableInput.tsx.
+    const nullInput = await screen.findByPlaceholderText('<Null>');
+    expect(nullInput).toBeInTheDocument();
+    expect(nullInput.getAttribute('readonly')).not.toBeNull();
+  });
+});
+
+describe('TypedVariableInput - variable rendering', () => {
+  it('renders a labelled pill when value is a {{ $env.X }} expression', async () => {
+    const ctx = createContextWithEnv();
+    renderWithCtx(
+      ctx,
+      <TypedVariableInput
+        value="{{$env.SMTP_PORT}}"
+        types={['number']}
+        namespaces={['$env']}
+        onChange={() => undefined}
+      />,
+    );
+    await waitFor(() => {
+      const tag = screen.getByRole('button', { name: 'variable-tag' });
+      expect(tag.textContent).toContain('Env');
+      expect(tag.textContent).toContain('SMTP Port');
+    });
+  });
+
+  it('clears back to null when the close button is clicked (nullable=true)', async () => {
+    const ctx = createContextWithEnv();
+    const handleChange = vi.fn();
+    renderWithCtx(
+      ctx,
+      <TypedVariableInput
+        value="{{$env.SMTP_PORT}}"
+        types={['number']}
+        namespaces={['$env']}
+        nullable
+        onChange={handleChange}
+      />,
+    );
+    const clear = await screen.findByRole('button', { name: 'icon-close' });
+    fireEvent.click(clear);
+    expect(handleChange).toHaveBeenCalledWith(null);
+  });
+
+  it('clears back to default-of-first-type when nullable=false', async () => {
+    const ctx = createContextWithEnv();
+    const handleChange = vi.fn();
+    renderWithCtx(
+      ctx,
+      <TypedVariableInput
+        value="{{$env.SMTP_PORT}}"
+        types={['number']}
+        namespaces={['$env']}
+        nullable={false}
+        onChange={handleChange}
+      />,
+    );
+    const clear = await screen.findByRole('button', { name: 'icon-close' });
+    fireEvent.click(clear);
+    expect(handleChange).toHaveBeenCalledWith(0);
+  });
+});
+
+describe('TypedVariableInput - editor onChange propagation', () => {
+  it('forwards numeric edits via onChange', async () => {
+    const ctx = createContextWithEnv();
+    const handleChange = vi.fn();
+    renderWithCtx(ctx, <TypedVariableInput value={465} types={['number']} onChange={handleChange} />);
+    const numberInput = await screen.findByDisplayValue('465');
+    fireEvent.change(numberInput, { target: { value: '587' } });
+    // antd InputNumber may emit on blur; force blur to flush
+    fireEvent.blur(numberInput);
+    expect(handleChange).toHaveBeenCalled();
+    const lastCall = handleChange.mock.calls[handleChange.mock.calls.length - 1][0];
+    expect(lastCall).toBe(587);
+  });
+});

package/src/components/form/index.tsx

@@ -16,4 +16,5 @@ export * from './FileSizeInput';
 export * from './JsonTextArea';
 export * from './PasswordInput';
 export * from './RemoteSelect';
+export * from './TypedVariableInput';
 export * from './VariableInput';

package/src/flow/actions/__tests__/linkageRules.hiddenSync.restore.test.ts

@@ -0,0 +1,100 @@
+/**
+ * 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 { describe, expect, it, vi } from 'vitest';
+import { actionLinkageRules } from '../linkageRules';
+
+function createRule(actions: any[]) {
+  return {
+    key: 'r1',
+    title: 'r1',
+    enable: true,
+    condition: { logic: '$and', items: [] },
+    actions,
+  };
+}
+
+describe('linkageRules hidden state propagation', () => {
+  it('restores hidden state to same-target models when reverting to original props', async () => {
+    const blockModel = { uid: 'block-1' };
+
+    const hostModel: any = {
+      uid: 'host',
+      hidden: false,
+      context: { blockModel },
+      __allModels: [],
+      setProps: vi.fn(),
+      getFlow: vi.fn(() => ({})),
+      getStepParams: vi.fn((_flowKey: string, stepKey: string) => {
+        if (stepKey === 'init') return { fieldPath: 'org_m2o' };
+        return undefined;
+      }),
+      translate: (s: string) => s,
+    };
+
+    const sameTargetModel: any = {
+      uid: 'same-target',
+      hidden: false,
+      context: { blockModel },
+      setProps: vi.fn(),
+      getStepParams: vi.fn((_flowKey: string, stepKey: string) => {
+        if (stepKey === 'init') return { fieldPath: 'org_m2o' };
+        return undefined;
+      }),
+      translate: (s: string) => s,
+    };
+
+    const engine = {
+      forEachModel: (visitor: (m: any) => void) => {
+        [hostModel, sameTargetModel].forEach(visitor);
+      },
+    };
+
+    const ctx: any = {
+      flowKey: 'buttonSettings',
+      model: hostModel,
+      engine,
+      app: {
+        jsonLogic: {
+          apply: vi.fn(() => true),
+        },
+      },
+      resolveJsonTemplate: vi.fn(async (value: any) => value),
+      getAction: (name: string) => {
+        if (name !== 'linkageSetActionProps') return undefined;
+        return {
+          handler: async (_ctx: any, params: any) => {
+            params.setProps(hostModel, {
+              hiddenModel: params.value === 'hidden',
+              disabled: false,
+              hiddenText: false,
+            });
+          },
+        };
+      },
+    };
+
+    await actionLinkageRules.handler(ctx, {
+      value: [
+        createRule([
+          {
+            name: 'linkageSetActionProps',
+            params: { value: 'hidden' },
+          },
+        ]),
+      ],
+    });
+    expect(hostModel.hidden).toBe(true);
+    expect(sameTargetModel.hidden).toBe(true);
+
+    await actionLinkageRules.handler(ctx, { value: [] });
+    expect(hostModel.hidden).toBe(false);
+    expect(sameTargetModel.hidden).toBe(false);
+  });
+});

package/src/flow/actions/__tests__/linkageRulesRefresh.test.ts

@@ -46,7 +46,7 @@ describe('linkageRulesRefresh action', () => {
     expect(handler).not.toHaveBeenCalled();
   });
 
-  it('runs linkage action on master model when forks are not mounted in runtime mode', async () => {
+  it('skips master model when forks can handle flow even if regular action buttons do not attach refs', async () => {
     const handler = vi.fn(async () => {});
     const model: any = {
       isFork: false,
@@ -74,6 +74,28 @@ describe('linkageRulesRefresh action', () => {
       flowKey: 'buttonSettings',
     });
 
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it('runs linkage action on master model when no forks exist in runtime mode', async () => {
+    const handler = vi.fn(async () => {});
+    const model: any = {
+      isFork: false,
+      forks: new Set(),
+      getFlow: vi.fn(() => ({})),
+      getStepParams: vi.fn(() => ({ value: ['master-runtime'] })),
+    };
+    const ctx: any = {
+      model,
+      resolveJsonTemplate: vi.fn(async (p: any) => p),
+      getAction: vi.fn(() => ({ handler })),
+    };
+
+    await linkageRulesRefresh.handler(ctx, {
+      actionName: 'actionLinkageRules',
+      flowKey: 'buttonSettings',
+    });
+
     expect(handler).toHaveBeenCalledWith(ctx, { value: ['master-runtime'] });
   });
 

package/src/flow/actions/linkageRules.tsx

@@ -2099,16 +2099,17 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
   mergedByUid.forEach((model: any, uid) => {
     const patchProps = mergedPropsByUid.get(uid) || {};
     const newProps = { ...model.__originalProps, ...patchProps };
-    const hasHiddenModelPatch = Object.prototype.hasOwnProperty.call(patchProps, 'hiddenModel');
+    const prevHidden = !!model.hidden;
+    const nextHidden = !!newProps.hiddenModel;
 
     model.setProps(_.omit(newProps, ['hiddenModel', 'value', 'hiddenText']));
     syncFieldOptionsToForks(model, patchProps);
     if (typeof model.setHidden === 'function') {
       model.setHidden(!!newProps.hiddenModel);
     } else {
-      model.hidden = !!newProps.hiddenModel;
-      if (hasHiddenModelPatch) {
-        hiddenStatePatches.push({ model, hidden: model.hidden });
+      model.hidden = nextHidden;
+      if (prevHidden !== nextHidden) {
+        hiddenStatePatches.push({ model, hidden: nextHidden });
       }
     }
 

package/src/flow/actions/linkageRulesRefresh.tsx

@@ -41,16 +41,15 @@ export const linkageRulesRefresh = defineAction({
     const flowSettingsEnabled = Boolean(
       (ctx as any)?.flowSettingsEnabled || (model as any)?.context?.flowSettingsEnabled,
     );
-    const hasMountedForkWithFlow =
+    const hasForkWithFlow =
       !model?.isFork &&
       !!model?.forks?.size &&
       Array.from(model?.forks || []).some((fork: any) => {
         if (!fork || fork.disposed) return false;
-        if (!fork?.context?.ref?.current) return false;
         return !!fork?.getFlow?.(flowKey);
       });
     const isMasterMounted = Boolean((model as any)?.context?.ref?.current);
-    if (hasMountedForkWithFlow && !isMasterMounted && !flowSettingsEnabled) {
+    if (hasForkWithFlow && !isMasterMounted && !flowSettingsEnabled) {
       return;
     }
 

package/src/flow/admin-shell/admin-layout/AdminLayoutMenuModels.tsx

@@ -55,6 +55,15 @@ const insertPositionToMethod = {
   afterEnd: 'insertAfter',
 } as const;
 
+const omitMenuRuntimeProps = (props: Record<string, unknown> = {}) => {
+  const persistableProps = { ...props };
+  delete persistableProps.item;
+  delete persistableProps.dom;
+  delete persistableProps.options;
+  delete persistableProps.renderType;
+  return persistableProps;
+};
+
 export class AdminLayoutMenuItemModel extends FlowModel<AdminLayoutMenuItemStructure> {
   private creationPersisted = false;
   private persistedStateHydrated = false;
@@ -261,6 +270,12 @@ export class AdminLayoutMenuItemModel extends FlowModel<AdminLayoutMenuItemStruc
     return currentFlowCount > 0 || initialFlowCount > 0;
   }
 
+  serialize(): ReturnType<FlowModel['serialize']> {
+    const data = super.serialize();
+    data.props = omitMenuRuntimeProps(data.props);
+    return data;
+  }
+
   setHidden(value: boolean) {
     const previous = this.hidden;
     super.setHidden(value);
@@ -698,7 +713,6 @@ AdminLayoutMenuItemModel.registerFlow({
 AdminLayoutMenuItemModel.registerFlow({
   key: 'menuSettings',
   title: 'Menu settings',
-  manual: true,
   steps: {
     edit: {
       title: 'Edit',

package/src/flow/admin-shell/admin-layout/__tests__/AdminLayoutMenuModels.test.ts

@@ -950,6 +950,73 @@ describe('AdminLayoutModel menu items', () => {
     });
   });
 
+  it('should save menu linkage rules without serializing runtime render props', async () => {
+    type SerializedFlowModel = Record<string, unknown> & {
+      props?: Record<string, unknown>;
+      subModels?: unknown;
+    };
+    const save = vi.fn(
+      async (targetModel: { serialize: () => SerializedFlowModel }, options?: { onlyStepParams?: boolean }) => {
+        const data = targetModel.serialize();
+        if (options?.onlyStepParams) {
+          delete data.subModels;
+        }
+
+        expect(data.props?.item).toBeUndefined();
+        expect(data.props?.dom).toBeUndefined();
+        expect(data.props?.options).toBeUndefined();
+        expect(data.props?.renderType).toBeUndefined();
+        expect(() => JSON.stringify(data)).not.toThrow();
+        return data;
+      },
+    );
+    const updateRoute = vi.fn().mockResolvedValue(undefined);
+    engine.setModelRepository({ save } as Parameters<FlowEngine['setModelRepository']>[0]);
+    engine.context.routeRepository.updateRoute = updateRoute;
+
+    const route = createRoute();
+    const model = engine.createModel<AdminLayoutMenuItemModel>({
+      uid: 'menu-item-linkage-runtime-props',
+      use: AdminLayoutMenuItemModel,
+      props: {
+        route,
+      },
+    });
+    const item = {
+      name: 'Page 1',
+      path: '/admin/page-1',
+      _route: route,
+      _model: model,
+    };
+
+    model.setProps({
+      item,
+      dom: React.createElement('span', null, 'Page 1'),
+      renderType: 'item',
+      options: { collapsed: false },
+    });
+    model.setStepParams('menuSettings', 'linkageRules', {
+      value: [
+        {
+          key: 'r1',
+          title: 'Hide menu item',
+          enable: true,
+          condition: { logic: '$and', items: [] },
+          actions: [{ key: 'a1', name: 'linkageSetMenuItemProps', params: { value: 'hidden' } }],
+        },
+      ],
+    });
+
+    await model.saveStepParams();
+
+    expect(save).toHaveBeenCalledWith(model, { onlyStepParams: true });
+    expect(updateRoute).toHaveBeenCalledWith(1, {
+      options: {
+        hasPersistedMenuInstanceFlow: true,
+      },
+    });
+  });
+
   it('should clear persisted menu linkage rules when no persisted state remains', async () => {
     const saveModel = vi.spyOn(engine, 'saveModel').mockResolvedValue(undefined as any);
     const destroy = vi.fn().mockResolvedValue(true);