@jrosadob/ms-sophia-framework-mysql 0.0.2 → 0.0.4

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

@@ -1,146 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

@@ -1,35 +0,0 @@
-// 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

@@ -1,26 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

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

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

@@ -1,186 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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

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