@nocobase/flow-engine 2.0.0-alpha.9 → 2.0.0-beta.2

package/src/views/__tests__/ViewNavigation.test.ts

@@ -22,28 +22,26 @@ describe('ViewNavigation', () => {
         pathname: '/admin/test',
       },
     };
+    // Mock window.location
+    Object.defineProperty(window, 'location', {
+      value: {
+        pathname: '/admin',
+      },
+      writable: true,
+    });
   });
 
   describe('changeTo', () => {
-    it('should replace current view when viewStack is empty', () => {
-      viewNavigation = new ViewNavigation(mockCtx, []);
-
-      viewNavigation.changeTo({ viewUid: 'new-view' });
-
-      expect(viewNavigation.viewStack).toEqual([{ viewUid: 'new-view' }]);
-      expect(mockCtx.router.navigate).toHaveBeenCalledWith('/admin/new-view', { replace: true });
-    });
-
-    it('should replace last view in viewStack', () => {
+    it('should keep viewStack unchanged', () => {
       viewNavigation = new ViewNavigation(mockCtx, [{ viewUid: 'old-view' }]);
 
       viewNavigation.changeTo({ viewUid: 'new-view', tabUid: 'tab1' });
 
-      expect(viewNavigation.viewStack).toEqual([{ viewUid: 'new-view', tabUid: 'tab1' }]);
+      expect(viewNavigation.viewStack).toEqual([{ viewUid: 'old-view' }]);
       expect(mockCtx.router.navigate).toHaveBeenCalledWith('/admin/new-view/tab/tab1', { replace: true });
     });
 
-    it('should replace last view with complex parameters', () => {
+    it('should keep viewStack unchanged with complex parameters', () => {
       viewNavigation = new ViewNavigation(mockCtx, [{ viewUid: 'view1' }, { viewUid: 'view2', tabUid: 'tab1' }]);
 
       viewNavigation.changeTo({
@@ -53,10 +51,7 @@ describe('ViewNavigation', () => {
         sourceId: 'source1',
       });
 
-      expect(viewNavigation.viewStack).toEqual([
-        { viewUid: 'view1' },
-        { viewUid: 'new-view', tabUid: 'new-tab', filterByTk: '123', sourceId: 'source1' },
-      ]);
+      expect(viewNavigation.viewStack).toEqual([{ viewUid: 'view1' }, { viewUid: 'view2', tabUid: 'tab1' }]); // keep unchanged
       expect(mockCtx.router.navigate).toHaveBeenCalledWith(
         '/admin/view1/view/new-view/tab/new-tab/filterbytk/123/sourceid/source1',
         { replace: true },
@@ -68,13 +63,15 @@ describe('ViewNavigation', () => {
 
       viewNavigation.changeTo({ tabUid: 'new-tab' });
 
-      expect(viewNavigation.viewStack).toEqual([{ viewUid: 'view1', tabUid: 'new-tab' }]);
+      expect(viewNavigation.viewStack).toEqual([{ viewUid: 'view1' }]);
+      expect(mockCtx.router.navigate).toHaveBeenCalledWith('/admin/view1/tab/new-tab', { replace: true });
     });
   });
 
   describe('navigateTo', () => {
     it('should navigate to new view', () => {
       viewNavigation = new ViewNavigation(mockCtx, [{ viewUid: 'current-view' }]);
+      window.location.pathname = '/admin/current-view';
 
       viewNavigation.navigateTo({ viewUid: 'new-view' });
 
@@ -85,20 +82,9 @@ describe('ViewNavigation', () => {
       expect(call[1]).toBeUndefined();
     });
 
-    it('should navigate back when pathname is the same', () => {
-      viewNavigation = new ViewNavigation(mockCtx, [{ viewUid: 'view1' }]);
-      // set browser location to match the generated pathname
-      window.history.pushState({}, '', '/admin/view1/view/view2');
-
-      viewNavigation.navigateTo({ viewUid: 'view2' });
-
-      // when same pathname, navigate(-1) to avoid "no reaction" UX
-      expect(mockCtx.router.navigate).toHaveBeenCalledWith(-1);
-      expect(viewNavigation.viewStack).toEqual([{ viewUid: 'view1' }]);
-    });
-
     it('should navigate with complex parameters', () => {
       viewNavigation = new ViewNavigation(mockCtx, [{ viewUid: 'view1', tabUid: 'tab1' }]);
+      window.location.pathname = '/admin/view1/tab/tab1';
 
       viewNavigation.navigateTo({
         viewUid: 'view2',
@@ -116,25 +102,49 @@ describe('ViewNavigation', () => {
 
     it('should navigate from empty viewStack', () => {
       viewNavigation = new ViewNavigation(mockCtx, []);
+      window.location.pathname = '/admin';
 
       viewNavigation.navigateTo({ viewUid: 'first-view' });
 
-      expect(viewNavigation.viewStack).toEqual([{ viewUid: 'first-view' }]);
+      expect(viewNavigation.viewStack).toEqual([]);
       const call = (mockCtx.router.navigate as any).mock.calls[0];
       expect(call[0]).toBe('/admin/first-view');
       expect(call[1]).toBeUndefined();
     });
+
+    it('should pass options to router.navigate', () => {
+      viewNavigation = new ViewNavigation(mockCtx, [{ viewUid: 'view1' }]);
+      window.location.pathname = '/admin/view1';
+
+      viewNavigation.navigateTo({ viewUid: 'view2' }, { replace: true });
+
+      expect(mockCtx.router.navigate).toHaveBeenCalledWith('/admin/view1/view/view2', { replace: true });
+    });
   });
 
   describe('back', () => {
-    it('should call router navigate with -1', () => {
+    it('should navigate to parent path', () => {
+      viewNavigation = new ViewNavigation(mockCtx, [{ viewUid: 'view1' }, { viewUid: 'view2' }]);
+
+      viewNavigation.back();
+
+      expect(mockCtx.router.navigate).toHaveBeenCalledWith('/admin/view1', { replace: true });
+    });
+
+    it('should navigate to root if stack has only one item', () => {
       viewNavigation = new ViewNavigation(mockCtx, [{ viewUid: 'view1' }]);
-      // set browser location to current stack pathname so back() triggers
-      window.history.pushState({}, '', '/admin/view1');
 
       viewNavigation.back();
 
-      expect(mockCtx.router.navigate).toHaveBeenCalledWith(-1);
+      expect(mockCtx.router.navigate).toHaveBeenCalledWith('/admin', { replace: true });
+    });
+
+    it('should navigate to root if stack is empty', () => {
+      viewNavigation = new ViewNavigation(mockCtx, []);
+
+      viewNavigation.back();
+
+      expect(mockCtx.router.navigate).toHaveBeenCalledWith('/admin', { replace: true });
     });
   });
 });
@@ -173,6 +183,16 @@ describe('generatePathnameFromViewParams', () => {
     );
   });
 
+  it('should encode object filterByTk as encoded key-value string', () => {
+    const path = generatePathnameFromViewParams([{ viewUid: 'xxx', filterByTk: { id: 1, tenant: 'ac' } }]);
+    expect(path).toBe('/admin/xxx/filterbytk/' + encodeURIComponent('id=1&tenant=ac'));
+  });
+
+  it('should omit filterByTk segment for empty string or when absent', () => {
+    expect(generatePathnameFromViewParams([{ viewUid: 'xxx' }])).toBe('/admin/xxx');
+    expect(generatePathnameFromViewParams([{ viewUid: 'xxx', filterByTk: '' }])).toBe('/admin/xxx');
+  });
+
   it('should match parsePathnameToViewParams test cases', () => {
     // Test cases from parsePathnameToViewParams.test.ts
     expect(generatePathnameFromViewParams([{ viewUid: 'xxx' }])).toBe('/admin/xxx');

package/src/views/__tests__/useDialog.closeDestroy.test.tsx

@@ -0,0 +1,132 @@
+/**
+ * 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 React from 'react';
+import { render } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { useDialog } from '../useDialog';
+import { FlowContext } from '../../flowContext';
+
+// Mock dependencies
+vi.mock('../provider', () => ({
+  FlowEngineProvider: ({ children }) => children,
+}));
+
+vi.mock('../FlowContextProvider', () => ({
+  FlowViewContextProvider: ({ children }) => children,
+}));
+
+vi.mock('../ViewScopedFlowEngine', () => ({
+  createViewScopedEngine: (engine) => ({
+    context: new FlowContext(),
+    unlinkFromStack: vi.fn(),
+  }),
+}));
+
+vi.mock('../utils/variablesParams', () => ({
+  createViewRecordResolveOnServer: vi.fn(),
+  getViewRecordFromParent: vi.fn(),
+}));
+
+vi.mock('../createViewMeta', () => ({
+  registerPopupVariable: vi.fn(),
+}));
+
+vi.mock('../DialogComponent', () => ({
+  default: ({ children }) => <div>{children}</div>,
+}));
+
+// Mock usePatchElement to return a mock close function
+const mockCloseFunc = vi.fn();
+const mockPatchElement = vi.fn(() => mockCloseFunc);
+vi.mock('../usePatchElement', () => ({
+  default: () => [[], mockPatchElement],
+}));
+
+describe('useDialog - close/destroy logic', () => {
+  const createMockFlowContext = () => {
+    const ctx = new FlowContext();
+    ctx.engine = {
+      context: new FlowContext(),
+    };
+    return ctx;
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  const renderUseDialog = () => {
+    let api: any;
+    const TestComponent = () => {
+      const [dialogApi, contextHolder] = useDialog();
+      api = dialogApi;
+      return contextHolder as any;
+    };
+    render(<TestComponent />);
+    return api;
+  };
+
+  it('should call destroy (and thus closeFunc) when close is called without preventClose', () => {
+    const api = renderUseDialog();
+    const flowContext = createMockFlowContext();
+
+    const dialog = api.open({}, flowContext);
+
+    dialog.close();
+
+    expect(mockCloseFunc).toHaveBeenCalled();
+  });
+
+  it('should not call destroy (and thus closeFunc) when close is called with preventClose=true', () => {
+    const api = renderUseDialog();
+    const flowContext = createMockFlowContext();
+
+    const dialog = api.open({ preventClose: true }, flowContext);
+
+    dialog.close();
+
+    expect(mockCloseFunc).not.toHaveBeenCalled();
+  });
+
+  it('should call destroy (and thus closeFunc) when close is called with preventClose=true but force=true', () => {
+    const api = renderUseDialog();
+    const flowContext = createMockFlowContext();
+
+    const dialog = api.open({ preventClose: true }, flowContext);
+
+    dialog.close(undefined, true);
+
+    expect(mockCloseFunc).toHaveBeenCalled();
+  });
+
+  it('should delegate to navigation.back when triggerByRouter is true', () => {
+    const api = renderUseDialog();
+    const flowContext = createMockFlowContext();
+    const backMock = vi.fn();
+
+    const dialog = api.open(
+      {
+        triggerByRouter: true,
+        inputArgs: {
+          navigation: {
+            back: backMock,
+          },
+        },
+      },
+      flowContext,
+    );
+
+    dialog.close();
+
+    expect(backMock).toHaveBeenCalled();
+    // Should not call destroy directly, let router handle it
+    expect(mockCloseFunc).not.toHaveBeenCalled();
+  });
+});

package/src/views/createViewMeta.ts

@@ -13,6 +13,8 @@ import type { RecordRef } from '../utils/serverContextParams';
 import type { Collection } from '../data-source';
 import type { FlowView } from './FlowView';
 
+type PopupModelLike = { getStepParams?: (a: string, b: string) => any } | undefined;
+
 // 判断是否为普通对象（Plain Object），避免对类实例/代理等进行深度遍历
 function isPlainObject(val: any) {
   if (val === null || typeof val !== 'object') return false;
@@ -134,24 +136,48 @@ export function createViewMeta(ctx: FlowContext): PropertyMetaFactory {
  * - popup.resource：数据源信息（前端解析）
  * - popup.parent：上级弹窗（无限级，前端解析；不存在则禁用/为空）
  */
-export function createPopupMeta(ctx: FlowContext): PropertyMetaFactory {
+export function createPopupMeta(ctx: FlowContext, anchorView?: FlowView): PropertyMetaFactory {
   const t = (k: string) => ctx.t(k);
 
-  const getCurrentCollection = (): Collection | null => {
-    try {
-      const ref = inferViewRecordRef(ctx);
-      if (!ref?.filterByTk) return null;
-      const ds = ctx.dataSourceManager?.getDataSource?.(ref.dataSourceKey || 'main');
-      return ds?.collectionManager?.getCollection?.(ref.collection) || null;
-    } catch (_) {
-      return null;
+  const isPopupView = (view?: FlowView): boolean => {
+    if (!view) return false;
+    const stack = Array.isArray(view.navigation?.viewStack) ? view.navigation.viewStack : [];
+    return stack.length >= 2;
+  };
+
+  const hasPopupNow = (): boolean => isPopupView(anchorView ?? ctx.view);
+
+  // 统一解析锚定视图下的 RecordRef，避免在设置弹窗等二级视图中被误导
+  const resolveRecordRef = async (flowCtx: FlowContext): Promise<RecordRef | undefined> => {
+    const view = anchorView ?? (flowCtx.view as any);
+    if (!view || !isPopupView(view)) return undefined;
+
+    const base = await buildPopupRuntime(flowCtx, view);
+    const res = base?.resource;
+    if (res?.collectionName && res.filterByTk != null) {
+      return {
+        collection: res.collectionName,
+        dataSourceKey: res.dataSourceKey || 'main',
+        filterByTk: res.filterByTk,
+        associationName: res.associationName,
+        sourceId: res.sourceId,
+      };
     }
+    return inferViewRecordRef(flowCtx);
+  };
+
+  const getCurrentCollection = async (): Promise<Collection | null> => {
+    const ref = await resolveRecordRef(ctx);
+    if (!ref?.collection) return null;
+    const ds = ctx.dataSourceManager?.getDataSource?.(ref.dataSourceKey || 'main');
+    return ds?.collectionManager?.getCollection?.(ref.collection) || null;
   };
 
   // 从视图堆栈推断 level 级父弹窗（level=1 上一层）
-  const getParentRecordRef = async (level: number): Promise<RecordRef | undefined> => {
+  const getParentRecordRef = async (level: number, flowCtx?: FlowContext): Promise<RecordRef | undefined> => {
     try {
-      const nav = ctx.view?.navigation;
+      const useCtx = flowCtx || ctx;
+      const nav = useCtx.view?.navigation;
       const stack = Array.isArray(nav?.viewStack) ? nav.viewStack : [];
       if (stack.length < 2 || level < 1) return undefined;
       const idx = stack.length - 1 - level;
@@ -159,12 +185,12 @@ export function createPopupMeta(ctx: FlowContext): PropertyMetaFactory {
       const parent = stack[idx];
       if (!parent?.viewUid) return undefined;
 
-      let model: any = ctx.engine?.getModel?.(parent.viewUid);
-      if (!model && typeof ctx.engine?.loadModel === 'function') {
+      let model = useCtx.engine?.getModel(parent.viewUid, true) as PopupModelLike;
+      if (!model) {
         try {
-          model = await ctx.engine.loadModel({ uid: parent.viewUid });
+          model = (await useCtx.engine.loadModel({ uid: parent.viewUid })) as PopupModelLike;
         } catch (e) {
-          console.warn('[FlowEngine] popup.getParentRecordRef loadModel failed:', e);
+          (useCtx.logger || ctx.logger)?.warn?.({ err: e }, '[FlowEngine] popup.getParentRecordRef loadModel failed');
         }
       }
       const params = model?.getStepParams?.('popupSettings', 'openView') || {};
@@ -172,16 +198,23 @@ export function createPopupMeta(ctx: FlowContext): PropertyMetaFactory {
       const dataSourceKey = params?.dataSourceKey || 'main';
       const filterByTk = parent?.filterByTk ?? parent?.sourceId;
       if (!collection || typeof filterByTk === 'undefined' || filterByTk === null) return undefined;
-      return { collection, dataSourceKey, filterByTk };
+      const ref: RecordRef = {
+        collection,
+        dataSourceKey,
+        filterByTk,
+        sourceId: parent?.sourceId,
+        associationName: params?.associationName,
+      };
+      return ref;
     } catch (e) {
-      console.warn('[FlowEngine] popup.getParentRecordRef failed:', e);
+      (flowCtx?.logger || ctx.logger)?.warn?.({ err: e }, '[FlowEngine] popup.getParentRecordRef failed');
       return undefined;
     }
   };
 
   const hasParentNow = (level: number): boolean => {
     try {
-      const nav = ctx.view?.navigation;
+      const nav = (anchorView ?? ctx.view)?.navigation;
       const stack = Array.isArray(nav?.viewStack) ? nav.viewStack : [];
       return stack.length >= level + 1; // level=1 需要至少2层
     } catch (_) {
@@ -196,6 +229,7 @@ export function createPopupMeta(ctx: FlowContext): PropertyMetaFactory {
         title: t('Parent popup'),
         disabled: () => !hasParentNow(level),
         disabledReason: () => (!hasParentNow(level) ? t('No parent popup') : undefined),
+        hidden: () => !hasParentNow(level),
         properties: async () => {
           const parentRef = await getParentRecordRef(level);
           const props: Record<string, any> = {};
@@ -229,6 +263,7 @@ export function createPopupMeta(ctx: FlowContext): PropertyMetaFactory {
             properties: async () => ({
               dataSourceKey: { type: 'string', title: t('Data source key') },
               collectionName: { type: 'string', title: t('Collection name') },
+              associationName: { type: 'string', title: t('Association name') },
               filterByTk: { type: 'string', title: t('filterByTk') },
               sourceId: { type: 'string', title: t('sourceId') },
             }),
@@ -251,10 +286,49 @@ export function createPopupMeta(ctx: FlowContext): PropertyMetaFactory {
     const meta: PropertyMeta = {
       type: 'object',
       title: t('Current popup'),
-      buildVariablesParams: (c) => {
-        const ref = inferViewRecordRef(c);
-        const inputArgs = (c?.view as any)?.inputArgs || {};
-        const out: Record<string, any> = { record: ref };
+      disabled: () => !hasPopupNow(),
+      hidden: () => !hasPopupNow(),
+      buildVariablesParams: async (c) => {
+        if (!hasPopupNow()) return undefined;
+        const ref = await resolveRecordRef(c);
+        const inputArgs = c.view?.inputArgs;
+        type PopupVariableParams = {
+          record?: RecordRef;
+          sourceRecord?: RecordRef;
+          parent?: PopupVariableParams;
+        };
+        const params: PopupVariableParams = {};
+        if (ref) {
+          const merged: RecordRef = { ...ref };
+          if (!merged.associationName && inputArgs?.associationName) {
+            merged.associationName = inputArgs.associationName;
+          }
+          if (typeof merged.sourceId === 'undefined' && typeof inputArgs?.sourceId !== 'undefined') {
+            merged.sourceId = inputArgs?.sourceId;
+          }
+          params.record = merged;
+        }
+
+        // 构建 parent 链（用于服务端解析 ctx.popup.parent[.parent...].record.*）
+        try {
+          const nav = c.view?.navigation;
+          const stack = Array.isArray(nav?.viewStack) ? nav.viewStack : [];
+          if (stack.length >= 2) {
+            let cur: Record<string, any> = params;
+            let level = 1;
+            let parentRef = await getParentRecordRef(level, c);
+            while (parentRef) {
+              if (!cur.parent) cur.parent = {};
+              cur.parent.record = parentRef;
+              cur = cur.parent;
+              level += 1;
+              parentRef = await getParentRecordRef(level, c);
+            }
+          }
+        } catch (err) {
+          c.logger?.debug?.({ err }, '[FlowEngine] buildVariablesParams: build parent-chain failed');
+        }
+
         try {
           const srcId = inputArgs?.sourceId;
           const assoc: string | undefined = inputArgs?.associationName;
@@ -263,32 +337,58 @@ export function createPopupMeta(ctx: FlowContext): PropertyMetaFactory {
             // associationName 形如 `posts.comments`，父级集合为 `posts`
             const parentCollectionName = String(assoc).split('.')[0];
             if (parentCollectionName) {
-              out.sourceRecord = {
+              params.sourceRecord = {
                 collection: parentCollectionName,
                 dataSourceKey: dsKey,
                 filterByTk: srcId,
               };
             }
           }
-        } catch (_) {
-          // 忽略异常，保持 record 正常返回
+        } catch (err) {
+          c.logger?.debug?.({ err }, '[FlowEngine] buildVariablesParams: infer sourceRecord failed');
         }
-        return out;
+        return params;
       },
       properties: async () => {
         const props: Record<string, any> = {};
         // 当前弹窗 UID（纯前端变量）
         props.uid = { type: 'string', title: t('Popup uid') };
-        const base = await buildRecordMeta(getCurrentCollection, t('Current popup record'), (c) =>
-          inferViewRecordRef(c),
-        );
-        if (base) props.record = base;
+        // 基于锚定视图计算“当前弹窗记录”的集合与 RecordRef
+        const recordFactory: PropertyMetaFactory = async () => {
+          const col = await getCurrentCollection();
+          if (!col) return null;
+          return await buildRecordMeta(
+            () => col,
+            t('Current popup record'),
+            (c) => resolveRecordRef(c),
+          );
+        };
+        recordFactory.title = t('Current popup record');
+        recordFactory.hasChildren = true;
+        props.record = recordFactory;
         // 当 view.inputArgs 带有 sourceId + associationName 时，提供“上级记录”变量（基于 sourceId 推断）
         try {
-          const inputArgs = (ctx.view as any)?.inputArgs || {};
+          const inputArgs = ctx.view?.inputArgs;
           const srcId = inputArgs?.sourceId;
-          const assoc: string | undefined = inputArgs?.associationName;
-          const dsKey: string = inputArgs?.dataSourceKey || 'main';
+          let assoc: string | undefined = inputArgs?.associationName;
+          let dsKey: string = inputArgs?.dataSourceKey || 'main';
+
+          // 兜底：若 associationName 缺失或不含“.”，尝试从当前视图模型的 openView 参数推断
+          if (!assoc || typeof assoc !== 'string' || !assoc.includes('.')) {
+            const nav = ctx.view?.navigation;
+            const stack = Array.isArray(nav?.viewStack) ? nav.viewStack : [];
+            const last = stack?.[stack.length - 1];
+            if (last?.viewUid) {
+              let model = ctx?.engine?.getModel(last.viewUid, true) as PopupModelLike;
+              if (!model) {
+                model = (await ctx.engine.loadModel({ uid: last.viewUid })) as PopupModelLike;
+              }
+              const p = model?.getStepParams?.('popupSettings', 'openView') || {};
+              assoc = p?.associationName || assoc;
+              dsKey = p?.dataSourceKey || dsKey;
+            }
+          }
+
           if (srcId != null && srcId !== '' && assoc && typeof assoc === 'string') {
             const parentCollectionName = String(assoc).includes('.') ? String(assoc).split('.')[0] : undefined;
             if (parentCollectionName) {
@@ -310,8 +410,8 @@ export function createPopupMeta(ctx: FlowContext): PropertyMetaFactory {
               }
             }
           }
-        } catch (_) {
-          // ignore
+        } catch (err) {
+          ctx.logger?.debug?.({ err }, '[FlowEngine] popup.properties: build sourceRecord failed');
         }
         const resourceMeta: PropertyMeta = {
           type: 'object',
@@ -319,6 +419,7 @@ export function createPopupMeta(ctx: FlowContext): PropertyMetaFactory {
           properties: async () => ({
             dataSourceKey: { type: 'string', title: t('Data source key') },
             collectionName: { type: 'string', title: t('Collection name') },
+            associationName: { type: 'string', title: t('Association name') },
             filterByTk: { type: 'string', title: t('filterByTk') },
             sourceId: { type: 'string', title: t('sourceId') },
           }),
@@ -346,6 +447,7 @@ export function createPopupMeta(ctx: FlowContext): PropertyMetaFactory {
 interface PopupNodeResource {
   dataSourceKey: string;
   collectionName?: string;
+  associationName?: string;
   filterByTk?: any;
   sourceId?: any;
 }
@@ -356,15 +458,40 @@ interface PopupNode {
   parent?: PopupNode;
 }
 
-export async function buildPopupRuntime(ctx: FlowContext, view: FlowView): Promise<PopupNode> {
+export async function buildPopupRuntime(ctx: FlowContext, view: FlowView): Promise<PopupNode | undefined> {
   const nav = view?.navigation;
   const stack = Array.isArray(nav?.viewStack) ? nav.viewStack : [];
+
+  const openerUids = view?.inputArgs?.openerUids;
+  const hasOpener = Array.isArray(openerUids) && openerUids.length > 0;
+  const hasStackPopup = stack.length >= 2;
+  const isPopup = hasStackPopup || hasOpener;
+  if (!isPopup) return undefined;
+
+  // 当没有 navigation 堆栈时，退回当前视图的 inputArgs 作为单节点弹窗上下文
+  if (!stack.length) {
+    const args = view?.inputArgs || {};
+    const hasAny =
+      args.collectionName || args.filterByTk != null || args.sourceId != null || args.associationName || args.viewUid;
+    if (!hasAny) return undefined;
+    return {
+      uid: args.viewUid,
+      resource: {
+        dataSourceKey: args.dataSourceKey || 'main',
+        collectionName: args.collectionName,
+        associationName: args.associationName,
+        filterByTk: args.filterByTk,
+        sourceId: args.sourceId,
+      },
+    };
+  }
+
   const buildNode = async (idx: number): Promise<PopupNode | undefined> => {
     if (idx < 0 || !stack[idx]?.viewUid) return undefined;
     const viewUid = stack[idx].viewUid;
-    let model: any = ctx.engine?.getModel?.(viewUid);
-    if (!model && typeof ctx.engine?.loadModel === 'function') {
-      model = await ctx.engine?.loadModel({ uid: viewUid });
+    let model = ctx.engine?.getModel(viewUid, true) as PopupModelLike;
+    if (!model) {
+      model = (await ctx.engine?.loadModel({ uid: viewUid })) as PopupModelLike;
     }
     const p = model?.getStepParams?.('popupSettings', 'openView') || {};
     const collectionName = p?.collectionName;
@@ -374,6 +501,7 @@ export async function buildPopupRuntime(ctx: FlowContext, view: FlowView): Promi
       resource: {
         dataSourceKey,
         collectionName,
+        associationName: p?.associationName,
         filterByTk: stack[idx]?.filterByTk,
         sourceId: stack[idx]?.sourceId,
       },
@@ -390,13 +518,22 @@ export async function buildPopupRuntime(ctx: FlowContext, view: FlowView): Promi
  * 在视图上下文中注册 popup 变量（统一消除重复）
  */
 export function registerPopupVariable(ctx: FlowContext, view: FlowView) {
+  // - 顶层 record / sourceRecord 及其子字段
+  // - 任意层级 parent.parent... 下的 record / sourceRecord 及其子字段
+  const POPUP_SERVER_PATH_RE =
+    /^(?:record|sourceRecord)(?:\.|$)|^parent(?:\.parent)*(?:\.(?:record|sourceRecord))(?:\.|$)/;
   // 始终注册 popup 变量：
   // - 若当前视图无可推断记录，仅在元信息中不呈现 record 字段；
   // - 但仍可依据 navigation 推断并展示上级弹窗信息。
   ctx.defineProperty('popup', {
     get: async () => buildPopupRuntime(ctx, view),
-    meta: createPopupMeta(ctx),
-    resolveOnServer: (p: string) =>
-      p === 'record' || p?.startsWith('record.') || p === 'sourceRecord' || p?.startsWith('sourceRecord.'),
+    meta: createPopupMeta(ctx, view),
+    resolveOnServer: (p: string) => {
+      try {
+        return !!p && POPUP_SERVER_PATH_RE.test(p);
+      } catch (_) {
+        return false;
+      }
+    },
   });
 }