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

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

@@ -0,0 +1,230 @@
+import { NestFactory } from '@nestjs/core'
+import { Transport } from '@nestjs/microservices'
+import { Logger as NestLogger, ParseArrayPipe, ParseIntPipe, PipeTransform } from '@nestjs/common'
+import { Logger } from './core/logger/logger'
+import { ConfigService } from './core/config/config.service'
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger'
+import * as yaml from 'js-yaml'
+import { readFileSync } from 'fs'
+import path, { join } from 'path'
+import { HeadersInterceptor, LoggingInterceptor } from './core/interceptors'
+import { AllExceptionsFilter, AppValidationPipe } from './core/common'
+import { CorsOptions } from '@nestjs/common/interfaces/external/cors-options.interface'
+import { replaceEnvVars } from './core/tools'
+
+interface AppConfig {
+  name: string
+  module: string
+  version: string
+  port: number
+  prefix: string
+}
+
+export async function bootstrap({
+  preHook,
+  postHook,
+}: {
+  preHook?: (app: any, configService: ConfigService, logger: Logger) => Promise<void>
+  postHook?: (app: any, configService: ConfigService, logger: Logger) => Promise<void>
+} = {}) {
+  let appModule: string = ''
+
+  try {
+    require('dotenv').config({ path: 'bootstrap.env' })
+    const configData = yaml.load(replaceEnvVars(readFileSync('bootstrap.yml', 'utf8'))) as Record<
+      string,
+      any
+    >
+    const configService = new ConfigService(configData)
+    const logstashUrl = configService.get<string>('logger.http.host') ?? ''
+    const appConfig = configService.get<AppConfig>('app')
+
+    const logger = new Logger(configService)
+    logger.setContext('Bootstrap')
+    const appModulePath = path.resolve(process.cwd(), appConfig?.module ?? '/app.module')
+    const { AppModule } = await import(appModulePath)
+
+    let app: any
+    try {
+      // app = await NestFactory.create(AppModule, { bufferLogs: true })
+      app = await NestFactory.create(AppModule)
+    } catch (createError: unknown) {
+      const createErr = createError as { message?: string; stack?: string; cause?: unknown }
+      console.error('Line: NestFactory.create(AppModule) failed')
+      console.error(`Create error message: ${createErr.message ?? 'unknown'}`)
+      console.error(`Create error stack: ${createErr.stack ?? 'no stack'}`)
+      if (createErr.cause) {
+        console.error(`Create error cause: ${String(createErr.cause)}`)
+      }
+      throw createError
+    }
+
+    Logger.setApplicationContext(app)
+    Logger.setLogstashUrl(logstashUrl)
+    logger.setContext('Bootstrap')
+    NestLogger.overrideLogger(logger)
+    Logger.log(`Loading app module from ${appModulePath}...`)
+
+    app.useLogger(logger)
+    const appPrefix = appConfig?.prefix ?? 'api'
+    app.setGlobalPrefix(appPrefix)
+    app.useGlobalInterceptors(new HeadersInterceptor())
+    app.useGlobalInterceptors(new LoggingInterceptor(configService))
+
+    useGlobalPipes(app, configService)
+    addSwagger(app, configService)
+    enableCors(app, configService)
+    useStaticAssets(app, configService)
+
+    const port = appConfig?.port ?? 3000
+
+    if (preHook) {
+      await preHook(app, configService, logger)
+    }
+
+    if (configService.get<Record<string, any>>('AMQP')) {
+      const amqpUrls = configService.get<string[]>('AMQP.urls') ?? []
+      const amqpQueue = configService.get<string>('AMQP.queue') ?? ''
+      app.connectMicroservice({
+        transport: Transport.RMQ,
+        options: {
+          urls: amqpUrls,
+          queue: amqpQueue,
+          prefetchCount: configService.get<number>('AMQP.prefetchCount') ?? 10,
+          isGlobalPrefetchCount: configService.get<boolean>('AMQP.isGlobalPrefetchCount') ?? false,
+          noAck: configService.get<boolean>('AMQP.noAck') ?? false,
+          queueOptions: {
+            durable: configService.get<boolean>('AMQP.queueOptions.durable'),
+            arguments: {
+              'x-message-ttl': configService.get<number>('AMQP.queueOptions.arguments.x-message-ttl'),
+              'x-dead-letter-exchange': configService.get<string>('AMQP.queueOptions.arguments.x-dead-letter-exchange'),
+              'x-dead-letter-routing-key': configService.get<string>('AMQP.queueOptions.arguments.x-dead-letter-routing-key'),
+            }
+          },
+          persistent: configService.get<boolean>('AMQP.queueOptions.persistent') ?? true,
+          exchange: configService.get<string>('AMQP.queueOptions.exchange') ?? '',
+          exchangeType: configService.get<string>('AMQP.queueOptions.exchangeType') ?? 'direct',
+          wildcards: (configService.get<string>('AMQP.queueOptions.exchangeType') ?? '') == 'topic' ? configService.get<string>('AMQP.queueOptions.exchangeType') ?? true : false,
+        },
+      })
+      await app.startAllMicroservices();
+      logger.log(`Transport.RMQ: Connected to queue: ${amqpQueue} in ${maskUrlsCredentials(amqpUrls)}`, 'Bootstrap')
+    }
+    await app.listen(port)
+
+    if (postHook) {
+      await postHook(app, configService, logger)
+    }
+
+    const appUrl = (await app.getUrl()).replace('[::1]', 'localhost')
+    const swaggerPrefix = configService.get<string>('swagger.prefix') ?? '/swagger'
+    Logger.log(`Application is running on: ${appUrl}/${appPrefix}`, 'Bootstrap')
+    logger.log(`Swagger is running on: ${appUrl}/${swaggerPrefix}`, 'Bootstrap')
+  } catch (error: unknown) {
+    const err = error as { code?: string; stack?: string }
+
+    if (err.code === 'MODULE_NOT_FOUND') {
+      console.error(
+        `Error in the bootstrap method. Cannot find module ${appModule}\nStack trace: ${err.stack}`,
+      )
+    } else {
+      console.error(
+        `Error in the bootstrap method. Terminating the application.\nStack trace: ${err.stack}`,
+      )
+    }
+    console.error(`Error details: ${JSON.stringify(error)}`)
+    process.exit(1)
+  }
+}
+
+function maskUrlsCredentials(urls: string[]): string[] {
+  return urls.map((url) =>
+    url.replace(/\/\/([^:@/\s]+)(:([^@/\s]*))?@/g, (_, username: string, __: string, password: string) => {
+      const maskedUsername = '*'.repeat(username.length)
+      if (password !== undefined) {
+        return `//${maskedUsername}:${'*'.repeat(password.length)}@`
+      }
+      return `//${maskedUsername}@`
+    }),
+  )
+}
+
+async function addSwagger(app: any, configService: ConfigService) {
+  const swaggerConfig = configService.get('swagger')
+
+  if (swaggerConfig) {
+    Logger.log(`Swagger is enabled`, 'Bootstrap')
+    const config = new DocumentBuilder()
+      .setTitle(configService.get<string>('swagger.title') ?? 'Undefined title API')
+      .setDescription(
+        configService.get<string>('swagger.description') ?? 'Undefined description API',
+      )
+      .setVersion(configService.get<string>('swagger.version') ?? 'Undefined version API')
+      .build()
+
+    const documentFactory = () => SwaggerModule.createDocument(app, config)
+
+    SwaggerModule.setup(
+      configService.get<string>('swagger.basePath') ?? '/swagger',
+      app,
+      documentFactory,
+      {
+        swaggerOptions: {
+          tagsSorter: 'alpha', // Ordena los controladores alfabéticamente
+        },
+      },
+    )
+  } else {
+    Logger.log(`Swagger is disabled`, 'Bootstrap')
+  }
+}
+
+function useGlobalPipes(app: any, configService: ConfigService) {
+  const globalPipes: PipeTransform[] = []
+
+  const validationPipeOptions = configService.get('validationPipe')
+  if (validationPipeOptions) {
+    // exceptionFactory
+
+    globalPipes.push(new AppValidationPipe(validationPipeOptions))
+    Logger.log(`Using ValidationPipe in useGlobalPipes()`, 'Bootstrap')
+  }
+
+  const parseIntPipeOptions = configService.get('parseIntPipe')
+  if (parseIntPipeOptions) {
+    globalPipes.push(new ParseIntPipe(parseIntPipeOptions))
+    Logger.log(`Using ParseIntPipe in useGlobalPipes()`, 'Bootstrap')
+  }
+
+  const parseArrayPipeOptions = configService.get('parseArrayPipe')
+  if (parseArrayPipeOptions) {
+    globalPipes.push(new ParseArrayPipe(parseArrayPipeOptions))
+    Logger.log(`Using ParseArrayPipe in useGlobalPipes()`, 'Bootstrap')
+  }
+
+  if (globalPipes.length > 0) {
+    app.useGlobalPipes(...globalPipes)
+    Logger.log(`Global Pipes are enabled`, 'Bootstrap')
+  }
+}
+
+function enableCors(app: any, configService: ConfigService) {
+  const corsOptions = configService.get<CorsOptions>('cors')
+
+  if (corsOptions) {
+    Logger.log(`CORS has been enabled per the configured settings.`, 'Bootstrap')
+    app.enableCors(corsOptions)
+  } else {
+    Logger.warn(`CORS has not been configured.`, 'Bootstrap')
+  }
+}
+
+function useStaticAssets(app: any, configService: ConfigService) {
+  const staticAssetsConfig = configService.get<{ path?: string }>('staticAssets')
+  if (staticAssetsConfig) {
+    const configPath = staticAssetsConfig.path ?? './public'
+    const staticPath = join(process.cwd(), configPath)
+    app.useStaticAssets(staticPath)
+    Logger.warn(`Static assets are being served from path: ${configPath}`, 'Bootstrap')
+  }
+}

