midway-fatcms 0.0.5 → 0.0.6

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

@@ -1,13 +1,16 @@
 import { CrudProServiceBase } from './CrudProServiceBase';
-import { IExecuteUnsafeQueryCtx, ITableColumn, ITableMeta, ITableMetaQuery } from '../interfaces';
+import { IExecuteUnsafeQueryCtx, ITableColumn, ITableInfo, ITableListResult, ITableMeta, ITableMetaQuery, ITableNamesQuery, ITableNamesOptions } from '../interfaces';
 import { SqlDbType } from '../models/keys';
 // import { pickAndConvertRowsByMix } from '../utils/sqlConvert/convertMix';
 
 class CrudProTableMetaCache {
   private cacheMap: Record<string, ITableMeta> = {};
+  private tableInfoCacheMap: Record<string, { tableInfos: ITableListResult; expiredTime: number }> = {};
+
   private getCacheKey(query: ITableMetaQuery) {
     return `${query.sqlDatabase}:::${query.sqlSchema}:::${query.sqlDbType}:::${query.sqlTable}`;
   }
+
   public getMeta(query: ITableMetaQuery) {
     const cacheKey = this.getCacheKey(query);
     const obj = this.cacheMap[cacheKey];
@@ -21,6 +24,21 @@ class CrudProTableMetaCache {
     const cacheKey = this.getCacheKey(query);
     this.cacheMap[cacheKey] = metaObj;
   }
+
+  public getTableInfos(cacheKey: string): ITableListResult | null {
+    const cached = this.tableInfoCacheMap[cacheKey];
+    if (cached && cached.expiredTime > Date.now()) {
+      return cached.tableInfos;
+    }
+    return null;
+  }
+
+  public setTableInfos(cacheKey: string, tableInfos: ITableListResult, cacheTime: number): void {
+    this.tableInfoCacheMap[cacheKey] = {
+      tableInfos,
+      expiredTime: Date.now() + cacheTime,
+    };
+  }
 }
 
 const metaCache = new CrudProTableMetaCache();
@@ -35,6 +53,126 @@ class CrudProTableMetaService extends CrudProServiceBase {
     return obj;
   }
 
+  // ============ 获取表和视图信息（带类型） ============
+
+
+  /**
+   * 获取数据库所有表和视图信息（包含类型）
+   *
+   * @param query 数据库查询参数
+   * @param options 缓存控制选项
+   *   - skipCache: 跳过缓存，直接查询数据库
+   *   - refreshCache: 查询后更新缓存
+   */
+  public async getAllTableInfos(
+    query: ITableNamesQuery,
+    options: ITableNamesOptions = {}
+  ): Promise<ITableListResult> {
+    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;
+  }
+
+  private getTableInfoCacheKey(query: ITableNamesQuery): string {
+    return `tableInfo:::${query.sqlDatabase}:::${query.sqlSchema || 'public'}:::${query.sqlDbType}`;
+  }
+
+  private async loadAllTableInfos(query: ITableNamesQuery): Promise<ITableListResult> {
+    const { sqlDbType } = query;
+
+    if (sqlDbType === SqlDbType.mysql) {
+      return this.loadMySQLAllTableInfos(query);
+    } else if (sqlDbType === SqlDbType.postgres) {
+      return this.loadPostgreSQLAllTableInfos(query);
+    } else if (sqlDbType === SqlDbType.sqlserver) {
+      return this.loadSQLServerAllTableInfos(query);
+    }
+
+    throw new Error('暂不支持的数据库类型：' + sqlDbType);
+  }
+
+  private async loadMySQLAllTableInfos(query: ITableNamesQuery): Promise<ITableListResult> {
+    const dbUtil = { sqlDatabase: query.sqlDatabase, sqlDbType: query.sqlDbType } as IExecuteUnsafeQueryCtx;
+
+    // 获取物理表
+    const tableSql = `SHOW TABLES FROM ${query.sqlDatabase}`;
+    const tableRes = await this.executeUnsafeQuery(dbUtil, tableSql);
+    const tableNames: string[] = (tableRes.rows || []).map((row: any) => Object.values(row)[0] as string);
+
+    // 获取视图
+    const viewSql = `SHOW FULL TABLES FROM ${query.sqlDatabase} WHERE Table_type = 'VIEW'`;
+    const viewRes = await this.executeUnsafeQuery(dbUtil, viewSql);
+    const viewNames: string[] = (viewRes.rows || []).map((row: any) => Object.values(row)[0] as string);
+
+    const tables: ITableInfo[] = [
+      ...tableNames.map(name => ({ name, tableType: 'table' })),
+      ...viewNames.map(name => ({ name, tableType: 'view' })),
+    ];
+
+    return { tables, tableNames, viewNames };
+  }
+
+  private async loadPostgreSQLAllTableInfos(query: ITableNamesQuery): Promise<ITableListResult> {
+    const schema = query.sqlSchema || 'public';
+    const dbUtil = { sqlDatabase: query.sqlDatabase, sqlDbType: query.sqlDbType } as IExecuteUnsafeQueryCtx;
+
+    // 获取物理表
+    const tableSql = `SELECT tablename FROM pg_tables WHERE schemaname = '${schema}' ORDER BY tablename`;
+    const tableRes = await this.executeUnsafeQuery(dbUtil, tableSql);
+    const tableNames: string[] = (tableRes.rows || []).map((row: any) => row.tablename);
+
+    // 获取视图
+    const viewSql = `SELECT viewname FROM pg_views WHERE schemaname = '${schema}' ORDER BY viewname`;
+    const viewRes = await this.executeUnsafeQuery(dbUtil, viewSql);
+    const viewNames: string[] = (viewRes.rows || []).map((row: any) => row.viewname);
+
+    const tables: ITableInfo[] = [
+      ...tableNames.map(name => ({ name, tableType: 'table' })),
+      ...viewNames.map(name => ({ name, tableType: 'view' })),
+    ];
+
+    return { tables, tableNames, viewNames };
+  }
+
+  private async loadSQLServerAllTableInfos(query: ITableNamesQuery): Promise<ITableListResult> {
+    const dbUtil = { sqlDatabase: query.sqlDatabase, sqlDbType: query.sqlDbType } as IExecuteUnsafeQueryCtx;
+
+    // 获取物理表
+    const tableSql = `SELECT name FROM sys.tables`;
+    const tableRes = await this.executeUnsafeQuery(dbUtil, tableSql);
+    const tableNames: string[] = (tableRes.rows || []).map((row: any) => row.name);
+
+    // 获取视图
+    const viewSql = `SELECT name FROM sys.views`;
+    const viewRes = await this.executeUnsafeQuery(dbUtil, viewSql);
+    const viewNames: string[] = (viewRes.rows || []).map((row: any) => row.name);
+
+    const tables: ITableInfo[] = [
+      ...tableNames.map(name => ({ name, tableType: 'table' })),
+      ...viewNames.map(name => ({ name, tableType: 'view' })),
+    ];
+
+    return { tables, tableNames, viewNames };
+  }
+
   private async loadTableMeta(query: ITableMetaQuery): Promise<ITableMeta> {
     const { tableMetaCacheTime } = this.getContextCfg();
 

package/src/libs/crud-pro/services/CurdProServiceHub.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 { CrudProFieldValidateService } from './CrudProFieldValidateService';
 import { CrudProFieldUpdateService } from './CrudProFieldUpdateService';
@@ -14,6 +14,7 @@ import { FuncContext } from '../models/FuncContext';
 import { CrudProExecuteFuncService } from './CrudProExecuteFuncService';
 import { CrudProTableMetaService } from './CrudProTableMetaService';
 import { CrudProDataFilterService } from './CrudProDataFilterService';
+import { CrudProDataTypeConvertService } from './CrudProDataTypeConvertService';
 
 class CurdProServiceHub implements ICurdProServiceHub {
   private readonly executeContext: ExecuteContext;
@@ -27,6 +28,7 @@ class CurdProServiceHub implements ICurdProServiceHub {
   private readonly executeFuncService: CrudProExecuteFuncService;
   private readonly tableMetaService: CrudProTableMetaService;
   private readonly dataFilterService: CrudProDataFilterService;
+  private readonly dataTypeConvertService: CrudProDataTypeConvertService;
 
   constructor(executeContext: ExecuteContext) {
     this.executeContext = executeContext;
@@ -39,6 +41,7 @@ class CurdProServiceHub implements ICurdProServiceHub {
     this.executeFuncService = new CrudProExecuteFuncService(this);
     this.tableMetaService = new CrudProTableMetaService(this);
     this.dataFilterService = new CrudProDataFilterService(this);
+    this.dataTypeConvertService = new CrudProDataTypeConvertService(this);
   }
 
   getExecuteContext(): ExecuteContext {
@@ -57,6 +60,10 @@ class CurdProServiceHub implements ICurdProServiceHub {
     return this.fieldValidateService.validateByCfg(cfgModel, reqModel);
   }
 
+  validateDataType(cfgModel: RequestCfgModel, reqModel: RequestModel) {
+    return this.fieldValidateService.validateDataType(cfgModel, reqModel);
+  }
+
   async validateByAuthCfg(cfgModel: RequestCfgModel, reqModel: RequestModel): Promise<any> {
     const contextFunc = this.executeContext.contextFunc;
     if (contextFunc && contextFunc.validateByAuthCfg) {
@@ -91,9 +98,17 @@ class CurdProServiceHub implements ICurdProServiceHub {
     return await this.tableMetaService.getTableMeta(query);
   }
 
+  async getAllTableInfos(query: ITableNamesQuery, options?: ITableNamesOptions): Promise<ITableListResult> {
+    return await this.tableMetaService.getAllTableInfos(query, options);
+  }
+
   async filterDataByTableMeta(data: Record<string, any>, sqlCfgModel: ISqlCfgModel | SqlCfgModel): Promise<Record<string, any>> {
     return await this.dataFilterService.filterDataByTableMeta(data, sqlCfgModel);
   }
+
+  async convertDataTypeByTableMeta(reqModel: RequestModel, cfgModel: RequestCfgModel): Promise<void> {
+    return await this.dataTypeConvertService.convertDataTypeByTableMeta(reqModel, cfgModel);
+  }
 }
 
 export { CurdProServiceHub };

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

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

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

@@ -3,6 +3,85 @@ import { CommonException, Exceptions } from '../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?: number): string {
+  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(): string {
+    // 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: any): boolean {
     return typeof obj === 'undefined' || obj === null;
@@ -284,7 +363,24 @@ const MixinUtils = {
   },
   sleepMs(ms: number): Promise<any> {
     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,
 };
 
 export { MixinUtils };

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

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