v0.5.0: 重新组织目录结构,按职责拆分

- Shrimp.ts (875 行) 按类拆分到 Shrimp/(7 文件: Shrimp, ShrimpModule, ShrimpTableModule, ShrimpPower, ShrimpCrud, UserRoleModule, OperationLogModule) - forMongo/: MongoShrimpCrud + MongoShrimp(原 ShrimpServer 的 mongo 装配部分,无 express) - forExpress/: buildShrimpRouter + jwtAuth + types - main/: index(0 依赖核心) + expmon(express+mongo 整合,导出 ShrimpServer) + types(纯协议) - 入口子路径 server → expmon(express+mongo 整合方案命名更准确) - 删除冗余的 index.ts / core.ts(合并为 main/index.ts)
2026-05-23 19:44:02 +08:00
parent e8fc126fa6
commit ca283c6733
27 changed files with 1059 additions and 1128 deletions
@@ -0,0 +1,429 @@
+import {
+    IFieldConfig, IFieldTypeHandler, IShrimpQuery, IShrimpCondition, IShrimpPopulate,
+    IPageQuery, IPageResult, ITableCrudProto, ILabel, ShrimpConfig, ShrimpError, ShrimpFieldTypes,
+} from "../IShrimpType"
+import { Shrimp } from "./Shrimp"
+import { ShrimpModule, IShrimpModuleOptions } from "./ShrimpModule"
+import type { ShrimpCrud } from "./ShrimpCrud"
+import type { RootShrimpPower } from "./ShrimpPower"
+
+/** 内置字段类型处理器 */
+export const defaultTypeHandlers: Record<string, IFieldTypeHandler> = {
+    [ShrimpFieldTypes.Password]: {
+        reqFilter: async (value) => {
+            if (typeof value === 'string' && value.length > 0) {
+                return Shrimp.passwordHasher.hash(value)
+            }
+            return value
+        },
+        resFilter: () => "***",
+    },
+    [ShrimpFieldTypes.Date]: {
+        defaultValue: () => Date.now(),
+    },
+    [ShrimpFieldTypes.Number]: {
+        defaultValue: 0,
+    },
+    [ShrimpFieldTypes.Boolean]: {
+        defaultValue: false,
+    },
+    [ShrimpFieldTypes.Json]: {
+        reqFilter: (value) => {
+            if (value == null || value === "") return undefined
+            if (typeof value === "string") {
+                try {
+                    return JSON.parse(value)
+                } catch {
+                    throw new ShrimpError({ t: 'shrimp.invalidJson' })
+                }
+            }
+            return value
+        },
+        resFilter: (value) => {
+            if (value == null) return value
+            if (typeof value === "object") {
+                return JSON.stringify(value)
+            }
+            return value
+        },
+    },
+    [ShrimpFieldTypes.Tab]: {
+        reqFilter: (value) => {
+            if (value == null || value === "") return undefined
+            if (typeof value === "string") {
+                try {
+                    return JSON.parse(value)
+                } catch {
+                    throw new ShrimpError({ t: 'shrimp.invalidJson' })
+                }
+            }
+            return value
+        },
+        resFilter: (value) => {
+            if (value == null) return value
+            if (typeof value === "object") {
+                return JSON.stringify(value)
+            }
+            return value
+        },
+    },
+}
+
+export class ShrimpTableModule<T, P extends ITableCrudProto<T> = ITableCrudProto<T>> extends ShrimpModule<P> implements ITableCrudProto<T> {
+    fields: IFieldConfig[] = []
+
+    constructor(public parent: Shrimp | ShrimpModule, moduleKey: string, public dataSource: ShrimpCrud<T>, fields?: IFieldConfig[], label?: ILabel, power?: RootShrimpPower, options?: IShrimpModuleOptions) {
+        super(parent, moduleKey, label || { t: moduleKey }, power, options)
+        if (fields) {
+            this.fields = fields
+        }
+        this.root.crudRegistry.set(moduleKey, dataSource)
+    }
+
+    getFields(): IFieldConfig[] {
+        return this.fields
+    }
+
+    static typeHandlers: Map<string, IFieldTypeHandler> = new Map(Object.entries(defaultTypeHandlers))
+
+    static registerTypeHandler(type: string, handler: IFieldTypeHandler) {
+        this.typeHandlers.set(type, handler)
+    }
+
+    private getTypeHandler(field: IFieldConfig): IFieldTypeHandler | undefined {
+        return ShrimpTableModule.typeHandlers.get(field.type)
+    }
+
+    /** 前置验证 */
+    private async validateField(field: IFieldConfig, value: any, item: Record<string, any>): Promise<ILabel | null> {
+        const isEmpty = value === undefined || value === null || value === '' || (Array.isArray(value) && value.length === 0)
+
+        if (field.required && isEmpty) {
+            return field.rules?.find(r => r.required)?.message || { t: 'shrimp.fieldRequired', params: { field: field.label } }
+        }
+
+        if (isEmpty) return null
+
+        if (Array.isArray(field.options)) {
+            const validValues = new Set(field.options.map(o => o.value))
+            const values = field.multiple && Array.isArray(value) ? value : [value]
+            for (const v of values) {
+                if (!validValues.has(v)) {
+                    return field.rules?.find(r => r.message)?.message || { t: 'shrimp.fieldInvalid', params: { field: field.label } }
+                }
+            }
+        }
+
+        switch (field.type) {
+            case ShrimpFieldTypes.String:
+                if (typeof value !== 'string') return { t: 'shrimp.fieldTypeError', params: { field: field.label } }
+                break
+            case ShrimpFieldTypes.Number:
+                if (typeof value !== 'number' || Number.isNaN(value)) return { t: 'shrimp.fieldTypeError', params: { field: field.label } }
+                break
+            case ShrimpFieldTypes.Boolean:
+                if (typeof value !== 'boolean') return { t: 'shrimp.fieldTypeError', params: { field: field.label } }
+                break
+            case ShrimpFieldTypes.Date:
+                if (typeof value !== 'number' && !(value instanceof Date) && isNaN(Date.parse(value))) {
+                    return { t: 'shrimp.fieldTypeError', params: { field: field.label } }
+                }
+                break
+        }
+
+        if (field.rules) {
+            for (const rule of field.rules) {
+                const msg = rule.message || { t: 'shrimp.fieldInvalid', params: { field: field.label } }
+
+                if (rule.min !== undefined) {
+                    if (typeof value === 'number' && value < rule.min) return { t: 'shrimp.fieldMin', params: { field: field.label, min: rule.min } }
+                    if (typeof value === 'string' && value.length < rule.min) return { t: 'shrimp.fieldMinLength', params: { field: field.label, min: rule.min } }
+                    if (Array.isArray(value) && value.length < rule.min) return { t: 'shrimp.fieldMinLength', params: { field: field.label, min: rule.min } }
+                }
+
+                if (rule.max !== undefined) {
+                    if (typeof value === 'number' && value > rule.max) return { t: 'shrimp.fieldMax', params: { field: field.label, max: rule.max } }
+                    if (typeof value === 'string' && value.length > rule.max) return { t: 'shrimp.fieldMaxLength', params: { field: field.label, max: rule.max } }
+                    if (Array.isArray(value) && value.length > rule.max) return { t: 'shrimp.fieldMaxLength', params: { field: field.label, max: rule.max } }
+                }
+
+                if (rule.pattern) {
+                    const regex = new RegExp(rule.pattern)
+                    if (!regex.test(String(value))) return msg
+                }
+            }
+        }
+
+        return null
+    }
+
+    private async prepareAddItem(item: Record<string, any>): Promise<Record<string, any>> {
+        const result = { ...item }
+        for (const field of this.fields) {
+            if (field.editable === "readonly") {
+                delete result[field.key]
+                continue
+            }
+
+            const handler = this.getTypeHandler(field)
+
+            if (result[field.key] === undefined) {
+                const dv = field.defaultValue !== undefined ? field.defaultValue : handler?.defaultValue
+                if (dv !== undefined) {
+                    result[field.key] = typeof dv === 'function' ? (dv as () => any)() : dv
+                }
+            }
+
+            if (handler?.reqFilter && result[field.key] !== undefined) {
+                result[field.key] = await handler.reqFilter(result[field.key], field, result)
+            }
+
+            const fieldErr = await this.validateField(field, result[field.key], result)
+            if (fieldErr) throw new ShrimpError(fieldErr)
+
+            if (handler?.validate && result[field.key] !== undefined) {
+                const err = await handler.validate(result[field.key], field, result)
+                if (err) throw new ShrimpError(err)
+            }
+        }
+        return result
+    }
+
+    private async prepareEditItem(item: Record<string, any>): Promise<Record<string, any>> {
+        const result = { ...item }
+        for (const field of this.fields) {
+            if (field.editable === "readonly" || field.editable === "addOnly") {
+                delete result[field.key]
+                continue
+            }
+
+            if (result[field.key] === undefined) {
+                delete result[field.key]
+                continue
+            }
+
+            const handler = this.getTypeHandler(field)
+
+            if (handler?.reqFilter) {
+                result[field.key] = await handler.reqFilter(result[field.key], field, result)
+            }
+
+            const fieldErr = await this.validateField(field, result[field.key], result)
+            if (fieldErr) throw new ShrimpError(fieldErr)
+
+            if (handler?.validate) {
+                const err = await handler.validate(result[field.key], field, result)
+                if (err) throw new ShrimpError(err)
+            }
+        }
+        return result
+    }
+
+    private async processResItem(item: Record<string, any>): Promise<Record<string, any>> {
+        const result = { ...item }
+        for (const field of this.fields) {
+            const handler = this.getTypeHandler(field)
+            if (handler?.resFilter && result[field.key] !== undefined) {
+                result[field.key] = await handler.resFilter(result[field.key], field, result)
+            }
+        }
+        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)
+        }
+        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)
+        }
+        return this.processResItem(item)
+    }
+
+    private excludeKeys(item: any, keys: string[]): any {
+        if (keys.length === 0) return item
+        const result = { ...item }
+        for (const key of keys) {
+            delete result[key]
+        }
+        return result
+    }
+
+    private filterHidden(item: any): any {
+        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
+        const ps = pageSize || ShrimpConfig.defaultPageSize
+        const shrimpQuery: IShrimpQuery = {
+            offset: (p - 1) * ps,
+            limit: ps,
+        }
+
+        if (filter && typeof filter === 'object') {
+            const filterableFields = new Map(this.fields.filter(f => f.filterable).map(f => [f.key, f]))
+            const stringLikeTypes = new Set(['string', 'textarea'])
+            const where: Record<string, IShrimpCondition> = {}
+            for (const [key, value] of Object.entries(filter)) {
+                const field = filterableFields.get(key)
+                if (!field) continue
+                if (value == null) continue
+                if (Array.isArray(value) && value.length === 0) continue
+                if (typeof value === 'string' && value === '') continue
+                const obj = value as any
+                if (typeof obj === 'object' && !Array.isArray(obj) && obj.min === undefined && obj.max === undefined) continue
+
+                if (Array.isArray(value)) {
+                    where[key] = { in: value }
+                } else if (typeof value === 'object') {
+                    const cond: IShrimpCondition = {}
+                    if (obj.min !== undefined) cond.gte = obj.min
+                    if (obj.max !== undefined) cond.lte = obj.max
+                    where[key] = cond
+                } else if (typeof value === 'boolean') {
+                    where[key] = { eq: value }
+                } else if (typeof value === 'string' && stringLikeTypes.has(field.type)) {
+                    where[key] = { like: value }
+                } else {
+                    where[key] = { eq: value }
+                }
+            }
+            if (Object.keys(where).length > 0) shrimpQuery.where = where
+        }
+
+        // 子表场景: ownerId + ownerKey 强制注入过滤
+        if (ownerId != null && ownerId !== '' && this.ownerKey) {
+            shrimpQuery.where = shrimpQuery.where || {}
+            shrimpQuery.where[this.ownerKey] = { eq: ownerId }
+        }
+
+        if (keyword) {
+            const stringLikeTypes = new Set(['string', 'textarea'])
+            const searchFields = this.fields
+                .filter(f => f.searchable && stringLikeTypes.has(f.type))
+                .map(f => f.key)
+            if (searchFields.length > 0) {
+                shrimpQuery.orWhere = searchFields.map(key => ({ [key]: { like: keyword } }))
+            }
+        }
+
+        if (sortBy) {
+            shrimpQuery.order = [[sortBy, sortOrder === 'desc' ? 'desc' : 'asc']]
+        }
+
+        return shrimpQuery
+    }
+
+    async list(query?: IPageQuery & any): Promise<IPageResult<T>> {
+        const shrimpQuery = this.buildQuery(query)
+        const result = await this.dataSource.list(shrimpQuery)
+        result.list = await this.prepareResponseItems(result.list)
+        result.list = result.list.map(item => this.filterHidden(item))
+        return result
+    }
+
+    async get(id: string): Promise<T | null> {
+        const item = await this.dataSource.get(id)
+        if (item) {
+            const processed = await this.prepareResponseItem(item)
+            return this.filterHidden(processed) as T
+        }
+        return item
+    }
+
+    async add(item: Omit<T, '_id'>, ownerId?: string): Promise<T> {
+        if (ownerId && this.ownerKey) {
+            (item as any)[this.ownerKey] = ownerId
+        }
+        const prepared = await this.prepareAddItem(item as any)
+        const result = await this.dataSource.add(prepared as Omit<T, '_id'>)
+        const processed = await this.prepareResponseItem(result)
+        return this.filterHidden(processed) as T
+    }
+    async edit(id: string, item: Partial<T>): Promise<T | null> {
+        const prepared = await this.prepareEditItem(item as any)
+        const result = await this.dataSource.edit(id, prepared as Partial<T>)
+        if (result) {
+            const processed = await this.prepareResponseItem(result)
+            return this.filterHidden(processed) as T
+        }
+        return result
+    }
+    async delete(id: string): Promise<boolean> {
+        return await this.dataSource.delete(id)
+    }
+    async clear(query?: IPageQuery & any): Promise<boolean> {
+        const hasFilter = query && (
+            (query.keyword) ||
+            (query.filter && typeof query.filter === 'object' && Object.keys(query.filter).length > 0)
+        )
+        if (hasFilter) {
+            const shrimpQuery = this.buildQuery(query)
+            delete shrimpQuery.offset
+            delete shrimpQuery.limit
+            const result = await this.dataSource.list(shrimpQuery)
+            for (const item of result.list as any[]) {
+                await this.dataSource.delete(item._id)
+            }
+            return true
+        }
+        return await this.dataSource.clear()
+    }
+    async export(query?: IPageQuery & any): Promise<T[]> {
+        const shrimpQuery = this.buildQuery(query)
+        delete shrimpQuery.offset
+        delete shrimpQuery.limit
+        const result = await this.dataSource.list(shrimpQuery)
+        result.list = await this.prepareResponseItems(result.list)
+        return result.list.map(item => this.filterHidden(item))
+    }
+    async import(data?: T[], ownerId?: string): Promise<void> {
+        if (!data || data.length === 0) return
+        for (const raw of data) {
+            const item = { ...raw } as Record<string, any>
+            if (ownerId && this.ownerKey) item[this.ownerKey] = ownerId
+            const id = item._id ? String(item._id) : undefined
+            if (id) {
+                const existing = await this.dataSource.get(id)
+                if (existing) {
+                    const prepared = await this.prepareEditItem(item)
+                    await this.dataSource.edit(id, prepared as Partial<T>)
+                    continue
+                }
+            }
+            const prepared = await this.prepareAddItem(item)
+            await this.dataSource.add(prepared as Omit<T, '_id'>)
+        }
+    }
+
+    initCrud() {
+        return this
+            .addEvent("list", this.power)
+            .addEvent("get", this.power)
+            .addEvent("add", { t: "power.add" })
+            .addEvent("edit", { t: "power.edit" })
+            .addEvent("delete", { t: "power.delete" })
+    }
+}