@jrosadob/ms-sophia-framework-mysql 0.0.1 → 0.0.3

package/libs/ms-sophia-framework-mysql/src/core/logger/logger.ts

@@ -0,0 +1,146 @@
+import {
+  ConsoleLogger,
+  INestApplicationContext,
+  Injectable,
+  Logger as NestLogger,
+  LoggerService as NestLoggerService,
+} from '@nestjs/common';
+import { ConfigService } from '../config/config.service';
+import { REQUEST } from '@nestjs/core';
+import { sendToLogstash } from '../tools/send-to-logstash';
+// import { get } from 'http'
+
+@Injectable()
+export class Logger extends ConsoleLogger implements NestLoggerService {
+  private static logstashUrl: string | undefined;
+  private static appContext: INestApplicationContext;
+  private static configService: ConfigService;
+
+  constructor(private readonly configService: ConfigService) {
+    super();
+    Logger.configService = this.configService;
+    Logger.logstashUrl = this.configService.get<string>('logger.http.host');
+  }
+
+  private static getConfigService(): ConfigService | undefined {
+    if (!this.appContext) {
+      return undefined;
+    }
+    return this.appContext.get(ConfigService);
+  }
+
+  private static async getRequest() {
+    const request = this.appContext
+      ? await this.appContext.resolve<any>(REQUEST).catch(() => null)
+      : null;
+    const value = typeof request?.method === 'string' ? request : null;
+    return value;
+  }
+
+  private static async getResponse() {
+    const request = await this.getRequest();
+    return request?.response ?? null;
+  }
+
+  private static async sendToLogstash(
+    level: string,
+    message: string,
+    meta?: any,
+  ): Promise<void> {
+    await sendToLogstash(
+      this.configService,
+      this.logstashUrl,
+      level,
+      message,
+      meta,
+      await this.getRequest(),
+      await this.getResponse(),
+    );
+  }
+
+  setContext(context: string): void {
+    super.setContext(context);
+  }
+
+  static setLogstashUrl(url: string) {
+    this.logstashUrl = url;
+  }
+
+  static setApplicationContext(appContext: INestApplicationContext) {
+    this.appContext = appContext;
+  }
+
+  //#region Public methods
+  setLogstashUrl(url: string) {
+    Logger.setLogstashUrl(url);
+  }
+  log(message: string): void;
+  log(message: any, context: string): void;
+  log(message: any, context?: string): void {
+    if (context) {
+      super.log('- ' + message, context);
+      Logger.sendToLogstash('log', message, { context: context });
+    } else {
+      super.log('- ' + message);
+      Logger.sendToLogstash('log', message);
+    }
+  }
+
+  warn(message: string) {
+    super.warn('- ' + message);
+  }
+
+  error(message: any, ...optionalParams: any[]) {
+    super.error('0' + message, ...optionalParams)
+    //this.safeSend('error', message, optionalParams)
+  }
+
+  // error(message: string) {
+  //   super.error('- ' + message);
+  // }
+
+  debug(message: string) {
+    super.debug('- ' + message);
+  }
+  //#endregion
+
+  //#region Static methods
+  static async log(message: string, meta?: any) {
+    NestLogger.log(message, meta);
+    //await Logger.sendToLogstash('log', message, { meta: meta })
+  }
+
+  static async warn(message: string, meta?: any) {
+    NestLogger.warn(message, meta);
+    await Logger.sendToLogstash('warn', message, { meta: meta });
+  }
+
+  static async error(message: any, ...optionalParams: any[])
+  static async error(message: string);
+  static async error(message: string, trace: string);
+  static async error(message: string, trace: string, meta: any);
+  static async error(message: string, trace?: string, meta?: any) {
+    if (meta) {
+      // Caso con mensaje, traza y metadatos
+      console.error('Error message1:', message);
+      NestLogger.error('1' + message, trace, meta);
+      await Logger.sendToLogstash('error', message, { trace, meta });
+    } else if (trace) {
+      // Caso con mensaje y traza
+      console.error('Error message2:', message);
+      NestLogger.error('2' + message, trace);
+      await Logger.sendToLogstash('error', message, { trace });
+    } else {
+      // Caso solo con mensaje
+      console.error('Error message3:', message);
+      NestLogger.error('3' + message);
+      await Logger.sendToLogstash('error', message);
+    }
+  }
+
+  static async debug(message: string, meta?: any) {
+    NestLogger.debug(message, meta);
+    await Logger.sendToLogstash('debug', message, { meta: meta });
+  }
+  //#endregion
+}

