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

package/libs/ms-sophia-framework-mysql/src/core/common/exceptions/app-http.exception.ts

@@ -0,0 +1,35 @@
+import { HttpException, HttpStatus, Logger } from '@nestjs/common';
+// import { nanoid } from 'src/core/tools';
+import { Result } from '../base/result';
+import { nanoid } from '../../tools';
+
+export class AppHttpException extends HttpException {
+  constructor(e: any, result: Result<any>) {
+    const loggerId = nanoid();
+    let status: HttpStatus;
+    let loggerMessage: string;
+
+    const errorType = e.constructor.name;
+    switch (errorType) {
+      case 'QueryFailedError':
+        status = HttpStatus.BAD_REQUEST;
+        super(result, status);
+        result.entity = undefined;
+        result.entities = undefined;
+        loggerMessage = `[${loggerId}] SqlState: ${e.driverError.sqlState} | QueryFailedError: ${e.driverError.sqlMessage}`;
+        Logger.log(loggerMessage, 'AppHttpException');
+        result.addError(loggerId, 400, 'Database error (QueryFailedError)');
+        break;
+      default:
+        status = HttpStatus.SERVICE_UNAVAILABLE;
+        super(result, status);
+        result.entity = undefined;
+        result.entities = undefined;
+        loggerMessage = `[${loggerId}] ${e.message}`;
+        Logger.log(loggerMessage, 'AppHttpException');
+        result.addError(loggerId, 503, 'Service unavailable');
+        break;
+    }
+    // super(result, status)
+  }
+}

package/libs/ms-sophia-framework-mysql/src/core/common/exceptions/app-unauthorized.exception.ts

@@ -0,0 +1,36 @@
+import { UnauthorizedException, Logger, HttpStatus } from '@nestjs/common';
+// import { nanoid } from 'src/core/tools';
+import { UnauthorizedResult } from '../result/unauthorized.result';
+import { nanoid } from '../../tools';
+
+const Logging = new Logger('AppUnauthorizedException');
+
+export class AppUnauthorizedException extends UnauthorizedException {
+  constructor(message: string) {
+    super(message);
+  }
+
+  getResponse(): UnauthorizedResult {
+    const response = super.getResponse();
+    const loggerId = nanoid();
+    if (typeof response === 'string') {
+      Logging.log(`[${loggerId}]: ${response}`);
+      return {
+        message: response,
+        error: 'Unauthorized',
+        statusCode: HttpStatus.UNAUTHORIZED,
+        loggerId: loggerId,
+      } as UnauthorizedResult;
+    }
+    // @ts-ignore: This line is to ignore the TypeScript error
+    Logging.log(`[${loggerId}]: ${response.message ?? response.error}`);
+
+    return {
+      error: 'Unauthorized',
+      // @ts-ignore: This line is to ignore the TypeScript error
+      message: response.message,
+      statusCode: HttpStatus.UNAUTHORIZED,
+      loggerId: loggerId,
+    } as UnauthorizedResult;
+  }
+}

package/libs/ms-sophia-framework-mysql/src/core/common/filters/all-exception.filter.ts

@@ -0,0 +1,42 @@
+import {
+  ExceptionFilter,
+  Catch,
+  ArgumentsHost,
+  HttpException,
+  HttpStatus,
+  Logger,
+} from '@nestjs/common';
+import { Response } from 'express';
+import { nanoid } from '../../tools';
+// import { nanoid } from 'src/core/tools';
+
+@Catch()
+export class AllExceptionsFilter implements ExceptionFilter {
+  catch(exception: unknown, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<Response>();
+
+    const status =
+      exception instanceof HttpException
+        ? exception.getStatus()
+        : HttpStatus.INTERNAL_SERVER_ERROR;
+
+    const message =
+      exception instanceof HttpException ? exception.getResponse() : exception;
+
+    const loggerId = nanoid();
+    const loggerMessage = `[${loggerId}] ${message}`;
+    Logger.error({ message: loggerMessage, context: 'AllExceptionsFilter' });
+
+    response.status(status).json({
+      hasError: true,
+      errors: [
+        {
+          message: message,
+          statusCode: status,
+          loggerId: loggerId,
+        },
+      ],
+    });
+  }
+}

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

