feat(refs): buildRefs 递归下钻 tab，覆盖嵌套 relation

collectRefs 递归收集:relation 叶子直接收，tab 按 value.type 进选中分支继续下钻
(顺带覆盖 tab 套 tab)。refs 字典现含嵌套关联名(如 sellType.goods)，
为 tab 显示搬前端(子组件渲染 + relation 查 refs)铺好地基。

package.json

@@ -1,6 +1,6 @@
 {
     "name": "shrimp-server",
-    "version": "0.6.5",
+    "version": "0.6.9",
     "description": "Shrimp 框架后端 — 声明式字段驱动的 Node.js 管理后台框架(Express + Mongoose + JWT)",
     "main": "dist/main/index.js",
     "types": "dist/main/index.d.ts",

src/IShrimpType.ts

@@ -278,9 +278,8 @@ export interface IFieldConfig {
     rules?: IFieldRule[]          // 通用验证规则（前后端共用）
     /** tab 类型专用：每个 type 对应的子字段配置 */
     tabs?: { key: any; label: ILabel; fields: IFieldConfig[] }[]
-    /** tab 类型专用：展示文本(表格列 `${key}_label`)，给人看、可有损好看，默认 JSON.stringify。
+    /** tab 类型专用：展示文本(表格列 `${key}_label`)，给人看、可有损好看，默认 JSON.stringify */
-     *  relLabels 是已解析的子 relation 名(`{childKey: 名 | 名[]}`)，单选为名、multiple 为名数组 */
+    format?: (value: any) => string
-    format?: (value: any, relLabels?: Record<string, any>) => string
     /** tab 类型专用：export 序列化，须与 parse 可逆(机器往返)，默认 JSON.stringify */
     stringify?: (value: any) => string
     /** tab 类型专用：import 反序列化，须与 stringify 可逆，默认 JSON.parse */
@@ -321,6 +320,7 @@ export interface IPageResult<T> {
     page: number       // 当前页码
     pageSize: number   // 每页数量
     totalPages: number // 总页数
+    refs?: Record<string, Record<string, any>>  // relation 显示名字典: { moduleKey: { id: 显示名 } }，前端显示时查名，替代逐行 _label
 }
 
 // ============== 数据源查询协议 ==============

src/Shrimp/ShrimpTableModule.ts

@@ -61,8 +61,7 @@ export const defaultTypeHandlers: Record<string, IFieldTypeHandler> = {
             return value
         },
         // 本体原样下发对象(不再 stringify)；展示文本走 _label，用 format(给人看,可有损)
-        // 第二参是已批量解析的子 relation 名(item.__tabRel[field.key])，让 format 能显示关联名而非 id
+        resLabel: (value, field) => (field.format ?? JSON.stringify)(value),
-        resLabel: (value, field, item) => (field.format ?? JSON.stringify)(value, item?.__tabRel?.[field.key]),
     },
 }
 
@@ -226,79 +225,59 @@ export class ShrimpTableModule<T, P extends ITableCrudProto<T> = ITableCrudProto
                 result[`${field.key}_label`] = handler.resLabel(result[field.key], field, result)
             }
         }
-        delete result.__tabRel // 临时挂的子 relation 解析结果，不下发
         return result
     }
 
     private async prepareResponseItems(items: any[]): Promise<any[]> {
         if (items.length === 0) return items
-        const populates = this.getRelationPopulates()
-        if (populates.length > 0 && this.dataSource.populateItems) {
-            await this.dataSource.populateItems(items, populates, this.root.crudRegistry)
-        }
-        await this.populateTabRelations(items)
         return Promise.all(items.map(item => this.processResItem(item)))
     }
 
     private async prepareResponseItem(item: any): Promise<any> {
         if (!item) return item
-        const populates = this.getRelationPopulates()
-        if (populates.length > 0 && this.dataSource.populateItems) {
-            await this.dataSource.populateItems([item], populates, this.root.crudRegistry)
-        }
-        await this.populateTabRelations([item])
         return this.processResItem(item)
     }
 
     /**
-     * 解析 tab 字段里 relation 子字段的名字，批量(每个关联模块一次 $in)，
+     * relation 字段(含 tab 分支里的嵌套 relation)批量解析成 refs 字典: { moduleKey: { id: 显示名 } }。
-     * 挂到 item.__tabRel[fieldKey][childKey]，供该字段的 format 第二参使用。
+     * 整页一次性、按模块各查一次 $in，去重；替代逐行注入 ${key}_label。前端显示时按 id 查名。
-     * 不污染 tab 本体对象(避免回灌进库)，__tabRel 在 processResItem 末尾删除。
      */