package/libs/ms-sophia-framework-mysql/tsconfig.lib.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "declaration": true,
+    "outDir": "../../dist/libs/ms-sophia-framework-mysql"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test", "**/*spec.ts"]
+}

package/nest-cli.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://json.schemastore.org/nest-cli",
+  "collection": "@nestjs/schematics",
+  "sourceRoot": "src",
+  "compilerOptions": {
+    "deleteOutDir": true,
+    "webpack": true
+  },
+  "projects": {
+    "ms-sophia-framework-mysql": {
+      "type": "library",
+      "root": "libs/ms-sophia-framework-mysql",
+      "entryFile": "index",
+      "sourceRoot": "libs/ms-sophia-framework-mysql/src",
+      "compilerOptions": {
+        "tsConfigPath": "libs/ms-sophia-framework-mysql/tsconfig.lib.json"
+      }
+    }
+  }
+}

package/package.json

@@ -1,50 +1,31 @@
 {
   "name": "@jrosadob/ms-sophia-framework-mysql",
-  "version": "0.0.1",
-  "description": "Sophia Framework para microservicios en NestJS",
-  "main": "dist/core/index.js",
-  "files": [
-    "dist"
-  ],
-  "peerDependencies": {
-    "@nestjs/common": "^11.0.1"
-  },
-  "keywords": [
-    "nest",
-    "nestjs",
-    "sophia",
-    "framework",
-    "microservices"
-  ],
-  "author": {
-    "name": "Javier A. Rosado Baltazar",
-    "email": "jrosadob@hotmail.com"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "license": "MIT",
+  "version": "0.0.2",
+  "description": "",
+  "author": "",
+  "private": false,
+  "license": "UNLICENSED",
   "dependencies": {
     "@nestjs/common": "^11.0.1",
-    "@nestjs/config": "^4.0.2",
+    "@nestjs/config": "^4.0.4",
     "@nestjs/core": "^11.0.1",
-    "@nestjs/microservices": "^11.1.27",
+    "@nestjs/microservices": "^11.1.28",
     "@nestjs/platform-express": "^11.0.1",
-    "@nestjs/swagger": "^11.2.0",
-    "@nestjs/typeorm": "^11.0.0",
+    "@nestjs/swagger": "^11.4.6",
+    "@nestjs/typeorm": "^11.0.3",
     "amqp-connection-manager": "^5.0.0",
     "amqplib": "^2.0.1",
-    "axios": "^1.12.2",
+    "axios": "^1.18.1",
     "class-transformer": "^0.5.1",
-    "class-validator": "^0.14.2",
-    "dotenv": "^17.2.3",
+    "class-validator": "^0.15.1",
+    "dotenv": "^17.4.2",
     "js": "^0.1.0",
-    "js-yaml": "^4.1.0",
-    "mysql2": "^3.14.5",
-    "nanoid": "^5.1.5",
+    "js-yaml": "^5.2.2",
+    "mysql2": "^3.23.1",
+    "nanoid": "^6.0.0",
     "reflect-metadata": "^0.2.2",
     "rxjs": "^7.8.1",
-    "typeorm": "^0.3.26"
+    "typeorm": "^1.1.0"
   },
   "devDependencies": {
     "@eslint/eslintrc": "^3.2.0",
@@ -54,12 +35,12 @@
     "@nestjs/testing": "^11.0.1",
     "@types/express": "^5.0.0",
     "@types/jest": "^30.0.0",
-    "@types/node": "^22.10.7",
-    "@types/supertest": "^6.0.2",
+    "@types/node": "^24.0.0",
+    "@types/supertest": "^7.0.0",
     "eslint": "^9.18.0",
     "eslint-config-prettier": "^10.0.1",
     "eslint-plugin-prettier": "^5.2.2",
-    "globals": "^16.0.0",
+    "globals": "^17.0.0",
     "jest": "^30.0.0",
     "prettier": "^3.4.2",
     "source-map-support": "^0.5.21",
@@ -77,7 +58,7 @@
       "json",
       "ts"
     ],
-    "rootDir": "src",
+    "rootDir": ".",
     "testRegex": ".*\\.spec\\.ts$",
     "transform": {
       "^.+\\.(t|j)s$": "ts-jest"
@@ -85,12 +66,19 @@
     "collectCoverageFrom": [
       "**/*.(t|j)s"
     ],