@@ -0,0 +1,24 @@
+export * from './base/error';
+export * from './base/result';
+export * from './base/status-base'; // Reemplazado por BaseEntity
+
+export * from './dto/change-status.dto';
+export * from './dto/log.dto';
+export * from './dto/order-by.dto';
+export * from './dto/pagination.dto';
+export * from './dto/search.dto';
+export * from './dto/select.dto';
+
+export * from './entity/base.entity';
+
+export * from './exceptions/app-badrequest.exception';
+export * from './exceptions/app-http.exception';
+export * from './exceptions/app-unauthorized.exception';
+
+export * from './filters/all-exception.filter';
+
+export * from './pipes/app-validation.pipe';
+
+export * from './result/bad-request.result';
+export * from './result/property.result';
+export * from './result/unauthorized.result';

package/libs/ms-sophia-framework-mysql/src/core/common/pipes/app-validation.pipe.ts

@@ -0,0 +1,35 @@
+import {
+  ValidationPipe,
+  ValidationError,
+  BadRequestException,
+  HttpStatus,
+  ValidationPipeOptions,
+} from '@nestjs/common';
+import { BadRequestResult } from '../result/bad-request.result';
+import { PropertyResult } from '../result/property.result';
+import { nanoid } from '../../tools';
+//import { nanoid } from 'src/core/tools';
+
+export class AppValidationPipe extends ValidationPipe {
+  constructor(options?: ValidationPipeOptions) {
+    super(options);
+  }
+
+  createExceptionFactory() {
+    return (validationErrors: ValidationError[] = []) => {
+      const loggerId = nanoid();
+      const customErrors = validationErrors.map((error) => ({
+        property: error.property,
+        message: Object.values(error.constraints || {}).join(', '),
+      }));
+
+      return new BadRequestException({
+        error: 'Bad Request',
+        message: 'Validation failed',
+        statusCode: HttpStatus.BAD_REQUEST,
+        errors: [...customErrors] as PropertyResult[],
+        loggerId: loggerId,
+      } as BadRequestResult);
+    };
+  }
+}

package/libs/ms-sophia-framework-mysql/src/core/common/result/bad-request.result.ts

@@ -0,0 +1,17 @@
+import { ApiProperty } from '@nestjs/swagger'
+import { PropertyResult } from './property.result'
+
+export class BadRequestResult {
+  @ApiProperty({ description: 'Mensaje de error' })
+  message: string
+  @ApiProperty({
+    description: 'Nombre del error según StatusCode, p.e: BAD REQUEST, NOT FOUND, CREATED, etc',
+  })
+  error: string
+  @ApiProperty({ description: 'Código de error HttpStatusCode: 200, 201, 400, 401, etc.' })
+  statusCode: number
+  @ApiProperty({ description: 'loggerId del mensaje de error, para ubicarlo en el Logger' })
+  loggerId: string
+  @ApiProperty({ description: 'Array de errores de validación', type: [PropertyResult] })
+  errors: PropertyResult[] | null
+}

package/libs/ms-sophia-framework-mysql/src/core/common/result/property.result.ts

@@ -0,0 +1,8 @@
+import { ApiProperty } from '@nestjs/swagger'
+
+export class PropertyResult {
+  @ApiProperty({ description: 'Nombre de la property que no cumple con la validación' })
+  property: string
+  @ApiProperty({ description: 'Descripción de la validación que la property no cumple' })
+  message: string
+}

package/libs/ms-sophia-framework-mysql/src/core/common/result/unauthorized.result.ts

