midway-fatcms 0.0.5 → 0.0.7

package/dist/libs/crud-pro/services/CrudProTableMetaService.js

@@ -7,6 +7,7 @@ const keys_1 = require("../models/keys");
 class CrudProTableMetaCache {
     constructor() {
         this.cacheMap = {};
+        this.tableInfoCacheMap = {};
     }
     getCacheKey(query) {
         return `${query.sqlDatabase}:::${query.sqlSchema}:::${query.sqlDbType}:::${query.sqlTable}`;
@@ -23,6 +24,19 @@ class CrudProTableMetaCache {
         const cacheKey = this.getCacheKey(query);
         this.cacheMap[cacheKey] = metaObj;
     }
+    getTableInfos(cacheKey) {
+        const cached = this.tableInfoCacheMap[cacheKey];
+        if (cached && cached.expiredTime > Date.now()) {
+            return cached.tableInfos;
+        }
+        return null;
+    }
+    setTableInfos(cacheKey, tableInfos, cacheTime) {
+        this.tableInfoCacheMap[cacheKey] = {
+            tableInfos,
+            expiredTime: Date.now() + cacheTime,
+        };
+    }
 }
 const metaCache = new CrudProTableMetaCache();
 class CrudProTableMetaService extends CrudProServiceBase_1.CrudProServiceBase {
@@ -34,6 +48,99 @@ class CrudProTableMetaService extends CrudProServiceBase_1.CrudProServiceBase {
         }
         return obj;
     }
+    // ============ 获取表和视图信息（带类型） ============
+    /**
+     * 获取数据库所有表和视图信息（包含类型）
+     *
+     * @param query 数据库查询参数
+     * @param options 缓存控制选项
+     *   - skipCache: 跳过缓存，直接查询数据库
+     *   - refreshCache: 查询后更新缓存
+     */
+    async getAllTableInfos(query, options = {}) {
+        const { skipCache = false, refreshCache = false } = options;
+        // 1. 尝试从缓存获取（使用独立的缓存key）
+        const cacheKey = this.getTableInfoCacheKey(query);
+        if (!skipCache) {
+            const cached = metaCache.getTableInfos(cacheKey);
+            if (cached) {
+                return cached;
+            }
+        }
+        // 2. 查询数据库
+        const result = await this.loadAllTableInfos(query);
+        // 3. 更新缓存
+        if (!skipCache || refreshCache) {
+            const { tableMetaCacheTime } = this.getContextCfg();
+            metaCache.setTableInfos(cacheKey, result, tableMetaCacheTime || 3600000);
+        }
+        return result;
+    }
+    getTableInfoCacheKey(query) {
+        return `tableInfo:::${query.sqlDatabase}:::${query.sqlSchema || 'public'}:::${query.sqlDbType}`;
+    }
+    async loadAllTableInfos(query) {
+        const { sqlDbType } = query;
+        if (sqlDbType === keys_1.SqlDbType.mysql) {
+            return this.loadMySQLAllTableInfos(query);
+        }
+        else if (sqlDbType === keys_1.SqlDbType.postgres) {
+            return this.loadPostgreSQLAllTableInfos(query);
+        }
+        else if (sqlDbType === keys_1.SqlDbType.sqlserver) {
+            return this.loadSQLServerAllTableInfos(query);
+        }
+        throw new Error('暂不支持的数据库类型：' + sqlDbType);
+    }
+    async loadMySQLAllTableInfos(query) {
+        const dbUtil = { sqlDatabase: query.sqlDatabase, sqlDbType: query.sqlDbType };
+        // 获取物理表
+        const tableSql = `SHOW TABLES FROM ${query.sqlDatabase}`;
+        const tableRes = await this.executeUnsafeQuery(dbUtil, tableSql);
+        const tableNames = (tableRes.rows || []).map((row) => Object.values(row)[0]);
+        // 获取视图
+        const viewSql = `SHOW FULL TABLES FROM ${query.sqlDatabase} WHERE Table_type = 'VIEW'`;
+        const viewRes = await this.executeUnsafeQuery(dbUtil, viewSql);
+        const viewNames = (viewRes.rows || []).map((row) => Object.values(row)[0]);
+        const tables = [
+            ...tableNames.map(name => ({ name, tableType: 'table' })),
+            ...viewNames.map(name => ({ name, tableType: 'view' })),
+        ];
+        return { tables, tableNames, viewNames };
+    }
+    async loadPostgreSQLAllTableInfos(query) {
+        const schema = query.sqlSchema || 'public';
+        const dbUtil = { sqlDatabase: query.sqlDatabase, sqlDbType: query.sqlDbType };
+        // 获取物理表
+        const tableSql = `SELECT tablename FROM pg_tables WHERE schemaname = '${schema}' ORDER BY tablename`;
+        const tableRes = await this.executeUnsafeQuery(dbUtil, tableSql);
+        const tableNames = (tableRes.rows || []).map((row) => row.tablename);
+        // 获取视图
+        const viewSql = `SELECT viewname FROM pg_views WHERE schemaname = '${schema}' ORDER BY viewname`;
+        const viewRes = await this.executeUnsafeQuery(dbUtil, viewSql);
+        const viewNames = (viewRes.rows || []).map((row) => row.viewname);
+        const tables = [
+            ...tableNames.map(name => ({ name, tableType: 'table' })),
+            ...viewNames.map(name => ({ name, tableType: 'view' })),
+        ];
+        return { tables, tableNames, viewNames };
+    }
+    async loadSQLServerAllTableInfos(query) {
+        const dbUtil = { sqlDatabase: query.sqlDatabase, sqlDbType: query.sqlDbType };
+        // 获取物理表
+        const tableSql = `SELECT name FROM sys.tables`;
+        const tableRes = await this.executeUnsafeQuery(dbUtil, tableSql);
+        const tableNames = (tableRes.rows || []).map((row) => row.name);
+        // 获取视图
+        const viewSql = `SELECT name FROM sys.views`;
+        const viewRes = await this.executeUnsafeQuery(dbUtil, viewSql);
+        const viewNames = (viewRes.rows || []).map((row) => row.name);
+        const tables = [
+            ...tableNames.map(name => ({ name, tableType: 'table' })),
+            ...viewNames.map(name => ({ name, tableType: 'view' })),
+        ];
+        return { tables, tableNames, viewNames };
+    }
     async loadTableMeta(query) {
         const { tableMetaCacheTime } = this.getContextCfg();
         const obj = {

package/dist/libs/crud-pro/services/CurdProServiceHub.d.ts

@@ -1,4 +1,4 @@
-import { IFuncCfgModel, IRequestCfgModel, ISqlCfgModel, ITableMeta, ITableMetaQuery } from '../interfaces';
+import { IFuncCfgModel, IRequestCfgModel, ISqlCfgModel, ITableListResult, ITableMeta, ITableMetaQuery, ITableNamesOptions, ITableNamesQuery } from '../interfaces';
 import { RequestModel } from '../models/RequestModel';
 import { ExecuteContext } from '../models/ExecuteContext';
 import { SqlCfgModel } from '../models/SqlCfgModel';
@@ -16,11 +16,13 @@ declare class CurdProServiceHub implements ICurdProServiceHub {
     private readonly executeFuncService;
     private readonly tableMetaService;
     private readonly dataFilterService;
+    private readonly dataTypeConvertService;
     constructor(executeContext: ExecuteContext);
     getExecuteContext(): ExecuteContext;
     validateByAllow(cfgModel: RequestCfgModel, reqModel: RequestModel): void;
     validateByReject(cfgModel: RequestCfgModel, reqModel: RequestModel): void;
     validateByCfg(cfgModel: RequestCfgModel, reqModel: RequestModel): void;
+    validateDataType(cfgModel: RequestCfgModel, reqModel: RequestModel): void;
     validateByAuthCfg(cfgModel: RequestCfgModel, reqModel: RequestModel): Promise<any>;
     updateByCfg(cfgModel: RequestCfgModel, reqModel: RequestModel): void;
     getCachedCfgByMethod(method: string, isEnableCache: boolean): Promise<IRequestCfgModel>;
@@ -29,6 +31,8 @@ declare class CurdProServiceHub implements ICurdProServiceHub {
     convertOriginToExecuteSql(sqlCfgModel: SqlCfgModel): Promise<void>;
     executeFuncCfg(funCfg: IFuncCfgModel, funcContext: FuncContext): any;
     getTableMeta(query: ITableMetaQuery): Promise<ITableMeta>;
+    getAllTableInfos(query: ITableNamesQuery, options?: ITableNamesOptions): Promise<ITableListResult>;
     filterDataByTableMeta(data: Record<string, any>, sqlCfgModel: ISqlCfgModel | SqlCfgModel): Promise<Record<string, any>>;
+    convertDataTypeByTableMeta(reqModel: RequestModel, cfgModel: RequestCfgModel): Promise<void>;
 }
 export { CurdProServiceHub };

package/dist/libs/crud-pro/services/CurdProServiceHub.js

@@ -10,6 +10,7 @@ const CrudProOriginToExecuteSql_1 = require("./CrudProOriginToExecuteSql");
 const CrudProExecuteFuncService_1 = require("./CrudProExecuteFuncService");
 const CrudProTableMetaService_1 = require("./CrudProTableMetaService");
 const CrudProDataFilterService_1 = require("./CrudProDataFilterService");
+const CrudProDataTypeConvertService_1 = require("./CrudProDataTypeConvertService");
 class CurdProServiceHub {
     constructor(executeContext) {
         this.executeContext = executeContext;
@@ -22,6 +23,7 @@ class CurdProServiceHub {
         this.executeFuncService = new CrudProExecuteFuncService_1.CrudProExecuteFuncService(this);
         this.tableMetaService = new CrudProTableMetaService_1.CrudProTableMetaService(this);
         this.dataFilterService = new CrudProDataFilterService_1.CrudProDataFilterService(this);
+        this.dataTypeConvertService = new CrudProDataTypeConvertService_1.CrudProDataTypeConvertService(this);
     }
     getExecuteContext() {
         return this.executeContext;
@@ -35,6 +37,9 @@ class CurdProServiceHub {
     validateByCfg(cfgModel, reqModel) {
         return this.fieldValidateService.validateByCfg(cfgModel, reqModel);
     }
+    validateDataType(cfgModel, reqModel) {
+        return this.fieldValidateService.validateDataType(cfgModel, reqModel);
+    }
     async validateByAuthCfg(cfgModel, reqModel) {
         const contextFunc = this.executeContext.contextFunc;
         if (contextFunc && contextFunc.validateByAuthCfg) {
@@ -62,8 +67,14 @@ class CurdProServiceHub {
     async getTableMeta(query) {
         return await this.tableMetaService.getTableMeta(query);
     }
+    async getAllTableInfos(query, options) {
+        return await this.tableMetaService.getAllTableInfos(query, options);
+    }
     async filterDataByTableMeta(data, sqlCfgModel) {
         return await this.dataFilterService.filterDataByTableMeta(data, sqlCfgModel);
     }
+    async convertDataTypeByTableMeta(reqModel, cfgModel) {
+        return await this.dataTypeConvertService.convertDataTypeByTableMeta(reqModel, cfgModel);
+    }
 }
 exports.CurdProServiceHub = CurdProServiceHub;

package/dist/libs/crud-pro/utils/DateTimeUtils.d.ts

@@ -1,5 +1,6 @@
 declare const DateTimeUtils: {
     getCurrentTimeStampMs(): number;
+    getCurrentTimeString(): string;
     getCurrentTimeStampSecond(): number;
     getCurrentDateFormat(format: string): string;
     getYesterdayDateFormat(format: string): string;

package/dist/libs/crud-pro/utils/DateTimeUtils.js

@@ -7,6 +7,9 @@ const DateTimeUtils = {
     getCurrentTimeStampMs() {
         return Date.now();
     },
+    getCurrentTimeString() {
+        return moment().format('YYYY-MM-DD HH:mm:ss');
+    },
     // 以秒为单位的时间戳
     getCurrentTimeStampSecond() {
         return Math.floor(Date.now() / 1000);

package/dist/libs/crud-pro/utils/MixinUtils.d.ts

@@ -1,3 +1,20 @@
+/**
+ * 生成雪花ID（64位整数，JS 中以 string 返回）
+ * 结构：1位符号 + 41位时间戳(ms) + 10位机器ID + 12位序列号
+ * - 时间戳：相对于 2024-01-01 00:00:00 的毫秒偏移，可用约 69 年
+ * - 机器ID：0-1023，优先取参数 > 环境变量 SNOWFLAKE_MACHINE_ID > process.pid 低10位
+ * - 序列号：0-4095，同一毫秒内自增
+ *
+ * @param machineId 机器ID（0-1023），不传则依次从环境变量 SNOWFLAKE_MACHINE_ID、process.pid 获取
+ * @returns 雪花ID字符串
+ */
+declare function generateSnowflakeId(machineId?: number): string;
+/**
+ * 生成 UUID v4 字符串（纯随机，无外部依赖）
+ * 格式：xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx，其中 y 为 8/9/a/b 之一
+ * @returns 符合 RFC 4122 v4 规范的 UUID 字符串
+ */
+declare function uuid(): string;
 declare const MixinUtils: {
     isNil(obj: any): boolean;
     isNotNil(obj: any): boolean;
@@ -36,5 +53,20 @@ declare const MixinUtils: {
     selectNotEmpty(a: any, b: any): any;
     parseValueByType(value: any, targetType: string): any;
     sleepMs(ms: number): Promise<any>;
+    /**
+     * 生成 UUID v4 字符串（纯随机，无外部依赖）
+     * 格式：xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx，其中 y 为 8/9/a/b 之一
+     * @returns 符合 RFC 4122 v4 规范的 UUID 字符串
+     */
+    uuid: typeof uuid;
+    /**
+     * 生成雪花ID（64位整数，以字符串返回）
+     * 结构：1位符号 + 41位时间戳(ms) + 10位机器ID + 12位序列号
+     * 同一毫秒内可生成 4096 个不重复ID，单机每秒可生成约 400 万个
+     *
+     * @param machineId 机器ID（0-1023），不传则依次从环境变量 SNOWFLAKE_MACHINE_ID、process.pid 获取
+     * @returns 雪花ID字符串
+     */
+    generateSnowflakeId: typeof generateSnowflakeId;
 };
 export { MixinUtils };

package/dist/libs/crud-pro/utils/MixinUtils.js

@@ -4,6 +4,75 @@ exports.MixinUtils = void 0;
 const exceptions_1 = require("../exceptions");
 //  至少需要2个字符
 const FIELD_NAME_REG_EXP = /^[a-zA-Z][0-9a-zA-Z_]+$/;
+// ===================== 雪花ID =====================
+let snowflakeSeq = 0;
+let snowflakeLastTs = -1;
+/**
+ * 生成雪花ID（64位整数，JS 中以 string 返回）
+ * 结构：1位符号 + 41位时间戳(ms) + 10位机器ID + 12位序列号
+ * - 时间戳：相对于 2024-01-01 00:00:00 的毫秒偏移，可用约 69 年
+ * - 机器ID：0-1023，优先取参数 > 环境变量 SNOWFLAKE_MACHINE_ID > process.pid 低10位
+ * - 序列号：0-4095，同一毫秒内自增
+ *
+ * @param machineId 机器ID（0-1023），不传则依次从环境变量 SNOWFLAKE_MACHINE_ID、process.pid 获取
+ * @returns 雪花ID字符串
+ */
+function generateSnowflakeId(machineId) {
+    const EPOCH = 1704067200000; // 2024-01-01 00:00:00 UTC
+    let mid = machineId;
+    if (mid === undefined || mid === null) {
+        // 优先从环境变量获取，适配多实例部署场景
+        const envMid = typeof process !== 'undefined' && process.env && process.env.SNOWFLAKE_MACHINE_ID
+            ? parseInt(process.env.SNOWFLAKE_MACHINE_ID, 10)
+            : NaN;
+        mid = !isNaN(envMid) ? envMid : (typeof process !== 'undefined' && process.pid ? process.pid & 0x3ff : 0);
+    }
+    mid = mid & 0x3ff; // 确保在 0-1023 范围
+    let now = Date.now();
+    let ts = now - EPOCH;
+    if (ts === snowflakeLastTs) {
+        snowflakeSeq = (snowflakeSeq + 1) & 0xfff; // 0-4095 循环
+        if (snowflakeSeq === 0) {
+            // 本毫秒序列号耗尽，等待下一毫秒
+            while (now <= Date.now()) {
+                now = Date.now();
+            }
+            ts = now - EPOCH;
+        }
+    }
+    else {
+        snowflakeSeq = 0;
+    }
+    snowflakeLastTs = ts;
+    // 雪花ID超过JS安全整数范围(2^53)，不能用Number位运算，采用字符串拼接
+    const tsPart = ts * 4194304; // ts << 22，等价于 ts * 2^22
+    const midPart = mid * 4096; // mid << 12，等价于 mid * 2^12
+    return '' + (tsPart + midPart + snowflakeSeq);
+}
+/**
+ * 生成 UUID v4 字符串（纯随机，无外部依赖）
+ * 格式：xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx，其中 y 为 8/9/a/b 之一
+ * @returns 符合 RFC 4122 v4 规范的 UUID 字符串
+ */
+function uuid() {
+    // crypto.getRandomValues 在 Node.js >= 11 和现代浏览器中可用
+    if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
+        const bytes = new Uint8Array(16);
+        crypto.getRandomValues(bytes);
+        // 版本位：第6字节高4位设为 0100 (v4)
+        bytes[6] = (bytes[6] & 0x0f) | 0x40;
+        // 变体位：第8字节高2位设为 10
+        bytes[8] = (bytes[8] & 0x3f) | 0x80;
+        const hex = Array.from(bytes, b => b.toString(16).padStart(2, '0')).join('');
+        return hex.slice(0, 8) + '-' + hex.slice(8, 12) + '-' + hex.slice(12, 16) + '-' + hex.slice(16, 20) + '-' + hex.slice(20);
+    }
+    // 降级方案：Math.random
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+        const r = Math.random() * 16 | 0;
+        const v = c === 'x' ? r : (r & 0x3 | 0x8);
+        return v.toString(16);
+    });
+}
 const MixinUtils = {
     isNil(obj) {
         return typeof obj === 'undefined' || obj === null;
@@ -254,6 +323,21 @@ const MixinUtils = {
     },
     sleepMs(ms) {
         return new Promise(resolve => setTimeout(resolve, ms));
-    }
+    },
+    /**
+     * 生成 UUID v4 字符串（纯随机，无外部依赖）
+     * 格式：xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx，其中 y 为 8/9/a/b 之一
+     * @returns 符合 RFC 4122 v4 规范的 UUID 字符串
+     */
+    uuid: uuid,
+    /**
+     * 生成雪花ID（64位整数，以字符串返回）
+     * 结构：1位符号 + 41位时间戳(ms) + 10位机器ID + 12位序列号
+     * 同一毫秒内可生成 4096 个不重复ID，单机每秒可生成约 400 万个
+     *
+     * @param machineId 机器ID（0-1023），不传则依次从环境变量 SNOWFLAKE_MACHINE_ID、process.pid 获取
+     * @returns 雪花ID字符串
+     */
+    generateSnowflakeId: generateSnowflakeId,
 };
 exports.MixinUtils = MixinUtils;

package/dist/libs/crud-pro/utils/OrderByUtils.d.ts

@@ -0,0 +1,70 @@
+import { IOrderByItem } from '../interfaces';
+/**
+ * OrderBy 解析工具类
+ *
+ * 提供统一的 orderBy 参数解析功能，支持多种格式：
+ * 1. 字符串格式（逗号分隔多个字段）：
+ *    - 标准 SQL 格式：'created_at DESC, amount ASC'
+ *    - 简写 +/- 格式：'created_at-, amount+'（'-' 表示 DESC，'+' 或省略表示 ASC）
+ *    - 默认升序：'order_id'（无后缀时默认为 ASC）
+ *
+ * 2. 数组格式：
+ *    - 纯对象数组：[{ fieldName: 'created_at', orderType: 'desc' }]
+ *    - 混合数组（字符串+对象）：['order_id+', { fieldName: 'amount', orderType: 'asc' }]
+ *
+ * SQL 注入防护：
+ * - 所有字段名必须通过 MixinUtils.isValidFieldName() 校验
+ * - 只允许 ASC/DESC 作为排序方向
+ */
+export declare class OrderByUtils {
+    /**
+     * 解析 orderBy 参数为 IOrderByItem 数组
+     *
+     * @param orderByStr 排序参数，可以是字符串或数组
+     * @returns IOrderByItem[] 解析后的排序项数组
+     */
+    static parseOrderBys(orderByStr: any): IOrderByItem[];
+    /**
+     * 获取第一个排序项
+     *
+     * @param orderByStr 排序参数
+     * @returns IOrderByItem | null 第一个排序项，无则返回 null
+     */
+    static getFirstOrderBy(orderByStr: any): IOrderByItem | null;
+    /**
+     * 判断是否为 ASC 升序排序
+     *
+     * @param orderByStr 排序参数
+     * @returns true 表示 ASC，false 表示 DESC 或无排序
+     */
+    static isFirstOrderByAsc(orderByStr: any): boolean;
+    /**
+     * 判断是否为 DESC 降序排序
+     *
+     * @param orderByStr 排序参数
+     * @returns true 表示 DESC，false 表示 ASC 或无排序
+     */
+    static isFirstOrderByDesc(orderByStr: any): boolean;
+    /**
+     * 判断排序字段是否匹配指定的时间字段
+     *
+     * 用于分表查询时校验排序字段是否为分表字段
+     *
+     * @param orderByStr 排序参数
+     * @param timeColumn 时间字段名
+     * @returns true 表示匹配，false 表示不匹配或无排序
+     */
+    static isOrderByTimeColumn(orderByStr: any, timeColumn: string): boolean;
+    /**
+     * 解析单个排序项（数组元素）
+     */
+    private static parseOrderByItem;
+    /**
+     * 解析字符串格式的排序项（支持标准 SQL 和简写格式）
+     */
+    private static parseOrderByString;
+    /**
+     * SQL 注入防护：校验字段名格式
+     */
+    private static validateFieldName;
+}

package/dist/libs/crud-pro/utils/OrderByUtils.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderByUtils = void 0;
+const MixinUtils_1 = require("./MixinUtils");
+const exceptions_1 = require("../exceptions");
+/**
+ * OrderBy 解析工具类
+ *
+ * 提供统一的 orderBy 参数解析功能，支持多种格式：
+ * 1. 字符串格式（逗号分隔多个字段）：
+ *    - 标准 SQL 格式：'created_at DESC, amount ASC'
+ *    - 简写 +/- 格式：'created_at-, amount+'（'-' 表示 DESC，'+' 或省略表示 ASC）
+ *    - 默认升序：'order_id'（无后缀时默认为 ASC）
+ *
+ * 2. 数组格式：
+ *    - 纯对象数组：[{ fieldName: 'created_at', orderType: 'desc' }]
+ *    - 混合数组（字符串+对象）：['order_id+', { fieldName: 'amount', orderType: 'asc' }]
+ *
+ * SQL 注入防护：
+ * - 所有字段名必须通过 MixinUtils.isValidFieldName() 校验
+ * - 只允许 ASC/DESC 作为排序方向
+ */
+class OrderByUtils {
+    /**
+     * 解析 orderBy 参数为 IOrderByItem 数组
+     *
+     * @param orderByStr 排序参数，可以是字符串或数组
+     * @returns IOrderByItem[] 解析后的排序项数组
+     */
+    static parseOrderBys(orderByStr) {
+        if (MixinUtils_1.MixinUtils.isEmpty(orderByStr)) {
+            return [];
+        }
+        // 数组格式：支持字符串和对象混合
+        if (Array.isArray(orderByStr)) {
+            return orderByStr
+                .map(item => this.parseOrderByItem(item))
+                .filter((o) => !!o);
+        }
+        // 字符串格式：逗号分隔多个字段
+        return orderByStr
+            .split(',')
+            .map(s => s.trim())
+            .filter(s => !!s)
+            .map(item => this.parseOrderByString(item))
+            .filter((o) => !!o);
+    }
+    /**
+     * 获取第一个排序项
+     *
+     * @param orderByStr 排序参数
+     * @returns IOrderByItem | null 第一个排序项，无则返回 null
+     */
+    static getFirstOrderBy(orderByStr) {
+        const orderBys = this.parseOrderBys(orderByStr);
+        return orderBys.length > 0 ? orderBys[0] : null;
+    }
+    /**
+     * 判断是否为 ASC 升序排序
+     *
+     * @param orderByStr 排序参数
+     * @returns true 表示 ASC，false 表示 DESC 或无排序
+     */
+    static isFirstOrderByAsc(orderByStr) {
+        const first = this.getFirstOrderBy(orderByStr);
+        if (!first) {
+            return false;
+        }
+        return first.orderType.toUpperCase() === 'ASC';
+    }
+    /**
+     * 判断是否为 DESC 降序排序
+     *
+     * @param orderByStr 排序参数
+     * @returns true 表示 DESC，false 表示 ASC 或无排序
+     */
+    static isFirstOrderByDesc(orderByStr) {
+        const first = this.getFirstOrderBy(orderByStr);
+        if (!first) {
+            return false;
+        }
+        return first.orderType.toUpperCase() === 'DESC';
+    }
+    /**
+     * 判断排序字段是否匹配指定的时间字段
+     *
+     * 用于分表查询时校验排序字段是否为分表字段
+     *
+     * @param orderByStr 排序参数
+     * @param timeColumn 时间字段名
+     * @returns true 表示匹配，false 表示不匹配或无排序
+     */
+    static isOrderByTimeColumn(orderByStr, timeColumn) {
+        const first = this.getFirstOrderBy(orderByStr);
+        if (!first) {
+            return false;
+        }
+        return first.fieldName === timeColumn;
+    }
+    /**
+     * 解析单个排序项（数组元素）
+     */
+    static parseOrderByItem(item) {
+        // 字符串格式：解析标准 SQL 格式或简写格式
+        if (typeof item === 'string') {
+            return this.parseOrderByString(item);
+        }
+        // 对象格式：提取 fieldName 和 orderType
+        const { fieldName, orderType = 'asc' } = item || {};
+        if (!fieldName) {
+            return null;
+        }
+        this.validateFieldName(fieldName, fieldName);
+        return { fieldName, orderType };
+    }
+    /**
+     * 解析字符串格式的排序项（支持标准 SQL 和简写格式）
+     */
+    static parseOrderByString(orderByStr) {
+        let orderType = 'asc';
+        let fieldName = orderByStr;
+        // 检查是否为空格分隔的标准 SQL 格式（如 'created_at DESC'）
+        const spaceIndex = orderByStr.lastIndexOf(' ');
+        if (spaceIndex > 0) {
+            const beforeSpace = orderByStr.substring(0, spaceIndex).trim();
+            const afterSpace = orderByStr.substring(spaceIndex + 1).trim().toUpperCase();
+            if (afterSpace === 'ASC' || afterSpace === 'DESC') {
+                fieldName = beforeSpace;
+                orderType = afterSpace.toLowerCase();
+            }
+            else {
+                throw new exceptions_1.CommonException(exceptions_1.Exceptions.REQUEST_MODEL_PARSE_ORDER_BY_FAILED, orderByStr);
+            }
+        }
+        else if (orderByStr.endsWith('+')) {
+            // 简写格式：+ 表示升序
+            fieldName = orderByStr.slice(0, -1);
+            orderType = 'asc';
+        }
+        else if (orderByStr.endsWith('-')) {
+            // 简写格式：- 表示降序
+            fieldName = orderByStr.slice(0, -1);
+            orderType = 'desc';
+        }
+        fieldName = fieldName.trim();
+        this.validateFieldName(fieldName, orderByStr);
+        return { fieldName, orderType };
+    }
+    /**
+     * SQL 注入防护：校验字段名格式
+     */
+    static validateFieldName(fieldName, originalValue) {
+        if (MixinUtils_1.MixinUtils.isEmpty(fieldName) || !MixinUtils_1.MixinUtils.isValidFieldName(fieldName)) {
+            throw new exceptions_1.CommonException(exceptions_1.Exceptions.REQUEST_MODEL_PARSE_ORDER_BY_FAILED, originalValue);
+        }
+    }
+}
+exports.OrderByUtils = OrderByUtils;

package/dist/libs/crud-pro/utils/ValidateUtils.js

@@ -50,7 +50,7 @@ const validatorUtils = {
         return false;
     },
     isMomentValid(itemCfg, itemValue) {
-        const cfgPart = itemCfg.substring(keys_1.KeysOfValidators.ENUM.length).trim();
+        const cfgPart = itemCfg.substring(keys_1.KeysOfValidators.MOMENT.length).trim();
         return moment(itemValue, cfgPart, true).isValid();
     },
     isEnumValid(itemCfg, itemValue) {