-    "coverageDirectory": "../coverage",
-    "testEnvironment": "node"
+    "coverageDirectory": "./coverage",
+    "testEnvironment": "node",
+    "roots": [
+      "<rootDir>/src/",
+      "<rootDir>/libs/"
+    ],
+    "moduleNameMapper": {
+      "^@sophia/ms-sophia-framework-mysql(|/.*)$": "<rootDir>/libs/ms-sophia-framework-mysql/src/$1"
+    }
   },
   "scripts": {
     "build": "nest build",
-    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\" \"libs/**/*.ts\"",
     "start": "nest start",
     "start:dev": "nest start --watch",
     "start:debug": "nest start --debug --watch",

package/pnpm-workspace.yaml

@@ -0,0 +1,3 @@
+allowBuilds:
+  '@scarf/scarf': set this to true or false
+  unrs-resolver: set this to true or false

package/publish.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+# Requiere login
+# npm login
+
+# Version npm
+# npm run build
+# cd dist/
+# npm publish
+# cd ..
+
+# Requiere login
+# pnpm login
+
+# Version pnpm
+pnpm run build
+pnpm publish --no-git-checks
+cd ..

package/src/app.controller.spec.ts

@@ -0,0 +1,22 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
+
+describe('AppController', () => {
+  let appController: AppController;
+
+  beforeEach(async () => {
+    const app: TestingModule = await Test.createTestingModule({
+      controllers: [AppController],
+      providers: [AppService],
+    }).compile();
+
+    appController = app.get<AppController>(AppController);
+  });
+
+  describe('root', () => {
+    it('should return "Hello World!"', () => {
+      expect(appController.getHello()).toBe('Hello World!');
+    });
+  });
+});

package/src/app.controller.ts

@@ -0,0 +1,12 @@
+import { Controller, Get } from '@nestjs/common';
+import { AppService } from './app.service';
+
+@Controller()
+export class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get()
+  getHello(): string {
+    return this.appService.getHello();
+  }
+}