@@ -0,0 +1,14 @@
+import { ApiProperty } from '@nestjs/swagger'
+
+export class UnauthorizedResult {
+  @ApiProperty({ description: 'Mensaje de error' })
+  message: string
+  @ApiProperty({
+    description: 'Nombre del error según StatusCode, p.e: BAD REQUEST, NOT FOUND, CREATED, etc',
+  })
+  error: string
+  @ApiProperty({ description: 'Código de error HttpStatusCode: 200, 201, 400, 401, etc.' })
+  statusCode: number
+  @ApiProperty({ description: 'loggerId del mensaje de error, para ubicarlo en el Logger' })
+  loggerId: string
+}

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

@@ -0,0 +1,22 @@
+import { Module, Global } from '@nestjs/common'
+import { ConfigService } from './config.service'
+import * as yaml from 'js-yaml'
+import { readFileSync } from 'node:fs'
+import { replaceEnvVars } from '../tools'
+
+@Global()
+@Module({
+  providers: [
+    {
+      provide: ConfigService,
+      useFactory: () => {
+        const configData = yaml.load(
+          replaceEnvVars(readFileSync('bootstrap.yml', 'utf8')),
+        ) as Record<string, any>
+        return new ConfigService(configData)
+      },
+    },
+  ],
+  exports: [ConfigService],
+})
+export class ConfigModule {}

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

