midway-fatcms 0.0.2 → 0.0.4

package/dist/libs/crud-pro/CrudPro.d.ts

@@ -29,6 +29,20 @@ declare class CrudPro {
      */
     executeCrudByCfg(reqJson: IRequestModel, cfgJson: IRequestCfgModel): Promise<ExecuteContext>;
     getCachedCfgByMethod(method: string, isEnableCache: boolean): Promise<IRequestCfgModel>;
+    /**
+     * 如果是 INSERT/UPDATE 操作（sqlSimpleName 模式），根据真实表结构过滤 reqModel.data 中的字段
+     * 避免传入不存在的字段导致 SQL 执行报错
+     * 注意：只处理 sqlSimpleName 模式，不处理 sqlCfgList 模式
+     * @param reqModel 请求模型
+     * @param cfgModel 配置模型
+     */
+    private filterDataByTableMetaIfNeeded;
+    /**
+     * 判断 sqlSimpleName 是否为 INSERT/UPDATE 类型
+     * @param sqlSimpleName 简单 SQL 名称
+     * @returns 是否为 INSERT/UPDATE 类型
+     */
+    private isSimpleInsertOrUpdateType;
     private executeSQLList;
     private parseRunSqlException;
     private afterExecuteSQLList;

package/dist/libs/crud-pro/CrudPro.js

@@ -7,6 +7,7 @@ const CurdProServiceHub_1 = require("./services/CurdProServiceHub");
 const exceptions_1 = require("./exceptions");
 const RequestCfgModel_1 = require("./models/RequestCfgModel");
 const MixinUtils_1 = require("./utils/MixinUtils");
+const keys_1 = require("./models/keys");
 class CrudPro {
     constructor() {
         this.executeContext = new ExecuteContext_1.ExecuteContext();
@@ -86,6 +87,8 @@ class CrudPro {
         const cfgModel = new RequestCfgModel_1.RequestCfgModel(cfgJson);
         exeCtx.setReqModel(reqModel);
         exeCtx.setCfgModel(cfgModel);
+        // 如果是 sqlSimpleName模式的 update/insert，则需要将 reqJson.data 部分根据真实的表结构进行过滤
+        await this.filterDataByTableMetaIfNeeded(reqModel, cfgModel);
         // 参数校验
         this.serviceHub.validateByAllow(cfgModel, reqModel);
         this.serviceHub.validateByReject(cfgModel, reqModel);
@@ -115,6 +118,64 @@ class CrudPro {
     async getCachedCfgByMethod(method, isEnableCache) {
         return this.serviceHub.getCachedCfgByMethod(method, isEnableCache);
     }
+    /**
+     * 如果是 INSERT/UPDATE 操作（sqlSimpleName 模式），根据真实表结构过滤 reqModel.data 中的字段
+     * 避免传入不存在的字段导致 SQL 执行报错
+     * 注意：只处理 sqlSimpleName 模式，不处理 sqlCfgList 模式
+     * @param reqModel 请求模型
+     * @param cfgModel 配置模型
+     */
+    async filterDataByTableMetaIfNeeded(reqModel, cfgModel) {
+        // 只有在有 data 数据时才需要过滤
+        if (!reqModel.data || Object.keys(reqModel.data).length === 0) {
+            return;
+        }
+        // 只处理 sqlSimpleName 模式
+        const sqlSimpleName = cfgModel.sqlSimpleName;
+        if (!sqlSimpleName) {
+            return;
+        }
+        // 判断是否为 INSERT/UPDATE 类型的简单 SQL
+        if (!this.isSimpleInsertOrUpdateType(sqlSimpleName)) {
+            return;
+        }
+        // 构建 SqlCfgModel 用于获取表结构
+        const sqlCfgModel = {
+            sqlTable: cfgModel.sqlTable,
+            sqlSchema: cfgModel.sqlSchema,
+            sqlDatabase: cfgModel.sqlDatabase,
+            sqlDbType: cfgModel.sqlDbType,
+            columns: cfgModel.columns,
+            columnsRelation: cfgModel.columnsRelation,
+        };
+        const filteredData = await this.serviceHub.filterDataByTableMeta(reqModel.data, sqlCfgModel);
+        // 记录被过滤的字段
+        const originalKeys = Object.keys(reqModel.data);
+        const filteredKeys = Object.keys(filteredData);
+        const removedKeys = originalKeys.filter(key => !filteredKeys.includes(key));
+        if (removedKeys.length > 0) {
+            this.executeContext.getLogger().info('CrudPro.filterDataByTableMetaIfNeeded: 过滤掉表中不存在的字段', {
+                table: cfgModel.sqlTable,
+                removedFields: removedKeys,
+            });
+        }
+        // 直接修改 reqModel.data，只保留表中存在的字段
+        reqModel.data = filteredData;
+    }
+    /**
+     * 判断 sqlSimpleName 是否为 INSERT/UPDATE 类型
+     * @param sqlSimpleName 简单 SQL 名称
+     * @returns 是否为 INSERT/UPDATE 类型
+     */
+    isSimpleInsertOrUpdateType(sqlSimpleName) {
+        const insertOrUpdateTypes = [
+            keys_1.KeysOfSimpleSQL.SIMPLE_INSERT,
+            keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE,
+            keys_1.KeysOfSimpleSQL.SIMPLE_INSERT_ON_DUPLICATE_UPDATE,
+            keys_1.KeysOfSimpleSQL.SIMPLE_INSERT_OR_UPDATE,
+        ];
+        return insertOrUpdateTypes.includes(sqlSimpleName);
+    }
     async executeSQLList() {
         try {
             await this.serviceHub.executeSqlCfgModels();

package/dist/libs/crud-pro/interfaces.d.ts

@@ -8,9 +8,19 @@ export interface ICrudProCfg {
     sysConfigTableName?: string;
     tableMetaCacheTime?: number;
 }
+export interface ITableColumn {
+    name: string;
+    type: string;
+    isNullable: boolean;
+    isPrimaryKey?: boolean;
+    defaultValue?: any;
+    maxLength?: number;
+    comment?: string;
+}
 export interface ITableMeta {
     expiredTime: number;
     tableColumns: string[];
+    columnDetails?: ITableColumn[];
 }
 export interface IConnectionPool {
     dbType: SqlDbType;
@@ -171,5 +181,15 @@ export interface IExecuteUnsafeQueryCtx {
     sqlTable: string;
     sqlDatabase: string;
     sqlDbType: SqlDbType;
+    sqlSchema?: string;
+}
+/**
+ * 表结构元数据查询参数
+ */
+export interface ITableMetaQuery {
+    sqlTable: string;
+    sqlDatabase: string;
+    sqlDbType: SqlDbType;
+    sqlSchema?: string;
 }
 export {};

package/dist/libs/crud-pro/models/ServiceHub.d.ts

@@ -2,7 +2,7 @@ import { RequestCfgModel } from './RequestCfgModel';
 import { RequestModel } from './RequestModel';
 import { SqlCfgModel } from './SqlCfgModel';
 import { ExecuteContext } from './ExecuteContext';
-import { IFuncCfgModel, IRequestCfgModel, ITableMeta } from '../interfaces';
+import { IFuncCfgModel, IRequestCfgModel, ITableMeta, ITableMetaQuery } from '../interfaces';
 import { FuncContext } from './FuncContext';
 export interface ICurdProServiceHub {
     getExecuteContext(): ExecuteContext;
@@ -16,5 +16,5 @@ export interface ICurdProServiceHub {
     executeSqlCfgModels(exeCtx: ExecuteContext): Promise<void>;
     convertOriginToExecuteSql(sqlCfgModel: SqlCfgModel): Promise<void>;
     executeFuncCfg(tmpFunCfg: IFuncCfgModel, exeFunCtx: FuncContext): string;
-    getTableMeta(sqlCfgModel: SqlCfgModel): Promise<ITableMeta>;
+    getTableMeta(query: ITableMetaQuery): Promise<ITableMeta>;
 }

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

@@ -139,7 +139,12 @@ class Transaction {
         const connections = this.connectionList;
         for (let i = 0; i < connections.length; i++) {
             const connection = connections[i];
-            await connection.rollback();
+            try {
+                await connection.rollback();
+            }
+            catch (e) {
+                console.error('[crud-pro] rollbackTx error', e);
+            }
         }
     }
     /**

package/dist/libs/crud-pro/models/keys.d.ts

@@ -85,6 +85,7 @@ export declare const KeysOfCustomSQL: {
  */
 export declare const KeysOfConditions: {
     $OR: string;
+    $AND: string;
     $NE: string;
     $LT: string;
     $LTE: string;

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

@@ -99,6 +99,7 @@ exports.KeysOfCustomSQL = {
  */
 exports.KeysOfConditions = {
     $OR: '$or',
+    $AND: '$and',
     $NE: '$ne',
     $LT: '$lt',
     $LTE: '$lte',
@@ -150,5 +151,6 @@ function initKeysOfConditions() {
     // 所有操作符
     exports.KeysOfConditions.ALL_KEYS = new Set([...exports.KeysOfConditions.COMPARE_KEYS]);
     addIgnoreCase(exports.KeysOfConditions.ALL_KEYS, exports.KeysOfConditions.$OR);
+    addIgnoreCase(exports.KeysOfConditions.ALL_KEYS, exports.KeysOfConditions.$AND);
 }
 initKeysOfConditions();

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

@@ -0,0 +1,17 @@
+import { CrudProServiceBase } from './CrudProServiceBase';
+import { ISqlCfgModel } from '../interfaces';
+/**
+ * 数据过滤服务
+ * 用于在 INSERT/UPDATE 操作前，根据真实表结构过滤 data 对象中的字段
+ */
+declare class CrudProDataFilterService extends CrudProServiceBase {
+    /**
+     * 根据表结构过滤 data 对象
+     * 只保留表中存在的字段
+     * @param data 原始 data 对象
+     * @param sqlCfgModel SQL 配置（可以是 ISqlCfgModel 接口或 SqlCfgModel 对象）
+     * @returns 过滤后的 data 对象
+     */
+    filterDataByTableMeta(data: Record<string, any>, sqlCfgModel: ISqlCfgModel): Promise<Record<string, any>>;
+}
+export { CrudProDataFilterService };

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrudProDataFilterService = void 0;
+const CrudProServiceBase_1 = require("./CrudProServiceBase");
+/**
+ * 数据过滤服务
+ * 用于在 INSERT/UPDATE 操作前，根据真实表结构过滤 data 对象中的字段
+ */
+class CrudProDataFilterService extends CrudProServiceBase_1.CrudProServiceBase {
+    /**
+     * 根据表结构过滤 data 对象
+     * 只保留表中存在的字段
+     * @param data 原始 data 对象
+     * @param sqlCfgModel SQL 配置（可以是 ISqlCfgModel 接口或 SqlCfgModel 对象）
+     * @returns 过滤后的 data 对象
+     */
+    async filterDataByTableMeta(data, sqlCfgModel) {
+        if (!data || Object.keys(data).length === 0) {
+            return data;
+        }
+        // 确保 sqlTable 存在
+        if (!sqlCfgModel.sqlTable) {
+            this.logger.warn('CrudProDataFilterService: sqlTable 为空，跳过过滤');
+            return data;
+        }
+        const query = {
+            sqlTable: sqlCfgModel.sqlTable,
+            sqlDatabase: sqlCfgModel.sqlDatabase,
+            sqlDbType: sqlCfgModel.sqlDbType,
+            sqlSchema: sqlCfgModel.sqlSchema
+        };
+        const tableMeta = await this.serviceHub.getTableMeta(query);
+        if (!tableMeta || !tableMeta.tableColumns || tableMeta.tableColumns.length === 0) {
+            this.logger.warn('CrudProDataFilterService: 无法获取表结构信息，跳过过滤', sqlCfgModel.sqlTable);
+            return data;
+        }
+        const validColumns = new Set(tableMeta.tableColumns);
+        const filteredData = {};
+        for (const [key, value] of Object.entries(data)) {
+            if (validColumns.has(key)) {
+                filteredData[key] = value;
+            }
+            else {
+                this.logger.debug('CrudProDataFilterService: 过滤掉不存在的字段', {
+                    table: sqlCfgModel.sqlTable,
+                    field: key,
+                });
+            }
+        }
+        return filteredData;
+    }
+}
+exports.CrudProDataFilterService = CrudProDataFilterService;

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

@@ -11,6 +11,7 @@ declare class CrudProGenSqlCondition {
      * @private
      */
     private generateByLogicalKey;
+    private generateByLogicalAnd;
     private generateByLogicalOR;
     private generateByCompareKey;
     /**

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

@@ -82,6 +82,17 @@ class CrudProGenSqlCondition {
                     }
                 }
                 // AND
+                if (equalsIgnoreCase(keys_1.KeysOfConditions.$AND, key)) {
+                    TypeUtils_1.TypeUtils.assertJsonArray(value, exceptions_1.Exceptions.REQUEST_OR_PARAM_MUST_ARRAY);
+                    const a = this.generateByLogicalAnd(value);
+                    if (a != null) {
+                        tmpSqlList.push(a.sql);
+                        if (isNotEmpty(a.args)) {
+                            tmpArgList.push(...a.args);
+                        }
+                    }
+                }
+                // AND
                 else if (TypeUtils_1.TypeUtils.isBasicType(value)) {
                     tmpSqlList.push(toSqlColumnName(key) + '= ?');
                     tmpArgList.push(value);
@@ -105,6 +116,25 @@ class CrudProGenSqlCondition {
         const sql = '(' + tmpSqlList.join(' AND ') + ')';
         return new SqlSegArg_1.SqlSegArg(sql, tmpArgList);
     }
+    generateByLogicalAnd(jsonArray) {
+        if (MixinUtils_1.MixinUtils.isEmpty(jsonArray)) {
+            return null;
+        }
+        const tmpSqlList = [];
+        const tmpArgList = [];
+        for (let i = 0; i < jsonArray.length; i++) {
+            const jsonObject = jsonArray[i];
+            const a = this.generateByLogicalKey(jsonObject);
+            if (a != null) {
+                tmpSqlList.push(a.sql);
+                if (MixinUtils_1.MixinUtils.isNotEmpty(a.args)) {
+                    tmpArgList.push(...a.args);
+                }
+            }
+        }
+        const sql = '(' + tmpSqlList.join(' AND ') + ')';
+        return new SqlSegArg_1.SqlSegArg(sql, tmpArgList);
+    }
     generateByLogicalOR(jsonArray) {
         if (MixinUtils_1.MixinUtils.isEmpty(jsonArray)) {
             return null;

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

@@ -310,7 +310,13 @@ class CrudProOriginToExecuteSql extends CrudProServiceBase_1.CrudProServiceBase
      * @private
      */
     async generateCfgColumns(sqlCfgModel) {
-        const tableMeta = await this.serviceHub.getTableMeta(sqlCfgModel);
+        const query = {
+            sqlTable: sqlCfgModel.sqlTable,
+            sqlDatabase: sqlCfgModel.sqlDatabase,
+            sqlDbType: sqlCfgModel.sqlDbType,
+            sqlSchema: sqlCfgModel.sqlSchema
+        };
+        const tableMeta = await this.serviceHub.getTableMeta(query);
         const tableColumns = tableMeta.tableColumns;
         const cfgColumns = sqlCfgModel.columns || [];
         // 没有配置: 全量

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

@@ -1,9 +1,12 @@
 import { CrudProServiceBase } from './CrudProServiceBase';
-import { SqlCfgModel } from '../models/SqlCfgModel';
-import { ITableMeta } from '../interfaces';
+import { ITableMeta, ITableMetaQuery } from '../interfaces';
 declare class CrudProTableMetaService extends CrudProServiceBase {
-    getTableMeta(sqlCfgModel: SqlCfgModel): Promise<ITableMeta>;
+    getTableMeta(query: ITableMetaQuery): Promise<ITableMeta>;
     private loadTableMeta;
-    private loadTableColumnInfo;
+    private loadTableColumnDetails;
+    private loadMySQLColumnDetails;
+    private loadPostgreSQLColumnDetails;
+    private loadPostgreSQLColumnComments;
+    private loadSQLServerColumnDetails;
 }
 export { CrudProTableMetaService };

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

@@ -8,71 +8,161 @@ class CrudProTableMetaCache {
     constructor() {
         this.cacheMap = {};
     }
-    getCacheKey(sqlCfgModel) {
-        return `${sqlCfgModel.sqlDatabase}:::${sqlCfgModel.sqlSchema}:::${sqlCfgModel.sqlTable}`;
+    getCacheKey(query) {
+        return `${query.sqlDatabase}:::${query.sqlSchema}:::${query.sqlDbType}:::${query.sqlTable}`;
     }
-    getMeta(sqlCfgModel) {
-        const cacheKey = this.getCacheKey(sqlCfgModel);
+    getMeta(query) {
+        const cacheKey = this.getCacheKey(query);
         const obj = this.cacheMap[cacheKey];
-        if (obj && obj.expiredTime < Date.now()) {
+        if (obj && obj.expiredTime > Date.now()) {
             return obj;
         }
         return null;
     }
-    setMeta(sqlCfgModel, metaObj) {
-        const cacheKey = this.getCacheKey(sqlCfgModel);
+    setMeta(query, metaObj) {
+        const cacheKey = this.getCacheKey(query);
         this.cacheMap[cacheKey] = metaObj;
     }
 }
 const metaCache = new CrudProTableMetaCache();
 class CrudProTableMetaService extends CrudProServiceBase_1.CrudProServiceBase {
-    async getTableMeta(sqlCfgModel) {
-        let obj = metaCache.getMeta(sqlCfgModel);
+    async getTableMeta(query) {
+        let obj = metaCache.getMeta(query);
         if (!obj) {
-            obj = await this.loadTableMeta(sqlCfgModel);
-            metaCache.setMeta(sqlCfgModel, obj);
+            obj = await this.loadTableMeta(query);
+            metaCache.setMeta(query, obj);
         }
         return obj;
     }
-    async loadTableMeta(sqlCfgModel) {
+    async loadTableMeta(query) {
         const { tableMetaCacheTime } = this.getContextCfg();
         const obj = {
-            expiredTime: Date.now() + tableMetaCacheTime || 1000 * 3600 * 24 * 365,
+            expiredTime: Date.now() + (tableMetaCacheTime || 1000 * 3600 * 24 * 365),
             tableColumns: [],
+            columnDetails: [],
         };
         const baseInfo = {
-            sqlTable: sqlCfgModel.sqlTable,
-            sqlDatabase: sqlCfgModel.sqlDatabase,
-            sqlDbType: sqlCfgModel.sqlDbType,
+            sqlTable: query.sqlTable,
+            sqlDatabase: query.sqlDatabase,
+            sqlDbType: query.sqlDbType,
         };
-        obj.tableColumns = await this.loadTableColumnInfo(baseInfo);
+        obj.columnDetails = await this.loadTableColumnDetails(baseInfo);
+        obj.tableColumns = obj.columnDetails.map(col => col.name);
         return obj;
     }
-    async loadTableColumnInfo(baseInfo) {
+    async loadTableColumnDetails(baseInfo) {
         if (baseInfo.sqlDbType === keys_1.SqlDbType.mysql) {
-            const queryRes = await this.executeUnsafeQuery(baseInfo, 'describe ' + baseInfo.sqlTable);
-            const tableDescribe = queryRes.rows || []; //pickAndConvertRowsByMix(queryRes, baseInfo.sqlDbType);
-            const tableDescribe2 = JSON.parse(JSON.stringify(tableDescribe));
-            return tableDescribe2.map(fieldObj => {
-                return fieldObj['Field'];
-            });
+            return this.loadMySQLColumnDetails(baseInfo);
         }
         else if (baseInfo.sqlDbType === keys_1.SqlDbType.postgres) {
-            const schemaname = 'public';
-            const columnArraySql = `
-      SELECT
-        *
-        FROM information_schema.columns
-        WHERE table_schema = '${schemaname}' and table_name = '${baseInfo.sqlTable}'
-        ORDER BY ordinal_position;
-      `.trim();
-            const queryRes = await this.executeUnsafeQuery(baseInfo, columnArraySql);
-            const tableDescribe = queryRes.rows || [];
-            return tableDescribe.map(fieldObj => {
-                return fieldObj['column_name'];
-            });
+            return this.loadPostgreSQLColumnDetails(baseInfo);
+        }
+        else if (baseInfo.sqlDbType === keys_1.SqlDbType.sqlserver) {
+            return this.loadSQLServerColumnDetails(baseInfo);
         }
         throw new Error('暂不支持的数据库类型：' + baseInfo.sqlDbType);
     }
+    async loadMySQLColumnDetails(baseInfo) {
+        const queryRes = await this.executeUnsafeQuery(baseInfo, 'DESCRIBE ' + baseInfo.sqlTable);
+        const tableDescribe = queryRes.rows || [];
+        return tableDescribe.map((fieldObj) => {
+            const { Field, Type, Null, Key, Default, Extra } = fieldObj;
+            return {
+                name: Field,
+                type: Type,
+                isNullable: Null === 'YES',
+                isPrimaryKey: Key === 'PRI',
+                defaultValue: Default,
+                comment: Extra,
+            };
+        });
+    }
+    async loadPostgreSQLColumnDetails(baseInfo) {
+        const schemaname = baseInfo.sqlSchema || 'public';
+        // 获取列基本信息
+        const columnArraySql = `
+      SELECT
+        column_name,
+        data_type,
+        is_nullable,
+        column_default,
+        character_maximum_length
+      FROM information_schema.columns
+      WHERE table_schema = '${schemaname}' AND table_name = '${baseInfo.sqlTable}'
+      ORDER BY ordinal_position;
+    `.trim();
+        const queryRes = await this.executeUnsafeQuery(baseInfo, columnArraySql);
+        const columnArray = queryRes.rows || [];
+        // 获取字段注释
+        const commentMap = await this.loadPostgreSQLColumnComments(baseInfo, schemaname);
+        return columnArray.map((columnObj) => {
+            const { column_name, data_type, is_nullable, column_default, character_maximum_length } = columnObj;
+            return {
+                name: column_name,
+                type: data_type,
+                isNullable: is_nullable === 'YES',
+                defaultValue: column_default,
+                maxLength: character_maximum_length,
+                comment: commentMap[column_name],
+            };
+        });
+    }
+    async loadPostgreSQLColumnComments(baseInfo, schemaname) {
+        const commentArraySql = `
+      SELECT
+        a.attname AS column_name,
+        d.description AS column_comment
+      FROM pg_class c
+      JOIN pg_namespace n ON c.relnamespace = n.oid
+      JOIN pg_attribute a ON c.oid = a.attrelid
+      LEFT JOIN pg_description d ON c.oid = d.objoid AND a.attnum = d.objsubid
+      WHERE n.nspname = '${schemaname}'
+        AND c.relname = '${baseInfo.sqlTable}'
+        AND a.attnum > 0
+      ORDER BY a.attnum;
+    `.trim();
+        const queryRes = await this.executeUnsafeQuery(baseInfo, commentArraySql);
+        const commentArray = queryRes.rows || [];
+        const map = {};
+        commentArray.forEach((commentObj) => {
+            const { column_name, column_comment } = commentObj;
+            map[column_name] = column_comment || '';
+        });
+        return map;
+    }
+    async loadSQLServerColumnDetails(baseInfo) {
+        const columnArraySql = `
+      SELECT
+        c.name AS column_name,
+        t.name AS data_type,
+        c.max_length,
+        c.precision,
+        c.scale,
+        c.is_nullable,
+        c.is_identity,
+        dc.definition AS column_default,
+        ep.value AS column_comment
+      FROM sys.columns c
+      JOIN sys.types t ON c.user_type_id = t.user_type_id
+      LEFT JOIN sys.default_constraints dc ON c.default_object_id = dc.object_id
+      LEFT JOIN sys.extended_properties ep ON c.object_id = ep.major_id AND c.column_id = ep.minor_id
+      WHERE c.object_id = OBJECT_ID('${baseInfo.sqlTable}')
+      ORDER BY c.column_id;
+    `.trim();
+        const queryRes = await this.executeUnsafeQuery(baseInfo, columnArraySql);
+        const columnArray = queryRes.rows || [];
+        return columnArray.map((columnObj) => {
+            const { column_name, data_type, is_nullable, column_default, column_comment, max_length, is_identity } = columnObj;
+            return {
+                name: column_name,
+                type: data_type,
+                isNullable: is_nullable,
+                defaultValue: column_default,
+                comment: column_comment,
+                maxLength: max_length,
+                isPrimaryKey: is_identity,
+            };
+        });
+    }
 }
 exports.CrudProTableMetaService = CrudProTableMetaService;

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

@@ -1,4 +1,4 @@
-import { IFuncCfgModel, IRequestCfgModel, ITableMeta } from '../interfaces';
+import { IFuncCfgModel, IRequestCfgModel, ISqlCfgModel, ITableMeta, ITableMetaQuery } from '../interfaces';
 import { RequestModel } from '../models/RequestModel';
 import { ExecuteContext } from '../models/ExecuteContext';
 import { SqlCfgModel } from '../models/SqlCfgModel';
@@ -15,6 +15,7 @@ declare class CurdProServiceHub implements ICurdProServiceHub {
     private readonly originToExecuteSql;
     private readonly executeFuncService;
     private readonly tableMetaService;
+    private readonly dataFilterService;
     constructor(executeContext: ExecuteContext);
     getExecuteContext(): ExecuteContext;
     validateByAllow(cfgModel: RequestCfgModel, reqModel: RequestModel): void;
@@ -27,6 +28,7 @@ declare class CurdProServiceHub implements ICurdProServiceHub {
     executeSqlCfgModels(): Promise<void>;
     convertOriginToExecuteSql(sqlCfgModel: SqlCfgModel): Promise<void>;
     executeFuncCfg(funCfg: IFuncCfgModel, funcContext: FuncContext): any;
-    getTableMeta(sqlCfgModel: SqlCfgModel): Promise<ITableMeta>;
+    getTableMeta(query: ITableMetaQuery): Promise<ITableMeta>;
+    filterDataByTableMeta(data: Record<string, any>, sqlCfgModel: ISqlCfgModel | SqlCfgModel): Promise<Record<string, any>>;
 }
 export { CurdProServiceHub };

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

@@ -9,6 +9,7 @@ const CrudProGenSqlService_1 = require("./CrudProGenSqlService");
 const CrudProOriginToExecuteSql_1 = require("./CrudProOriginToExecuteSql");
 const CrudProExecuteFuncService_1 = require("./CrudProExecuteFuncService");
 const CrudProTableMetaService_1 = require("./CrudProTableMetaService");
+const CrudProDataFilterService_1 = require("./CrudProDataFilterService");
 class CurdProServiceHub {
     constructor(executeContext) {
         this.executeContext = executeContext;
@@ -20,6 +21,7 @@ class CurdProServiceHub {
         this.originToExecuteSql = new CrudProOriginToExecuteSql_1.CrudProOriginToExecuteSql(this);
         this.executeFuncService = new CrudProExecuteFuncService_1.CrudProExecuteFuncService(this);
         this.tableMetaService = new CrudProTableMetaService_1.CrudProTableMetaService(this);
+        this.dataFilterService = new CrudProDataFilterService_1.CrudProDataFilterService(this);
     }
     getExecuteContext() {
         return this.executeContext;
@@ -57,8 +59,11 @@ class CurdProServiceHub {
     executeFuncCfg(funCfg, funcContext) {
         return this.executeFuncService.executeFuncCfg(funCfg, funcContext);
     }
-    async getTableMeta(sqlCfgModel) {
-        return await this.tableMetaService.getTableMeta(sqlCfgModel);
+    async getTableMeta(query) {
+        return await this.tableMetaService.getTableMeta(query);
+    }
+    async filterDataByTableMeta(data, sqlCfgModel) {
+        return await this.dataFilterService.filterDataByTableMeta(data, sqlCfgModel);
     }
 }
 exports.CurdProServiceHub = CurdProServiceHub;

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

@@ -176,6 +176,16 @@ const MixinUtils = {
         if (!obj || !objTravelCallback) {
             return;
         }
+        if (Array.isArray(obj)) {
+            const collection = obj;
+            for (let i = 0; i < collection.length; i++) {
+                const value = collection[i];
+                const curKeyPath = keyPath + '[' + i + ']';
+                objTravelCallback(value, null, i, curKeyPath);
+                MixinUtils.deepTravelObject(value, objTravelCallback, curKeyPath);
+            }
+            return;
+        }
         if (typeof obj === 'object') {
             const keys = Object.keys(obj);
             for (let i = 0; i < keys.length; i++) {
@@ -187,15 +197,6 @@ const MixinUtils = {
                 MixinUtils.deepTravelObject(value, objTravelCallback, curKeyPath);
             }
         }
-        if (Array.isArray(obj)) {
-            const collection = obj;
-            for (let i = 0; i < collection.length; i++) {
-                const value = collection[i];
-                const curKeyPath = keyPath + '[' + i + ']';
-                objTravelCallback(value, null, i, curKeyPath);
-                MixinUtils.deepTravelObject(value, objTravelCallback, curKeyPath);
-            }
-        }
     },
     removeEmptyAttrs(obj) {
         const result = {};