package/src/app.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
+
+@Module({
+  imports: [],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}

package/src/app.service.ts

@@ -0,0 +1,8 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class AppService {
+  getHello(): string {
+    return 'Hello World!';
+  }
+}

package/src/main.ts

@@ -0,0 +1,8 @@
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  await app.listen(process.env.PORT ?? 3000);
+}
+bootstrap();

package/test/app.e2e-spec.ts

@@ -0,0 +1,29 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { INestApplication } from '@nestjs/common';
+import request from 'supertest';
+import { App } from 'supertest/types';
+import { AppModule } from './../src/app.module';
+
+describe('AppController (e2e)', () => {
+  let app: INestApplication<App>;
+
+  beforeEach(async () => {
+    const moduleFixture: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    app = moduleFixture.createNestApplication();
+    await app.init();
+  });
+
+  it('/ (GET)', () => {
+    return request(app.getHttpServer())
+      .get('/')
+      .expect(200)
+      .expect('Hello World!');
+  });
+
+  afterEach(async () => {
+    await app.close();
+  });
+});

package/test/jest-e2e.json

@@ -0,0 +1,16 @@
+{
+  "moduleFileExtensions": [
+    "js",
+    "json",
+    "ts"
+  ],
+  "rootDir": ".",
+  "testEnvironment": "node",
+  "testRegex": ".e2e-spec.ts$",
+  "transform": {
+    "^.+\\.(t|j)s$": "ts-jest"
+  },
+  "moduleNameMapper": {
+    "^@sophia/ms-sophia-framework-mysql(|/.*)$": "<rootDir>/../libs/ms-sophia-framework-mysql/src/$1"
+  }
+}

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,33 @@
+{
+  "compilerOptions": {
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "resolvePackageJsonExports": true,
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "ES2023",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": true,
+    "forceConsistentCasingInFileNames": true,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "noFallthroughCasesInSwitch": false,
+    // "paths": {
+    //   "@sophia/ms-sophia-framework-mysql": [
+    //     "libs/ms-sophia-framework-mysql/src"
+    //   ],
+    //   "@sophia/ms-sophia-framework-mysql/*": [
+    //     "libs/ms-sophia-framework-mysql/src/*"
+    //   ]
+    // }
+  }
+}