@@ -0,0 +1,37 @@
+import { Injectable } from '@nestjs/common'
+import { Logger } from '../logger/logger'
+
+@Injectable()
+export class ConfigService {
+  private readonly config: Record<string, any>
+
+  constructor(config: Record<string, any>) {
+    this.config = config
+    this.getKey = this.getKey.bind(this)
+    this.get = this.get.bind(this)
+  }
+
+  getKey<T>(key: string): T | undefined {
+    const keys = key.split('.')
+    let current: any = this.config
+
+    for (const k of keys) {
+      if (current && typeof current === 'object' && k in current) {
+        current = current[k]
+      } else {
+        return undefined
+      }
+    }
+
+    return current as T | undefined
+  }
+
+  get<T>(key: string): T | undefined {
+    const value = this.getKey<T>(key)
+    if (value === undefined) {
+      Logger.warn(`[ConfigService] Missing property: ${key}`)
+      return undefined
+    }
+    return value
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from './config.module'
+export * from './config.service'

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

@@ -0,0 +1,18 @@
+import { Global, Module } from '@nestjs/common'
+import { databaseProviders } from './database.provider'
+import { ConfigService } from '@nestjs/config'
+import { ConfigModule } from '../config/config.module'
+import { Logger } from '../logger/logger'
+// import { ConfigService } from '@nestjs/config'
+// import { LoggerHttpService } from 'src/logger/logger-http.service'
+// import { LoggerModule } from 'src/logger/logger.module'
+// import { LoggerService } from 'src/logger/logger.service'
+// import { LoggerHttpService } from 'src/logger/logger-http.service'
+
+@Global()
+@Module({
+  imports: [ConfigModule],
+  providers: [ConfigService, ...databaseProviders, Logger],
+  exports: [...databaseProviders],
+})
+export class DatabaseModule {}

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

@@ -0,0 +1,70 @@
+//import { DatabaseType, DataSource, LoggerOptions } from 'typeorm'
+import { DataSource, EntitySchema, MixedList } from 'typeorm';
+import { Providers } from './providers';
+import { ConfigModule } from '../config/config.module';
+import { ConfigService } from '../config/config.service';
+import { Logger } from '../logger/logger';
+import { LoggerModule } from '../logger/logger.module';
+import { TypeOrmLoggerService } from '../logger/typeorm-logger.service';
+import { EntitySubscriber } from '../subscribers/entity.subscriber';
+import { Logs } from '../subscribers/log.entity';
+
+type MySqlDatabaseType = 'mysql' | 'mariadb';
+export const databaseProviders = [
+  {
+    provide: Providers.DATA_SOURCE,
+    imports: [ConfigModule, LoggerModule],
+    inject: [ConfigService, Logger],
+    useFactory: async (configService: ConfigService, logger: Logger) => {
+      const includeLogs: boolean = getIncludeLogs(configService);
+      logger.log('Value process.cwd(): ' + process.cwd(), 'DatabaseProvider');
+
+      const entities: MixedList<string | Function | EntitySchema<any>> | undefined = [
+        process.cwd() + configService.get<string>('typeorm.mysql.entities'),
+      ];
+      if (includeLogs) {
+        entities.push(Logs);
+      }
+      const subscribers = includeLogs ? [EntitySubscriber] : undefined;
+      const synchronize = configService.get<boolean>('typeorm.mysql.synchronize');
+      const logging = configService.get<boolean>('typeorm.mysql.logging') as boolean;
+      const typeOrmLogger = logging ? new TypeOrmLoggerService(logger, logging) : undefined;
+
+      const dataSource = new DataSource({
+        type: configService.get<string>(
+          'typeorm.mysql.type',
+        ) as MySqlDatabaseType,
+        host: configService.get<string>('typeorm.mysql.host'),
+        port: configService.get<number>('typeorm.mysql.port'),
+        database: configService.get<string>('typeorm.mysql.database'),
+        username: configService.get<string>('typeorm.mysql.username'),
+        password: configService.get<string>('typeorm.mysql.password'),
+        // Se define las entities, subscribers, synchronize, logging, logger dinámicamente, mas arriba, según la configuración
+        // entities: [
+        //   process.cwd() + configService.get<string>('typeorm.mysql.entities'),
+        //   Logs
+        // ],
+        // subscribers: [EntitySubscriber],
+        // NOT USE. La sincronización elimina todas las columnas y las crea nuevas
+        // synchronize: configService.get<boolean>('typeorm.mysql.synchronize'),
+        entities,
+        subscribers,
+        synchronize,
+        logging,
+        logger: typeOrmLogger,
+      });
+      const data = await dataSource.initialize();
+      logger.log('Database connection established', 'DatabaseProvider');
+      //return dataSource.initialize()
+      return data;
+    },
+  },
+];
+
+function getIncludeLogs(configService: ConfigService): boolean {
+  const includeLogs = configService.get<boolean>('entityLogs.insertEnabled') || 
+  configService.get<boolean>('entityLogs.updateEnabled') || 
+  configService.get<boolean>('entityLogs.removeEnabled') || 
+  false;
+  return includeLogs
+}

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

@@ -0,0 +1,3 @@
+export * from './database.module'
+export * from './database.provider'
+export * from './providers'

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

@@ -0,0 +1,3 @@
+export enum Providers {
+  DATA_SOURCE = 'DATA_SOURCE',
+}

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

@@ -0,0 +1,36 @@
+import { Controller, Get, HttpException, HttpStatus, Inject } from '@nestjs/common'
+import { ApiOperation, ApiResponse } from '@nestjs/swagger'
+import { DataSource } from 'typeorm'
+import { Providers } from '../database'
+
+@Controller('health')
+export class HealthController {
+  constructor(
+    @Inject(Providers.DATA_SOURCE)
+    private readonly dataSource: DataSource,
+  ) {}
+
+  @Get('liveness')
+  @ApiOperation({ summary: 'Enpoint liveness for Kubernetes' })
+  @ApiResponse({ status: 200, description: 'Ok' })
+  @ApiResponse({ status: 500, description: 'Internal server error' })
+  liveness() {
+    return { status: 'ok' }
+  }
+
+  @Get('readiness')
+  @ApiOperation({ summary: 'Enpoint readiness for Kubernetes' })
+  @ApiResponse({ status: 200, description: 'Ok' })
+  @ApiResponse({ status: 503, description: 'Service unaivalable' })
+  async readiness() {
+    try {
+      await this.dataSource.query('SELECT 1')
+      return { status: 'ok' }
+    } catch (error) {
+      throw new HttpException(
+        { status: 'error', message: 'Database connection failed' },
+        HttpStatus.SERVICE_UNAVAILABLE,
+      )
+    }
+  }
+}

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

@@ -0,0 +1,16 @@
+import { Module } from '@nestjs/common'
+import { HealthController } from './health.controller'
+import { Logger } from '../logger'
+// import { ConfigModule } from './core/config/config.module'
+// import { DatabaseModule } from './core/database/database.module'
+// import { LoggerModule } from './core/logger/logger.module'
+// import { Logger } from './core/logger/logger'
+// import { HealthController } from './core/health/HealthController'
+
+@Module({
+  imports: [],
+  controllers: [HealthController],
+  providers: [Logger],
+  exports: [Logger],
+})
+export class HealthModule {}

package/libs/ms-sophia-framework-mysql/src/core/interceptors/headers.interceptor.ts

@@ -0,0 +1,16 @@
+import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common'
+import { Observable } from 'rxjs'
+
+@Injectable()
+export class HeadersInterceptor implements NestInterceptor {
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    const request = context.switchToHttp().getRequest()
+    request.startTime = Date.now()
+    request.appName = request.headers['app-name'] ?? ''
+    request.scopes = request.headers['scopes'] ?? ''
+
+    return next.handle()
+  }
+}
+
+//Pasar todo esto al Loggin interceptor

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

@@ -0,0 +1,2 @@
+export * from './headers.interceptor'
+export * from './logging.interceptor'

package/libs/ms-sophia-framework-mysql/src/core/interceptors/logging.interceptor.ts

@@ -0,0 +1,43 @@
+import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common'
+import { Observable } from 'rxjs'
+import { tap } from 'rxjs/operators'
+import { LoggerRequest } from '../logger/logger.request'
+import { ConfigService } from '../config'
+import { nanoid } from '../tools/nanoid'
+
+@Injectable()
+export class LoggingInterceptor implements NestInterceptor {
+  //private readonly configService: ConfigService
+  constructor(private readonly configService: ConfigService) {
+    this.configService = configService
+  }
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    const request = context.switchToHttp().getRequest()
+    const response = context.switchToHttp().getResponse()
+    const { method, url } = request
+    const startTime = Date.now()
+
+    request.requestId = request.headers['request-id'] ?? nanoid()
+
+    response.setHeader('Request-ID', request.requestId)
+    response['responseTime'] = Date.now() - startTime
+    request.response = response
+
+    LoggerRequest.setConfigService(this.configService)
+    LoggerRequest.setResponse(response)
+    LoggerRequest.setRequest(request)
+    LoggerRequest.log(
+      `[${request.requestId}] Incoming Request: ${method} ${url}`,
+      'LoggingInterceptor',
+    )
+
+    return next.handle().pipe(
+      tap((resp) => {
+        LoggerRequest.log(
+          `[${request.requestId}] Outgoing Response: ${method} ${url} - ${response['responseTime']}ms`,
+          'LoggingInterceptor',
+        )
+      }),
+    )
+  }
+}

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

