midway-fatcms 0.0.3 → 0.0.4

package/src/libs/crud-pro/CrudPro.ts

@@ -7,6 +7,7 @@ import { RequestCfgModel } from './models/RequestCfgModel';
 import { MixinUtils } from './utils/MixinUtils';
 import { Transaction } from './models/Transaction';
 import { IExecuteContextFunc } from './models/ExecuteContextFunc';
+import { KeysOfSimpleSQL } from './models/keys';
 
 class CrudPro {
   private readonly executeContext: ExecuteContext;
@@ -106,6 +107,9 @@ class CrudPro {
     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);
@@ -144,6 +148,73 @@ class CrudPro {
     return this.serviceHub.getCachedCfgByMethod(method, isEnableCache);
   }
 
+  /**
+   * 如果是 INSERT/UPDATE 操作（sqlSimpleName 模式），根据真实表结构过滤 reqModel.data 中的字段
+   * 避免传入不存在的字段导致 SQL 执行报错
+   * 注意：只处理 sqlSimpleName 模式，不处理 sqlCfgList 模式
+   * @param reqModel 请求模型
+   * @param cfgModel 配置模型
+   */
+  private async filterDataByTableMetaIfNeeded(reqModel: RequestModel, cfgModel: RequestCfgModel): Promise<void> {
+    // 只有在有 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: ISqlCfgModel = {
+      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 as ISqlCfgModel);
+
+    // 记录被过滤的字段
+    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 类型
+   */
+  private isSimpleInsertOrUpdateType(sqlSimpleName: string): boolean {
+    const insertOrUpdateTypes = [
+      KeysOfSimpleSQL.SIMPLE_INSERT,
+      KeysOfSimpleSQL.SIMPLE_UPDATE,
+      KeysOfSimpleSQL.SIMPLE_INSERT_ON_DUPLICATE_UPDATE,
+      KeysOfSimpleSQL.SIMPLE_INSERT_OR_UPDATE,
+    ];
+    return insertOrUpdateTypes.includes(sqlSimpleName as KeysOfSimpleSQL);
+  }
+
   private async executeSQLList() {
     try {
       await this.serviceHub.executeSqlCfgModels();

package/src/libs/crud-pro/interfaces.ts

@@ -12,9 +12,20 @@ export interface ICrudProCfg {
   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 {
@@ -200,4 +211,15 @@ export interface IExecuteUnsafeQueryCtx {
   sqlTable: string;
   sqlDatabase: string;
   sqlDbType: SqlDbType;
+  sqlSchema?: string;
+}
+
+/**
+ * 表结构元数据查询参数
+ */
+export interface ITableMetaQuery {
+  sqlTable: string;
+  sqlDatabase: string;
+  sqlDbType: SqlDbType;
+  sqlSchema?: string;
 }

package/src/libs/crud-pro/models/ServiceHub.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 {
@@ -28,5 +28,5 @@ export interface ICurdProServiceHub {
 
   executeFuncCfg(tmpFunCfg: IFuncCfgModel, exeFunCtx: FuncContext): string;
 
-  getTableMeta(sqlCfgModel: SqlCfgModel): Promise<ITableMeta>;
+  getTableMeta(query: ITableMetaQuery): Promise<ITableMeta>;
 }

package/src/libs/crud-pro/services/CrudProDataFilterService.ts

@@ -0,0 +1,58 @@
+import { CrudProServiceBase } from './CrudProServiceBase';
+import { ISqlCfgModel, ITableMetaQuery } from '../interfaces';
+
+/**
+ * 数据过滤服务
+ * 用于在 INSERT/UPDATE 操作前，根据真实表结构过滤 data 对象中的字段
+ */
+class CrudProDataFilterService extends CrudProServiceBase {
+  /**
+   * 根据表结构过滤 data 对象
+   * 只保留表中存在的字段
+   * @param data 原始 data 对象
+   * @param sqlCfgModel SQL 配置（可以是 ISqlCfgModel 接口或 SqlCfgModel 对象）
+   * @returns 过滤后的 data 对象
+   */
+  async filterDataByTableMeta(data: Record<string, any>, sqlCfgModel: ISqlCfgModel): Promise<Record<string, any>> {
+    if (!data || Object.keys(data).length === 0) {
+      return data;
+    }
+
+    // 确保 sqlTable 存在
+    if (!sqlCfgModel.sqlTable) {
+      this.logger.warn('CrudProDataFilterService: sqlTable 为空，跳过过滤');
+      return data;
+    }
+
+    const query: ITableMetaQuery = {
+      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: Record<string, any> = {};
+
+    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;
+  }
+}
+
+export { CrudProDataFilterService };

package/src/libs/crud-pro/services/CrudProOriginToExecuteSql.ts

@@ -1,5 +1,6 @@
 import { CrudProServiceBase } from './CrudProServiceBase';
 import { SqlCfgModel } from '../models/SqlCfgModel';
+import { ITableMetaQuery } from '../interfaces';
 import { MixinUtils } from '../utils/MixinUtils';
 import { SqlSegArg } from '../models/SqlSegArg';
 import { KeysOfCustomSQL, SqlDbType } from '../models/keys';
@@ -365,7 +366,15 @@ class CrudProOriginToExecuteSql extends CrudProServiceBase {
    * @private
    */
   private async generateCfgColumns(sqlCfgModel: SqlCfgModel): Promise<string[]> {
-    const tableMeta = await this.serviceHub.getTableMeta(sqlCfgModel);
+
+    const query: ITableMetaQuery = {
+      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/src/libs/crud-pro/services/CrudProTableMetaService.ts

@@ -1,25 +1,24 @@
 import { CrudProServiceBase } from './CrudProServiceBase';
-import { SqlCfgModel } from '../models/SqlCfgModel';
-import { IExecuteUnsafeQueryCtx, ITableMeta } from '../interfaces';
+import { IExecuteUnsafeQueryCtx, ITableColumn, ITableMeta, ITableMetaQuery } from '../interfaces';
 import { SqlDbType } from '../models/keys';
 // import { pickAndConvertRowsByMix } from '../utils/sqlConvert/convertMix';
 
 class CrudProTableMetaCache {
   private cacheMap: Record<string, ITableMeta> = {};
-  private getCacheKey(sqlCfgModel: SqlCfgModel) {
-    return `${sqlCfgModel.sqlDatabase}:::${sqlCfgModel.sqlSchema}:::${sqlCfgModel.sqlTable}`;
+  private getCacheKey(query: ITableMetaQuery) {
+    return `${query.sqlDatabase}:::${query.sqlSchema}:::${query.sqlDbType}:::${query.sqlTable}`;
   }
-  public getMeta(sqlCfgModel: SqlCfgModel) {
-    const cacheKey = this.getCacheKey(sqlCfgModel);
+  public getMeta(query: ITableMetaQuery) {
+    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;
   }
 
-  public setMeta(sqlCfgModel: SqlCfgModel, metaObj: ITableMeta) {
-    const cacheKey = this.getCacheKey(sqlCfgModel);
+  public setMeta(query: ITableMetaQuery, metaObj: ITableMeta) {
+    const cacheKey = this.getCacheKey(query);
     this.cacheMap[cacheKey] = metaObj;
   }
 }
@@ -27,60 +26,166 @@ class CrudProTableMetaCache {
 const metaCache = new CrudProTableMetaCache();
 
 class CrudProTableMetaService extends CrudProServiceBase {
-  async getTableMeta(sqlCfgModel: SqlCfgModel): Promise<ITableMeta> {
-    let obj = metaCache.getMeta(sqlCfgModel);
+  public async getTableMeta(query: ITableMetaQuery): Promise<ITableMeta> {
+    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;
   }
 
-  private async loadTableMeta(sqlCfgModel: SqlCfgModel): Promise<ITableMeta> {
+  private async loadTableMeta(query: ITableMetaQuery): Promise<ITableMeta> {
     const { tableMetaCacheTime } = this.getContextCfg();
 
-    const obj = {
-      expiredTime: Date.now() + tableMetaCacheTime || 1000 * 3600 * 24 * 365,
+    const obj: ITableMeta = {
+      expiredTime: Date.now() + (tableMetaCacheTime || 1000 * 3600 * 24 * 365),
       tableColumns: [],
+      columnDetails: [],
     };
 
     const baseInfo: IExecuteUnsafeQueryCtx = {
-      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;
   }
 
-  private async loadTableColumnInfo(baseInfo: IExecuteUnsafeQueryCtx): Promise<string[]> {
+  private async loadTableColumnDetails(baseInfo: IExecuteUnsafeQueryCtx): Promise<ITableColumn[]> {
     if (baseInfo.sqlDbType === 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 === 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 === SqlDbType.sqlserver) {
+      return this.loadSQLServerColumnDetails(baseInfo);
     }
 
     throw new Error('暂不支持的数据库类型：' + baseInfo.sqlDbType);
   }
+
+  private async loadMySQLColumnDetails(baseInfo: IExecuteUnsafeQueryCtx): Promise<ITableColumn[]> {
+    const queryRes = await this.executeUnsafeQuery(baseInfo, 'DESCRIBE ' + baseInfo.sqlTable);
+    const tableDescribe = queryRes.rows || [];
+
+    return tableDescribe.map((fieldObj: any) => {
+      const { Field, Type, Null, Key, Default, Extra } = fieldObj;
+      return {
+        name: Field,
+        type: Type,
+        isNullable: Null === 'YES',
+        isPrimaryKey: Key === 'PRI',
+        defaultValue: Default,
+        comment: Extra,
+      };
+    });
+  }
+
+  private async loadPostgreSQLColumnDetails(baseInfo: IExecuteUnsafeQueryCtx): Promise<ITableColumn[]> {
+    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: any) => {
+      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],
+      };
+    });
+  }
+
+  private async loadPostgreSQLColumnComments(
+    baseInfo: IExecuteUnsafeQueryCtx,
+    schemaname: string
+  ): Promise<Record<string, string>> {
+    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: Record<string, string> = {};
+    commentArray.forEach((commentObj: any) => {
+      const { column_name, column_comment } = commentObj;
+      map[column_name] = column_comment || '';
+    });
+
+    return map;
+  }
+
+  private async loadSQLServerColumnDetails(baseInfo: IExecuteUnsafeQueryCtx): Promise<ITableColumn[]> {
+    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: any) => {
+      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,
+      };
+    });
+  }
 }
 
 export { CrudProTableMetaService };

package/src/libs/crud-pro/services/CurdProServiceHub.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 { CrudProFieldValidateService } from './CrudProFieldValidateService';
 import { CrudProFieldUpdateService } from './CrudProFieldUpdateService';
@@ -13,6 +13,7 @@ import { ICurdProServiceHub } from '../models/ServiceHub';
 import { FuncContext } from '../models/FuncContext';
 import { CrudProExecuteFuncService } from './CrudProExecuteFuncService';
 import { CrudProTableMetaService } from './CrudProTableMetaService';
+import { CrudProDataFilterService } from './CrudProDataFilterService';
 
 class CurdProServiceHub implements ICurdProServiceHub {
   private readonly executeContext: ExecuteContext;
@@ -25,6 +26,7 @@ class CurdProServiceHub implements ICurdProServiceHub {
   private readonly originToExecuteSql: CrudProOriginToExecuteSql;
   private readonly executeFuncService: CrudProExecuteFuncService;
   private readonly tableMetaService: CrudProTableMetaService;
+  private readonly dataFilterService: CrudProDataFilterService;
 
   constructor(executeContext: ExecuteContext) {
     this.executeContext = executeContext;
@@ -36,6 +38,7 @@ class CurdProServiceHub implements ICurdProServiceHub {
     this.originToExecuteSql = new CrudProOriginToExecuteSql(this);
     this.executeFuncService = new CrudProExecuteFuncService(this);
     this.tableMetaService = new CrudProTableMetaService(this);
+    this.dataFilterService = new CrudProDataFilterService(this);
   }
 
   getExecuteContext(): ExecuteContext {
@@ -84,8 +87,12 @@ class CurdProServiceHub implements ICurdProServiceHub {
     return this.executeFuncService.executeFuncCfg(funCfg, funcContext);
   }
 
-  async getTableMeta(sqlCfgModel: SqlCfgModel): Promise<ITableMeta> {
-    return await this.tableMetaService.getTableMeta(sqlCfgModel);
+  async getTableMeta(query: ITableMetaQuery): Promise<ITableMeta> {
+    return await this.tableMetaService.getTableMeta(query);
+  }
+
+  async filterDataByTableMeta(data: Record<string, any>, sqlCfgModel: ISqlCfgModel | SqlCfgModel): Promise<Record<string, any>> {
+    return await this.dataFilterService.filterDataByTableMeta(data, sqlCfgModel);
   }
 }
 

package/src/libs/crud-pro/utils/CrudMonitor.ts

@@ -1,13 +1,13 @@
-
-const CrudMonitor = {
-  mysqlGetConnectionCount: 0,
-  mysqlReleaseConnectionCount: 0,
-  postgresGetConnectionCount: 0,
-  postgresReleaseConnectionCount: 0,
-  mssqlGetConnectionCount: 0,
-  mssqlReleaseConnectionCount: 0,
-}
-
-export  {
-  CrudMonitor,
-}
+
+const CrudMonitor = {
+  mysqlGetConnectionCount: 0,
+  mysqlReleaseConnectionCount: 0,
+  postgresGetConnectionCount: 0,
+  postgresReleaseConnectionCount: 0,
+  mssqlGetConnectionCount: 0,
+  mssqlReleaseConnectionCount: 0,
+}
+
+export  {
+  CrudMonitor,
+}