-    private async populateTabRelations(items: any[]): Promise<void> {
+    private async buildRefs(rows: any[]): Promise<Record<string, Record<string, any>>> {
-        const tabFields = this.fields.filter(f => f.type === ShrimpFieldTypes.Tab && Array.isArray(f.tabs))
+        if (rows.length === 0) return {}
-        if (tabFields.length === 0 || items.length === 0) return
+        const buckets = new Map<string, { labelKey: string; ids: Set<string> }>()
-
+        const add = (moduleKey: string, labelKey: string, id: any) => {
-        const need = new Map<string, { labelKey: string; ids: Set<string> }>()
+            let b = buckets.get(moduleKey)
-        const refs: { item: any; fieldKey: string; childKey: string; moduleKey: string; multiple: boolean }[] = []
+            if (!b) buckets.set(moduleKey, (b = { labelKey, ids: new Set() }))
-        for (const item of items) {
+            b.ids.add(String(id))
-            for (const tf of tabFields) {
-                const val = item[tf.key]
-                if (!val || typeof val !== "object") continue
-                const tab = tf.tabs!.find(t => t.key === val.type)
-                if (!tab) continue
-                for (const child of tab.fields) {
-                    if (child.type !== ShrimpFieldTypes.Relation || !child.relation || val[child.key] == null) continue
-                    const { moduleKey, labelKey } = child.relation
-                    let bucket = need.get(moduleKey)
-                    if (!bucket) need.set(moduleKey, (bucket = { labelKey, ids: new Set() }))
-                    const cv = val[child.key]
-                    ;(Array.isArray(cv) ? cv : [cv]).forEach((id: any) => id != null && bucket!.ids.add(String(id)))
-                    refs.push({ item, fieldKey: tf.key, childKey: child.key, moduleKey, multiple: !!child.multiple })
-                }
-            }
         }
-        if (refs.length === 0) return
+        for (const row of rows) {
-
+            this.collectRefs(this.fields, (k) => row[k], add)
-        const labelMaps = new Map<string, Map<string, any>>()
+        }
-        for (const [moduleKey, b] of need) {
+        if (buckets.size === 0) return {}
-            const m = new Map<string, any>()
+        const refs: Record<string, Record<string, any>> = {}
+        for (const [moduleKey, b] of buckets) {
+            const dict: Record<string, any> = {}
             const crud = this.root.crudRegistry.get(moduleKey)
             if (crud && b.ids.size > 0) {
                 const res = await crud.list({ where: { _id: { in: Array.from(b.ids) } }, limit: b.ids.size })
-                for (const doc of res.list as any[]) m.set(String(doc._id), doc[b.labelKey])
+                for (const d of res.list as any[]) dict[String(d._id)] = d[b.labelKey]
             }
-            labelMaps.set(moduleKey, m)
+            refs[moduleKey] = dict
         }
+        return refs
+    }
 
-        for (const ref of refs) {
+    /** 递归收集 relation 引用：relation 叶子直接收；tab 按 value.type 进选中分支继续下钻(覆盖嵌套/tab套tab) */
-            const m = labelMaps.get(ref.moduleKey)!
+    private collectRefs(fields: IFieldConfig[], valueOf: (key: string) => any, add: (moduleKey: string, labelKey: string, id: any) => void): void {
-            const cv = ref.item[ref.fieldKey][ref.childKey]
+        for (const f of fields) {
-            const label = ref.multiple
+            const v = valueOf(f.key)
-                ? (Array.isArray(cv) ? cv.map((id: any) => m.get(String(id)) ?? null) : [])
+            if (v == null) continue
-                : m.get(String(cv)) ?? null
+            if (f.type === "relation" && f.relation) {
-            const bag = (ref.item.__tabRel ||= {})
+                ;(Array.isArray(v) ? v : [v]).forEach((id: any) => id != null && add(f.relation!.moduleKey, f.relation!.labelKey, id))
-            ;(bag[ref.fieldKey] ||= {})[ref.childKey] = label
+            } else if (f.type === ShrimpFieldTypes.Tab && Array.isArray(f.tabs) && typeof v === "object") {
+                const branch = f.tabs.find(t => t.key === v.type)
+                if (branch) this.collectRefs(branch.fields, (k) => v[k], add)
+            }
         }
     }
 
@@ -315,18 +294,6 @@ export class ShrimpTableModule<T, P extends ITableCrudProto<T> = ITableCrudProto
         return this.excludeKeys(item, this.fields.filter(f => f.hidden).map(f => f.key))
     }
 
-    private getRelationFields(): IFieldConfig[] {
-        return this.fields.filter(f => f.type === "relation" && f.relation)
-    }
-
-    private getRelationPopulates(): IShrimpPopulate[] {
-        return this.getRelationFields().map(f => ({
-            key: f.key,
-            moduleKey: f.relation!.moduleKey,
-            labelKey: f.relation!.labelKey,
-        }))
-    }
-
     private buildQuery(query?: IPageQuery & any): IShrimpQuery {
         const { keyword, page, pageSize, sortBy, sortOrder, filter, ownerId } = query || {}
         const p = page || 1
@@ -341,6 +308,11 @@ export class ShrimpTableModule<T, P extends ITableCrudProto<T> = ITableCrudProto
             const stringLikeTypes = new Set(['string', 'textarea'])
             const where: Record<string, IShrimpCondition> = {}
             for (const [key, value] of Object.entries(filter)) {
+                // _id 始终放行精确过滤(单项查看/relation 跳转用)，无需配 filterable
+                if (key === '_id') {
+                    if (value != null && value !== '') where['_id'] = { eq: value }
+                    continue
+                }
                 const field = filterableFields.get(key)
                 if (!field) continue
                 if (value == null) continue
@@ -395,6 +367,7 @@ export class ShrimpTableModule<T, P extends ITableCrudProto<T> = ITableCrudProto
         const result = await this.dataSource.list(shrimpQuery)
         result.list = await this.prepareResponseItems(result.list)
         result.list = result.list.map(item => this.filterHidden(item))
+        result.refs = await this.buildRefs(result.list)
         return result
     }