@nocobase/flow-engine 2.0.0-alpha.7 → 2.0.0-alpha.71

package/src/utils/safeGlobals.ts

@@ -8,12 +8,73 @@
  */
 
 /**
- * 统一的安全全局对象代理：window/document
- * - 默认仅允许常用的定时器、console、Math、Date、addEventListener（绑定原 window）
- * - document 仅允许 createElement/querySelector/querySelectorAll
+ * 统一的安全全局对象代理：window/document/navigator
+ * - window：仅允许常用的定时器、console、Math、Date、FormData、Blob、URL、addEventListener、open（安全包装）、location（安全代理）
+ * - document：仅允许 createElement/querySelector/querySelectorAll
+ * - navigator：仅提供极少量低风险能力（clipboard.writeText、onLine、language、languages）
  * - 不允许随意访问未声明的属性，最小权限原则
  */
 
+type RunJSSafeGlobalsRegistry = {
+  windowAllow: Set<string>;
+  documentAllow: Set<string>;
+};
+
+function getRunJSSafeGlobalsRegistry(): RunJSSafeGlobalsRegistry {
+  const g: any = globalThis as any;
+  if (g.__nocobaseRunJSSafeGlobalsRegistry?.windowAllow && g.__nocobaseRunJSSafeGlobalsRegistry?.documentAllow) {
+    return g.__nocobaseRunJSSafeGlobalsRegistry as RunJSSafeGlobalsRegistry;
+  }
+  const reg: RunJSSafeGlobalsRegistry = {
+    windowAllow: new Set<string>(),
+    documentAllow: new Set<string>(),
+  };
+  g.__nocobaseRunJSSafeGlobalsRegistry = reg;
+  return reg;
+}
+
+export function registerRunJSSafeWindowGlobals(keys: Iterable<string> | null | undefined): void {
+  if (!keys) return;
+  const reg = getRunJSSafeGlobalsRegistry();
+  for (const k of keys) {
+    if (typeof k !== 'string') continue;
+    const key = k.trim();
+    if (!key) continue;
+    reg.windowAllow.add(key);
+  }
+}
+
+export function registerRunJSSafeDocumentGlobals(keys: Iterable<string> | null | undefined): void {
+  if (!keys) return;
+  const reg = getRunJSSafeGlobalsRegistry();
+  for (const k of keys) {
+    if (typeof k !== 'string') continue;
+    const key = k.trim();
+    if (!key) continue;
+    reg.documentAllow.add(key);
+  }
+}
+
+export function __resetRunJSSafeGlobalsRegistryForTests(): void {
+  const g: any = globalThis as any;
+  if (g.__nocobaseRunJSSafeGlobalsRegistry) {
+    try {
+      g.__nocobaseRunJSSafeGlobalsRegistry.windowAllow?.clear?.();
+      g.__nocobaseRunJSSafeGlobalsRegistry.documentAllow?.clear?.();
+    } catch {
+      // ignore
+    }
+  }
+}
+
+function isAllowedDynamicWindowKey(key: string): boolean {
+  return getRunJSSafeGlobalsRegistry().windowAllow.has(key);
+}
+
+function isAllowedDynamicDocumentKey(key: string): boolean {
+  return getRunJSSafeGlobalsRegistry().documentAllow.has(key);
+}
+
 export function createSafeWindow(extra?: Record<string, any>) {
   // 解析相对 URL 使用脱敏 base（不含 query/hash），避免在解析时泄露敏感信息
   const getSafeBaseHref = () => `${window.location.origin}${window.location.pathname}`;
@@ -123,7 +184,7 @@ export function createSafeWindow(extra?: Record<string, any>) {
           case 'replace':
             return (u: string) => guardedNavigate(u, { replace: true });
           case 'reload':
-            throw new Error('Access to location.reload is not allowed.');
+            return window.location.reload.bind(window.location);
           case 'href':
             throw new Error('Reading location.href is not allowed.');
           default:
@@ -149,6 +210,9 @@ export function createSafeWindow(extra?: Record<string, any>) {
     console,
     Math,
     Date,
+    FormData,
+    ...(typeof Blob !== 'undefined' ? { Blob } : {}),
+    ...(typeof URL !== 'undefined' ? { URL } : {}),
     // 事件侦听仅绑定到真实 window，便于少量需要的全局监听
     addEventListener: addEventListener.bind(window),
     // 安全的 window.open 代理
@@ -158,15 +222,44 @@ export function createSafeWindow(extra?: Record<string, any>) {
     ...(extra || {}),
   };
 
-  return new Proxy(
-    {},
-    {
-      get(_target, prop: string) {
-        if (prop in allowedGlobals) return allowedGlobals[prop];
-        throw new Error(`Access to global property "${prop}" is not allowed.`);
-      },
+  const target: Record<string, any> = Object.create(null);
+
+  return new Proxy(target, {
+    get(t, prop: string | symbol) {
+      if (typeof prop !== 'string') {
+        return Reflect.get(t, prop);
+      }
+
+      if (prop in allowedGlobals) return allowedGlobals[prop];
+      if (Object.prototype.hasOwnProperty.call(t, prop)) return (t as any)[prop];
+      if (isAllowedDynamicWindowKey(prop)) {
+        const v = (window as any)[prop];
+        // Bind functions to the real window to avoid Illegal invocation
+        if (typeof v === 'function') return v.bind(window);
+        return v;
+      }
+
+      throw new Error(`Access to global property "${prop}" is not allowed.`);
     },
-  );
+    set(t, prop: string | symbol, value: any) {
+      if (typeof prop !== 'string') {
+        Reflect.set(t, prop, value);
+        return true;
+      }
+      if (prop in allowedGlobals) {
+        throw new Error(`Mutation of global property "${prop}" is not allowed.`);
+      }
+      (t as any)[prop] = value;
+      return true;
+    },
+    has(t, prop: string | symbol) {
+      if (typeof prop !== 'string') return Reflect.has(t, prop);
+      if (prop in allowedGlobals) return true;
+      if (Object.prototype.hasOwnProperty.call(t, prop)) return true;
+      if (isAllowedDynamicWindowKey(prop)) return true;
+      return false;
+    },
+  });
 }
 
 export function createSafeDocument(extra?: Record<string, any>) {
@@ -176,12 +269,85 @@ export function createSafeDocument(extra?: Record<string, any>) {
     querySelectorAll: document.querySelectorAll.bind(document),
     ...(extra || {}),
   };
+  const target: Record<string, any> = Object.create(null);
+  return new Proxy(target, {
+    get(t, prop: string | symbol) {
+      if (typeof prop !== 'string') {
+        return Reflect.get(t, prop);
+      }
+
+      if (prop in allowed) return allowed[prop];
+      if (Object.prototype.hasOwnProperty.call(t, prop)) return (t as any)[prop];
+      if (isAllowedDynamicDocumentKey(prop)) {
+        const v = (document as any)[prop];
+        // Bind functions to the real document to avoid Illegal invocation
+        if (typeof v === 'function') return v.bind(document);
+        return v;
+      }
+
+      throw new Error(`Access to document property "${prop}" is not allowed.`);
+    },
+    set(t, prop: string | symbol, value: any) {
+      if (typeof prop !== 'string') {
+        Reflect.set(t, prop, value);
+        return true;
+      }
+      if (prop in allowed) {
+        throw new Error(`Mutation of document property "${prop}" is not allowed.`);
+      }
+      (t as any)[prop] = value;
+      return true;
+    },
+    has(t, prop: string | symbol) {
+      if (typeof prop !== 'string') return Reflect.has(t, prop);
+      if (prop in allowed) return true;
+      if (Object.prototype.hasOwnProperty.call(t, prop)) return true;
+      if (isAllowedDynamicDocumentKey(prop)) return true;
+      return false;
+    },
+  });
+}
+
+export function createSafeNavigator(extra?: Record<string, any>) {
+  const nav: any = (typeof window !== 'undefined' && window.navigator) || undefined;
+
+  // 始终提供 clipboard 对象，避免可选链访问时抛错
+  const clipboard: Record<string, any> = {};
+  const writeText = nav?.clipboard?.writeText;
+  if (typeof writeText === 'function') {
+    clipboard.writeText = writeText.bind(nav.clipboard);
+  }
+
+  const allowed: Record<string, any> = {
+    clipboard,
+  };
+
+  // 只读常用标识，避免泄露更多指纹信息
+  Object.defineProperty(allowed, 'onLine', {
+    get: () => !!nav?.onLine,
+    enumerable: true,
+    configurable: false,
+  });
+  Object.defineProperty(allowed, 'language', {
+    get: () => nav?.language,
+    enumerable: true,
+    configurable: false,
+  });
+  Object.defineProperty(allowed, 'languages', {
+    get: () => (nav?.languages ? [...nav.languages] : undefined),
+    enumerable: true,
+    configurable: false,
+  });
+
+  // 允许额外注入（例如自定义能力的受控暴露）
+  Object.assign(allowed, extra || {});
+
   return new Proxy(
     {},
     {
-      get(_target, prop: string) {
-        if (prop in allowed) return allowed[prop];
-        throw new Error(`Access to document property "${prop}" is not allowed.`);
+      get(_t, prop: string) {
+        if (prop in allowed) return (allowed as any)[prop];
+        throw new Error(`Access to navigator property "${String(prop)}" is not allowed.`);
       },
     },
   );

package/src/utils/schema-utils.ts

@@ -76,6 +76,29 @@ export async function resolveUiMode<TModel extends FlowModel = FlowModel>(
 // 模块级全局缓存，与 useCompile 保持一致
 const compileCache = {};
 
+const hasFunctionValue = (source: any): boolean => {
+  if (typeof source === 'function') return true;
+  if (!source || typeof source !== 'object') return false;
+  const seen = new WeakSet<object>();
+  const walk = (val: any): boolean => {
+    if (typeof val === 'function') return true;
+    if (!val || typeof val !== 'object') return false;
+    if (seen.has(val)) return false;
+    seen.add(val);
+    if (Array.isArray(val)) {
+      for (const it of val) {
+        if (walk(it)) return true;
+      }
+      return false;
+    }
+    for (const k of Object.keys(val)) {
+      if (walk((val as any)[k])) return true;
+    }
+    return false;
+  };
+  return walk(source);
+};
+
 /**
  * 编译 UI Schema 中的表达式
  *
@@ -110,8 +133,18 @@ export function compileUiSchema(scope: Record<string, any>, uiSchema: any, optio
         console.warn('Failed to stringify:', e);
         return source;
       }
-      if (compileCache[cacheKey]) return compileCache[cacheKey];
       shouldCompile = hasVariable(cacheKey);
+      // schema 中包含函数（如 x-reactions 的闭包）时，缓存会导致跨上下文复用旧闭包，必须禁用缓存
+      const hasFn = shouldCompile && !noCache ? hasFunctionValue(source) : false;
+      if (compileCache[cacheKey] && !noCache && !hasFn) return compileCache[cacheKey];
+      if (hasFn) {
+        try {
+          return Schema.compile(source, scope);
+        } catch (error) {
+          console.warn('Failed to compile with Formily Schema.compile:', error);
+          return source;
+        }
+      }
     }
 
     // source is Array, for example: [{ 'title': "{{ t('Admin') }}", name: 'admin' }, { 'title': "{{ t('Root') }}", name: 'root' }]
@@ -122,8 +155,17 @@ export function compileUiSchema(scope: Record<string, any>, uiSchema: any, optio
         console.warn('Failed to stringify:', e);
         return source;
       }
-      if (compileCache[cacheKey]) return compileCache[cacheKey];
       shouldCompile = hasVariable(cacheKey);
+      const hasFn = shouldCompile && !noCache ? hasFunctionValue(source) : false;
+      if (compileCache[cacheKey] && !noCache && !hasFn) return compileCache[cacheKey];
+      if (hasFn) {
+        try {
+          return Schema.compile(source, scope);
+        } catch (error) {
+          console.warn('Failed to compile with Formily Schema.compile:', error);
+          return source;
+        }
+      }
     }
 
     if (shouldCompile) {
@@ -181,7 +223,7 @@ export async function resolveStepUiSchema<TModel extends FlowModel = FlowModel>(
 
   if (step.use) {
     try {
-      const action = model.flowEngine?.getAction?.(step.use);
+      const action = model.getAction?.(step.use);
       if (action && action.uiSchema) {
         stepUiSchema = stepUiSchema || action.uiSchema;
       }
@@ -199,3 +241,39 @@ export async function resolveStepUiSchema<TModel extends FlowModel = FlowModel>(
 
   return resolvedStepUiSchema;
 }
+
+/**
+ * 判断步骤在设置菜单中是否应被隐藏。
+ * - 支持 StepDefinition.hideInSettings 与 ActionDefinition.hideInSettings（step 优先）。
+ * - hideInSettings 可为布尔值或函数（接收 FlowRuntimeContext）。
+ */
+export async function shouldHideStepInSettings<TModel extends FlowModel = FlowModel>(
+  model: TModel,
+  flow: any,
+  step: StepDefinition,
+): Promise<boolean> {
+  if (!step) return true;
+
+  // 优先使用 step.hideInSettings，其次回退到 action.hideInSettings
+  let hideInSettings = step.hideInSettings;
+
+  if (typeof hideInSettings === 'undefined' && step.use) {
+    const action = model.getAction?.(step.use);
+    hideInSettings = action?.hideInSettings;
+  }
+
+  if (typeof hideInSettings === 'function') {
+    try {
+      const ctx = new FlowRuntimeContext(model, flow.key, 'settings');
+      setupRuntimeContextSteps(ctx, flow.steps, model, flow.key);
+      ctx.defineProperty('currentStep', { value: step });
+      const result = await hideInSettings(ctx as any);
+      return !!result;
+    } catch (error) {
+      console.warn(`Error evaluating hideInSettings for step '${step.key || ''}' in flow '${flow.key}':`, error);
+      return false;
+    }
+  }
+
+  return !!hideInSettings;
+}

package/src/utils/serverContextParams.ts

@@ -14,6 +14,8 @@ export type RecordRef = {
   id?: any; // primary key value
   filterByTk?: any; // alias for id
   dataSourceKey?: string;
+  associationName?: string;
+  sourceId?: any;
   fields?: string[];
   appends?: string[];
   record?: any; // full record object (try to infer pk from it)
@@ -27,6 +29,8 @@ export type NormalizedRecordParams = {
   collection: string;
   filterByTk: any;
   dataSourceKey?: string;
+  associationName?: string;
+  sourceId?: any;
   fields?: string[];
   appends?: string[];
 };
@@ -63,6 +67,8 @@ function normalizeOne(ctx: FlowContext, ref?: RecordRef): NormalizedRecordParams
     collection,
     filterByTk,
     dataSourceKey,
+    associationName: ref.associationName,
+    sourceId: ref.sourceId,
     fields: ref.fields,
     appends: ref.appends,
   });

package/src/utils/translation.ts

@@ -27,11 +27,16 @@ export function getT(model: FlowModel): (key: string, options?: any) => string {
   return (key: string) => key;
 }
 
-export function escapeT(text: TFuncKey | TFuncKey[], options?: TOptions) {
+export function tExpr(text: TFuncKey | TFuncKey[], options?: TOptions) {
   if (options) {
     return `{{t(${JSON.stringify(text)}, ${JSON.stringify(options)})}}`;
   }
   return `{{t(${JSON.stringify(text)})}}`;
 }
 
-export { escapeT as tExpr };
+/**
+ * @deprecated use tExpr from `@nocobase/flow-engine` instead
+ */
+export function escapeT(text: TFuncKey | TFuncKey[], options?: TOptions) {
+  return tExpr(text, options);
+}

package/src/utils/variablesParams.ts

@@ -7,51 +7,27 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import type { FlowContext, PropertyMeta, PropertyMetaFactory } from '../flowContext';
-import type { JSONValue } from './params-resolvers';
-import type { Collection } from '../data-source';
-import { createCollectionContextMeta } from './createCollectionContextMeta';
-import { buildServerContextParams, type RecordRef, type ServerContextParams } from '../utils/serverContextParams';
 import {
   extractUsedVariableNames as _extractUsedVariableNames,
   extractUsedVariablePaths as _extractUsedVariablePaths,
-} from '@nocobase/utils/client';
-
-// Narrowest resource shape we rely on for inference
-type ResourceLike = {
-  getResourceName?: () => string;
-  getDataSourceKey?: () => string | undefined;
-  getFilterByTk?: () => unknown;
-  getSourceId?: () => unknown;
-};
-
-function isObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null;
-}
-
-function getResource(ctx: FlowContext): ResourceLike | undefined {
-  const r = (ctx as FlowContext)['resource'];
-  return isObject(r) ? (r as ResourceLike) : undefined;
-}
-
-type CollectionShape = { name?: string; dataSourceKey?: string };
-
-function getCollection(ctx: FlowContext): CollectionShape | undefined {
-  const c = (ctx as FlowContext)['collection'] as unknown;
-  if (isObject(c)) {
-    const mc = c as Partial<CollectionShape>;
-    return { name: mc.name, dataSourceKey: mc.dataSourceKey };
-  }
-  return undefined;
-}
+} from '@nocobase/shared';
+import type { Collection } from '../data-source';
+import type { FlowContext, PropertyMeta, PropertyMetaFactory } from '../flowContext';
+import { buildServerContextParams, type RecordRef, type ServerContextParams } from '../utils/serverContextParams';
+import { createCollectionContextMeta } from './createCollectionContextMeta';
+import { createAssociationSubpathResolver } from './associationObjectVariable';
+import type { JSONValue } from './params-resolvers';
+import _ from 'lodash';
 
+// 从 FlowContext 中推断当前记录的 context params 信息
 export function inferRecordRef(ctx: FlowContext): RecordRef | undefined {
-  const resource = getResource(ctx);
-  const collectionObj = getCollection(ctx);
+  const resource = ctx.resource;
+  const collectionObj = ctx.collection;
+  const recordValue = ctx.record;
 
   const resourceName = collectionObj?.name || resource?.getResourceName?.();
   const dataSourceKey = collectionObj?.dataSourceKey || resource?.getDataSourceKey?.();
-  const filterByTk = resource?.getFilterByTk?.();
+  const filterByTk = resource?.getFilterByTk?.() ?? collectionObj?.getFilterByTK?.(recordValue);
 
   if (!resourceName || typeof filterByTk === 'undefined' || filterByTk === null) return undefined;
   const parts = String(resourceName).split('.');
@@ -59,13 +35,131 @@ export function inferRecordRef(ctx: FlowContext): RecordRef | undefined {
   return { collection, dataSourceKey, filterByTk };
 }
 
+// 从 FlowContext.view 中推断记录的 context params 信息
+export function inferViewRecordRef(ctx: FlowContext): RecordRef | undefined {
+  const view = ctx.view;
+  if (!view) return undefined;
+  const inputArgs = (view as any)?.inputArgs || {};
+  const collection = inputArgs?.collectionName || (view as any)?.record?.collection;
+  const dataSourceKey = inputArgs?.dataSourceKey || (view as any)?.record?.dataSourceKey || 'main';
+  const filterByTk = inputArgs?.filterByTk || (view as any)?.record?.filterByTk;
+  const associationName = inputArgs?.associationName;
+  const sourceId = inputArgs?.sourceId;
+  if (!collection || typeof filterByTk === 'undefined' || filterByTk === null) return undefined;
+  return { collection, dataSourceKey, filterByTk, sourceId, associationName };
+}
+
+// 统一视图场景中“视图记录”的本地复用逻辑：
+// - 当视图 inputArgs.filterByTk 与父 FlowContext.record.filterByTk 一致时，
+//   认为视图正在查看同一条记录，此时返回父记录的深拷贝作为 view.record；
+// - 否则视为不同记录，不复用父记录（返回 undefined，让后续逻辑走服务端解析）。
+
+export function getViewRecordFromParent(flowContext: FlowContext, viewContext: FlowContext): unknown {
+  const parentRecord = flowContext.inputArgs?.record;
+  const parentTk = flowContext.collection?.filterTargetKey;
+  if (!parentRecord || !parentTk) return undefined;
+
+  const view = viewContext.view;
+  const viewFilterByTk = view?.inputArgs?.filterByTk;
+  const recordFilterByTk = parentRecord[parentTk];
+
+  // 仅当视图的 filterByTk 与父记录的 filterByTk 一致时，才复用父记录，
+  // 否则视为不同记录，不返回本地记录（统一走服务端解析）。
+  if (viewFilterByTk == null || recordFilterByTk == null) return undefined;
+  if (viewFilterByTk !== recordFilterByTk) return undefined;
+
+  return _.cloneDeep(parentRecord);
+}
+
+// 针对视图场景（Page/Dialog/Drawer），创建用于 view.resolveOnServer 的判定函数
+export function createViewRecordResolveOnServer(
+  ctx: FlowContext,
+  getLocalRecord: () => unknown,
+): (subPath: string) => boolean {
+  return (p: string) => {
+    if (!(p === 'record' || p.startsWith('record.'))) return false;
+    const local = getLocalRecord();
+    // 前端没有可用记录数据：统一走服务端
+    if (!local) return true;
+
+    // 直接访问整个 record 对象，使用前端值
+    if (p === 'record') return false;
+
+    // 仅在访问关联字段子路径时走服务端；非关联字段使用前端值
+    const ref = inferViewRecordRef(ctx);
+    const colName = ref?.collection;
+    const dsKey = ref?.dataSourceKey || 'main';
+    if (!colName) return true; // 未能推断集合，保守起见走服务端
+    const ds = (
+      ctx as FlowContext & { dataSourceManager?: { getDataSource?: (key: string) => any } }
+    ).dataSourceManager?.getDataSource?.(dsKey);
+    const collection = ds?.collectionManager?.getCollection?.(colName);
+    if (!collection) return true; // 未找到集合定义，保守走服务端
+
+    const resolver = createAssociationSubpathResolver(
+      () => collection as Collection,
+      () => local,
+    );
+    const subPath = p.startsWith('record.') ? p.slice('record.'.length) : '';
+    if (!subPath) return false;
+    return resolver(subPath);
+  };
+}
+
+/**
+ * 创建一个用于 “ctx.record” 变量的 resolveOnServer 判定函数：
+ * - 若本地 record 不存在：统一走服务端；
+ * - 若本地 record 存在：
+ *   - 访问空子路径（"{{ ctx.record }}"）时使用本地值，不走服务端；
+ *   - 访问非关联字段（如 id/title）：使用本地值；
+ *   - 访问关联字段：
+ *     - 若本地该字段无值（undefined/null），则交给服务端解析（无论是 "author" 还是 "author.name"）；
+ *     - 若本地已有值，则仅在访问子属性且本地缺少该子属性值时交给服务端。
+ */
+export function createRecordResolveOnServerWithLocal(
+  collectionAccessor: () => Collection | null,
+  valueAccessor: () => unknown,
+): (subPath: string) => boolean {
+  const assocSubpathResolver = createAssociationSubpathResolver(collectionAccessor, () => valueAccessor());
+  return (p: string) => {
+    const local = valueAccessor();
+    if (!local) return true;
+    if (!p) return false;
+
+    const collection = collectionAccessor() as any;
+
+    // 访问关联字段整体：当本地该字段无值时，统一交给服务端
+    if (!p.includes('.')) {
+      const name = p;
+      let field: any;
+      if (collection) {
+        if (typeof collection.getField === 'function') {
+          field = collection.getField(name);
+        }
+        if (!field && typeof collection.getFields === 'function') {
+          const fields = collection.getFields() || [];
+          field = fields.find((f: any) => f?.name === name);
+        }
+      }
+      const isAssoc = !!field?.isAssociationField?.();
+      if (!isAssoc) return false;
+      const value = (local as any)?.[name];
+      if (value === undefined || value === null) return true;
+      return false;
+    }
+
+    // 访问关联字段子属性：复用 associationSubpathResolver 的“本地优先 + 关联字段才走服务端”逻辑
+    return assocSubpathResolver(p);
+  };
+}
+
 export function inferParentRecordRef(ctx: FlowContext): RecordRef | undefined {
-  const resource = getResource(ctx);
-  const dataSourceKey = getCollection(ctx)?.dataSourceKey || resource?.getDataSourceKey?.();
-  const rn = resource?.getResourceName?.();
+  const resource = ctx.resource;
+  const dataSourceKey = ctx.collection?.dataSourceKey || resource?.getDataSourceKey?.();
+  const resourceName = resource?.getResourceName?.();
   const sourceId = resource?.getSourceId?.();
-  if (!rn || typeof sourceId === 'undefined' || sourceId === null) return undefined;
-  const parts = String(rn).split('.');
+  if (!resourceName || typeof sourceId === 'undefined' || sourceId === null) return undefined;
+  const parts = String(resourceName).split('.');
   if (parts.length < 2) return undefined;
   return { collection: parts[0], dataSourceKey, filterByTk: sourceId };
 }
@@ -80,7 +174,7 @@ export async function buildRecordMeta(
   title?: string,
   paramsBuilder?: RecordParamsBuilder,
 ): Promise<PropertyMeta | null> {
-  const base = await createCollectionContextMeta(collectionAccessor, title)();
+  const base = await createCollectionContextMeta(collectionAccessor, title, true)();
   if (!base) return null;
   return {
     ...base,
@@ -110,8 +204,11 @@ export function createRecordMetaFactory(
 export function createCurrentRecordMetaFactory(
   ctx: FlowContext,
   collectionAccessor: () => Collection | null,
+  options?: { title?: string },
 ): PropertyMetaFactory {
-  const title = (ctx as any)?.t?.('Current record') || 'Current record';
+  const title = options?.title
+    ? ctx.t?.(options.title) || options.title
+    : ctx.t?.('Current record') || 'Current record';
   return createRecordMetaFactory(collectionAccessor, title, (c) => inferRecordRef(c));
 }
 
@@ -141,35 +238,30 @@ export async function collectContextParamsForTemplate(
   ctx: FlowContext,
   template: JSONValue,
 ): Promise<ServerContextParams | undefined> {
-  try {
-    const usage = _extractUsedVariablePaths(template) || {};
-    const varNames = Object.keys(usage);
-    if (!varNames.length) return undefined;
-
-    const input: Record<string, any> = {};
-    for (const key of varNames) {
-      const opt = (ctx as any).getPropertyOptions?.(key);
-      const meta: PropertyMeta | (() => Promise<PropertyMeta | null> | PropertyMeta | null) | undefined = opt?.meta;
-      if (!meta) continue;
-      let built: any;
-      try {
-        const resolvedMeta = typeof meta === 'function' ? await (meta as any)() : (meta as any);
-        const builder = resolvedMeta?.buildVariablesParams;
-        if (typeof builder === 'function') {
-          built = await builder(ctx);
-        }
-      } catch (err) {
-        // 忽略构建变量参数时的异常，继续处理其他变量
-        // 使用 void 引用以避免 no-unused-vars，同时避免空代码块触发 no-empty
-        void err;
-        continue;
-      }
-      if (built) {
-        input[key] = built;
+  const usage = _extractUsedVariablePaths(template) || {};
+  const varNames = Object.keys(usage);
+  if (!varNames.length) return undefined;
+
+  const input: Record<string, any> = {};
+  for (const key of varNames) {
+    const opt = ctx.getPropertyOptions?.(key);
+    const meta: PropertyMeta | (() => Promise<PropertyMeta | null> | PropertyMeta | null) | undefined = opt?.meta;
+    if (!meta) continue;
+    let built: any;
+    try {
+      const resolvedMeta = typeof meta === 'function' ? await (meta as any)() : (meta as any);
+      const builder = resolvedMeta?.buildVariablesParams;
+      if (typeof builder === 'function') {
+        built = await builder(ctx);
       }
+    } catch (err) {
+      // 忽略构建变量参数时的异常，继续处理其他变量
+      void err;
+      continue;
+    }
+    if (built) {
+      input[key] = built;
     }
-    return buildServerContextParams(ctx, input);
-  } catch (_) {
-    return undefined;
   }
+  return buildServerContextParams(ctx, input);
 }