@nocobase/flow-engine 2.3.0-alpha.1 → 2.3.0-beta.11

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

@@ -864,4 +864,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/data-source/__tests__/index.test.ts

@@ -114,6 +114,34 @@ describe('DataSource & Collection APIs', () => {
     await expect(rules[0].validator({}, '123')).rejects.toBe('单行文本 长度必须为 18 个字符');
   });
 
+  it('enforces collection field precision in component validation rules', async () => {
+    const { m, engine } = makeManager();
+    const translate = vi.spyOn(engine, 'translate').mockImplementation((key) => key);
+    const ds = new DataSource({ key: 'main' });
+    m.addDataSource(ds);
+    ds.addCollection({
+      name: 'employees',
+      fields: [
+        {
+          name: 'years',
+          type: 'double',
+          interface: 'number',
+          title: 'Years',
+          validation: { type: 'number', rules: [{ name: 'precision', args: { limit: 2 } }] },
+        },
+      ],
+    });
+    const rules = ds.getCollection('employees').getField('years').getComponentProps().rules;
+
+    await expect(rules[0].validator({}, 39.2234)).rejects.toContain('2 decimal places');
+    expect(translate).toHaveBeenCalledWith(
+      'number.precision',
+      expect.objectContaining({ ns: 'data-source-main', label: 'Years', limit: 2 }),
+    );
+    await expect(rules[0].validator({}, 39.22)).resolves.toBeUndefined();
+    translate.mockRestore();
+  });
+
   it('ensureLoaded, reload and data source events work for main loader', async () => {
     const { m, engine } = makeManager();
     const loadedListener = vi.fn();

package/src/data-source/__tests__/jioToJoiSchema.test.ts

@@ -49,6 +49,57 @@ describe('jioToJoiSchema', () => {
     expect(s2.validate('zz').error).toBeTruthy();
   });
 
+  describe('number precision', () => {
+    const schema = jioToJoiSchema({ type: 'number', rules: [{ name: 'precision', args: { limit: 2 } }] });
+
+    it.each([39.2234, -39.2234, 0.001, 1e-7])('rejects %s without rounding', (value) => {
+      const result = schema.validate(value);
+      expect(result.error?.details[0]).toMatchObject({ type: 'number.precision', context: { limit: 2 } });
+      expect(result.value).toBe(value);
+    });
+
+    it.each([39.22, -39.22, 39.2, 39, 0, 0.01, '', null, undefined])('accepts %s', (value) => {
+      expect(schema.validate(value).error).toBeUndefined();
+    });
+
+    it('supports zero precision', () => {
+      const integerSchema = jioToJoiSchema({ type: 'number', rules: [{ name: 'precision', args: { limit: 0 } }] });
+      expect(integerSchema.validate(39).error).toBeUndefined();
+      expect(integerSchema.validate(39.2).error?.details[0].type).toBe('number.precision');
+    });
+
+    it('validates numeric strings without rounding them', () => {
+      expect(schema.validate('39.22')).toEqual({ value: 39.22 });
+      expect(schema.validate('39.2200')).toEqual({ value: 39.22 });
+      expect(schema.validate('39.2234').error?.details[0].type).toBe('number.precision');
+      expect(schema.validate('1e-7').error?.details[0].type).toBe('number.precision');
+      expect(schema.validate('not a number').error?.details[0].type).toBe('number.base');
+    });
+
+    it('preserves required and min/max validation', () => {
+      const requiredSchema = jioToJoiSchema({
+        type: 'number',
+        rules: [
+          { name: 'precision', args: { limit: 2 } },
+          { name: 'min', args: { limit: 1 } },
+          { name: 'max', args: { limit: 10 } },
+          { name: 'required' },
+        ],
+      });
+      expect(requiredSchema.validate(undefined).error?.details[0].type).toBe('any.required');
+      expect(requiredSchema.validate('').error).toBeDefined();
+      expect(requiredSchema.validate(null).error).toBeDefined();
+      expect(requiredSchema.validate(0.99).error?.details[0].type).toBe('number.min');
+      expect(requiredSchema.validate(10.01).error?.details[0].type).toBe('number.max');
+      expect(requiredSchema.validate(1.23).error).toBeUndefined();
+    });
+
+    it('preserves numeric string conversion when precision is not configured', () => {
+      const numberSchema = jioToJoiSchema({ type: 'number', rules: [{ name: 'min', args: { limit: 1 } }] });
+      expect(numberSchema.validate('39.2234')).toEqual({ value: 39.2234 });
+    });
+  });
+
   it('optional when no required and allows empty string', () => {
     const schema = jioToJoiSchema({ type: 'string' });
     expect(schema.validate('').error).toBeUndefined();

package/src/data-source/jioToJoiSchema.ts

@@ -85,7 +85,16 @@ export function jioToJoiSchema<T extends JioType>(jioConfig: {
     if (name === 'required') hasRequired = true;
     if (typeof schema[name] === 'function') {
       try {
-        schema = schema[name](...getArgs(name, args));
+        if (jioConfig.type === 'number' && name === 'precision') {
+          // Validate precision without rounding, while preserving the outer schema's numeric string conversion.
+          const precisionSchema = Joi.number().precision(getArgs(name, args)[0]).strict();
+          schema = schema.custom((value: number, helpers: Joi.CustomHelpers) => {
+            const { error } = precisionSchema.validate(value);
+            return error ? helpers.error('number.precision', error.details[0].context) : value;
+          });
+        } else {
+          schema = schema[name](...getArgs(name, args));
+        }
       } catch (err) {
         console.warn(`调用 Joi 方法 ${name} 失败:`, err);
       }

package/src/flow-registry/BaseFlowRegistry.ts

@@ -10,10 +10,12 @@
 import { FlowDefinitionOptions } from '../types';
 import { FlowDefinition } from '../FlowDefinition';
 import { observable } from '@formily/reactive';
+import type { FlowModel } from '../models';
 
 type FlowKey = string;
 
 export interface IFlowRepository {
+  readonly model?: FlowModel;
   addFlows(flowDefs: Record<string, Omit<FlowDefinitionOptions, 'key'>>): void;
   addFlow(flowKey: string, flowOptions: Omit<FlowDefinitionOptions, 'key'>): FlowDefinition | void;
   removeFlow(flowKey: string): void;

package/src/flow-registry/InstanceFlowRegistry.ts

@@ -15,7 +15,7 @@ type FlowKey = string;
 
 export class InstanceFlowRegistry extends BaseFlowRegistry {
   static readonly _type = 'instance' as const;
-  constructor(protected model: FlowModel) {
+  constructor(public readonly model: FlowModel) {
     super();
   }
 

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 { getDirtyAwareApiClient, PREPARE_CONTEXT_RESOURCE_ACTION_PARAMS } from './utils/dirtyAwareApiClient';
+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';
@@ -165,6 +165,10 @@ function inferSelectsFromUsage(paths: string[] = []): { generatedAppends?: strin
 
 type Getter<T = any> = (ctx: FlowContext) => T | Promise<T>;
 
+export type ResolveJsonTemplateOptions = {
+  contractModelUid?: string | number | null;
+};
+
 export type FlowContextDocRef = string | { url: string; title?: string };
 
 export type FlowDeprecationDoc =
@@ -221,6 +225,8 @@ export interface MetaTreeNode {
   // 变量禁用状态与原因（用于变量选择器 UI 展示）
   disabled?: boolean | (() => boolean);
   disabledReason?: string | (() => string | undefined);
+  // 允许节点仅用于展开子级，而不能作为变量值被选中
+  selectable?: boolean;
   children?: MetaTreeNode[] | (() => Promise<MetaTreeNode[]>);
 }
 
@@ -3044,7 +3050,8 @@ class BaseFlowEngineContext extends FlowContext {
    * @deprecated use `resolveJsonTemplate` instead
    */
   declare renderJson: (template: JSONValue) => Promise<any>;
-  declare resolveJsonTemplate: (template: JSONValue) => Promise<any>;
+  declare resolveJsonTemplate: (template: JSONValue, options?: ResolveJsonTemplateOptions) => Promise<any>;
+  declare variableContractModelUid?: string;
   declare getVar: (path: string) => Promise<any>;
   declare request: (options: RequestOptions) => Promise<any>;
   declare runjs: (code: string, variables?: Record<string, any>, options?: JSRunnerOptions) => Promise<any>;
@@ -3227,7 +3234,11 @@ export class FlowEngineContext extends BaseFlowEngineContext {
     this.defineMethod('renderJson', function (template: any) {
       return this.resolveJsonTemplate(template);
     });
-    this.defineMethod('resolveJsonTemplate', async function (this: BaseFlowEngineContext, template: any) {
+    const resolveJsonTemplate = async function (
+      this: BaseFlowEngineContext,
+      template: any,
+      options?: ResolveJsonTemplateOptions,
+    ) {
       // 提取模板使用到的变量及其子路径
       const used = extractUsedVariablePaths(template);
       const usedVarNames = Object.keys(used || {});
@@ -3316,6 +3327,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),
@@ -3387,7 +3407,13 @@ export class FlowEngineContext extends BaseFlowEngineContext {
 
         if (this.api) {
           try {
+            const contractRd = buildFlowModelResolveDescriptor(
+              this as FlowRuntimeContext<FlowModel>,
+              options?.contractModelUid ?? this.variableContractModelUid,
+            );
             serverResolved = await enqueueVariablesResolve(this as FlowRuntimeContext<FlowModel>, {
+              ...(contractRd ? { contractRd } : {}),
+              rd: buildFlowModelResolveDescriptor(this as FlowRuntimeContext<FlowModel>, this.model?.uid),
               template,
               contextParams: autoContextParams || {},
             });
@@ -3399,7 +3425,8 @@ export class FlowEngineContext extends BaseFlowEngineContext {
       }
 
       return resolveExpressions(serverResolved, this);
-    });
+    };
+    this.defineMethod('resolveJsonTemplate', resolveJsonTemplate);
 
     // Helper: resolve a single ctx expression value via resolveJsonTemplate behavior.
     // Example: await ctx.getVar('ctx.record.id')
@@ -3917,6 +3944,11 @@ export class FlowRuntimeContext<
   ) {
     super();
     this.addDelegate(this.model.context);
+    const owner = model.getFlow?.(flowKey)?.model;
+    if (owner && owner.uid !== model.uid) {
+      // A forwarded instance flow keeps its configuration owner, without changing the runtime model.
+      this.defineProperty('variableContractModelUid', { value: owner.uid });
+    }
     this.defineMethod('getStepParams', (stepKey: string) => {
       return model.getStepParams(flowKey, stepKey) || {};
     });
@@ -4582,9 +4614,56 @@ function __mergeRunJSDocMeta(base: any, patch: any): RunJSDocMeta {
   return out as RunJSDocMeta;
 }
 export class FlowRunJSContext extends FlowContext {
+  [PREPARE_CONTEXT_RESOURCE_ACTION_PARAMS](
+    action: { actionName: string; dataSourceKey?: string; resourceName: string; resourceOf?: unknown },
+    params: Record<string, unknown> | undefined,
+  ) {
+    if (
+      action.actionName.toLowerCase() !== 'create' ||
+      !params ||
+      Array.isArray(params) ||
+      Object.prototype.hasOwnProperty.call(params, 'updateAssociationValues') ||
+      !this.form ||
+      typeof this.blockModel?.submitFromRunJs !== 'function'
+    ) {
+      return params;
+    }
+
+    const resource = this.resource;
+    const currentResourceName = resource?.getResourceName?.();
+    const currentDataSourceKey = resource?.getDataSourceKey?.() || 'main';
+    if (action.resourceName !== currentResourceName || (action.dataSourceKey || 'main') !== currentDataSourceKey) {
+      return params;
+    }
+
+    const currentSourceId = resource?.getSourceId?.();
+    if (
+      currentResourceName?.includes('.') &&
+      currentSourceId !== null &&
+      typeof currentSourceId !== 'undefined' &&
+      String(action.resourceOf ?? '') !== String(currentSourceId)
+    ) {
+      return params;
+    }
+
+    const updateAssociationValues = resource?.getUpdateAssociationValues?.();
+    if (!Array.isArray(updateAssociationValues) || updateAssociationValues.length === 0) {
+      return params;
+    }
+
+    return {
+      ...params,
+      updateAssociationValues: [...updateAssociationValues],
+    };
+  }
+
   constructor(delegate: FlowContext) {
     super();
     this.addDelegate(delegate);
+    const submit = delegate.blockModel?.submitFromRunJs?.bind(delegate.blockModel);
+    if (delegate.form && submit) {
+      this.defineProperty('form', { value: { ...delegate.form, submit } });
+    }
     this.defineProperty('React', { value: React });
     this.defineProperty('antd', { value: antd });
     this.defineProperty('dayjs', {

package/src/locale/__tests__/index.test.ts

@@ -0,0 +1,21 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { describe, expect, it } from 'vitest';
+
+import { getFlowEngineTranslation } from '../index';
+
+describe('flow engine locale', () => {
+  it('translates the default secondary confirmation text into Chinese', () => {
+    expect(getFlowEngineTranslation('Please Confirm', 'zh-CN')).toBe('请确认');
+    expect(getFlowEngineTranslation('Are you sure you want to perform the action?', 'zh-CN')).toBe(
+      '确定要执行此操作吗？',
+    );
+  });
+});

package/src/locale/en-US.json

@@ -1,5 +1,6 @@
 {
   "Add": "Add",
+  "Are you sure you want to perform the action?": "Are you sure you want to perform the action?",
   "Are you sure you want to delete this item? This action cannot be undone.": "Are you sure you want to delete this item? This action cannot be undone.",
   "Are you sure to convert this template block to copy mode?": "Are you sure you want to convert this template block to copy mode?",
   "Array index out of bounds": "Array index {{index}} out of bounds for '{{subKey}}'",
@@ -53,6 +54,7 @@
   "Other blocks": "Other blocks",
   "Parent not found, cannot replace block": "Parent not found, cannot replace block",
   "Previous step": "Previous step",
+  "Please Confirm": "Please Confirm",
   "Replace current block with template?": "Replace current block with template?",
   "Replaced with template block": "Replaced with template block",
   "Render failed": "Render failed",

package/src/locale/zh-CN.json

@@ -1,5 +1,6 @@
 {
   "Add": "添加",
+  "Are you sure you want to perform the action?": "确定要执行此操作吗？",
   "Are you sure you want to delete this item? This action cannot be undone.": "确定要删除此项吗？此操作不可撤销。",
   "Are you sure to convert this template block to copy mode?": "确定将该模板区块转换为复制模式吗？",
   "Array index out of bounds": "数组索引 {{index}} 超出 '{{subKey}}' 的边界",
@@ -59,6 +60,7 @@
   "OK": "确定",
   "Other blocks": "其他区块",
   "Previous step": "上一步",
+  "Please Confirm": "请确认",
   "Render failed": "渲染失败",
   "Response record": "响应结果记录",
   "Step configuration": "步骤配置",

package/src/models/CollectionFieldModel.tsx

@@ -51,7 +51,7 @@ export function FieldDeletePlaceholder() {
     const dataSourcePrefix = dataSource ? `${t(dataSource.displayName || dataSource.key)} > ` : '';
     const collectionPrefix = collection ? `${t(collection.title) || collection.name || collection.tableName} > ` : '';
     return `${dataSourcePrefix}${collectionPrefix}${name}`;
-  }, []);
+  }, [collection, dataSource, name, t]);
   return (
     <Form.Item>
       <div
@@ -80,7 +80,7 @@ function FieldWithoutPermissionPlaceholder() {
     const dataSourcePrefix = `${t(dataSource.displayName || dataSource.key)} > `;
     const collectionPrefix = collection ? `${t(collection.title) || collection.name || collection.tableName} > ` : '';
     return `${dataSourcePrefix}${collectionPrefix}${name}`;
-  }, []);
+  }, [collection, dataSource.displayName, dataSource.key, name, t]);
   const { actionName } = model.forbidden;
   const messageValue = useMemo(() => {
     return t(
@@ -90,7 +90,7 @@ function FieldWithoutPermissionPlaceholder() {
         actionName: t(_.capitalize(actionName)),
       },
     ).replaceAll('&gt;', '>');
-  }, [nameValue, t]);
+  }, [actionName, nameValue, t]);
 
   return (
     <Tooltip title={messageValue}>
@@ -198,13 +198,16 @@ export class CollectionFieldModel<T extends DefaultStructure = DefaultStructure>
 
   static getDefaultBindingByField(
     ctx: FlowEngineContext,
-    collectionField: CollectionField,
+    collectionField: CollectionField | null | undefined,
     options: {
       useStrict?: boolean;
       fallbackToTargetTitleField?: boolean;
       targetCollectionTitleField?: CollectionField;
     } = {},
   ): BindingOptions | null {
+    if (!collectionField) {
+      return null;
+    }
     if (options.fallbackToTargetTitleField) {
       const binding = this.getDefaultBindingByField(ctx, collectionField, { useStrict: true });
       if (!binding) {

package/src/models/__tests__/CollectionFieldModel.test.ts

@@ -108,6 +108,11 @@ describe('CollectionFieldModel', () => {
     expect(defaultBinding).toBeNull();
   });
 
+  it('should return null when the collection field has been deleted', () => {
+    const defaultBinding = TestModel.getDefaultBindingByField(mockContext, undefined);
+    expect(defaultBinding).toBeNull();
+  });
+
   it('should return null if no bindings exist for the interface', () => {
     class Test1Model extends CollectionFieldModel {}
     class Test2Model extends Test1Model {}

package/src/resources/__tests__/flowResource.test.ts

@@ -79,6 +79,9 @@ describe('FlowResource - error handling', () => {
     expect(r.getError()).toBeNull();
 
     const err = new ResourceError({ response: { data: { error: { message: 'boom', code: 'X' } } } });
+    expect(err.data).toEqual({ message: 'boom', code: 'X' });
+    expect(err.message).toBe('boom');
+    expect(err.code).toBe('X');
     const ret = r.setError(err);
     expect(ret).toBe(r);
     expect(r.error).toBe(err);

package/src/resources/flowResource.ts

@@ -47,6 +47,7 @@ export class ResourceError extends Error {
   constructor(error) {
     const data = toErrMessages(error).shift();
     super(data.message);
+    this.data = data;
     this.name = 'ResponseError';
   }
 

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,