@@ -0,0 +1,4 @@
+export * from './logger.module'
+export * from './logger'
+export * from './logger.request'
+export * from './typeorm-logger.service'

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

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common'
+import { ConfigModule } from '../config/config.module'
+import { Logger, TypeOrmLoggerService } from '.'
+
+@Module({
+  imports: [ConfigModule],
+  providers: [Logger, TypeOrmLoggerService],
+  exports: [Logger, TypeOrmLoggerService],
+})
+export class LoggerModule {}

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

@@ -0,0 +1,137 @@
+import {
+  ConsoleLogger,
+  Injectable,
+  Logger,
+  Logger as NestLogger,
+  LoggerService as NestLoggerService,
+  Scope,
+} from '@nestjs/common'
+import { ConfigService } from '../config/config.service'
+import { sendToLogstash } from '../tools/send-to-logstash'
+import { Request, Response } from 'express'
+
+@Injectable({ scope: Scope.REQUEST })
+export class LoggerRequest extends ConsoleLogger implements NestLoggerService {
+  private static logstashUrl: string | undefined
+  private static configService: ConfigService
+  private static request: Request
+  private static response: Response
+
+  constructor(private readonly configService: ConfigService) {
+    super()
+    LoggerRequest.configService = this.configService
+    LoggerRequest.logstashUrl = this.configService.get<string>('logger.http.host')
+  }
+
+  static setConfigService(configService: ConfigService) {
+    this.configService = configService
+    this.logstashUrl = this.configService.get<string>('logger.http.host')
+  }
+
+  static async setRequest(request: any): Promise<void> {
+    this.request = request
+  }
+
+  static async setResponse(response: any): Promise<void> {
+    this.response = response
+  }
+
+  private static async sendToLogstash(level: string, message: string, meta?: any): Promise<void> {
+    await sendToLogstash(
+      this.configService,
+      this.logstashUrl,
+      level,
+      message,
+      meta,
+      this.request,
+      this.response,
+    )
+  }
+
+  // _log(message: string): void
+  // _log(message: any, context: string): void
+  // _log(message: any, context?: string): void {
+  //   if (context) {
+  //     super.log('- ' + message, context)
+  //     LoggerRequest.sendToLogstash('log', message, { context: context })
+  //   } else {
+  //     super.log('- ' + message)
+  //     LoggerRequest.sendToLogstash('log', message)
+  //   }
+  // }
+
+  warn(message: any)
+  warn(message: any, context: string)
+  warn(message: any, context?: string) {
+    if (context) {
+      super.warn('- ' + message, context)
+      LoggerRequest.sendToLogstash('warn', message, { context: context })
+    } else {
+      super.warn('- ' + message)
+      LoggerRequest.sendToLogstash('warn', message)
+    }
+  }
+
+  error(message: string)
+  error(message: string, trace: string)
+  error(message: string, trace: string, meta: any)
+  error(message: string, trace?: string, meta?: any) {
+    if (meta) {
+      super.error('- ' + message, trace, meta)
+      LoggerRequest.sendToLogstash('error', message, { trace, meta })
+    } else if (trace) {
+      super.error('- ' + message, trace)
+      LoggerRequest.sendToLogstash('error', message, { trace })
+    } else {
+      super.error('- ' + message)
+      LoggerRequest.sendToLogstash('error', message)
+    }
+  }
+
+  debug(message: string)
+  debug(message: any, context: string)
+  debug(message: any, context?: string) {
+    if (context) {
+      super.debug('- ' + message, context)
+      LoggerRequest.sendToLogstash('warn', message, { context: context })
+    } else {
+      super.debug('- ' + message)
+      LoggerRequest.sendToLogstash('warn', message)
+    }
+  }
+  //#endregion
+
+  //#region Static methods
+  static async log(message: string, meta?: any) {
+    const logger = new Logger()
+    logger.log(message, meta)
+    await LoggerRequest.sendToLogstash('log', message, { meta: meta })
+  }
+
+  static async warn(message: string, meta?: any) {
+    NestLogger.warn(message, meta)
+    await LoggerRequest.sendToLogstash('warn', message, { meta: meta })
+  }
+
+  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) {
+      NestLogger.error(message, trace, meta)
+      // await LoggerRequest.sendToLogstash('error', message, { trace, meta })
+    } else if (trace) {
+      NestLogger.error(message, trace)
+      // await LoggerRequest.sendToLogstash('error', message, { trace })
+    } else {
+      NestLogger.error(message)
+      // await LoggerRequest.sendToLogstash('error', message)
+    }
+  }
+
+  static async debug(message: string, meta?: any) {
+    NestLogger.debug(message, meta)
+    await LoggerRequest.sendToLogstash('debug', message, { meta: meta })
+  }
+  //#endregion
+}