package/libs/ms-sophia-framework-mysql/src/core/logger/typeorm-logger.service.ts

@@ -0,0 +1,76 @@
+import { Logger as TypeOrmLogger, QueryRunner } from 'typeorm'
+import { Logger } from './logger'
+
+export class TypeOrmLoggerService implements TypeOrmLogger {
+  //private readonly logger = new Logger(TypeOrmLoggerService.name)
+
+  constructor(private readonly loggerHttpService: Logger, private readonly logging: boolean) {
+    //Logger.setContext(TypeOrmLoggerService.name)
+  }
+
+  logQuery(query: string, parameters?: any[], queryRunner?: QueryRunner) {
+    const message = `Query: ${query} | Parameters: ${JSON.stringify(parameters)}`
+    if (!this.logging) return;
+    //this.logger.log(message)
+    //this.loggerHttpService.log(message, 'TypeORM')
+    Logger.log(message, 'TypeORM')
+    //this.loggerHttpService.log(message)
+  }
+
+  logQueryError(error: string, query: string, parameters?: any[], queryRunner?: QueryRunner) {
+    const message = `Query Error: ${error} | Query: ${query} | Parameters: ${JSON.stringify(parameters)}`
+    if (!this.logging) return;
+    //this.loggerHttpService.error(message, undefined, 'TypeORM')
+    //this.loggerHttpService.error(message)
+    Logger.error(message, 'undefined', 'TypeORM')
+  }
+
+  logQuerySlow(time: number, query: string, parameters?: any[], queryRunner?: QueryRunner) {
+    const message = `Slow Query (${time}ms): ${query} | Parameters: ${JSON.stringify(parameters)}`
+    if (!this.logging) return;
+    //this.logger.warn(message)
+    // this.loggerHttpService.warn(message, 'TypeORM')
+    //this.loggerHttpService.warn(message)
+    Logger.warn(message, 'TypeORM')
+  }
+
+  logSchemaBuild(message: string, queryRunner?: QueryRunner) {
+    if (!this.logging) return;
+    //this.logger.log(`Schema Build: ${message}`)
+    //this.loggerHttpService.log(`Schema Build: ${message}`, 'TypeORM')
+    this.loggerHttpService.log(`Schema Build: ${message}`)
+    Logger.log(`Schema Build: ${message}`)
+  }
+
+  logMigration(message: string, queryRunner?: QueryRunner) {
+    if (!this.logging) return;
+    //this.logger.log(`Migration: ${message}`)
+    //this.loggerHttpService.log(`Migration: ${message}`, 'TypeORM')
+    //this.loggerHttpService.log(`- Migration: ${message}`)
+    Logger.log(`Migration: ${message}`)
+  }
+
+  log(level: 'log' | 'info' | 'warn', message: any, queryRunner?: QueryRunner) {
+    if (!this.logging) return;
+    switch (level) {
+      case 'log':
+        //this.logger.log(message)
+        //this.loggerHttpService.log(message, 'TypeORM')
+        //this.loggerHttpService.log(message)
+        Logger.log(message, 'TypeORM')
+        break
+      case 'info':
+        //this.logger.log(message)
+        // this.loggerHttpService.log(message, 'TypeORM')
+        //this.loggerHttpService.log(message)
+        Logger.log(message, 'TypeORM')
+        break
+      case 'warn':
+        //this.logger.warn(message)
+        // this.loggerHttpService.warn(message, 'TypeORM')
+        //this.loggerHttpService.warn(message)
+        Logger.warn(message, 'TypeORM')
+        break
+    }
+  }
+}

package/libs/ms-sophia-framework-mysql/src/core/subscribers/entity.subscriber.ts

