@nocobase/flow-engine 2.1.35 → 2.1.37

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.1.35",
+  "version": "2.1.37",
   "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.1.35",
-    "@nocobase/shared": "2.1.35",
+    "@nocobase/sdk": "2.1.37",
+    "@nocobase/shared": "2.1.37",
     "ahooks": "^3.7.2",
     "axios": "^1.7.0",
     "dayjs": "^1.11.9",
@@ -37,5 +37,5 @@
   ],
   "author": "NocoBase Team",
   "license": "Apache-2.0",
-  "gitHead": "d844133f9bd61a3506a3be1af25a1cb06dafbc6f"
+  "gitHead": "a0c3201363ae028058845af0176ee902a9eeb3e1"
 }

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);
+  });
 });

package/src/__tests__/flowContext.test.ts

@@ -16,6 +16,7 @@ import { RunJSContextRegistry } from '../runjs-context/registry';
 import { setupRunJSContexts } from '../runjs-context/setup';
 import { createViewScopedEngine } from '../ViewScopedFlowEngine';
 import { DATA_SOURCE_DIRTY_EVENT } from '../views/viewEvents';
+import { serializeCtxDateExpressionConfig } from '../utils/dateVariable';
 
 describe('FlowContext properties and methods', () => {
   it('should return static property value', () => {
@@ -2068,10 +2069,16 @@ describe('getPropertyMetaTree with deep delegate meta', () => {
 describe('FlowContext resolveOnServer selective server resolution', () => {
   it('resolves ctx.date expressions on client context', async () => {
     const engine = new FlowEngine();
+    const formattedToday = serializeCtxDateExpressionConfig({
+      kind: 'preset',
+      preset: 'today',
+      format: 'YYYY/MM/DD',
+    });
     const out = await (engine.context as any).resolveJsonTemplate({
       today: '{{ ctx.date.preset.today }}',
       next12: '{{ ctx.date.relative.next.day.n12 }}',
       now: '{{ ctx.date.preset.now }}',
+      formattedToday,
     });
 
     expect(typeof out.today).toBe('string');
@@ -2080,6 +2087,7 @@ describe('FlowContext resolveOnServer selective server resolution', () => {
     expect(out.next12).toMatch(/^\d{4}-\d{2}-\d{2}$/);
     expect(typeof out.now).toBe('string');
     expect(out.now.length).toBeGreaterThan(0);
+    expect(out.formattedToday).toMatch(/^\d{4}\/\d{2}\/\d{2}$/);
   });
 
   it('does not call server by default (no resolveOnServer set)', async () => {

package/src/components/FlowContextSelector.tsx

@@ -286,6 +286,7 @@ const FlowContextSelectorComponent: React.FC<FlowContextSelectorProps> = ({
       const path = selectedValues.map(String);
       const pathString = path.join('.');
       const isLeaf = lastOption?.isLeaf;
+      const isSelectable = lastOption?.meta?.selectable !== false;
       const now = Date.now();
 
       // 使用自定义格式化函数或默认函数
@@ -300,6 +301,10 @@ const FlowContextSelectorComponent: React.FC<FlowContextSelectorProps> = ({
       }
 
       if (isLeaf) {
+        if (!isSelectable) {
+          setTempSelectedPath(path);
+          return;
+        }
         onChange?.(formattedValue, lastOption?.meta);
         // 选中叶子节点后，可清空内部临时路径（外部 value 将驱动级联）
         setTempSelectedPath([]);
@@ -308,7 +313,8 @@ const FlowContextSelectorComponent: React.FC<FlowContextSelectorProps> = ({
 
       // 非叶子节点：检查双击
       const lastSelected = lastSelectedRef.current;
-      const isDoubleClick = !onlyLeafSelectable && lastSelected?.path === pathString && now - lastSelected.time < 300;
+      const isDoubleClick =
+        isSelectable && !onlyLeafSelectable && lastSelected?.path === pathString && now - lastSelected.time < 300;
 
       if (isDoubleClick) {
         // 双击：选中非叶子节点

package/src/components/variables/__tests__/FlowContextSelector.test.tsx

@@ -405,10 +405,11 @@ describe('FlowContextSelector', () => {
 
     const clearIcon = document.querySelector('.ant-input-clear-icon') as HTMLElement | null;
     expect(clearIcon).toBeInTheDocument();
+    if (!clearIcon) throw new Error('Expected clear icon to be rendered');
 
-    fireEvent.mouseDown(clearIcon!);
-    fireEvent.mouseUp(clearIcon!);
-    fireEvent.click(clearIcon!);
+    fireEvent.mouseDown(clearIcon);
+    fireEvent.mouseUp(clearIcon);
+    fireEvent.click(clearIcon);
 
     await waitFor(() => {
       expect(onChange).toHaveBeenCalledWith('', undefined);
@@ -807,4 +808,39 @@ describe('FlowContextSelector', () => {
     // It should only expand the node, not select it
     expect(onChange).not.toHaveBeenCalled();
   });
+
+  it('should expand but never select a node marked selectable=false', async () => {
+    const onChange = vi.fn();
+    const flowContext = createTestFlowContext();
+    const metaTree = [
+      {
+        name: 'date',
+        title: 'Date',
+        type: 'date',
+        paths: ['date'],
+        selectable: false,
+        children: [{ name: 'today', title: 'Today', type: 'date', paths: ['date', 'today'] }],
+      },
+    ];
+
+    render(
+      <TestFlowContextWrapper context={flowContext}>
+        <FlowContextSelector metaTree={metaTree} onChange={onChange} />
+      </TestFlowContextWrapper>,
+    );
+
+    fireEvent.click(screen.getByRole('button'));
+    await waitFor(() => expect(screen.getByText('Date')).toBeInTheDocument());
+
+    fireEvent.click(screen.getByText('Date'));
+    fireEvent.click(screen.getByText('Date'));
+    expect(onChange).not.toHaveBeenCalled();
+
+    await waitFor(() => expect(screen.getByText('Today')).toBeInTheDocument());
+    fireEvent.click(screen.getByText('Today'));
+    expect(onChange).toHaveBeenCalledWith(
+      '{{ ctx.date.today }}',
+      expect.objectContaining({ paths: ['date', 'today'] }),
+    );
+  });
 });

package/src/flowContext.ts

@@ -50,11 +50,11 @@ import {
   resolveModuleUrl,
 } from './utils';
 import { FlowExitAllException } from './utils/exceptions';
-import { enqueueVariablesResolve, JSONValue } from './utils/params-resolvers';
+import { buildFlowModelResolveDescriptor, enqueueVariablesResolve, JSONValue } from './utils/params-resolvers';
 import type { RecordRef } from './utils/serverContextParams';
 import { buildServerContextParams as _buildServerContextParams } from './utils/serverContextParams';
 import { getDirtyAwareApiClient } from './utils/dirtyAwareApiClient';
-import { inferRecordRef } from './utils/variablesParams';
+import { inferRecordRef, inferViewRecordRef } from './utils/variablesParams';
 import { FlowView, FlowViewer } from './views/FlowView';
 import { RunJSContextRegistry, getModelClassName, type RunJSVersion } from './runjs-context/registry';
 import { createEphemeralContext } from './utils/createEphemeralContext';
@@ -221,6 +221,8 @@ export interface MetaTreeNode {
   // 变量禁用状态与原因（用于变量选择器 UI 展示）
   disabled?: boolean | (() => boolean);
   disabledReason?: string | (() => string | undefined);
+  // 允许节点仅用于展开子级，而不能作为变量值被选中
+  selectable?: boolean;
   children?: MetaTreeNode[] | (() => Promise<MetaTreeNode[]>);
 }
 
@@ -3316,6 +3318,15 @@ export class FlowEngineContext extends BaseFlowEngineContext {
         const inputFromMeta = await collectFromMeta();
         const autoInput = { ...inputFromMeta } as Record<string, any>;
 
+        const viewPaths = serverVarPaths.view || [];
+        if (
+          !autoInput.view &&
+          viewPaths.some((path) => path === 'record' || path.startsWith('record.') || path.startsWith('record['))
+        ) {
+          const recordRef = inferViewRecordRef(this);
+          if (recordRef) autoInput.view = { record: recordRef };
+        }
+
         // Special-case: formValues
         // If server needs to resolve some formValues paths but meta params only cover association anchors
         // (e.g. formValues.customer) and some top-level paths are missing (e.g. formValues.status),
@@ -3388,6 +3399,7 @@ export class FlowEngineContext extends BaseFlowEngineContext {
         if (this.api) {
           try {
             serverResolved = await enqueueVariablesResolve(this as FlowRuntimeContext<FlowModel>, {
+              rd: buildFlowModelResolveDescriptor(this as FlowRuntimeContext<FlowModel>, this.model?.uid),
               template,
               contextParams: autoContextParams || {},
             });

package/src/utils/__tests__/dateVariable.test.ts

@@ -12,9 +12,12 @@ import {
   decodeBase64Url,
   encodeBase64Url,
   isCompleteCtxDatePath,
+  isCtxDatePathPrefix,
   isCtxDateExpression,
   parseCtxDateExpression,
+  parseCtxDateExpressionConfig,
   resolveCtxDatePath,
+  serializeCtxDateExpressionConfig,
   serializeCtxDateValue,
 } from '../dateVariable';
 
@@ -54,13 +57,60 @@ describe('dateVariable utils', () => {
       number: 2,
     });
 
-    const singleExpr = serializeCtxDateValue('2026-02-12')!;
+    const singleExpr = serializeCtxDateValue('2026-02-12');
+    if (!singleExpr) throw new Error('Expected exact date expression');
     expect(parseCtxDateExpression(singleExpr)).toBe('2026-02-12');
 
-    const rangeExpr = serializeCtxDateValue(['2026-02-12', '2026-02-20'])!;
+    const rangeExpr = serializeCtxDateValue(['2026-02-12', '2026-02-20']);
+    if (!rangeExpr) throw new Error('Expected exact date range expression');
     expect(parseCtxDateExpression(rangeExpr)).toEqual(['2026-02-12', '2026-02-20']);
   });
 
+  it('serializes, parses and resolves formatted expressions', () => {
+    const expression = serializeCtxDateExpressionConfig({
+      kind: 'preset',
+      preset: 'today',
+      format: 'YYYY/MM/DD',
+    });
+    if (!expression) throw new Error('Expected formatted date expression');
+
+    expect(expression).toMatch(/^\{\{ ctx\.date\.format\.v[A-Za-z0-9_-]+\.preset\.today \}\}$/);
+    expect(parseCtxDateExpressionConfig(expression)).toEqual({
+      kind: 'preset',
+      preset: 'today',
+      format: 'YYYY/MM/DD',
+    });
+    // Keep the legacy parser contract for filter-form consumers.
+    expect(parseCtxDateExpression(expression)).toEqual({ type: 'today' });
+
+    const path = expression.replace('{{ ctx.', '').replace(' }}', '').split('.');
+    expect(resolveCtxDatePath(path)).toMatch(/^\d{4}\/\d{2}\/\d{2}$/);
+    expect(isCompleteCtxDatePath(path)).toBe(true);
+  });
+
+  it('preserves significant whitespace in a custom Format', () => {
+    const expression = serializeCtxDateExpressionConfig({
+      kind: 'preset',
+      preset: 'today',
+      format: 'YYYY-MM-DD ',
+    });
+    if (!expression) throw new Error('Expected formatted date expression');
+
+    expect(parseCtxDateExpressionConfig(expression)?.format).toBe('YYYY-MM-DD ');
+  });
+
+  it('formats exact ranges element by element', () => {
+    const expression = serializeCtxDateExpressionConfig({
+      kind: 'exact',
+      value: ['2026-02-12', '2026-02-20'],
+      format: 'YYYYMMDD',
+    });
+    if (!expression) throw new Error('Expected formatted date range expression');
+    const path = expression.replace('{{ ctx.', '').replace(' }}', '').split('.');
+
+    expect(resolveCtxDatePath(path)).toEqual(['20260212', '20260220']);
+  });
+
   it('resolves preset/relative/exact path', () => {
     expect(typeof resolveCtxDatePath(['date', 'preset', 'now'])).toBe('string');
 
@@ -72,11 +122,13 @@ describe('dateVariable utils', () => {
     expect(typeof rel).toBe('string');
     expect(rel).toMatch(/^\d{4}-\d{2}-\d{2}$/);
 
-    const singleExpr = serializeCtxDateValue('2026-02-12')!;
+    const singleExpr = serializeCtxDateValue('2026-02-12');
+    if (!singleExpr) throw new Error('Expected exact date expression');
     const token = singleExpr.replace('{{ ctx.date.exact.single.date.', '').replace(' }}', '');
     expect(resolveCtxDatePath(['date', 'exact', 'single', 'date', token])).toBe('2026-02-12');
 
-    const rangeExpr = serializeCtxDateValue(['2026-02-12', '2026-02-20'])!;
+    const rangeExpr = serializeCtxDateValue(['2026-02-12', '2026-02-20']);
+    if (!rangeExpr) throw new Error('Expected exact date range expression');
     const parts = rangeExpr.replace('{{ ctx.date.exact.range.date.', '').replace(' }}', '').split('.');
     expect(resolveCtxDatePath(['date', 'exact', 'range', 'date', parts[0], parts[1]])).toEqual([
       '2026-02-12',
@@ -90,6 +142,7 @@ describe('dateVariable utils', () => {
     expect(isCompleteCtxDatePath(['date', 'exact', 'single', 'date', 'vabc'])).toBe(true);
     expect(isCompleteCtxDatePath(['date', 'exact', 'range', 'date', 'vabc', 'vdef'])).toBe(true);
     expect(isCompleteCtxDatePath(['date', 'relative', 'next', 'day'])).toBe(false);
+    expect(isCtxDatePathPrefix(['date', 'format'])).toBe(true);
     expect(isCompleteCtxDatePath(['user', 'name'])).toBe(false);
   });
 

package/src/utils/__tests__/variablesParams.test.ts

@@ -34,7 +34,8 @@ describe('variablesParams helpers', () => {
 
   it('inferRecordRef fallback to collection.getFilterByTK when resource has no filterByTk', () => {
     const engine = new FlowEngine();
-    const ds = engine.context.dataSourceManager.getDataSource('main')!;
+    const ds = engine.context.dataSourceManager.getDataSource('main');
+    if (!ds) throw new Error('main data source is required');
     ds.addCollection({
       name: 'users',
       filterTargetKey: 'id',
@@ -108,6 +109,32 @@ describe('variablesParams helpers', () => {
     });
   });
 
+  it('collectContextParamsForTemplate infers view.record when its meta has no descriptor', async () => {
+    const ctx: any = {
+      getPropertyOptions: () => undefined,
+      view: {
+        inputArgs: {
+          collectionName: 'posts',
+          dataSourceKey: 'main',
+          filterByTk: 3,
+        },
+      },
+    };
+
+    const res = await collectContextParamsForTemplate(ctx, {
+      recordId: '{{ ctx.view.record.id }}',
+      viewType: '{{ ctx.view.type }}',
+    });
+
+    expect(res).toEqual({
+      'view.record': {
+        collection: 'posts',
+        dataSourceKey: 'main',
+        filterByTk: 3,
+      },
+    });
+  });
+
   it('createRecordResolveOnServerWithLocal: no local record => always use server', () => {
     const resolver = createRecordResolveOnServerWithLocal(
       () => ({ name: 'posts', dataSourceKey: 'main' }) as any,

package/src/utils/associationObjectVariable.ts

@@ -51,13 +51,14 @@ function findFieldByName(collection: Collection | null | undefined, name?: strin
  * @param primaryKey 主键字段名
  * @returns 解析出的主键值，无法解析时返回 undefined
  */
-function toFilterByTk(value: unknown, primaryKey: string | string[]) {
+export function getAssociationFilterByTk(value: unknown, primaryKey: string | string[]) {
   if (value == null) return undefined;
   if (Array.isArray(primaryKey)) {
     if (typeof value !== 'object' || !value) return undefined;
-    const out: Record<string, any> = {};
+    const record = value as Record<string, unknown>;
+    const out: Record<string, unknown> = {};
     for (const k of primaryKey) {
-      const v = (value as any)[k];
+      const v = record[k];
       if (typeof v === 'undefined' || v === null) return undefined;
       out[k] = v;
     }
@@ -65,7 +66,7 @@ function toFilterByTk(value: unknown, primaryKey: string | string[]) {
   }
   if (typeof value === 'string' || typeof value === 'number') return value;
   if (typeof value === 'object') {
-    return (value as any)[primaryKey];
+    return (value as Record<string, unknown>)[primaryKey];
   }
   return undefined;
 }
@@ -149,7 +150,9 @@ export function createAssociationAwareObjectMetaFactory(
           if (associationValue == null) continue;
 
           if (Array.isArray(associationValue)) {
-            const ids = associationValue.map((item) => toFilterByTk(item, primaryKey)).filter((v) => v != null);
+            const ids = associationValue
+              .map((item) => getAssociationFilterByTk(item, primaryKey))
+              .filter((v) => v != null);
             if (ids.length) {
               params[name] = {
                 collection: target,
@@ -158,7 +161,7 @@ export function createAssociationAwareObjectMetaFactory(
               };
             }
           } else {
-            const id = toFilterByTk(associationValue, primaryKey);
+            const id = getAssociationFilterByTk(associationValue, primaryKey);
             if (id != null) {
               params[name] = {
                 collection: target,