@nocobase/flow-engine 2.2.0-beta.9 → 2.2.0

package/src/utils/dirtyAwareApiClient.ts

@@ -7,13 +7,28 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import type { ActionParams, APIClient, IResource, RequestOptions } from '@nocobase/sdk';
+import { APIClient } from '@nocobase/sdk';
+import type { ActionParams, IResource, RequestOptions } from '@nocobase/sdk';
 import type { FlowContext } from '../flowContext';
 import { getDataSourceKeyFromHeaders, markDataSourceDirty } from './dataSourceDirty';
 
 type ResourceActionFn = (params?: ActionParams, opts?: unknown) => Promise<unknown>;
 
 export const SKIP_DATA_SOURCE_DIRTY = '__nocobaseSkipDataSourceDirty';
+// Carries one logical mutation through APIClient's request/resource cross-dispatch.
+const DIRTY_DISPATCH_TOKEN = Symbol('nocobaseDirtyDispatchToken');
+
+type DirtyDispatchToken = {
+  marked: boolean;
+  requestKey?: string;
+  resourceKey?: string;
+  skip: boolean;
+};
+
+type DirtyDispatchFrame = {
+  key?: string;
+  token: DirtyDispatchToken;
+};
 
 type ResourceRequestOptions = RequestOptions & {
   resource?: unknown;
@@ -21,14 +36,25 @@ type ResourceRequestOptions = RequestOptions & {
   action?: unknown;
   headers?: unknown;
   [SKIP_DATA_SOURCE_DIRTY]?: boolean;
+  [DIRTY_DISPATCH_TOKEN]?: DirtyDispatchToken;
 };
 
 type DirtyResourceAction = {
   dataSourceKey?: string;
   resourceName: string;
+  resourceOf?: unknown;
   actionName: string;
 };
 
+export const PREPARE_CONTEXT_RESOURCE_ACTION_PARAMS = Symbol('prepareContextResourceActionParams');
+
+type ContextResourceActionParamsPreparer = {
+  [PREPARE_CONTEXT_RESOURCE_ACTION_PARAMS]?: (
+    action: DirtyResourceAction,
+    params: ActionParams | undefined,
+  ) => ActionParams | undefined;
+};
+
 type ApiUrlProvider = {
   getApiUrl?: (pathname?: string) => string;
 };
@@ -312,6 +338,7 @@ function resolveDirtyResourceActionFromResource(
 
   return {
     resourceName: normalizedResourceName,
+    resourceOf,
     actionName: normalizedActionName,
   };
 }
@@ -329,6 +356,53 @@ function resolveDirtyResourceAction(
   return parseDirtyResourceActionFromUrl(options?.url, context);
 }
 
+function getDirtyResourceActionDispatchKey(
+  dirtyResourceAction: DirtyResourceAction | undefined,
+  headers: unknown,
+): string | undefined {
+  if (!dirtyResourceAction) {
+    return undefined;
+  }
+  return JSON.stringify([
+    dirtyResourceAction.dataSourceKey || getDataSourceKeyFromHeaders(headers),
+    dirtyResourceAction.resourceName,
+    dirtyResourceAction.actionName,
+  ]);
+}
+
+function getRequestDispatchKey(options: ResourceRequestOptions, context: FlowContext): string | undefined {
+  return getDirtyResourceActionDispatchKey(resolveDirtyResourceAction(options, context), options.headers);
+}
+
+function getResourceDispatchKey(name: unknown, of: unknown, headers: unknown): string | undefined {
+  const resourceName = String(name ?? '').trim();
+  if (!resourceName) {
+    return undefined;
+  }
+  return JSON.stringify([resourceName, String(of ?? ''), getDataSourceKeyFromHeaders(headers)]);
+}
+
+function getMatchingRequestToken(
+  token: DirtyDispatchToken | undefined,
+  requestKey: string | undefined,
+): DirtyDispatchToken | undefined {
+  // A matching key prevents helper requests inside an override from sharing the outer mutation token.
+  if (!token || !requestKey || (token.requestKey && token.requestKey !== requestKey)) {
+    return undefined;
+  }
+  return token;
+}
+
+function getMatchingResourceToken(
+  token: DirtyDispatchToken | undefined,
+  resourceKey: string | undefined,
+): DirtyDispatchToken | undefined {
+  if (!token || !resourceKey || (token.resourceKey && token.resourceKey !== resourceKey)) {
+    return undefined;
+  }
+  return token;
+}
+
 function markResourceActionDataSourceDirty(
   context: FlowContext,
   dirtyResourceAction: DirtyResourceAction,
@@ -342,12 +416,31 @@ function markResourceActionDataSourceDirty(
   });
 }
 
