@nocobase/flow-engine 2.2.0-beta.15 → 2.2.0-beta.17

package/lib/utils/dateVariable.js

@@ -43,13 +43,15 @@ __export(dateVariable_exports, {
   isCtxDateExpression: () => isCtxDateExpression,
   isCtxDatePathPrefix: () => isCtxDatePathPrefix,
   parseCtxDateExpression: () => parseCtxDateExpression,
+  parseCtxDateExpressionConfig: () => parseCtxDateExpressionConfig,
   resolveCtxDatePath: () => resolveCtxDatePath,
+  serializeCtxDateExpressionConfig: () => serializeCtxDateExpressionConfig,
   serializeCtxDateValue: () => serializeCtxDateValue
 });
 module.exports = __toCommonJS(dateVariable_exports);
 var import_dayjs = __toESM(require("dayjs"));
 const CTX_DATE_REGEX = /^\{\{\s*ctx\.date(?:\.(.+?))?\s*\}\}$/;
-const PRESET_KEYS = /* @__PURE__ */ new Set([
+const PRESET_KEY_LIST = [
   "today",
   "now",
   "yesterday",
@@ -66,9 +68,11 @@ const PRESET_KEYS = /* @__PURE__ */ new Set([
   "thisYear",
   "lastYear",
   "nextYear"
-]);
+];
+const PRESET_KEYS = new Set(PRESET_KEY_LIST);
 const RELATIVE_DIRECTIONS = /* @__PURE__ */ new Set(["next", "past"]);
 const RELATIVE_UNITS = /* @__PURE__ */ new Set(["day", "week", "month", "year"]);
+const MAX_DATE_FORMAT_LENGTH = 128;
 function parseCtxDateSegments(value) {
   if (typeof value !== "string") return null;
   const trimmed = value.trim();
@@ -79,8 +83,7 @@ function parseCtxDateSegments(value) {
   return rawPath.split(".").map((seg) => seg.trim()).filter(Boolean);
 }
 __name(parseCtxDateSegments, "parseCtxDateSegments");
-function isCtxDatePathPrefix(pathSegments) {
-  const segments = withDatePrefix((pathSegments || []).map((seg) => String(seg)));
+function isBaseCtxDatePathPrefix(segments) {
   if (segments[0] !== "date") return false;
   if (segments.length === 1) return true;
   if (segments[1] === "preset") {
@@ -117,6 +120,34 @@ function isCtxDatePathPrefix(pathSegments) {
   }
   return false;
 }
+__name(isBaseCtxDatePathPrefix, "isBaseCtxDatePathPrefix");
+function decodeFormatToken(token) {
+  const raw = String(token || "");
+  if (!raw.startsWith("v")) return void 0;
+  const decoded = decodeBase64Url(raw.slice(1));
+  if (!decoded || decoded.length > MAX_DATE_FORMAT_LENGTH) return void 0;
+  return decoded;
+}
+__name(decodeFormatToken, "decodeFormatToken");
+function splitFormattedDateSegments(segments) {
+  if (segments[0] !== "date") return null;
+  if (segments[1] !== "format") return { baseSegments: segments };
+  if (segments.length < 4) return null;
+  const format = decodeFormatToken(segments[2]);
+  if (!format) return null;
+  return { baseSegments: ["date", ...segments.slice(3)], format };
+}
+__name(splitFormattedDateSegments, "splitFormattedDateSegments");
+function isCtxDatePathPrefix(pathSegments) {
+  const segments = withDatePrefix((pathSegments || []).map((seg) => String(seg)));
+  if (segments[0] !== "date") return false;
+  if (segments.length === 1) return true;
+  if (segments[1] !== "format") return isBaseCtxDatePathPrefix(segments);
+  if (segments.length === 2) return true;
+  if (segments.length === 3) return typeof decodeFormatToken(segments[2]) === "string";
+  const formatted = splitFormattedDateSegments(segments);
+  return formatted ? isBaseCtxDatePathPrefix(formatted.baseSegments) : false;
+}
 __name(isCtxDatePathPrefix, "isCtxDatePathPrefix");
 function withDatePrefix(pathSegments) {
   if (pathSegments[0] === "date") {
@@ -225,26 +256,31 @@ __name(isCtxDateExpression, "isCtxDateExpression");
 function isCompleteCtxDatePath(pathSegments) {
   if (!isCtxDatePathPrefix(pathSegments)) return false;
   const segments = withDatePrefix((pathSegments || []).map((seg) => String(seg)));
-  if (segments[0] !== "date") return false;
-  if (segments[1] === "preset") {
-    return segments.length === 3 && PRESET_KEYS.has(segments[2]);
+  const formatted = splitFormattedDateSegments(segments);
+  if (!formatted) return false;
+  const baseSegments = formatted.baseSegments;
+  if (baseSegments[1] === "preset") {
+    return baseSegments.length === 3 && PRESET_KEYS.has(baseSegments[2]);
   }
-  if (segments[1] === "relative") {
-    if (segments.length !== 5) return false;
-    return RELATIVE_DIRECTIONS.has(segments[2]) && RELATIVE_UNITS.has(segments[3]) && typeof parseNumberToken(segments[4]) === "number";
+  if (baseSegments[1] === "relative") {
+    if (baseSegments.length !== 5) return false;
+    return RELATIVE_DIRECTIONS.has(baseSegments[2]) && RELATIVE_UNITS.has(baseSegments[3]) && typeof parseNumberToken(baseSegments[4]) === "number";
   }
-  if (segments[1] === "exact" && segments[2] === "single" && segments[3] === "date") {
-    return segments.length === 5 && /^v.+/.test(segments[4]);
+  if (baseSegments[1] === "exact" && baseSegments[2] === "single" && baseSegments[3] === "date") {
+    return baseSegments.length === 5 && /^v.+/.test(baseSegments[4]);
   }
-  if (segments[1] === "exact" && segments[2] === "range" && segments[3] === "date") {
-    return segments.length === 6 && /^v.+/.test(segments[4]) && /^v.+/.test(segments[5]);
+  if (baseSegments[1] === "exact" && baseSegments[2] === "range" && baseSegments[3] === "date") {
+    return baseSegments.length === 6 && /^v.+/.test(baseSegments[4]) && /^v.+/.test(baseSegments[5]);
   }
   return false;
 }
 __name(isCompleteCtxDatePath, "isCompleteCtxDatePath");
 function parseCtxDateExpression(value) {
   if (!isCtxDateExpression(value)) return void 0;
-  const segments = withDatePrefix(parseCtxDateSegments(value) || []);
+  const rawSegments = withDatePrefix(parseCtxDateSegments(value) || []);
+  const formatted = splitFormattedDateSegments(rawSegments);
+  if (!formatted) return void 0;
+  const segments = formatted.baseSegments;
   if (segments[1] === "preset" && segments.length === 3 && PRESET_KEYS.has(segments[2])) {
     return { type: segments[2] };
   }
@@ -272,6 +308,60 @@ function parseCtxDateExpression(value) {
   return void 0;
 }
 __name(parseCtxDateExpression, "parseCtxDateExpression");
+function parseCtxDateExpressionConfig(value) {
+  if (!isCtxDateExpression(value)) return void 0;
+  const segments = withDatePrefix(parseCtxDateSegments(value) || []);
+  const formatted = splitFormattedDateSegments(segments);
+  if (!formatted) return void 0;
+  const parsed = parseCtxDateExpression(value);
+  const formatConfig = formatted.format ? { format: formatted.format } : {};
+  if (typeof parsed === "string") {
+    return { kind: "exact", value: parsed, ...formatConfig };
+  }
+  if (Array.isArray(parsed) && parsed.length === 2 && typeof parsed[0] === "string" && typeof parsed[1] === "string") {
+    return { kind: "exact", value: [parsed[0], parsed[1]], ...formatConfig };
+  }
+  if (!parsed || typeof parsed !== "object") return void 0;
+  const typed = parsed;
+  if (typed.type === "past" || typed.type === "next") {
+    if (typeof typed.unit !== "string" || !RELATIVE_UNITS.has(typed.unit) || typeof typed.number !== "number") {
+      return void 0;
+    }
+    return {
+      kind: "relative",
+      direction: typed.type,
+      amount: typed.number,
+      unit: typed.unit,
+      ...formatConfig
+    };
+  }
+  if (typeof typed.type === "string" && PRESET_KEYS.has(typed.type)) {
+    return { kind: "preset", preset: typed.type, ...formatConfig };
+  }
+  return void 0;
+}
+__name(parseCtxDateExpressionConfig, "parseCtxDateExpressionConfig");
+function serializeCtxDateExpressionConfig(config) {
+  let legacyValue;
+  if (config.kind === "preset") {
+    if (!PRESET_KEYS.has(config.preset)) return void 0;
+    legacyValue = { type: config.preset };
+  } else if (config.kind === "relative") {
+    if (!RELATIVE_DIRECTIONS.has(config.direction) || !RELATIVE_UNITS.has(config.unit)) return void 0;
+    const amount = Math.floor(Number(config.amount));
+    if (!Number.isFinite(amount) || amount <= 0) return void 0;
+    legacyValue = { type: config.direction, unit: config.unit, number: amount };
+  } else {
+    legacyValue = config.value;
+  }
+  const expression = serializeCtxDateValue(legacyValue);
+  if (!expression || !config.format) return expression;
+  const format = String(config.format);
+  if (!format.trim() || format.length > MAX_DATE_FORMAT_LENGTH) return void 0;
+  const segments = withDatePrefix(parseCtxDateSegments(expression) || []);
+  return toCtxDateExpression(["date", "format", `v${encodeBase64Url(format)}`, ...segments.slice(1)]);
+}
+__name(serializeCtxDateExpressionConfig, "serializeCtxDateExpressionConfig");
 function serializeCtxDateValue(value) {
   if (isCtxDateExpression(value)) {
     return String(value).trim();
@@ -317,8 +407,23 @@ function serializeCtxDateValue(value) {
   return void 0;
 }
 __name(serializeCtxDateValue, "serializeCtxDateValue");
+function formatResolvedDateValue(value, format) {
+  const formatValue = /* @__PURE__ */ __name((item) => {
+    if (typeof item !== "string") return item;
+    const parsed = (0, import_dayjs.default)(item);
+    return parsed.isValid() ? parsed.format(format) : item;
+  }, "formatValue");
+  return Array.isArray(value) ? value.map(formatValue) : formatValue(value);
+}
+__name(formatResolvedDateValue, "formatResolvedDateValue");
 function resolveCtxDatePath(pathSegments) {
-  const segments = withDatePrefix((pathSegments || []).map((seg) => String(seg)));
+  const rawSegments = withDatePrefix((pathSegments || []).map((seg) => String(seg)));
+  const formatted = splitFormattedDateSegments(rawSegments);
+  if (!formatted) return void 0;
+  if (formatted.format) {
+    return formatResolvedDateValue(resolveCtxDatePath(formatted.baseSegments), formatted.format);
+  }
+  const segments = formatted.baseSegments;
   if (segments[0] !== "date") return void 0;
   if (segments[1] === "preset" && segments.length === 3) {
     const key = segments[2];
@@ -375,6 +480,8 @@ __name(resolveCtxDatePath, "resolveCtxDatePath");
   isCtxDateExpression,
   isCtxDatePathPrefix,
   parseCtxDateExpression,
+  parseCtxDateExpressionConfig,
   resolveCtxDatePath,
+  serializeCtxDateExpressionConfig,
   serializeCtxDateValue
 });

package/lib/utils/index.d.ts

@@ -11,17 +11,17 @@ export { escapeT, getT, tExpr } from './translation';
 export { FlowCancelSaveException, FlowExitAllException, FlowExitException } from './exceptions';
 export { defineAction } from './flow-definitions';
 export { isInheritedFrom } from './inheritance';
-export { resolveCreateModelOptions, resolveDefaultParams, resolveExpressions } from './params-resolvers';
+export { buildFlowModelResolveDescriptor, resolveCreateModelOptions, resolveDefaultParams, resolveExpressions, } from './params-resolvers';
 export { compileUiSchema, resolveStepUiSchema, resolveStepDisabledInSettings, resolveUiMode, shouldHideEventInSettings, shouldHideStepInSettings, } from './schema-utils';
 export { setupRuntimeContextSteps } from './setupRuntimeContextSteps';
 export { createCollectionContextMeta } from './createCollectionContextMeta';
-export { createAssociationAwareObjectMetaFactory, createAssociationSubpathResolver } from './associationObjectVariable';
+export { createAssociationAwareObjectMetaFactory, createAssociationSubpathResolver, getAssociationFilterByTk, } from './associationObjectVariable';
 export { buildRecordMeta, collectContextParamsForTemplate, createCurrentRecordMetaFactory, createRecordResolveOnServerWithLocal, createRecordMetaFactory, extractUsedVariableNames, extractUsedVariablePaths, inferRecordRef, type RecordParamsBuilder, } from './variablesParams';
 export { extractPropertyPath, formatPathToVariable, isVariableExpression } from './context';
 export { clearAutoFlowError, getAutoFlowError, setAutoFlowError, type AutoFlowError } from './autoFlowError';
 export { parsePathnameToViewParams, type ViewParam } from './parsePathnameToViewParams';
 export { createOpenViewRouteState, decodeOpenViewRouteState, encodeOpenViewRouteState, isOpenViewRouteStateToken, RUNJS_OPEN_VIEW_ROUTE_STATE, type OpenViewRouteMode, type OpenViewRouteSize, type OpenViewRouteState, } from './openViewRouteState';
-export { decodeBase64Url, encodeBase64Url, isCompleteCtxDatePath, isCtxDatePathPrefix, isCtxDateExpression, parseCtxDateExpression, resolveCtxDatePath, serializeCtxDateValue, } from './dateVariable';
+export { decodeBase64Url, encodeBase64Url, isCompleteCtxDatePath, isCtxDatePathPrefix, isCtxDateExpression, parseCtxDateExpression, parseCtxDateExpressionConfig, resolveCtxDatePath, serializeCtxDateExpressionConfig, serializeCtxDateValue, type CtxDateExpressionConfig, type CtxDatePreset, type CtxDateRelativeDirection, type CtxDateRelativeUnit, } from './dateVariable';
 export { isRunJSValue, normalizeRunJSValue, extractUsedVariablePathsFromRunJS, type RunJSValue } from './runjsValue';
 export { resolveRunJSObjectValues } from './resolveRunJSObjectValues';
 export { prepareRunJsCode, preprocessRunJsTemplates } from './runjsTemplateCompat';

package/lib/utils/index.js

@@ -34,6 +34,7 @@ __export(utils_exports, {
   FlowExitException: () => import_exceptions.FlowExitException,
   MENU_KEYS: () => import_constants.MENU_KEYS,
   RUNJS_OPEN_VIEW_ROUTE_STATE: () => import_openViewRouteState.RUNJS_OPEN_VIEW_ROUTE_STATE,
+  buildFlowModelResolveDescriptor: () => import_params_resolvers.buildFlowModelResolveDescriptor,
   buildRecordMeta: () => import_variablesParams.buildRecordMeta,
   clearAutoFlowError: () => import_autoFlowError.clearAutoFlowError,
   collectContextParamsForTemplate: () => import_variablesParams.collectContextParamsForTemplate,
@@ -57,6 +58,7 @@ __export(utils_exports, {
   extractUsedVariablePaths: () => import_variablesParams.extractUsedVariablePaths,
   extractUsedVariablePathsFromRunJS: () => import_runjsValue.extractUsedVariablePathsFromRunJS,
   formatPathToVariable: () => import_context.formatPathToVariable,
+  getAssociationFilterByTk: () => import_associationObjectVariable.getAssociationFilterByTk,
   getAutoFlowError: () => import_autoFlowError.getAutoFlowError,
   getT: () => import_translation.getT,
   inferRecordRef: () => import_variablesParams.inferRecordRef,
@@ -71,6 +73,7 @@ __export(utils_exports, {
   isVariableExpression: () => import_context.isVariableExpression,
   normalizeRunJSValue: () => import_runjsValue.normalizeRunJSValue,
   parseCtxDateExpression: () => import_dateVariable.parseCtxDateExpression,
+  parseCtxDateExpressionConfig: () => import_dateVariable.parseCtxDateExpressionConfig,
   parsePathnameToViewParams: () => import_parsePathnameToViewParams.parsePathnameToViewParams,
   prepareRunJsCode: () => import_runjsTemplateCompat.prepareRunJsCode,
   preprocessRunJsTemplates: () => import_runjsTemplateCompat.preprocessRunJsTemplates,
@@ -85,6 +88,7 @@ __export(utils_exports, {
   resolveStepDisabledInSettings: () => import_schema_utils.resolveStepDisabledInSettings,
   resolveStepUiSchema: () => import_schema_utils.resolveStepUiSchema,
   resolveUiMode: () => import_schema_utils.resolveUiMode,
+  serializeCtxDateExpressionConfig: () => import_dateVariable.serializeCtxDateExpressionConfig,
   serializeCtxDateValue: () => import_dateVariable.serializeCtxDateValue,
   setAutoFlowError: () => import_autoFlowError.setAutoFlowError,
   setupRuntimeContextSteps: () => import_setupRuntimeContextSteps.setupRuntimeContextSteps,
@@ -127,6 +131,7 @@ var import_randomId = require("./randomId");
   FlowExitException,
   MENU_KEYS,
   RUNJS_OPEN_VIEW_ROUTE_STATE,
+  buildFlowModelResolveDescriptor,
   buildRecordMeta,
   clearAutoFlowError,
   collectContextParamsForTemplate,
@@ -150,6 +155,7 @@ var import_randomId = require("./randomId");
   extractUsedVariablePaths,
   extractUsedVariablePathsFromRunJS,
   formatPathToVariable,
+  getAssociationFilterByTk,
   getAutoFlowError,
   getT,
   inferRecordRef,
@@ -164,6 +170,7 @@ var import_randomId = require("./randomId");
   isVariableExpression,
   normalizeRunJSValue,
   parseCtxDateExpression,
+  parseCtxDateExpressionConfig,
   parsePathnameToViewParams,
   prepareRunJsCode,
   preprocessRunJsTemplates,
@@ -178,6 +185,7 @@ var import_randomId = require("./randomId");
   resolveStepDisabledInSettings,
   resolveStepUiSchema,
   resolveUiMode,
+  serializeCtxDateExpressionConfig,
   serializeCtxDateValue,
   setAutoFlowError,
   setupRuntimeContextSteps,

package/lib/utils/params-resolvers.d.ts

@@ -27,10 +27,13 @@ export type JSONValue = string | {
     [key: string]: JSONValue;
 } | JSONValue[];
 type BatchPayload = {
+    contractRd?: string;
+    rd?: string;
     template: JSONValue;
     contextParams?: ServerContextParams | undefined;
 };
 export declare function enqueueVariablesResolve(ctx: FlowRuntimeContext, payload: BatchPayload): Promise<unknown>;
+export declare function buildFlowModelResolveDescriptor(ctx: Pick<FlowModelContext, 'api'>, flowModelUid?: string | number | null): any;
 /**
  * 解析参数中的 {{xxx}} 表达式，自动处理异步属性访问
  */

package/lib/utils/params-resolvers.js

@@ -37,6 +37,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var params_resolvers_exports = {};
 __export(params_resolvers_exports, {
+  buildFlowModelResolveDescriptor: () => buildFlowModelResolveDescriptor,
   enqueueVariablesResolve: () => enqueueVariablesResolve,
   preprocessExpression: () => preprocessExpression,
   resolveCreateModelOptions: () => resolveCreateModelOptions,
@@ -45,6 +46,7 @@ __export(params_resolvers_exports, {
 });
 module.exports = __toCommonJS(params_resolvers_exports);
 var import_shared = require("@nocobase/shared");
+var import_client = require("@nocobase/utils/client");
 var import_lodash = __toESM(require("lodash"));
 async function resolveDefaultParams(defaultParams, ctx) {
   if (!defaultParams) {
@@ -144,6 +146,8 @@ function enqueueVariablesResolve(ctx, payload) {
     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 || {}
       }));
@@ -187,6 +191,11 @@ function enqueueVariablesResolve(ctx, payload) {
   return p;
 }
 __name(enqueueVariablesResolve, "enqueueVariablesResolve");
+function buildFlowModelResolveDescriptor(ctx, flowModelUid) {
+  var _a, _b;
+  return (0, import_client.generateFlowModelRdFromToken)(flowModelUid, (_b = (_a = ctx == null ? void 0 : ctx.api) == null ? void 0 : _a.auth) == null ? void 0 : _b.token);
+}
+__name(buildFlowModelResolveDescriptor, "buildFlowModelResolveDescriptor");
 async function resolveExpressions(params, ctx) {
   const compile = /* @__PURE__ */ __name(async (source) => {
     if (typeof source === "string" && /\{\{.*?\}\}/.test(source)) {
@@ -308,6 +317,7 @@ async function compileExpression(expression, ctx) {
 __name(compileExpression, "compileExpression");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  buildFlowModelResolveDescriptor,
   enqueueVariablesResolve,
   preprocessExpression,
   resolveCreateModelOptions,

package/lib/utils/variablesParams.js

@@ -210,6 +210,11 @@ async function collectContextParamsForTemplate(ctx, template) {
       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 (0, import_serverContextParams.buildServerContextParams)(ctx, input);
 }
 __name(collectContextParamsForTemplate, "collectContextParamsForTemplate");

package/lib/views/createViewMeta.d.ts

@@ -28,6 +28,7 @@ interface PopupNodeResource {
 interface PopupNode {
     uid?: string;
     resource: PopupNodeResource;
+    sourceRecord?: unknown;
     parent?: PopupNode;
 }
 export declare function buildPopupRuntime(ctx: FlowContext, view: FlowView): Promise<PopupNode | undefined>;

package/lib/views/createViewMeta.js

@@ -33,6 +33,13 @@ __export(createViewMeta_exports, {
 });
 module.exports = __toCommonJS(createViewMeta_exports);
 var import_variablesParams = require("../utils/variablesParams");
+function buildPopupSourceRecordRef(ref) {
+  if ((ref == null ? void 0 : ref.sourceId) == null || ref.sourceId === "" || typeof ref.associationName !== "string") return void 0;
+  const collection = ref.associationName.split(".")[0];
+  if (!collection) return void 0;
+  return { collection, dataSourceKey: ref.dataSourceKey || "main", filterByTk: ref.sourceId };
+}
+__name(buildPopupSourceRecordRef, "buildPopupSourceRecordRef");
 function isDefined(value) {
   return value !== void 0 && value !== null;
 }
@@ -306,9 +313,11 @@ function createPopupMeta(ctx, anchorView) {
             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 = { record: parentRef };
+              const sourceRecord = buildPopupSourceRecordRef(parentRef);
+              if (sourceRecord) parent.sourceRecord = sourceRecord;
+              cur.parent = parent;
+              cur = parent;
               level += 1;
               parentRef = await getParentRecordRef(level, c);
             }
@@ -317,19 +326,12 @@ function createPopupMeta(ctx, anchorView) {
           (_b = (_a = c.logger) == null ? void 0 : _a.debug) == null ? void 0 : _b.call(_a, { err }, "[FlowEngine] buildVariablesParams: build parent-chain failed");
         }
         try {
-          const srcId = inputArgs == null ? void 0 : inputArgs.sourceId;
-          const assoc = inputArgs == null ? void 0 : inputArgs.associationName;
-          const dsKey = (inputArgs == null ? void 0 : inputArgs.dataSourceKey) || "main";
-          if (srcId != null && srcId !== "" && assoc && typeof assoc === "string") {
-            const parentCollectionName = String(assoc).split(".")[0];
-            if (parentCollectionName) {
-              params.sourceRecord = {
-                collection: parentCollectionName,
-                dataSourceKey: dsKey,
-                filterByTk: srcId
-              };
-            }
-          }
+          const sourceRecord = buildPopupSourceRecordRef({
+            sourceId: inputArgs == null ? void 0 : inputArgs.sourceId,
+            associationName: inputArgs == null ? void 0 : inputArgs.associationName,
+            dataSourceKey: inputArgs == null ? void 0 : inputArgs.dataSourceKey
+          });
+          if (sourceRecord) params.sourceRecord = sourceRecord;
         } catch (err) {
           (_d = (_c = c.logger) == null ? void 0 : _c.debug) == null ? void 0 : _d.call(_c, { err }, "[FlowEngine] buildVariablesParams: infer sourceRecord failed");
         }
@@ -426,10 +428,11 @@ function createPopupMeta(ctx, anchorView) {
 }
 __name(createPopupMeta, "createPopupMeta");
 async function buildPopupRuntime(ctx, view) {
-  var _a;
+  var _a, _b, _c;
   const stack = getViewStack(view);
   const currentIndex = getAnchoredViewStackIndex(view, stack);
-  const openerUids = (_a = view == null ? void 0 : view.inputArgs) == null ? void 0 : _a.openerUids;
+  const sourceRecord = (_b = (_a = view == null ? void 0 : view.inputArgs) == null ? void 0 : _a.parentItem) == null ? void 0 : _b.value;
+  const openerUids = (_c = view == null ? void 0 : view.inputArgs) == null ? void 0 : _c.openerUids;
   const hasOpener = Array.isArray(openerUids) && openerUids.length > 0;
   const hasStackPopup = currentIndex >= 1;
   const isPopup = hasStackPopup || hasOpener;
@@ -446,16 +449,17 @@ async function buildPopupRuntime(ctx, view) {
         associationName: args.associationName,
         filterByTk: args.filterByTk,
         sourceId: args.sourceId
-      }
+      },
+      ...typeof sourceRecord !== "undefined" ? { sourceRecord } : {}
     };
   }
   const buildNode = /* @__PURE__ */ __name(async (idx) => {
-    var _a2, _b, _c, _d, _e, _f;
+    var _a2, _b2, _c2, _d, _e, _f;
     if (idx < 0 || !((_a2 = stack[idx]) == null ? void 0 : _a2.viewUid)) return void 0;
     const viewUid = stack[idx].viewUid;
-    let model = (_b = ctx.engine) == null ? void 0 : _b.getModel(viewUid, true);
+    let model = (_b2 = ctx.engine) == null ? void 0 : _b2.getModel(viewUid, true);
     if (!model) {
-      model = await ((_c = ctx.engine) == null ? void 0 : _c.loadModel({ uid: viewUid }));
+      model = await ((_c2 = ctx.engine) == null ? void 0 : _c2.loadModel({ uid: viewUid }));
     }
     const p = ((_d = model == null ? void 0 : model.getStepParams) == null ? void 0 : _d.call(model, "popupSettings", "openView")) || {};
     const collectionName = p == null ? void 0 : p.collectionName;
@@ -475,16 +479,43 @@ async function buildPopupRuntime(ctx, view) {
     return node;
   }, "buildNode");
   const currentNode = await buildNode(currentIndex);
+  if (currentNode && typeof sourceRecord !== "undefined") {
+    currentNode.sourceRecord = sourceRecord;
+  }
   return currentNode;
 }
 __name(buildPopupRuntime, "buildPopupRuntime");
 function registerPopupVariable(ctx, view) {
   const POPUP_SERVER_PATH_RE = /^(?:record|sourceRecord)(?:\.|$)|^parent(?:\.parent)*(?:\.(?:record|sourceRecord))(?:\.|$)/;
+  const shouldResolveSourceRecordOnServer = /* @__PURE__ */ __name((path) => {
+    var _a, _b;
+    if (path !== "sourceRecord" && !path.startsWith("sourceRecord.")) return false;
+    const parentItem = (_a = view == null ? void 0 : view.inputArgs) == null ? void 0 : _a.parentItem;
+    if (typeof (parentItem == null ? void 0 : parentItem.value) === "undefined") return true;
+    const sourcePath = path === "sourceRecord" ? "" : path.slice("sourceRecord.".length);
+    if (!sourcePath) return false;
+    const parentItemResolver = (_b = view == null ? void 0 : view.inputArgs) == null ? void 0 : _b.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;
+  }, "shouldResolveSourceRecordOnServer");
   ctx.defineProperty("popup", {
     get: /* @__PURE__ */ __name(async () => buildPopupRuntime(ctx, view), "get"),
     meta: createPopupMeta(ctx, view),
     resolveOnServer: /* @__PURE__ */ __name((p) => {
       try {
+        if (p === "sourceRecord" || p.startsWith("sourceRecord.")) {
+          return shouldResolveSourceRecordOnServer(p);
+        }
         return !!p && POPUP_SERVER_PATH_RE.test(p);
       } catch (_) {
         return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/flow-engine",
-  "version": "2.2.0-beta.15",
+  "version": "2.2.0-beta.17",
   "private": false,
   "description": "A standalone flow engine for NocoBase, managing workflows, models, and actions.",
   "main": "lib/index.js",
@@ -8,8 +8,8 @@
   "dependencies": {
     "@formily/antd-v5": "1.x",
     "@formily/reactive": "2.x",
-    "@nocobase/sdk": "2.2.0-beta.15",
-    "@nocobase/shared": "2.2.0-beta.15",
+    "@nocobase/sdk": "2.2.0-beta.17",
+    "@nocobase/shared": "2.2.0-beta.17",
     "ahooks": "^3.7.2",
     "axios": "^1.7.0",
     "dayjs": "^1.11.9",
@@ -37,5 +37,5 @@
   ],
   "author": "NocoBase Team",
   "license": "Apache-2.0",
-  "gitHead": "4c471f6b7d26adc412b2cc1d91264572296ca873"
+  "gitHead": "d7a69c4f47fe38b17a2ce1408258902cf64f6c83"
 }

package/src/__tests__/createViewMeta.popup.test.ts

@@ -11,7 +11,7 @@ import { describe, it, expect, vi } from 'vitest';
 import { FlowContext } from '../flowContext';
 import { FlowEngine } from '../flowEngine';
 import type { FlowView } from '../views/FlowView';
-import { buildPopupRuntime, createPopupMeta } from '../views/createViewMeta';
+import { buildPopupRuntime, createPopupMeta, registerPopupVariable } from '../views/createViewMeta';
 
 describe('createPopupMeta - popup variables', () => {
   function makeCtx() {
@@ -167,6 +167,7 @@ describe('createPopupMeta - popup variables', () => {
   it('buildPopupRuntime anchors current popup even when the navigation stack already has a child popup', async () => {
     const { engine, ctx } = makeCtx();
     const parentView = makeNestedPopupView('parent-popup-uid', 13);
+    parentView.inputArgs.parentItem = { value: { id: 13, phone: '9999' } };
     mockNestedPopupModels(engine);
 
     const popup = await buildPopupRuntime(ctx, parentView);
@@ -179,6 +180,7 @@ describe('createPopupMeta - popup variables', () => {
       filterByTk: 13,
       sourceId: 13,
     });
+    expect(popup?.sourceRecord).toEqual({ id: 13, phone: '9999' });
   });
 
   it('buildVariablesParams(record) keeps the parent view record when a child popup is open', async () => {
@@ -314,4 +316,85 @@ describe('createPopupMeta - popup variables', () => {
     const props = typeof meta.properties === 'function' ? await (meta.properties as any)() : meta.properties || {};
     expect(props.record).toBeUndefined();
   });
+
+  it('uses the current parent item value for popup sourceRecord fields', async () => {
+    const { ctx } = makeCtx();
+    const parentItemResolver = vi.fn(() => false);
+    const anchorView: FlowView = {
+      type: 'dialog',
+      inputArgs: {
+        openerUids: ['opener-uid-1'],
+        viewUid: 'popup-uid',
+        dataSourceKey: 'main',
+        collectionName: 'roles',
+        associationName: 'users.roles',
+        sourceId: 1,
+        parentItem: { value: { id: 1, phone: '9999' } },
+        parentItemResolver,
+      },
+      Header: null,
+      Footer: null,
+      close: () => void 0,
+      update: () => void 0,
+    } as any;
+
+    registerPopupVariable(ctx, anchorView);
+
+    await expect(ctx.popup).resolves.toMatchObject({
+      sourceRecord: { id: 1, phone: '9999' },
+    });
+    expect(ctx.getPropertyOptions('popup')?.resolveOnServer?.('sourceRecord.phone')).toBe(false);
+    expect(parentItemResolver).toHaveBeenCalledWith('value.phone');
+  });
+
+  it('resolves a popup sourceRecord field from the current parent item without a server request', async () => {
+    const engine = new FlowEngine();
+    const ctx = engine.context;
+    const anchorView: FlowView = {
+      type: 'dialog',
+      inputArgs: {
+        openerUids: ['opener-uid-1'],
+        viewUid: 'popup-uid',
+        dataSourceKey: 'main',
+        collectionName: 'roles',
+        associationName: 'users.roles',
+        sourceId: 1,
+        parentItem: { value: { id: 1, phone: '9999' } },
+        parentItemResolver: () => false,
+      },
+      Header: null,
+      Footer: null,
+      close: () => void 0,
+      update: () => void 0,
+    } as any;
+
+    registerPopupVariable(ctx, anchorView);
+
+    await expect(ctx.resolveJsonTemplate('{{ ctx.popup.sourceRecord.phone }}')).resolves.toBe('9999');
+  });
+
+  it('keeps server resolution for popup sourceRecord association subpaths', async () => {
+    const { ctx } = makeCtx();
+    const anchorView: FlowView = {
+      type: 'dialog',
+      inputArgs: {
+        openerUids: ['opener-uid-1'],
+        viewUid: 'popup-uid',
+        dataSourceKey: 'main',
+        collectionName: 'roles',
+        associationName: 'users.roles',
+        sourceId: 1,
+        parentItem: { value: { id: 1, departmentId: 2 } },
+        parentItemResolver: (path: string) => path === 'value.department.title',
+      },
+      Header: null,
+      Footer: null,
+      close: () => void 0,
+      update: () => void 0,
+    } as any;
+
+    registerPopupVariable(ctx, anchorView);
+
+    expect(ctx.getPropertyOptions('popup')?.resolveOnServer?.('sourceRecord.department.title')).toBe(true);
+  });
 });