@@ -0,0 +1,79 @@
+import { DataSource, EntitySubscriberInterface, EventSubscriber, InsertEvent, RemoveEvent, UpdateEvent } from "typeorm";
+import { Logs } from "./log.entity";
+import { Inject } from "@nestjs/common";
+import { Providers } from "../database/providers";
+import { nanoid } from "../tools";
+import { Logger } from "../logger";
+import { BaseEntity } from "../common";
+import { ConfigService } from "../config";
+
+@EventSubscriber()
+export class EntitySubscriber implements EntitySubscriberInterface<BaseEntity>
+{
+  constructor(
+    @Inject(Providers.DATA_SOURCE)
+    private readonly dataSource: DataSource,
+    // private readonly configService: ConfigService
+  ) {
+		if (dataSource && dataSource.subscribers) {
+			dataSource.subscribers.push(this);
+		}
+  }
+
+  afterInsert(event: InsertEvent<any>) {
+
+    if (event.metadata.target === Logs) {
+      Logger.log(`Logs. EntitySubscriber: afterInsert skipped on ${event.metadata.name} for Logs entity`);
+      return;
+    }
+    if (!(event.entity instanceof BaseEntity)) {
+      Logger.log(`BaseEntity. EntitySubscriber: afterInsert skipped on ${event.metadata.name} for non-BaseEntity`);
+      return;
+    }
+    Logger.log(`Nothing. EntitySubscriber: afterInsert on ${event.metadata.name}`);
+    return event.manager.save(Logs, this.getLog(event.entity));
+  }
+
+  afterUpdate(event: UpdateEvent<any>) {
+    if (event.metadata.target === Logs) return;
+		if (!(event.entity instanceof BaseEntity)) return;
+		Logger.log(`EntitySubscriber: afterUpdate on ${event.metadata.name}`);
+    return event.manager.save(Logs, this.getLog(event.entity));
+  }
+
+  afterRemove(event: RemoveEvent<any>) {
+    if (event.metadata.target === Logs) return;
+		if (!(event.entity instanceof BaseEntity)) return;
+		Logger.log(`EntitySubscriber: afterRemove on ${event.metadata.name}`);
+    return event.manager.save(Logs, this.getLog(event.entity));
+  }
+
+  getLog(entity: any): Logs {
+    var log: Logs = new Logs();
+    // Implement custom logging logic here
+    log.logId = nanoid();
+    log.entity = entity.constructor.name;
+    if (typeof entity.id === 'string') {
+        log.primaryKeyGuid = entity.id;
+        log.primaryKeyNumber = 0;
+    } else if (typeof entity.id === 'number') {
+			log.primaryKeyGuid = '';
+			log.primaryKeyNumber = entity.id;
+    }
+
+		// Custom data
+    log.action = 'CUSTOM_ACTION';
+    log.reason = 'Custom reason';
+    
+    log.typeId = 0;
+    log.userId = 'system';
+    log.roleId = 0;
+    log.bossId = 'system';
+
+    log.statusId = 0;
+    log.correlationId = nanoid();
+		// Custom data
+
+    return log;
+  }
+}

package/libs/ms-sophia-framework-mysql/src/core/subscribers/log.entity.ts