+function markResourceActionDataSourceDirtyOnce(
+  token: DirtyDispatchToken,
+  context: FlowContext,
+  dirtyResourceAction: DirtyResourceAction | undefined,
+  headers: unknown,
+) {
+  if (token.skip || token.marked || !dirtyResourceAction || !isMutatingResourceAction(dirtyResourceAction.actionName)) {
+    return;
+  }
+  token.marked = true;
+  markResourceActionDataSourceDirty(context, dirtyResourceAction, headers);
+}
+
+function isObjectRecord(value: unknown): value is Record<PropertyKey, unknown> {
+  return !!value && typeof value === 'object';
+}
+
 function createDirtyAwareResource(
   context: FlowContext,
   resource: IResource,
   resourceName: string,
   resourceOf: unknown,
   headers: unknown,
+  requestTokenStack: DirtyDispatchFrame[],
+  parentToken?: DirtyDispatchToken,
 ): IResource {
   return new Proxy(resource, {
     get(target, prop, receiver) {
@@ -358,10 +451,54 @@ function createDirtyAwareResource(
 
       const action = original as ResourceActionFn;
       return async (...args: Parameters<ResourceActionFn>) => {
-        const result = await action(...args);
+        const actionOptions = isObjectRecord(args[1]) ? args[1] : undefined;
         const dirtyResourceAction = resolveDirtyResourceActionFromResource(resourceName, resourceOf, prop, context);
-        if (dirtyResourceAction) {
-          markResourceActionDataSourceDirty(context, dirtyResourceAction, headers);
+        const prepareParams = (context as ContextResourceActionParamsPreparer)[PREPARE_CONTEXT_RESOURCE_ACTION_PARAMS];
+        const actionParams =
+          dirtyResourceAction && typeof prepareParams === 'function'
+            ? prepareParams.call(
+                context,
+                {
+                  ...dirtyResourceAction,
+                  dataSourceKey: dirtyResourceAction.dataSourceKey || getDataSourceKeyFromHeaders(headers),
+                },
+                args[0],
+              )
+            : args[0];
+        const requestKey = getDirtyResourceActionDispatchKey(dirtyResourceAction, headers);
+        const resourceKey = getResourceDispatchKey(resourceName, resourceOf, headers);
+        const inheritedToken =
+          getMatchingRequestToken(
+            actionOptions?.[DIRTY_DISPATCH_TOKEN] as DirtyDispatchToken | undefined,
+            requestKey,
+          ) || getMatchingRequestToken(parentToken, requestKey);
+        const token = inheritedToken || { marked: false, skip: false };
+        const ownsToken = !inheritedToken;
+        token.requestKey ||= requestKey;
+        token.resourceKey ||= resourceKey;
+        if (actionOptions?.[SKIP_DATA_SOURCE_DIRTY]) {
+          token.skip = true;
+        }
+        const forwardedArgs: Parameters<ResourceActionFn> =
+          actionOptions || args[1] == null
+            ? [
+                actionParams,
+                {
+                  ...actionOptions,
+                  [DIRTY_DISPATCH_TOKEN]: token,
+                },
+              ]
+            : [actionParams, args[1]];
+        let actionResult: Promise<unknown>;
+        requestTokenStack.push({ key: requestKey, token });
+        try {
+          actionResult = Reflect.apply(action, receiver, forwardedArgs);
+        } finally {
+          requestTokenStack.pop();
+        }
+        const result = await actionResult;
+        if (ownsToken) {
+          markResourceActionDataSourceDirtyOnce(token, context, dirtyResourceAction, headers);
         }
         return result;
       };
@@ -370,34 +507,232 @@ function createDirtyAwareResource(
 }
 
 function createDirtyAwareApiClient(api: DirtyAwareAPIClient, context: FlowContext): APIClient {
+  const baseResource = api.resource;
+  const baseRequest = api.request;
+  // SDK methods use the dispatch receiver; custom methods keep the original instance for private fields and state.
+  const shouldUseResourceDispatchReceiver = baseResource === APIClient.prototype.resource;
+  const shouldUseRequestDispatchReceiver = baseRequest === APIClient.prototype.request;
+  // Stacks cover synchronous delegation; the symbol token survives async overrides that forward arguments.
+  const resourceTokenStack: DirtyDispatchFrame[] = [];
+  const requestTokenStack: DirtyDispatchFrame[] = [];
+  let hasResourceOverride = false;
+  let resourceOverride: unknown;
+  let hasRequestOverride = false;
+  let requestOverride: unknown;
+
+  const getCurrentResource = () => (hasResourceOverride ? resourceOverride : resource) as APIClient['resource'];
+  const getCurrentRequest = () => (hasRequestOverride ? requestOverride : request) as APIClient['request'];
+
+  const dispatchResource = (
+    token: DirtyDispatchToken | undefined,
+    args: Parameters<APIClient['resource']>,
+  ): IResource => {
+    const resourceKey = getResourceDispatchKey(args[0], args[1], args[2]);
+    const activeToken = getMatchingResourceToken(token, resourceKey);
+    const shouldWrapActions = !!activeToken && hasResourceOverride;
+    if (activeToken) {
+      activeToken.resourceKey ||= resourceKey;
+      resourceTokenStack.push({ key: resourceKey, token: activeToken });
+    }
+    try {
+      const resourceInstance = Reflect.apply(getCurrentResource(), proxy, args);
+      if (!shouldWrapActions || !activeToken) {
+        return resourceInstance;
+      }
+      return new Proxy(resourceInstance, {
+        get(target, prop, receiver) {
+          const original = Reflect.get(target, prop, receiver);
+          if (typeof prop !== 'string' || typeof original !== 'function' || !isMutatingResourceAction(prop)) {
+            return original;
+          }
+
+          const action = original as ResourceActionFn;
+          return (...actionArgs: Parameters<ResourceActionFn>) => {
+            const actionOptions = isObjectRecord(actionArgs[1]) ? actionArgs[1] : undefined;
+            const forwardedArgs: Parameters<ResourceActionFn> =
+              actionOptions || actionArgs[1] == null
+                ? [
+                    actionArgs[0],
+                    {
+                      ...actionOptions,
+                      [DIRTY_DISPATCH_TOKEN]: activeToken,
+                    },
+                  ]
+                : actionArgs;
+            resourceTokenStack.push({ key: resourceKey, token: activeToken });
+            requestTokenStack.push({ key: activeToken.requestKey, token: activeToken });
+            try {
+              return Reflect.apply(action, receiver, forwardedArgs);
+            } finally {
+              requestTokenStack.pop();
+              resourceTokenStack.pop();
+            }
+          };
+        },
+      });
+    } finally {
+      if (activeToken) {
+        resourceTokenStack.pop();
+      }
+    }
+  };
+
+  const createDispatchReceiver = (token?: DirtyDispatchToken): DirtyAwareAPIClient => {
+    const receiver = Object.create(api) as DirtyAwareAPIClient;
+    Object.defineProperties(receiver, {
+      request: {
+        configurable: true,
+        value: (<T, R, D>(config: APIClientRequestConfig): Promise<R> => {
+          const options = config as ResourceRequestOptions;
+          const requestKey = getRequestDispatchKey(options, context);
+          const stackFrame = requestTokenStack.at(-1);
+          const activeToken =
+            getMatchingRequestToken(options?.[DIRTY_DISPATCH_TOKEN], requestKey) ||
+            (requestKey && stackFrame?.key === requestKey ? stackFrame.token : undefined) ||
+            getMatchingRequestToken(token, requestKey);
+          const { [DIRTY_DISPATCH_TOKEN]: _dirtyDispatchToken, ...cleanOptions } = options;
+          const configWithToken = activeToken ? { ...cleanOptions, [DIRTY_DISPATCH_TOKEN]: activeToken } : cleanOptions;
+          if (activeToken) {
+            activeToken.requestKey ||= requestKey;
+            requestTokenStack.push({ key: requestKey, token: activeToken });
+          }
+          try {
+            return Reflect.apply(getCurrentRequest(), proxy, [configWithToken]) as Promise<R>;
+          } finally {
+            if (activeToken) {
+              requestTokenStack.pop();
+            }
+          }
+        }) as APIClient['request'],
+      },
+      resource: {
+        configurable: true,
+        value: ((...args: Parameters<APIClient['resource']>) => {
+          const resourceKey = getResourceDispatchKey(args[0], args[1], args[2]);
+          const stackFrame = resourceTokenStack.at(-1);
+          const activeToken =
+            getMatchingResourceToken(token, resourceKey) ||
+            (resourceKey && stackFrame?.key === resourceKey ? stackFrame.token : undefined);
+          return dispatchResource(activeToken, args);
+        }) as APIClient['resource'],
+      },
+    });
+    return receiver;
+  };
+
   const resource: APIClient['resource'] = (name, of, headers, cancel) => {
-    const targetResource = api.resource(name, of, headers, cancel);
-    return createDirtyAwareResource(context, targetResource, name, of, headers);
+    const resourceKey = getResourceDispatchKey(name, of, headers);
+    const stackFrame = resourceTokenStack.at(-1);
+    const parentToken = resourceKey && stackFrame?.key === resourceKey ? stackFrame.token : undefined;
+    const receiver = createDispatchReceiver(parentToken);
+    const resourceInstance = Reflect.apply(baseResource, shouldUseResourceDispatchReceiver ? receiver : api, [
+      name,
+      of,
+      headers,
+      cancel,
+    ]);
+    return createDirtyAwareResource(context, resourceInstance, name, of, headers, requestTokenStack, parentToken);
   };
 
   const request = (<T, R, D>(config: APIClientRequestConfig): Promise<R> => {
     const options = config as ResourceRequestOptions;
+    const requestKey = getRequestDispatchKey(options, context);
+    const stackFrame = requestTokenStack.at(-1);
+    const inheritedToken =
+      getMatchingRequestToken(options?.[DIRTY_DISPATCH_TOKEN], requestKey) ||
+      (requestKey && stackFrame?.key === requestKey ? stackFrame.token : undefined);
+    const token = inheritedToken || { marked: false, skip: false };
+    const ownsToken = !inheritedToken;
+    token.requestKey ||= requestKey;
+    if (typeof options.resource === 'string') {
+      token.resourceKey ||= getResourceDispatchKey(options.resource, options.resourceOf, options.headers);
+    }
     const skipDataSourceDirty = options?.[SKIP_DATA_SOURCE_DIRTY];
-    const dirtyResourceAction = skipDataSourceDirty ? undefined : resolveDirtyResourceAction(options, context);
-    const { [SKIP_DATA_SOURCE_DIRTY]: _skipDataSourceDirty, ...cleanConfig } = options;
-    return api.request<T, R, D>(cleanConfig as typeof config).then((result) => {
-      if (dirtyResourceAction && isMutatingResourceAction(dirtyResourceAction.actionName)) {
-        markResourceActionDataSourceDirty(context, dirtyResourceAction, options.headers);
+    if (skipDataSourceDirty) {
+      token.skip = true;
+    }
+    const dirtyResourceAction = resolveDirtyResourceAction(options, context);
+    const {
+      [DIRTY_DISPATCH_TOKEN]: _dirtyDispatchToken,
+      [SKIP_DATA_SOURCE_DIRTY]: _skipDataSourceDirty,
+      ...cleanConfig
+    } = options;
+    const receiver = createDispatchReceiver(token);
+    return (
+      Reflect.apply(baseRequest, shouldUseRequestDispatchReceiver ? receiver : api, [cleanConfig]) as Promise<R>
+    ).then((result) => {
+      if (ownsToken) {
+        markResourceActionDataSourceDirtyOnce(token, context, dirtyResourceAction, options.headers);
       }
       return result;
     });
   }) as APIClient['request'];
 
+  const isLockedOwnProperty = (target: DirtyAwareAPIClient, prop: PropertyKey) => {
+    const descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+    return !!descriptor && !descriptor.configurable;
+  };
+
   const proxy = new Proxy(api, {
     get(target, prop, receiver) {
       if (prop === 'resource') {
-        return resource;
+        if (isLockedOwnProperty(target, prop)) {
+          return Reflect.get(target, prop, receiver);
+        }
+        return hasResourceOverride ? resourceOverride : resource;
       }
       if (prop === 'request') {
-        return request;
+        if (isLockedOwnProperty(target, prop)) {
+          return Reflect.get(target, prop, receiver);
+        }
+        return hasRequestOverride ? requestOverride : request;
       }
       return Reflect.get(target, prop, receiver);
     },
+    set(target, prop, value, receiver) {
+      if (prop === 'resource') {
+        const descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+        if (descriptor && (!descriptor.configurable || !Reflect.isExtensible(target))) {
+          return false;
+        }
+        hasResourceOverride = true;
+        resourceOverride = value;
+        return true;
+      }
+      if (prop === 'request') {
+        const descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+        if (descriptor && (!descriptor.configurable || !Reflect.isExtensible(target))) {
+          return false;
+        }
+        hasRequestOverride = true;
+        requestOverride = value;
+        return true;
+      }
+      return Reflect.set(target, prop, value, receiver);
+    },
+    deleteProperty(target, prop) {
+      if (prop !== 'resource' && prop !== 'request') {
+        return Reflect.deleteProperty(target, prop);
+      }
+      const descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+      if (descriptor && (!descriptor.configurable || !Reflect.isExtensible(target))) {
+        return false;
+      }
+      if (prop === 'resource') {
+        hasResourceOverride = false;
+        resourceOverride = undefined;
+      } else {
+        hasRequestOverride = false;
+        requestOverride = undefined;
+      }
+      return true;
+    },
+    defineProperty(target, prop, descriptor) {
+      if (prop === 'resource' || prop === 'request') {
+        return false;
+      }
+      return Reflect.defineProperty(target, prop, descriptor);
+    },
   }) as APIClient;
   dirtyAwareApiClientProxies.add(proxy);
   return proxy;

package/src/utils/index.ts

@@ -31,7 +31,12 @@ export { defineAction } from './flow-definitions';
 export { isInheritedFrom } from './inheritance';
 
 // 参数解析器
-export { resolveCreateModelOptions, resolveDefaultParams, resolveExpressions } from './params-resolvers';
+export {
+  buildFlowModelResolveDescriptor,
+  resolveCreateModelOptions,
+  resolveDefaultParams,
+  resolveExpressions,
+} from './params-resolvers';
 
 // Schema 工具
 export {
@@ -48,7 +53,11 @@ export { setupRuntimeContextSteps } from './setupRuntimeContextSteps';
 
 // Record Proxy 工具
 export { createCollectionContextMeta } from './createCollectionContextMeta';
-export { createAssociationAwareObjectMetaFactory, createAssociationSubpathResolver } from './associationObjectVariable';
+export {
+  createAssociationAwareObjectMetaFactory,
+  createAssociationSubpathResolver,
+  getAssociationFilterByTk,
+} from './associationObjectVariable';
 export {
   buildRecordMeta,
   collectContextParamsForTemplate,
@@ -83,8 +92,14 @@ export {
   isCtxDatePathPrefix,
   isCtxDateExpression,
   parseCtxDateExpression,
+  parseCtxDateExpressionConfig,
   resolveCtxDatePath,
+  serializeCtxDateExpressionConfig,
   serializeCtxDateValue,
+  type CtxDateExpressionConfig,
+  type CtxDatePreset,
+  type CtxDateRelativeDirection,
+  type CtxDateRelativeUnit,
 } from './dateVariable';
 
 // RunJS value helpers

package/src/utils/loadedPageCache.ts

@@ -123,6 +123,13 @@ export const createLoadedPageCache = () => {
       }
     },
 
+    markDirtyForOptions(options?: LoadedPageOptions): void {
+      const key = getLoadedPageKey(options);
+      if (key) {
+        dirtyKeys.add(key);
+      }
+    },
+
     shouldBypass(options?: LoadedPageOptions, isFlowSettingsEnabled?: () => boolean): boolean {
       const key = getLoadedPageKey(options);
       if (!key || !dirtyKeys.has(key)) {

package/src/utils/params-resolvers.ts

@@ -8,6 +8,7 @@
  */
 
 import { getValuesByPath } from '@nocobase/shared';
+import { generateFlowModelRdFromToken } from '@nocobase/utils/client';
 import _ from 'lodash';
 import { FlowContext, FlowModelContext, FlowRuntimeContext } from '../flowContext';
 import type { FlowModel } from '../models';
@@ -78,6 +79,8 @@ export type JSONValue = string | { [key: string]: JSONValue } | JSONValue[];
 // =========================
 
 type BatchPayload = {
+  contractRd?: string;
+  rd?: string;
   template: JSONValue;
   contextParams?: ServerContextParams | undefined;
 };
@@ -170,6 +173,8 @@ export function enqueueVariablesResolve(ctx: FlowRuntimeContext, payload: BatchP
     try {
       const batch = items.map((it) => ({
         id: it.id,
+        contractRd: it.payload.contractRd,
+        rd: it.payload.rd,
         template: it.payload.template,
         contextParams: it.payload.contextParams || {},
       }));
@@ -218,6 +223,13 @@ export function enqueueVariablesResolve(ctx: FlowRuntimeContext, payload: BatchP
   return p;
 }
 
+export function buildFlowModelResolveDescriptor(
+  ctx: Pick<FlowModelContext, 'api'>,
+  flowModelUid?: string | number | null,
+) {
+  return generateFlowModelRdFromToken(flowModelUid, ctx?.api?.auth?.token);
+}
+
 /**
  * 解析参数中的 {{xxx}} 表达式，自动处理异步属性访问
  */

package/src/utils/variablesParams.ts

@@ -263,5 +263,15 @@ export async function collectContextParamsForTemplate(
       input[key] = built;
     }
   }
+
+  const viewPaths = usage.view || [];
+  if (
+    !input.view &&
+    viewPaths.some((path) => path === 'record' || path.startsWith('record.') || path.startsWith('record['))
+  ) {
+    const recordRef = inferViewRecordRef(ctx);
+    if (recordRef) input.view = { record: recordRef };
+  }
+
   return buildServerContextParams(ctx, input);
 }

package/src/views/createViewMeta.ts

@@ -15,6 +15,13 @@ import type { FlowView } from './FlowView';
 
 type PopupModelLike = { getStepParams?: (a: string, b: string) => any } | undefined;
 
+function buildPopupSourceRecordRef(ref?: Pick<RecordRef, 'associationName' | 'dataSourceKey' | 'sourceId'>) {
+  if (ref?.sourceId == null || ref.sourceId === '' || typeof ref.associationName !== 'string') return undefined;
+  const collection = ref.associationName.split('.')[0];
+  if (!collection) return undefined;
+  return { collection, dataSourceKey: ref.dataSourceKey || 'main', filterByTk: ref.sourceId };
+}
+
 function isDefined(value: any) {
   return value !== undefined && value !== null;
 }
@@ -327,13 +334,15 @@ export function createPopupMeta(ctx: FlowContext, anchorView?: FlowView): Proper
           const stack = getViewStack(view);
           const currentIndex = getAnchoredViewStackIndex(view, stack);
           if (currentIndex >= 2) {
-            let cur: Record<string, any> = params;
+            let cur = params;
             let level = 1;
             let parentRef = await getParentRecordRef(level, c);
             while (parentRef) {
-              if (!cur.parent) cur.parent = {};
-              cur.parent.record = parentRef;
-              cur = cur.parent;
+              const parent: PopupVariableParams = { record: parentRef };
+              const sourceRecord = buildPopupSourceRecordRef(parentRef);
+              if (sourceRecord) parent.sourceRecord = sourceRecord;
+              cur.parent = parent;
+              cur = parent;
               level += 1;
               parentRef = await getParentRecordRef(level, c);
             }
@@ -343,20 +352,12 @@ export function createPopupMeta(ctx: FlowContext, anchorView?: FlowView): Proper
         }
 
         try {
-          const srcId = inputArgs?.sourceId;
-          const assoc: string | undefined = inputArgs?.associationName;
-          const dsKey: string = inputArgs?.dataSourceKey || 'main';
-          if (srcId != null && srcId !== '' && assoc && typeof assoc === 'string') {
-            // associationName 形如 `posts.comments`，父级集合为 `posts`
-            const parentCollectionName = String(assoc).split('.')[0];
-            if (parentCollectionName) {
-              params.sourceRecord = {
-                collection: parentCollectionName,
-                dataSourceKey: dsKey,
-                filterByTk: srcId,
-              };
-            }
-          }
+          const sourceRecord = buildPopupSourceRecordRef({
+            sourceId: inputArgs?.sourceId,
+            associationName: inputArgs?.associationName,
+            dataSourceKey: inputArgs?.dataSourceKey,
+          });
+          if (sourceRecord) params.sourceRecord = sourceRecord;
         } catch (err) {
           c.logger?.debug?.({ err }, '[FlowEngine] buildVariablesParams: infer sourceRecord failed');
         }
@@ -474,12 +475,14 @@ interface PopupNodeResource {
 interface PopupNode {
   uid?: string;
   resource: PopupNodeResource;
+  sourceRecord?: unknown;
   parent?: PopupNode;
 }
 
 export async function buildPopupRuntime(ctx: FlowContext, view: FlowView): Promise<PopupNode | undefined> {
   const stack = getViewStack(view);
   const currentIndex = getAnchoredViewStackIndex(view, stack);
+  const sourceRecord = view?.inputArgs?.parentItem?.value;
 
   const openerUids = view?.inputArgs?.openerUids;
   const hasOpener = Array.isArray(openerUids) && openerUids.length > 0;
@@ -502,6 +505,7 @@ export async function buildPopupRuntime(ctx: FlowContext, view: FlowView): Promi
         filterByTk: args.filterByTk,
         sourceId: args.sourceId,
       },
+      ...(typeof sourceRecord !== 'undefined' ? { sourceRecord } : {}),
     };
   }
 
@@ -530,6 +534,9 @@ export async function buildPopupRuntime(ctx: FlowContext, view: FlowView): Promi
     return node;
   };
   const currentNode = await buildNode(currentIndex);
+  if (currentNode && typeof sourceRecord !== 'undefined') {
+    currentNode.sourceRecord = sourceRecord;
+  }
   return currentNode;
 }
 
@@ -541,6 +548,30 @@ export function registerPopupVariable(ctx: FlowContext, view: FlowView) {
   // - 任意层级 parent.parent... 下的 record / sourceRecord 及其子字段
   const POPUP_SERVER_PATH_RE =
     /^(?:record|sourceRecord)(?:\.|$)|^parent(?:\.parent)*(?:\.(?:record|sourceRecord))(?:\.|$)/;
+  const shouldResolveSourceRecordOnServer = (path: string): boolean => {
+    if (path !== 'sourceRecord' && !path.startsWith('sourceRecord.')) return false;
+
+    const parentItem = view?.inputArgs?.parentItem;
+    if (typeof parentItem?.value === 'undefined') return true;
+
+    const sourcePath = path === 'sourceRecord' ? '' : path.slice('sourceRecord.'.length);
+    if (!sourcePath) return false;
+
+    const parentItemResolver = view?.inputArgs?.parentItemResolver;
+    if (typeof parentItemResolver === 'function') {
+      return parentItemResolver(`value.${sourcePath}`);
+    }
+
+    const segments = sourcePath.split('.').filter(Boolean);
+    let current = parentItem.value;
+    for (const segment of segments) {
+      if (current === null || typeof current !== 'object' || !(segment in current)) {
+        return true;
+      }
+      current = current[segment];
+    }
+    return false;
+  };
   // 始终注册 popup 变量：
   // - 若当前视图无可推断记录，仅在元信息中不呈现 record 字段；
   // - 但仍可依据 navigation 推断并展示上级弹窗信息。
@@ -549,6 +580,9 @@ export function registerPopupVariable(ctx: FlowContext, view: FlowView) {
     meta: createPopupMeta(ctx, view),
     resolveOnServer: (p: string) => {
       try {
+        if (p === 'sourceRecord' || p.startsWith('sourceRecord.')) {
+          return shouldResolveSourceRecordOnServer(p);
+        }
         return !!p && POPUP_SERVER_PATH_RE.test(p);
       } catch (_) {
         return false;