@nocobase/flow-engine 2.1.35 → 2.1.37

package/src/utils/dateVariable.ts

@@ -11,7 +11,7 @@ import dayjs from 'dayjs';
 
 const CTX_DATE_REGEX = /^\{\{\s*ctx\.date(?:\.(.+?))?\s*\}\}$/;
 
-const PRESET_KEYS = new Set([
+const PRESET_KEY_LIST = [
   'today',
   'now',
   'yesterday',
@@ -28,10 +28,28 @@ const PRESET_KEYS = new Set([
   'thisYear',
   'lastYear',
   'nextYear',
-]);
+] as const;
+
+export type CtxDatePreset = (typeof PRESET_KEY_LIST)[number];
+export type CtxDateRelativeDirection = 'next' | 'past';
+export type CtxDateRelativeUnit = 'day' | 'week' | 'month' | 'year';
+
+export type CtxDateExpressionConfig =
+  | { kind: 'exact'; value: string | [string, string]; format?: string }
+  | {
+      kind: 'relative';
+      direction: CtxDateRelativeDirection;
+      amount: number;
+      unit: CtxDateRelativeUnit;
+      format?: string;
+    }
+  | { kind: 'preset'; preset: CtxDatePreset; format?: string };
+
+const PRESET_KEYS = new Set<string>(PRESET_KEY_LIST);
 
 const RELATIVE_DIRECTIONS = new Set(['next', 'past']);
 const RELATIVE_UNITS = new Set(['day', 'week', 'month', 'year']);
+const MAX_DATE_FORMAT_LENGTH = 128;
 
 function parseCtxDateSegments(value: string): string[] | null {
   if (typeof value !== 'string') return null;
@@ -46,8 +64,7 @@ function parseCtxDateSegments(value: string): string[] | null {
     .filter(Boolean);
 }
 
-export function isCtxDatePathPrefix(pathSegments: string[]): boolean {
-  const segments = withDatePrefix((pathSegments || []).map((seg) => String(seg)));
+function isBaseCtxDatePathPrefix(segments: string[]): boolean {
   if (segments[0] !== 'date') return false;
   if (segments.length === 1) return true;
 
@@ -96,6 +113,36 @@ export function isCtxDatePathPrefix(pathSegments: string[]): boolean {
   return false;
 }
 
+function decodeFormatToken(token: string): string | undefined {
+  const raw = String(token || '');
+  if (!raw.startsWith('v')) return undefined;
+  const decoded = decodeBase64Url(raw.slice(1));
+  if (!decoded || decoded.length > MAX_DATE_FORMAT_LENGTH) return undefined;
+  return decoded;
+}
+
+function splitFormattedDateSegments(segments: string[]): { baseSegments: string[]; format?: string } | null {
+  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 };
+}
+
+export function isCtxDatePathPrefix(pathSegments: string[]): boolean {
+  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;
+}
+
 function withDatePrefix(pathSegments: string[]): string[] {
   if (pathSegments[0] === 'date') {
     return pathSegments;
@@ -210,27 +257,29 @@ export function isCtxDateExpression(value: unknown): value is string {
 export function isCompleteCtxDatePath(pathSegments: string[]): boolean {
   if (!isCtxDatePathPrefix(pathSegments)) return false;
   const segments = withDatePrefix((pathSegments || []).map((seg) => String(seg)));
-  if (segments[0] !== 'date') return false;
+  const formatted = splitFormattedDateSegments(segments);
+  if (!formatted) return false;
+  const baseSegments = formatted.baseSegments;
 
-  if (segments[1] === 'preset') {
-    return segments.length === 3 && PRESET_KEYS.has(segments[2]);
+  if (baseSegments[1] === 'preset') {
+    return baseSegments.length === 3 && PRESET_KEYS.has(baseSegments[2]);
   }
 
-  if (segments[1] === 'relative') {
-    if (segments.length !== 5) return false;
+  if (baseSegments[1] === 'relative') {
+    if (baseSegments.length !== 5) return false;
     return (
-      RELATIVE_DIRECTIONS.has(segments[2]) &&
-      RELATIVE_UNITS.has(segments[3]) &&
-      typeof parseNumberToken(segments[4]) === 'number'
+      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;
@@ -238,7 +287,10 @@ export function isCompleteCtxDatePath(pathSegments: string[]): boolean {
 
 export function parseCtxDateExpression(value: unknown): any {
   if (!isCtxDateExpression(value)) return undefined;
-  const segments = withDatePrefix(parseCtxDateSegments(value as string) || []);
+  const rawSegments = withDatePrefix(parseCtxDateSegments(value as string) || []);
+  const formatted = splitFormattedDateSegments(rawSegments);
+  if (!formatted) return undefined;
+  const segments = formatted.baseSegments;
 
   if (segments[1] === 'preset' && segments.length === 3 && PRESET_KEYS.has(segments[2])) {
     return { type: segments[2] };
@@ -276,6 +328,66 @@ export function parseCtxDateExpression(value: unknown): any {
   return undefined;
 }
 
+export function parseCtxDateExpressionConfig(value: unknown): CtxDateExpressionConfig | undefined {
+  if (!isCtxDateExpression(value)) return undefined;
+  const segments = withDatePrefix(parseCtxDateSegments(value) || []);
+  const formatted = splitFormattedDateSegments(segments);
+  if (!formatted) return undefined;
+
+  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 undefined;
+  const typed = parsed as { type?: unknown; unit?: unknown; number?: unknown };
+  if (typed.type === 'past' || typed.type === 'next') {
+    if (typeof typed.unit !== 'string' || !RELATIVE_UNITS.has(typed.unit) || typeof typed.number !== 'number') {
+      return undefined;
+    }
+    return {
+      kind: 'relative',
+      direction: typed.type,
+      amount: typed.number,
+      unit: typed.unit as CtxDateRelativeUnit,
+      ...formatConfig,
+    };
+  }
+
+  if (typeof typed.type === 'string' && PRESET_KEYS.has(typed.type)) {
+    return { kind: 'preset', preset: typed.type as CtxDatePreset, ...formatConfig };
+  }
+  return undefined;
+}
+
+export function serializeCtxDateExpressionConfig(config: CtxDateExpressionConfig): string | undefined {
+  let legacyValue: unknown;
+
+  if (config.kind === 'preset') {
+    if (!PRESET_KEYS.has(config.preset)) return undefined;
+    legacyValue = { type: config.preset };
+  } else if (config.kind === 'relative') {
+    if (!RELATIVE_DIRECTIONS.has(config.direction) || !RELATIVE_UNITS.has(config.unit)) return undefined;
+    const amount = Math.floor(Number(config.amount));
+    if (!Number.isFinite(amount) || amount <= 0) return undefined;
+    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 undefined;
+  const segments = withDatePrefix(parseCtxDateSegments(expression) || []);
+  return toCtxDateExpression(['date', 'format', `v${encodeBase64Url(format)}`, ...segments.slice(1)]);
+}
+
 export function serializeCtxDateValue(value: unknown): string | undefined {
   if (isCtxDateExpression(value)) {
     return String(value).trim();
@@ -327,8 +439,23 @@ export function serializeCtxDateValue(value: unknown): string | undefined {
   return undefined;
 }
 
+function formatResolvedDateValue(value: unknown, format: string): unknown {
+  const formatValue = (item: unknown) => {
+    if (typeof item !== 'string') return item;
+    const parsed = dayjs(item);
+    return parsed.isValid() ? parsed.format(format) : item;
+  };
+  return Array.isArray(value) ? value.map(formatValue) : formatValue(value);
+}
+
 export function resolveCtxDatePath(pathSegments: string[]): any {
-  const segments = withDatePrefix((pathSegments || []).map((seg) => String(seg)));
+  const rawSegments = withDatePrefix((pathSegments || []).map((seg) => String(seg)));
+  const formatted = splitFormattedDateSegments(rawSegments);
+  if (!formatted) return undefined;
+  if (formatted.format) {
+    return formatResolvedDateValue(resolveCtxDatePath(formatted.baseSegments), formatted.format);
+  }
+  const segments = formatted.baseSegments;
   if (segments[0] !== 'date') return undefined;
 
   if (segments[1] === 'preset' && segments.length === 3) {

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';
 
 // 安全全局对象（window/document）

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,7 @@ export type JSONValue = string | { [key: string]: JSONValue } | JSONValue[];
 // =========================
 
 type BatchPayload = {
+  rd?: string;
   template: JSONValue;
   contextParams?: ServerContextParams | undefined;
 };
@@ -170,6 +172,7 @@ export function enqueueVariablesResolve(ctx: FlowRuntimeContext, payload: BatchP
     try {
       const batch = items.map((it) => ({
         id: it.id,
+        rd: it.payload.rd,
         template: it.payload.template,
         contextParams: it.payload.contextParams || {},
       }));
@@ -218,6 +221,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;