@@ -0,0 +1,35 @@
+// See: https://typeorm.io/entities#column-types
+// See: https://github.com/paralleldrive/cuid2
+// import { createId } from '@paralleldrive/cuid2';
+// import { nanoid } from 'nanoid'
+import { Column, Entity, PrimaryColumn } from 'typeorm'
+
+@Entity('logs')
+export class Logs {
+  @PrimaryColumn({ name: 'log_id', type: 'varchar', length: 21 })
+  logId: string
+  @Column({ type: 'varchar', length: 32 })
+  entity: string
+  @Column({ name: 'primary_key_guid', type: 'varchar', length: 21 })
+  primaryKeyGuid: string
+  @Column({ name: 'primary_key_number', type: 'int' })
+  primaryKeyNumber: number
+  @Column({ type: 'varchar', length: 16 })
+  action: string
+  @Column({ type: 'varchar', length: 128 })
+  reason: string
+  @Column({ name: 'type_id', type: 'int' })
+  typeId: number
+  @Column({ name: 'user_id', type: 'varchar', length: 21 })
+  userId: string
+  @Column({ name: 'role_id', type: 'int' })
+  roleId: number
+  @Column({ name: 'boss_id', type: 'varchar', length: 21 })
+  bossId: string
+  @Column({ name: 'status_id', type: 'int' })
+  statusId: number
+  @Column({ name: 'correlation_id', type: 'varchar', length: 21 })
+  correlationId: string
+  @Column({ name: 'date_log', type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
+  dateLog: string
+}

package/libs/ms-sophia-framework-mysql/src/core/tools/env-vars.ts

@@ -0,0 +1,26 @@
+export function replaceEnvVars(str) {
+  return str.replaceAll(/\${([^}]+)}/g, (_, name) => process.env[name] || '')
+}
+
+// export function replaceEnvVars(str) {
+//   return str.replaceAll(/${([^}]+)}/g, (_, name) => {
+//     const value = process.env[name] || '';
+//     // Convierte los saltos de línea literales en saltos reales para las private keys u otros valores multilínea
+//     return typeof value === 'string' ? value.replace(/\n/g, '\n') : value;
+//   });
+// }
+
+// export function replaceEnvVars(str) {
+//   return str.replaceAll(/\${([^}]+)}/g, (_, name) => {
+//     const value = process.env[name] || '';
+//     Convierte los saltos de línea literales (\n) en saltos reales
+//     if (name === 'FIREBASE_PRIVATE_KEY') {
+//       console.log('value FIREBASE_PRIVATE_KEY:', value);
+//     }
+//     const returnValue = typeof value === 'string' ? value.replace(/\\n/g, '\n') : value;
+//     if (name === 'FIREBASE_PRIVATE_KEY') {
+//       console.log('returnValue FIREBASE_PRIVATE_KEY:', returnValue);
+//     }
+//     return returnValue;
+//   });
+// }

package/libs/ms-sophia-framework-mysql/src/core/tools/index.ts

@@ -0,0 +1,4 @@
+export * from './nanoid'
+export * from './send-to-logstash'
+export * from './query'
+export * from './env-vars'

package/libs/ms-sophia-framework-mysql/src/core/tools/nanoid.ts

@@ -0,0 +1,4 @@
+import { customAlphabet } from 'nanoid';
+
+export const nanoid = customAlphabet('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ', 21);
+

package/libs/ms-sophia-framework-mysql/src/core/tools/query.ts

@@ -0,0 +1,186 @@
+import { SearchDto } from '../common/dto/search.dto'
+import { ObjectLiteral, SelectQueryBuilder } from 'typeorm'
+
+export function applyWhere<E extends ObjectLiteral>(
+  query: SelectQueryBuilder<E>,
+  where: Record<string, any> | Record<string, any>[] | null,
+): SelectQueryBuilder<E> {
+  if (!where) return query
+
+  for (const [key, value] of Object.entries(where)) {
+    if (typeof value === 'string' && value.startsWith('LIKE:')) {
+      const likeValue = value.replace('LIKE:', '')
+      query = query.andWhere(`${key} LIKE :${key}`, {
+        [key]: `%${likeValue}%`,
+      })
+    } else {
+      query = query.andWhere(`${key} = :${key}`, { [key]: value })
+    }
+  }
+  return query
+}
+
+export async function applyOrderAndPagination<E extends ObjectLiteral>(
+  query: SelectQueryBuilder<E>,
+  orderBy: Array<{ orderBy: string; orderSort: 'ASC' | 'DESC' }>,
+  pagination?: { page: number; pageSize: number; totalPages?: number },
+): Promise<SelectQueryBuilder<E>> {
+  if (orderBy !== undefined && orderBy.length > 0) {
+    query = query.orderBy(orderBy[0].orderBy, orderBy[0].orderSort)
+    for (let i = 1; i < orderBy.length; i++) {
+      query = query.addOrderBy(orderBy[i].orderBy, orderBy[i].orderSort)
+    }
+  }
+
+  if (pagination !== undefined) {
+    query = query.skip((pagination.page - 1) * pagination.pageSize)
+    query = query.take(pagination.pageSize)
+
+    // Calcula el total de páginas
+    pagination.totalPages = Math.ceil((await query.getCount()) / pagination.pageSize)
+  }
+
+  return query
+}
+
+export async function applyWhereOrderAndPagination<E extends ObjectLiteral>(
+  query: SelectQueryBuilder<E>,
+  where: Record<string, any> | Record<string, any>[] | null,
+  orderBy: Array<{ orderBy: string; orderSort: 'ASC' | 'DESC' }>,
+  pagination?: { page: number; pageSize: number; totalPages?: number },
+): Promise<SelectQueryBuilder<E>> {
+  // Apply where
+  if (where) {
+    for (const [key, value] of Object.entries(where)) {
+      if (typeof value === 'string' && value.startsWith('LIKE:')) {
+        const likeValue = value.replace('LIKE:', '')
+        query = query.andWhere(`${key} LIKE :${key}`, {
+          [key]: `%${likeValue}%`,
+        })
+      } else {
+        query = query.andWhere(`${key} = :${key}`, { [key]: value })
+      }
+    }
+  }
+
+  // Apply order
+  if (orderBy !== undefined && orderBy.length > 0) {
+    query = query.orderBy(orderBy[0].orderBy, orderBy[0].orderSort)
+    for (let i = 1; i < orderBy.length; i++) {
+      query = query.addOrderBy(orderBy[i].orderBy, orderBy[i].orderSort)
+    }
+  }
+
+  // Apply pagination
+  if (pagination !== undefined) {
+    query = query.skip((pagination.page - 1) * pagination.pageSize)
+    query = query.take(pagination.pageSize)
+
+    // Calcula el total de páginas
+    pagination.totalPages = Math.ceil((await query.getCount()) / pagination.pageSize)
+  }
+
+  return query
+}
+
+export async function applySearchWhereOrderAndPagination<E extends ObjectLiteral>(
+  query: SelectQueryBuilder<E>,
+  search: SearchDto | null,
+  where: Record<string, any> | Record<string, any>[] | null,
+  orderBy: Array<{ orderBy: string; orderSort: 'ASC' | 'DESC' }>,
+  pagination?: { page: number; pageSize: number; totalPages?: number },
+): Promise<SelectQueryBuilder<E>> {
+  // Apply search agrupando los OR
+  let searchApplied = false
+  if (search?.text && Array.isArray(search.properties) && search.properties.length > 0) {
+    const orConditions: string[] = []
+    const params: Record<string, any> = {}
+    search.properties.forEach((prop, idx) => {
+      const paramName = `searchText${idx}`
+      orConditions.push(`${prop} LIKE :${paramName}`)
+      params[paramName] = `%${search.text}%`
+    })
+    if (orConditions.length > 0) {
+      query = query.where(`(${orConditions.join(' OR ')})`, params)
+      searchApplied = true
+    }
+  }
+
+  // Apply where (si ya se aplicó search, usar andWhere, si no, usar where para la primera condición)
+  if (where) {
+    const entries = Object.entries(where)
+    entries.forEach(([key, value], idx) => {
+      const useAnd = searchApplied || idx > 0
+      if (typeof value === 'string' && value.startsWith('LIKE:')) {
+        const likeValue = value.replace('LIKE:', '')
+        if (useAnd) {
+          query = query.andWhere(`${key} LIKE :${key}`, {
+            [key]: `%${likeValue}%`,
+          })
+        } else {
+          query = query.where(`${key} LIKE :${key}`, {
+            [key]: `%${likeValue}%`,
+          })
+        }
+      } else {
+        if (useAnd) {
+          query = query.andWhere(`${key} = :${key}`, { [key]: value })
+        } else {
+          query = query.where(`${key} = :${key}`, { [key]: value })
+        }
+      }
+    })
+  }
+
+  // Apply order
+  if (orderBy !== undefined && orderBy.length > 0) {
+    query = query.orderBy(orderBy[0].orderBy, orderBy[0].orderSort)
+    for (let i = 1; i < orderBy.length; i++) {
+      query = query.addOrderBy(orderBy[i].orderBy, orderBy[i].orderSort)
+    }
+  }
+
+  // Apply pagination
+  if (pagination !== undefined) {
+    query = query.skip((pagination.page - 1) * pagination.pageSize)
+    query = query.take(pagination.pageSize)
+
+    // Calcula el total de páginas
+    pagination.totalPages = Math.ceil((await query.getCount()) / pagination.pageSize)
+  }
+
+  return query
+}
+
+// Original code in Service
+// Extraer: queryService.applyWhere(query, where): query
+// if (where !== undefined) {
+//   for (const [key, value] of Object.entries(where)) {
+//     if (typeof value === 'string' && value.startsWith('LIKE:')) {
+//       const likeValue = value.replace('LIKE:', '');
+//       query = query.andWhere(`${key} LIKE :${key}`, {
+//         [key]: `%${likeValue}%`,
+//       });
+//     } else {
+//       query = query.andWhere(`${key} = :${key}`, { [key]: value });
+//     }
+//   }
+// }
+// Estraer: queryService.applyOrderAndPagination(query, orderBy, pagination): query
+// if (orderBy !== undefined) {
+//   if (orderBy.length > 0) {
+//     query = query.orderBy(orderBy[0].orderBy, orderBy[0].orderSort);
+//   }
+//   for (let i = 1; i < orderBy.length; i++) {
+//     query = query.addOrderBy(orderBy[i].orderBy, orderBy[i].orderSort);
+//   }
+//   query = query.skip((pagination.page - 1) * pagination.pageSize);
+//   query = query.take(pagination.pageSize);
+// }
+// if (pagination !== undefined) {
+//   pagination.totalPages = Math.ceil(
+//     (await query.getCount()) / pagination.pageSize,
+//   );
+// }
+// query = applyWhere(query, where);
+// query = await applyOrderAndPagination(query, orderBy, pagination);

package/libs/ms-sophia-framework-mysql/src/core/tools/send-to-logstash.ts

@@ -0,0 +1,103 @@
+import axios from 'axios'
+import * as os from 'os'
+import { Logger as NestLogger } from '@nestjs/common'
+//import { ConfigService } from '../config'
+import { ConfigService } from '../config/config.service'
+
+// export interface LogstashPayload {
+//   level: string
+//   message: string
+//   timestamp?: string
+//   requestId?: string
+//   appName?: string
+//   appVersion?: string
+//   appPort?: number | string
+//   hostname?: string
+//   [key: string]: any
+// }
+
+export async function sendToLogstash(
+  configService: ConfigService,
+  logstashUrl: string | undefined,
+  level: string,
+  message: string,
+  meta?: any,
+  request?: any,
+  response?: any,
+): Promise<void> {
+  try {
+    if (request === null) {
+      return
+    }
+    const responseHeaders = response?.getHeaderNames().reduce(
+      (acc, headerName) => {
+        acc[headerName] = response.getHeader(headerName)
+        return acc
+      },
+      {} as Record<string, any>,
+    )
+
+    if (request.requestId === '') {
+      console.log('Request ID is empty')
+    }
+
+    const payload = {
+      level,
+      message,
+      timestamp: new Date().toISOString(),
+      requestId: request?.requestId ?? '',
+      appName: configService.get<string>('app.name') ?? '',
+      appVersion: configService.get<string>('app.version') ?? '',
+      appPort: configService.get<number>('app.port') ?? '',
+      hostname: os.hostname(),
+      method: request?.method ?? '', // Método HTTP (GET, POST, etc.)
+      url: request?.originalUrl ?? '', // URL original de la solicitud
+      ip: request?.ip ?? '', // Dirección IP del cliente
+      userAgent: request?.headers['user-agent'] ?? '', // Información del cliente
+      query: request?.query ?? {}, // Parámetros de consulta
+      requestBody: request?.body ?? {}, // Cuerpo de la solicitud (si no contiene datos sensibles)
+      requestHeaders: filterHeaders(request?.headers ?? {}),
+      statusCode: response?.statusCode ?? '', // Código de estado de la respuesta
+      responseHeaders: responseHeaders ?? {}, // Encabezados de la respuesta
+      responseTime: response?.responseTime ?? 0, // Tiempo de respuesta en milisegundos
+      ...meta,
+    }
+
+    // Implementar reintentos
+    if (logstashUrl) {
+      await axios.post(logstashUrl, payload)
+    }
+  } catch (error: unknown) {
+    const err = error as { code?: string; message?: string; stack?: string }
+    NestLogger.error(
+      `${err.message}\n${' '.repeat(61)}When trying to register: ${message}\nError trace: ${err.stack}`,
+    )
+  }
+}
+
+function filterHeaders(headers: Record<string, any>): Record<string, any> {
+  const sensitiveHeaders = ['authorization', 'cookie', 'set-cookie']
+
+  return Object.keys(headers).reduce(
+    (filtered, key) => {
+      if (sensitiveHeaders.includes(key.toLowerCase())) {
+        const value = headers[key]
+        if (typeof value === 'string') {
+          // Enmascarar el valor sensible
+          filtered[key] =
+            value.length > 10
+              ? `${value.slice(0, 10)}${'*'.repeat(value.length - 10)}`
+              : '*'.repeat(value.length)
+        } else {
+          // Si el valor no es una cadena, lo dejamos como está
+          filtered[key] = value
+        }
+      } else {
+        // Mantener los encabezados no sensibles sin cambios
+        filtered[key] = headers[key]
+      }
+      return filtered
+    },
+    {} as Record<string, any>,
+  )
+}

package/libs/ms-sophia-framework-mysql/src/index.ts

@@ -0,0 +1 @@
+export * from './main'