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

package/src/components/subModel/__tests__/utils.test.ts

@@ -7,14 +7,14 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-import { describe, it, expect } from 'vitest';
-import { buildItems, buildSubModelGroups, buildSubModelItem, buildSubModelItems } from '../utils';
-import { mergeSubModelItems } from '../AddSubModelButton';
+import { describe, expect, it } from 'vitest';
+import type { FlowModelContext } from '../../../flowContext';
 import { FlowEngine } from '../../../flowEngine';
 import { FlowModel } from '../../../models';
-import type { FlowModelContext } from '../../../flowContext';
-import type { SubModelItem } from '../AddSubModelButton';
 import type { ModelConstructor } from '../../../types';
+import type { SubModelItem } from '../AddSubModelButton';
+import { mergeSubModelItems } from '../AddSubModelButton';
+import { buildItems, buildSubModelGroups, buildSubModelItem, buildSubModelItems } from '../utils';
 
 type DefineChildren = (ctx: FlowModelContext) => SubModelItem[] | Promise<SubModelItem[]>;
 type WithDefineChildren<T extends ModelConstructor = ModelConstructor> = T & { defineChildren: DefineChildren };
@@ -153,7 +153,7 @@ describe('subModel/utils', () => {
   });
 
   describe('buildSubModelItem', () => {
-    it('returns undefined for hidden meta entries', () => {
+    it('returns undefined for hidden meta entries', async () => {
       const engine = new FlowEngine();
 
       class Parent extends FlowModel {}
@@ -163,7 +163,7 @@ describe('subModel/utils', () => {
       engine.registerModels({ Parent, HiddenChild });
       const parent = engine.createModel({ use: 'Parent', uid: 'parent-hidden' });
 
-      const item = buildSubModelItem(HiddenChild, parent.context);
+      const item = await buildSubModelItem(HiddenChild, parent.context);
       expect(item).toBeUndefined();
     });
 
@@ -194,7 +194,7 @@ describe('subModel/utils', () => {
       const parent = engine.createModel<Parent>({ use: 'Parent', uid: 'parent-child-group' });
       const ctx = parent.context;
 
-      const item = buildSubModelItem(ChildGroup, ctx, false);
+      const item = await buildSubModelItem(ChildGroup, ctx, false);
       expect(item).toBeTruthy();
       expect(item?.label).toBe('Child Group');
       expect(item?.searchable).toBe(true);
@@ -214,7 +214,7 @@ describe('subModel/utils', () => {
       expect(merged?.extra).toMatchObject({ fromTest: true });
     });
 
-    it('falls back to use=current class name when meta createModelOptions omitted', () => {
+    it('falls back to use=current class name when meta createModelOptions omitted', async () => {
       const engine = new FlowEngine();
 
       class Parent extends FlowModel {}
@@ -223,11 +223,11 @@ describe('subModel/utils', () => {
       engine.registerModels({ Parent, PlainChild });
       const parent = engine.createModel<Parent>({ use: 'Parent', uid: 'parent-default-create-options' });
 
-      const item = buildSubModelItem(PlainChild, parent.context);
+      const item = await buildSubModelItem(PlainChild, parent.context);
       expect(item?.createModelOptions).toEqual({ use: 'PlainChild' });
     });
 
-    it('still returns item when skipHide=true', () => {
+    it('still returns item when skipHide=true', async () => {
       const engine = new FlowEngine();
 
       class Parent extends FlowModel {}
@@ -237,7 +237,7 @@ describe('subModel/utils', () => {
       engine.registerModels({ Parent, HiddenChild });
       const parent = engine.createModel({ use: 'Parent', uid: 'parent-skip-hide' });
 
-      const item = buildSubModelItem(HiddenChild, parent.context, true);
+      const item = await buildSubModelItem(HiddenChild, parent.context, true);
       expect(item).toBeTruthy();
       expect(item?.label).toBe('Hidden but allowed');
     });

package/src/components/subModel/utils.ts

@@ -14,9 +14,23 @@ import { FlowModelMeta, ModelConstructor } from '../../types';
 import { isInheritedFrom, resolveCreateModelOptions } from '../../utils';
 import { SubModelItem } from './AddSubModelButton';
 
-export function buildSubModelItem(M: ModelConstructor, ctx: FlowModelContext, skipHide = false): SubModelItem {
+async function callHideFunction(
+  hide: boolean | ((context: FlowModelContext) => boolean | Promise<boolean>),
+  ctx: FlowModelContext,
+) {
+  if (typeof hide === 'function') {
+    return await hide(ctx);
+  }
+  return hide;
+}
+
+export async function buildSubModelItem(
+  M: ModelConstructor,
+  ctx: FlowModelContext,
+  skipHide = false,
+): Promise<SubModelItem | undefined> {
   const meta: FlowModelMeta = (M.meta ?? {}) as FlowModelMeta;
-  if (meta.hide && !skipHide) {
+  if ((await callHideFunction(meta.hide, ctx)) && !skipHide) {
     return;
   }
   // 判断是否为 CollectionBlockModel 的子类（用于集合选择层开启搜索）
@@ -102,8 +116,13 @@ export function buildSubModelItems(subModelBaseClass: string | ModelConstructor,
   return async (ctx: FlowModelContext) => {
     const SubModelClasses = ctx.engine.getSubclassesOf(subModelBaseClass);
     // Collect and sort subclasses by meta.sort (ascending), excluding hidden or inherited ones in `exclude`
-    let candidates = Array.from(SubModelClasses.values())
-      .filter((C) => !C.meta?.hide)
+    let candidates = [];
+    for (const C of Array.from(SubModelClasses.values())) {
+      if (!(await callHideFunction(C.meta?.hide, ctx))) {
+        candidates.push(C);
+      }
+    }
+    candidates = candidates
       .filter((C) => {
         for (const P of exclude as (string | ModelConstructor)[]) {
           if (typeof P === 'string') {
@@ -120,14 +139,14 @@ export function buildSubModelItems(subModelBaseClass: string | ModelConstructor,
     if (candidates.length === 0) {
       const BaseClass =
         typeof subModelBaseClass === 'string' ? ctx.engine.getModelClass(subModelBaseClass) : subModelBaseClass;
-      if (BaseClass && !BaseClass.meta?.hide) {
+      if (BaseClass && !(await callHideFunction(BaseClass.meta?.hide, ctx))) {
         candidates = [BaseClass];
       }
     }
 
     const items: SubModelItem[] = [];
     for (const M of candidates) {
-      const item = buildSubModelItem(M, ctx);
+      const item = await buildSubModelItem(M, ctx);
       if (item) items.push(item);
     }
     return items;

package/src/components/variables/VariableInput.tsx

@@ -85,6 +85,7 @@ const VariableInputComponent: React.FC<VariableInputProps> = ({
   showValueComponent = true,
   onlyLeafSelectable = false,
   clearValue,
+  ignoreFieldNames,
   ...restProps
 }) => {
   const [currentMetaTreeNode, setCurrentMetaTreeNode] = useState<MetaTreeNode | null>(null);
@@ -138,7 +139,7 @@ const VariableInputComponent: React.FC<VariableInputProps> = ({
   // 当 value 存在但 currentMetaTreeNode 还未恢复，尝试按路径逐级加载（支持 children 为函数的场景）
   useEffect(() => {
     const restoreFromValue = async () => {
-      if (!Array.isArray(resolvedMetaTree) || !value) return;
+      if (!Array.isArray(resolvedMetaTree) || value == null) return;
 
       // 若已存在且路径匹配，跳过
       if (currentMetaTreeNode) {
@@ -202,7 +203,7 @@ const VariableInputComponent: React.FC<VariableInputProps> = ({
 
   useEffect(() => {
     if (!resolvedMetaTreeNode) return;
-    if (!Array.isArray(resolvedMetaTree) || !innerValue) return;
+    if (!Array.isArray(resolvedMetaTree) || innerValue == null) return;
     const finalValue = resolveValueFromPath?.(resolvedMetaTreeNode) || innerValue;
     emitChange(finalValue, resolvedMetaTreeNode);
     setCurrentMetaTreeNode(resolvedMetaTreeNode);
@@ -240,12 +241,18 @@ const VariableInputComponent: React.FC<VariableInputProps> = ({
 
   const handleVariableSelect = useCallback(
     (variableValue: string, metaTreeNode?: MetaTreeNode) => {
+      if (!metaTreeNode && variableValue === '') {
+        const cleared = clearValue !== undefined ? clearValue : null;
+        setInnerValue(cleared);
+        emitChange(cleared as any);
+        return;
+      }
       setCurrentMetaTreeNode(metaTreeNode);
       const finalValue = resolveValueFromPath?.(metaTreeNode) || variableValue;
       setInnerValue(finalValue);
       emitChange(finalValue, metaTreeNode);
     },
-    [emitChange, resolveValueFromPath],
+    [emitChange, resolveValueFromPath, clearValue],
   );
 
   const { disabled } = restProps;
@@ -254,11 +261,29 @@ const VariableInputComponent: React.FC<VariableInputProps> = ({
     if (disabled) {
       return;
     }
-    setCurrentMetaTreeNode(null);
     const cleared = clearValue !== undefined ? clearValue : null;
     setInnerValue(cleared);
+
+    // 若 clearValue 能解析到某个路径（例如 ['constant']），
+    // 则尝试立即定位到对应的 MetaTreeNode，以便渲染正确的常量组件。
+    try {
+      const path = resolvePathFromValue?.(cleared);
+      if (Array.isArray(resolvedMetaTree) && path && path.length > 0) {
+        const node = findMetaTreeNodeByPath(resolvedMetaTree as MetaTreeNode[], path as string[]);
+        if (node) {
+          setCurrentMetaTreeNode(node);
+          emitChange(cleared as any, node);
+          return;
+        }
+      }
+    } catch (_) {
+      // 忽略解析异常，走默认回退
+    }
+
+    // 默认回退（无法定位具体 MetaTreeNode 时）
+    setCurrentMetaTreeNode(null);
     emitChange(cleared as any);
-  }, [emitChange, disabled, clearValue]);
+  }, [emitChange, disabled, clearValue, resolvedMetaTree, resolvePathFromValue]);
 
   const stableProps = useMemo(() => {
     const { style, onFocus, onBlur, disabled, ...otherProps } = restProps;
@@ -267,7 +292,7 @@ const VariableInputComponent: React.FC<VariableInputProps> = ({
 
   const inputProps = useMemo(() => {
     const baseProps = {
-      value: innerValue || '',
+      value: ValueComponent === Input ? innerValue ?? '' : innerValue,
       onChange: handleInputChange,
       disabled,
     };
@@ -333,6 +358,7 @@ const VariableInputComponent: React.FC<VariableInputProps> = ({
         parseValueToPath={resolvePathFromValue}
         formatPathToValue={resolveValueFromPath}
         onlyLeafSelectable={onlyLeafSelectable}
+        ignoreFieldNames={ignoreFieldNames}
         {...(!showValueComponent && { children: null, placeholder: restProps?.placeholder })}
       />
     </Space.Compact>

package/src/components/variables/VariableTag.tsx

@@ -15,6 +15,7 @@ import { parseValueToPath } from './utils';
 import { useResolvedMetaTree } from './useResolvedMetaTree';
 import { useRequest } from 'ahooks';
 import { useFlowContext } from '../../FlowContextProvider';
+import type { MetaTreeNode } from '../../flowContext';
 
 const VariableTagComponent: React.FC<VariableTagProps> = ({
   value,
@@ -29,14 +30,65 @@ const VariableTagComponent: React.FC<VariableTagProps> = ({
 
   const { data: displayedValue } = useRequest(
     async () => {
+      // 1) 优先使用已解析到的节点（包含完整父标题链）
       if (metaTreeNode) {
         return metaTreeNode.parentTitles
           ? [...metaTreeNode.parentTitles, metaTreeNode.title].map(ctx.t).join('/')
           : ctx.t(metaTreeNode.title) || '';
       }
+
+      // 2) 无 metaTreeNode 时，尝试从值还原路径，并在 metaTree 中寻找“最深前缀节点”，
+      //    即便最后一段无效，也能显示前缀的翻译标题。
       if (!value) return String(value);
-      const path = parseValueToPath(value);
-      return path ? path.join('/') : String(value);
+      const rawPath = parseValueToPath(value);
+      if (!rawPath || !Array.isArray(resolvedMetaTree)) {
+        return Array.isArray(rawPath) ? rawPath.join('/') : String(value);
+      }
+
+      // 兼容 metaTree 为子树：顶层不含首段时，裁剪首段
+      const topNames = new Set((resolvedMetaTree || []).map((n: any) => String(n?.name)));
+      const path = !topNames.has(String(rawPath[0])) ? rawPath.slice(1) : rawPath;
+      if (!path.length) return '';
+
+      let nodes: MetaTreeNode[] | undefined = resolvedMetaTree as MetaTreeNode[];
+      let deepest: MetaTreeNode | null = null;
+      let matchedCount = 0;
+      for (let i = 0; i < path.length; i++) {
+        if (!nodes) break;
+        const seg = String(path[i]);
+        const node = nodes.find((n) => String(n?.name) === seg) as MetaTreeNode | undefined;
+        if (!node) break; // 停在第一个无效段之前
+        deepest = node;
+        matchedCount = i + 1;
+        if (i < path.length - 1) {
+          if (Array.isArray(node.children)) {
+            nodes = node.children as any;
+          } else if (typeof node.children === 'function') {
+            try {
+              const childNodes = await (node.children as any)();
+              (node as any).children = childNodes;
+              nodes = childNodes as any;
+            } catch {
+              nodes = undefined;
+            }
+          } else {
+            nodes = undefined;
+          }
+        }
+      }
+
+      if (deepest) {
+        const titles = deepest.parentTitles ? [...deepest.parentTitles, deepest.title] : [deepest.title];
+        let label = titles.map(ctx.t).join('/');
+        if (matchedCount < path.length) {
+          const tail = path.slice(matchedCount).join('/');
+          label = tail ? `${label}/${tail}` : label;
+        }
+        return label;
+      }
+
+      // 3) 完全找不到任何前缀时，退回原始路径字符串
+      return path.join('/');
     },
     { refreshDeps: [resolvedMetaTree, value, metaTreeNode] },
   );

package/src/components/variables/types.ts

@@ -21,6 +21,7 @@ export interface FlowContextSelectorProps
   formatPathToValue?: (item: MetaTreeNode) => string;
   open?: boolean;
   onlyLeafSelectable?: boolean;
+  ignoreFieldNames?: string[];
 }
 
 export interface ContextSelectorItem {
@@ -69,6 +70,7 @@ export interface VariableInputProps {
    * 默认行为为 null；可设置为 '' 等，以便清空后默认切换为“常量-空字符串”。
    */
   clearValue?: any;
+  ignoreFieldNames?: string[];
   [key: string]: any;
 }
 

package/src/components/variables/utils.ts

@@ -95,7 +95,9 @@ export const buildContextSelectorItems = (metaTree: MetaTreeNode[]): ContextSele
     return [];
   }
 
-  const convertNode = (node: MetaTreeNode): ContextSelectorItem => {
+  const convertNode = (node: MetaTreeNode): ContextSelectorItem | null => {
+    const hidden = !!(typeof node.hidden === 'function' ? node.hidden() : node.hidden);
+    if (hidden) return null;
     const hasChildren = !!(
       node.children &&
       (typeof node.children === 'function' || (Array.isArray(node.children) && node.children.length > 0))
@@ -112,13 +114,15 @@ export const buildContextSelectorItems = (metaTree: MetaTreeNode[]): ContextSele
     };
 
     if (Array.isArray(node.children) && node.children.length > 0) {
-      option.children = node.children.map((child) => convertNode(child));
+      option.children = node.children
+        .map((child) => convertNode(child))
+        .filter((item): item is ContextSelectorItem => item !== null);
     }
 
     return option;
   };
 
-  return metaTree.map((node) => convertNode(node));
+  return metaTree.map((node) => convertNode(node)).filter((item): item is ContextSelectorItem => item !== null);
 };
 
 /**

package/src/data-source/index.ts

@@ -8,6 +8,7 @@
  */
 
 import { observable } from '@formily/reactive';
+import { CascaderProps } from 'antd';
 import _ from 'lodash';
 import { FlowEngine } from '../flowEngine';
 import { jioToJoiSchema } from './jioToJoiSchema';
@@ -144,8 +145,8 @@ export class DataSource {
     return this.collectionManager.upsertCollection(options);
   }
 
-  upsertCollections(collections: CollectionOptions[]) {
-    return this.collectionManager.upsertCollections(collections);
+  upsertCollections(collections: CollectionOptions[], options: { clearFields?: boolean } = {}) {
+    return this.collectionManager.upsertCollections(collections, options);
   }
 
   removeCollection(name: string) {
@@ -166,7 +167,7 @@ export class DataSource {
     const fieldName = otherKeys.join('.');
     const collection = this.getCollection(collectionName);
     if (!collection) {
-      throw new Error(`Collection ${collectionName} not found in data source ${this.key}`);
+      return;
     }
     const field = collection.getFieldByPath(fieldName);
     if (!field) {
@@ -186,6 +187,9 @@ export interface CollectionOptions {
 export class CollectionManager {
   collections: Map<string, Collection>;
 
+  allCollectionsInheritChain: string[];
+  protected childrenCollectionsName: { supportView?: string[]; notSupportView?: string[] } = {};
+
   constructor(public dataSource: DataSource) {
     this.collections = observable.shallow<Map<string, Collection>>(new Map());
   }
@@ -210,12 +214,12 @@ export class CollectionManager {
     this.collections.delete(name);
   }
 
-  updateCollection(newOptions: CollectionOptions) {
+  updateCollection(newOptions: CollectionOptions, options: { clearFields?: boolean } = {}) {
     const collection = this.getCollection(newOptions.name);
     if (!collection) {
       throw new Error(`Collection ${newOptions.name} not found`);
     }
-    collection.setOptions(newOptions);
+    collection.setOptions(newOptions, options);
   }
 
   upsertCollection(options: CollectionOptions) {
@@ -227,10 +231,10 @@ export class CollectionManager {
     return this.getCollection(options.name);
   }
 
-  upsertCollections(collections: CollectionOptions[]) {
+  upsertCollections(collections: CollectionOptions[], options: { clearFields?: boolean } = {}) {
     for (const collection of sortCollectionsByInherits(collections)) {
       if (this.collections.has(collection.name)) {
-        this.updateCollection(collection);
+        this.updateCollection(collection, options);
       } else {
         this.addCollection(collection);
       }
@@ -321,6 +325,98 @@ export class CollectionManager {
     }
     return collection.getField(fieldName);
   }
+
+  getChildrenCollections(name) {
+    const childrens = [];
+    const collections = Array.from(this.collections.values());
+    const getChildrens = (name) => {
+      const inheritCollections = collections.filter((v: any) => {
+        return v.options.inherits?.includes(name);
+      });
+      inheritCollections.forEach((v) => {
+        const collectionKey = v.name;
+        childrens.push(v);
+        return getChildrens(collectionKey);
+      });
+      return childrens;
+    };
+    return getChildrens(name);
+  }
+  getChildrenCollectionsName(name, isSupportView = false) {
+    const cacheKey = isSupportView ? 'supportView' : 'notSupportView';
+    if (this.childrenCollectionsName[cacheKey]) {
+      return this.childrenCollectionsName[cacheKey].slice();
+    }
+
+    const children: string[] = [];
+    const collections = [...this.getCollections()];
+    const getChildrenCollectionsInner = (collectionName: string) => {
+      const inheritCollections = collections.filter((v: any) => {
+        return [...v.inherits]?.includes(collectionName);
+      });
+      inheritCollections.forEach((v) => {
+        const collectionKey = v.name;
+        children.push(collectionKey);
+        return getChildrenCollectionsInner(collectionKey);
+      });
+      if (isSupportView) {
+        const sourceCollections = collections.filter((v: any) => {
+          return [...v.sources]?.length === 1 && v?.sources[0] === collectionName;
+        });
+        sourceCollections.forEach((v) => {
+          const collectionKey = v.name;
+          children.push(v.name);
+          return getChildrenCollectionsInner(collectionKey);
+        });
+      }
+      return _.uniq(children);
+    };
+
+    this.childrenCollectionsName[cacheKey] = getChildrenCollectionsInner(name);
+    return this.childrenCollectionsName[cacheKey];
+  }
+
+  getAllCollectionsInheritChain(name) {
+    if (this.allCollectionsInheritChain) {
+      return this.allCollectionsInheritChain.slice();
+    }
+
+    const collectionsInheritChain = [name];
+    const getInheritChain = (name: string) => {
+      const collection = this.getCollection(name);
+      if (collection) {
+        const { inherits } = collection as any;
+        const children = this.getChildrenCollectionsName(name);
+        // 搜寻祖先表
+        if (inherits) {
+          for (let index = 0; index < inherits.length; index++) {
+            const collectionKey = inherits[index];
+            if (collectionsInheritChain.includes(collectionKey)) {
+              continue;
+            }
+            collectionsInheritChain.push(collectionKey);
+            getInheritChain(collectionKey);
+          }
+        }
+        // 搜寻后代表
+        if (children) {
+          for (let index = 0; index < children.length; index++) {
+            const collection = this.getCollection(children[index]);
+            const collectionKey = collection.name;
+            if (collectionsInheritChain.includes(collectionKey)) {
+              continue;
+            }
+            collectionsInheritChain.push(collectionKey);
+            getInheritChain(collectionKey);
+          }
+        }
+      }
+      return collectionsInheritChain;
+    };
+
+    this.allCollectionsInheritChain = getInheritChain(name);
+    return this.allCollectionsInheritChain || [];
+  }
 }
 
 // Collection 负责管理自己的 Field
@@ -337,6 +433,12 @@ export class Collection {
     this.setFields(options.fields || []);
   }
 
+  clone() {
+    const newCollection = new Collection(_.cloneDeep(this.options));
+    newCollection.setDataSource(this.dataSource);
+    return newCollection;
+  }
+
   getFilterByTK(record) {
     if (!record) {
       throw new Error('Record is required to get filterByTk');
@@ -350,9 +452,16 @@ export class Collection {
     if (typeof this.filterTargetKey === 'string') {
       return record[this.filterTargetKey];
     }
+    if (Array.isArray(this.filterTargetKey) && this.filterTargetKey.length === 1) {
+      return record[this.filterTargetKey[0]];
+    }
     return _.pick(record, this.filterTargetKey);
   }
 
+  get titleableFields() {
+    return this.getFields().filter((field) => field.titleable);
+  }
+
   get hidden() {
     return this.options.hidden || false;
   }
@@ -412,10 +521,13 @@ export class Collection {
     this.dataSource = dataSource;
   }
 
-  setOptions(newOptions: any = {}) {
+  setOptions(newOptions: any = {}, options: { clearFields?: boolean } = {}) {
     Object.keys(this.options).forEach((key) => delete this.options[key]);
     Object.assign(this.options, newOptions);
     this.initInherits();
+    if (options.clearFields) {
+      this.clearFields();
+    }
     this.upsertFields(this.options.fields || []);
   }
 
@@ -483,14 +595,13 @@ export class Collection {
     if (otherKeys.length === 0) {
       return field;
     }
-    if (!field.targetCollection) {
+    if (!field?.targetCollection) {
       return null;
     }
     return field.targetCollection.getFieldByPath(otherKeys.join('.'));
   }
 
   getField(fieldName: string): CollectionField | undefined {
-    this.setFields(this.options.fields); //数据表字段被删除
     return this.fields.get(fieldName);
   }
 
@@ -621,6 +732,10 @@ export class CollectionField {
     return this.options.readonly || this.options.uiSchema?.['x-read-pretty'] || false;
   }
 
+  get titleable() {
+    return !!(this.options.titleable ?? this.options.titleUsable);
+  }
+
   get fullpath() {
     return this.collection.dataSource.key + '.' + this.collection.name + '.' + this.name;
   }
@@ -654,7 +769,7 @@ export class CollectionField {
   }
 
   get title() {
-    const titleValue = this.options?.title || this.options?.uiSchema?.title || this.options.name;
+    const titleValue = this.options?.uiSchema?.title || this.options?.title || this.options.name;
     return this.flowEngine.translate(titleValue);
   }
 
@@ -663,7 +778,22 @@ export class CollectionField {
   }
 
   get enum(): any[] {
-    return this.options.uiSchema?.enum || [];
+    const options = this.options.uiSchema?.enum || [];
+    if (this.type === 'integer') {
+      return options.map((v) => {
+        if (typeof v !== 'object') {
+          return v;
+        }
+        if (v.value === null || v.value === undefined) {
+          return v;
+        }
+        return {
+          ...v,
+          value: Number(v.value),
+        };
+      });
+    }
+    return options;
   }
 
   get defaultValue() {
@@ -703,6 +833,7 @@ export class CollectionField {
         multiple: target ? ['belongsToMany', 'hasMany', 'belongsToArray'].includes(type) : undefined,
         maxCount: target && !['belongsToMany', 'hasMany', 'belongsToArray'].includes(type) ? 1 : undefined,
         target: target,
+        template: this.targetCollection?.template,
       },
       _.isUndefined,
     );

package/src/data-source/jioToJoiSchema.ts

@@ -97,6 +97,7 @@ export function jioToJoiSchema<T extends JioType>(jioConfig: {
   // 4️⃣ 如果没有 required，默认可选并允许空字符串
   if (!hasRequired) {
     schema = schema.optional().allow('');
+    schema = schema.optional().allow(null);
   }
 
   return schema;

package/src/emitter.ts

@@ -30,4 +30,18 @@ export class Emitter {
     }
     (this.events[event] || []).forEach((fn) => fn(...args));
   }
+
+  /**
+   * 异步触发事件：按监听器注册顺序依次（串行）等待执行完成。
+   * - 若某个监听器抛错/Promise reject，将中断后续执行并将异常向上传递（便于调用方统一处理）。
+   * - 当前不提供并行触发能力；如需并发处理，请在监听器内部自行管理（例如在回调内使用 Promise.all）。
+   */
+  async emitAsync(event: string, ...args: any[]): Promise<void> {
+    if (this.paused) return;
+    const listeners = (this.events[event] || []).slice(); // 防止触发过程中被修改
+    for (const fn of listeners) {
+      // 兼容同步/异步监听器
+      await fn(...args);
+    }
+  }
 }