midway-fatcms 0.0.6 → 0.0.8

package/dist/libs/crud-pro/models/RequestModel.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RequestModel = void 0;
 const _ = require("lodash");
 const MixinUtils_1 = require("../utils/MixinUtils");
+const OrderByUtils_1 = require("../utils/OrderByUtils");
 const exceptions_1 = require("../exceptions");
 const defaultConfigs_1 = require("../defaultConfigs");
 class RequestModel {
@@ -10,109 +11,11 @@ class RequestModel {
         Object.assign(this, req);
         this.visitor = visitor;
         this.columns = MixinUtils_1.MixinUtils.parseColumns(req.columns);
-        this.orderBys = this.parseOrderBys(req.orderBy);
+        this.orderBys = OrderByUtils_1.OrderByUtils.parseOrderBys(req.orderBy);
         const limitOffset = this.parseOffsetList(req);
         this.limit = limitOffset.limit;
         this.offset = limitOffset.offset;
     }
-    /**
-     * 解析 orderBy 参数为 IOrderByItem 数组
-     *
-     * 支持的格式：
-     * 1. 字符串格式（逗号分隔多个字段）：
-     *    - 标准 SQL 格式：'created_at DESC, amount ASC'
-     *    - 简写 +/- 格式：'created_at-, amount+'（'-' 表示 DESC，'+' 或省略表示 ASC）
-     *    - 默认升序：'order_id'（无后缀时默认为 ASC）
-     *
-     * 2. 数组格式：
-     *    - 纯对象数组：[{ fieldName: 'created_at', orderType: 'desc' }]
-     *    - 混合数组1（字符串+对象）：['order_id', { fieldName: 'amount', orderType: 'asc' }]
-     *    - 混合数组2（字符串+对象）：['order_id+', { fieldName: 'amount', orderType: 'asc' }]
-     *    - 混合数组3（字符串+对象）：['order_id DESC', { fieldName: 'amount', orderType: 'asc' }]
-     *      注：数组中的字符串元素支持标准 SQL 格式和简写格式，与字符串参数格式一致。
-     *
-     * SQL 注入防护：
-     * - 所有字段名必须通过 MixinUtils.isValidFieldName() 校验
-     * - 只允许 ASC/DESC 作为排序方向
-     *
-     * @param orderByStr 排序参数，可以是字符串或数组
-     * @returns IOrderByItem[] 解析后的排序项数组
-     */
-    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);
-    }
-    /**
-     * 解析单个排序项（数组元素）
-     */
-    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 和简写格式）
-     */
-    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 注入防护：校验字段名格式
-     */
-    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);
-        }
-    }
     parseOffsetList(req) {
         const { limit, offset, pageSize, pageNo } = req;
         const limitOffset = {

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

@@ -16,6 +16,7 @@ class CrudProExecuteSqlService extends CrudProServiceBase_1.CrudProServiceBase {
     async executeSqlCfgModels() {
         const exeCtx = this.getExecuteContext();
         const sqlCfgModels = exeCtx.getSqlCfgModels();
+        console.log("CrudProExecuteSqlService===> " + JSON.stringify(sqlCfgModels));
         for (let i = 0; i < sqlCfgModels.length; i++) {
             const sqlCfgModel = sqlCfgModels[i];
             const checkResult = this.executeSqlCfgModelPreCheck(sqlCfgModel);
@@ -73,9 +74,42 @@ class CrudProExecuteSqlService extends CrudProServiceBase_1.CrudProServiceBase {
             // 允许空SQL，没有需要执行的正常。
             return false;
         }
+        const errorMsg = `禁止执行的SQL: ${sqlCfgModel.executeSql}`;
         if (keys_1.KeyOfCrudTypes.NOT_CRUD === crudType) {
-            // 只支持增删改查，其他语句不支持。
-            throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_NOT_SUPPORT_THE_SQL, sqlCfgModel.executeSql);
+            // 在 isNativeSQL 模式下，允许特定的 DDL 操作（CREATE TABLE、CREATE INDEX 等），但禁止 DROP TABLE
+            if (sqlCfgModel.isNativeSQL) {
+                // 禁止的 DDL 操作（破坏性操作）
+                const forbiddenPatterns = [
+                    /^\s*DROP\s+TABLE/i,
+                    /^\s*DROP\s+DATABASE/i,
+                    /^\s*DROP\s+SCHEMA/i,
+                    /^\s*TRUNCATE\s+TABLE/i,
+                ];
+                for (const pattern of forbiddenPatterns) {
+                    if (pattern.test(sqlCfgModel.executeSql)) {
+                        throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_NOT_SUPPORT_THE_SQL, errorMsg);
+                    }
+                }
+                // 允许的 DDL 操作白名单
+                const allowedPatterns = [
+                    /^\s*CREATE\s+TABLE/i,
+                    /^\s*CREATE\s+INDEX/i,
+                    /^\s*CREATE\s+UNIQUE\s+INDEX/i,
+                    /^\s*ALTER\s+TABLE/i,
+                ];
+                const isAllowed = allowedPatterns.some(pattern => pattern.test(sqlCfgModel.executeSql));
+                if (isAllowed) {
+                    // 允许的 DDL 操作，继续执行后续校验
+                }
+                else {
+                    // 非允许的 DDL 操作，仍然抛出异常
+                    throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_NOT_SUPPORT_THE_SQL, errorMsg);
+                }
+            }
+            else {
+                // 非 isNativeSQL 模式下，只支持增删改查，其他语句不支持。
+                throw new exceptions_1.CommonException(exceptions_1.Exceptions.CFG_NOT_SUPPORT_THE_SQL, errorMsg);
+            }
         }
         // 此SQL不需要执行
         if (!this.isNeedExecute(sqlCfgModel)) {

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

@@ -174,12 +174,16 @@ class CrudProGenSqlCondition {
                 const value0 = map[compare];
                 let tmpSql = '';
                 if (equalsIgnoreCase(keys_1.KeysOfConditions.$NULL, compare)) {
-                    tmpSql = `${toSqlColumnName(key)} is null `;
-                    hasNoArgSql = true;
+                    if (value0 === true) {
+                        tmpSql = `${toSqlColumnName(key)} is null `;
+                        hasNoArgSql = true;
+                    }
                 }
                 else if (equalsIgnoreCase(keys_1.KeysOfConditions.$NOT_NULL, compare)) {
-                    tmpSql = `${toSqlColumnName(key)} is not null `;
-                    hasNoArgSql = true;
+                    if (value0 === true) {
+                        tmpSql = `${toSqlColumnName(key)} is not null `;
+                        hasNoArgSql = true;
+                    }
                 }
                 else if (equalsIgnoreCase(keys_1.KeysOfConditions.$GT, compare)) {
                     tmpArgList.push(value0);

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

@@ -71,8 +71,7 @@ class CrudProTableMetaService extends CrudProServiceBase_1.CrudProServiceBase {
         const result = await this.loadAllTableInfos(query);
         // 3. 更新缓存
         if (!skipCache || refreshCache) {
-            const { tableMetaCacheTime } = this.getContextCfg();
-            metaCache.setTableInfos(cacheKey, result, tableMetaCacheTime || 3600000);
+            metaCache.setTableInfos(cacheKey, result, 1000 * 5);
         }
         return result;
     }

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;