xcally-nest-library 0.0.1

package/index.ts

@@ -0,0 +1,9 @@
+export * from './src/types';
+export * from './src/interceptors/log-request.interceptor';
+export * from './src/interceptors/serialize.interceptor';
+export * from './src/modules/logger/winston.service';
+export * from './src/modules/logger/winston.module';
+export * from './src/modules/tracer/tracer.module';
+export * from './src/db/typeorm/generic.repository';
+export * from './src/decorators/utils.decorators';
+export * from './src/config/env.validation';

package/nest-cli.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://json.schemastore.org/nest-cli",
+  "collection": "@nestjs/schematics",
+  "sourceRoot": "src",
+  "compilerOptions": {
+    "deleteOutDir": true
+  }
+}

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "xcally-nest-library",
+  "version": "0.0.1",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": "",
+  "license": "UNLICENSED",
+  "scripts": {
+    "prepublish": "pnpm build",
+    "build": "nest build",
+    "build:watch": "rimraf dist && tsc-watch -b -v",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "prettier:check": "prettier --check ./**/*.{ts,js,json,*rc}",
+    "prettier:write": "prettier --write ./**/*.{ts,js,json,*rc}",
+    "start": "nest start",
+    "start:dev": "nest start --watch",
+    "start:debug": "nest start --debug --watch",
+    "start:prod": "node dist/main",
+    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:cov": "jest --coverage",
+    "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
+    "test:e2e": "jest --config ./test/jest-e2e.json",
+    "link:lib": "pnpm link --global",
+    "unlink:lib": "pnpm unlink xcally-nest-libs"
+  },
+  "dependencies": {
+    "@nestjs/axios": "^3.0.2",
+    "@nestjs/common": "^10.3.7",
+    "@nestjs/config": "^3.2.2",
+    "@nestjs/core": "^10.3.7",
+    "@nestjs/microservices": "^10.3.7",
+    "@nestjs/platform-express": "^10.3.7",
+    "axios": "^1.6.8",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1",
+    "datadog-winston": "^1.6.0",
+    "nest-winston": "^1.9.4",
+    "nestjs-grpc-exceptions": "^0.2.2",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1",
+    "typeorm": "^0.3.20",
+    "winston": "^3.13.0",
+    "winston-elasticsearch": "^0.18.0"
+  },
+  "devDependencies": {
+    "@nestjs/cli": "^10.3.2",
+    "@nestjs/schematics": "^10.1.1",
+    "@nestjs/testing": "^10.3.7",
+    "@types/express": "^4.17.21",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.12.7",
+    "@types/supertest": "^6.0.2",
+    "@typescript-eslint/eslint-plugin": "^7.6.0",
+    "@typescript-eslint/parser": "^7.6.0",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "jest": "^29.7.0",
+    "prettier": "^3.2.5",
+    "source-map-support": "^0.5.21",
+    "supertest": "^6.3.4",
+    "ts-jest": "^29.1.2",
+    "ts-loader": "^9.5.1",
+    "ts-node": "^10.9.2",
+    "tsc-watch": "^6.2.0",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.4.5"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": "src",
+    "testRegex": ".*\\.spec\\.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "collectCoverageFrom": [
+      "**/*.(t|j)s"
+    ],
+    "coverageDirectory": "../coverage",
+    "testEnvironment": "node"
+  }
+}

package/src/config/env.validation.ts

@@ -0,0 +1,59 @@
+import { plainToClass } from 'class-transformer';
+import { IsEnum, IsNumber, IsBoolean, IsString, validateSync, NotContains } from 'class-validator';
+
+enum EnvironmentType {
+  Dev = 'development',
+  Prod = 'production',
+  Test = 'test',
+  Staging = 'staging',
+}
+
+class EnvironmentVariables {
+  @IsEnum(EnvironmentType)
+  NODE_ENV: EnvironmentType;
+
+  @IsString()
+  MYSQL_HOST: string;
+
+  @IsNumber()
+  MYSQL_PORT: number;
+
+  @IsString()
+  @NotContains(' ')
+  MYSQL_DATABASE: string;
+
+  @IsString()
+  MYSQL_USERNAME: string;
+
+  @IsString()
+  MYSQL_PASSWORD: string;
+
+  @IsBoolean()
+  MYSQL_SYNCHRONIZE: boolean;
+
+  @IsNumber()
+  HTTP_TIMEOUT: number;
+
+  @IsNumber()
+  HTTP_MAX_REDIRECTS: number;
+
+  @IsString()
+  BASE_MOTION_URL: string;
+
+  @IsString()
+  ACTOR_SERVICE_URL: string;
+}
+
+export function validate(configuration: Record<string, unknown>) {
+  const finalConfig = plainToClass(EnvironmentVariables, configuration, {
+    enableImplicitConversion: true,
+  });
+
+  const errors = validateSync(finalConfig, { skipMissingProperties: true });
+
+  if (errors.length > 0) {
+    throw new Error(errors.toString());
+  }
+
+  return finalConfig;
+}

package/src/db/typeorm/generic.repository.ts

@@ -0,0 +1,43 @@
+import { Repository, EntityTarget, EntityManager, Equal, FindOptionsWhere, ObjectLiteral, DeepPartial } from 'typeorm';
+import { Injectable } from '@nestjs/common';
+
+interface IId {
+  id: number;
+}
+
+interface IGenericRepository<E> {
+  save<T extends DeepPartial<E>>(entity: T): Promise<E>;
+  update<T extends DeepPartial<E> & IId>(entity: T): Promise<E>;
+  count(options: FindOptionsWhere<E>): Promise<number>;
+}
+
+@Injectable()
+export class GenericRepository<E extends ObjectLiteral> implements IGenericRepository<E> {
+  protected repository: Repository<E>;
+
+  constructor(
+    readonly entityManager: EntityManager,
+    entity: EntityTarget<E>,
+  ) {
+    this.repository = entityManager.getRepository(entity);
+  }
+  save<T extends DeepPartial<E>>(entity: T): Promise<E> {
+    const res = this.repository.create({ ...entity });
+    return this.repository.save(res);
+  }
+
+  async update<T extends DeepPartial<E> & IId>(dto: T): Promise<E> {
+    const entity = await this.repository.findOneBy({
+      id: Equal(dto.id),
+    } as unknown as FindOptionsWhere<E>);
+    if (!entity) {
+      throw new Error('Entity not found');
+    }
+    const entityUpdated = await this.repository.save({ id: entity.id, ...dto });
+    return Object.assign(entity, entityUpdated);
+  }
+
+  count(options: FindOptionsWhere<E>): Promise<number> {
+    return this.repository.count(options);
+  }
+}

package/src/decorators/utils.decorators.ts

@@ -0,0 +1,28 @@
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+
+/**
+ * Creates a parameter decorator that retrieves the metadata from the execution context.
+ *
+ * @param data - Additional data passed to the decorator (unused)
+ * @param ctx - The execution context
+ * @returns The metadata from the execution context
+ */
+export const GetMeta = createParamDecorator((data: unknown, ctx: ExecutionContext) => {
+  const context = ctx.switchToRpc();
+  return context.getContext();
+});
+
+/**
+ * Creates a parameter decorator that retrieves the trace ID from the execution context.
+ * The 'traceId' key should be used when setting this value in the metadata.
+ *
+ * @param data - Additional data passed to the decorator (unused)
+ * @param ctx - The execution context
+ * @returns The trace ID
+ */
+export const GetTraceId = createParamDecorator((data: unknown, ctx: ExecutionContext) => {
+  const context = ctx.switchToRpc();
+  const metadata = context.getContext();
+  const traceId = metadata.get('traceId')[0];
+  return traceId; // 'traceId' should match the key used when setting this value in metadata
+});

package/src/interceptors/log-request.interceptor.ts

@@ -0,0 +1,30 @@
+import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { tap } from 'rxjs/operators';
+import { WinstonLoggerService } from '../modules/logger/winston.service';
+// import { CustomLoggerService } from '../modules/logger/winston.service';
+@Injectable()
+export class LogRequestInterceptor implements NestInterceptor {
+  constructor(private readonly logger: WinstonLoggerService) {}
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    const req = context.switchToHttp().getRequest();
+    this.logger.info('Before Middleware...', {
+      traceId: req?.local?.traceId,
+      className: 'LogRequestInterceptor',
+    });
+    const now = Date.now();
+
+    if (req) {
+      const method = req.method;
+      const url = req.url;
+      return next.handle().pipe(
+        tap(() =>
+          this.logger.info(`After Middleware... ${method} ${url} ${Date.now() - now}ms`, {
+            traceId: req?.local?.traceId,
+            className: 'LogRequestInterceptor',
+          }),
+        ),
+      );
+    }
+  }
+}

package/src/interceptors/serialize.interceptor.ts

@@ -0,0 +1,27 @@
+import { UseInterceptors, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { plainToInstance } from 'class-transformer';
+
+interface ClassConstructor {
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  new (...args: any[]): {};
+}
+
+export function Serialize(dto: ClassConstructor) {
+  return UseInterceptors(new SerializeInterceptor(dto));
+}
+
+export class SerializeInterceptor implements NestInterceptor {
+  constructor(private dto: any) {}
+
+  intercept(context: ExecutionContext, handler: CallHandler): Observable<any> {
+    return handler.handle().pipe(
+      map((data: any) => {
+        return plainToInstance(this.dto, data, {
+          excludeExtraneousValues: true,
+        });
+      }),
+    );
+  }
+}

package/src/modules/logger/winston.decorator.ts

@@ -0,0 +1,14 @@
+export const TraceLog = () => {
+  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+    const originalMethod = descriptor.value;
+
+    descriptor.value = function (message: string, meta: any) {
+      const traceId = meta?.traceId || 'unknown-trace-id';
+      const className = meta.className;
+      meta = { ...meta, traceId, className };
+      originalMethod.call(this, message, meta);
+    };
+
+    return descriptor;
+  };
+};

package/src/modules/logger/winston.interface.ts

@@ -0,0 +1,22 @@
+import { ElasticsearchTransportOptions } from 'winston-elasticsearch';
+import { DatadogTransportOptions } from 'datadog-winston';
+export interface IWinstonLogger {
+  info(message: string, meta?: Record<string, any>): void;
+  error(message: string, meta?: Record<string, any>): void;
+  warn(message: string, meta?: Record<string, any>): void;
+  help(message: string, meta?: Record<string, any>): void;
+  data(message: string, meta?: Record<string, any>): void;
+  debug(message: string, meta?: Record<string, any>): void;
+  prompt(message: string, meta?: Record<string, any>): void;
+  http(message: string, meta?: Record<string, any>): void;
+  verbose(message: string, meta?: Record<string, any>): void;
+  input(message: string, meta?: Record<string, any>): void;
+  silly(message: string, meta?: Record<string, any>): void;
+}
+
+export interface WinstonLoggerModuleOptions {
+  transportFile?: boolean;
+  transportConsole?: boolean;
+  transportElasticsearch?: ElasticsearchTransportOptions;
+  transportDatadog?: DatadogTransportOptions;
+}

package/src/modules/logger/winston.module.ts

@@ -0,0 +1,105 @@
+// winston.module.ts
+import { Module, DynamicModule, Global } from '@nestjs/common';
+import { createLogger, transports, format, Logger } from 'winston';
+// import * as Elasticsearch from 'winston-elasticsearch';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { WinstonLoggerService } from './winston.service';
+import { ElasticsearchTransport } from 'winston-elasticsearch';
+import DatadogWinston = require('datadog-winston');
+
+const myFormat = format.printf(({ level = 'info', message, timestamp, err, ...metadata }) => {
+  return `${timestamp} [${level}]: ${message} ${err ? err.stack : ''} ${JSON.stringify(metadata)} `;
+});
+
+@Global()
+@Module({})
+export class WinstonModule {
+  static forRoot(): DynamicModule {
+    const winstonProvider = {
+      provide: 'WINSTON_LOGGER',
+      useFactory: (configService: ConfigService): Logger => {
+        const transportType = configService.getOrThrow<string>('LOG_TRANSPORTS');
+        // Split the string by commas and check if at least one entry exists.
+        const transportsArray = transportType.split(',');
+        if (transportsArray.length === 0 || transportsArray.every((item) => item.trim() === '')) {
+          throw new Error('LOG_TRANSPORTS must contain at least one transport method.');
+        }
+        const selectedTransport = [];
+        for (const iterator of transportsArray) {
+          if (iterator === 'elasticsearch') {
+            selectedTransport.push(
+              new ElasticsearchTransport({
+                clientOpts: {
+                  node: configService.getOrThrow<string>('ELASTICSEARCH_sURL'),
+                },
+              }),
+            );
+          }
+          if (iterator === 'datadog') {
+            selectedTransport.push(
+              new DatadogWinston({
+                apiKey: configService.getOrThrow<string>('DATADOG_APIKEY'),
+                hostname: configService.getOrThrow<string>('DATADOG_HOSTNAME'),
+                service: configService.getOrThrow<string>('DATADOG_SERVICE'), // 'service',
+                ddsource: configService.getOrThrow<string>('DATADOG_DDSOURCE'), // 'nodejs',
+                ddtags: configService.getOrThrow<string>('DATADOG_DDTAGS'), //'foo:bar,boo:baz',
+                intakeRegion: configService.getOrThrow<string>('DATADOG_INTAKEREGION'), // 'eu'
+              }),
+            );
+          }
+          if (iterator === 'file') {
+            selectedTransport.push(
+              new transports.File({
+                filename: 'logs/error.log',
+                level: 'error',
+                format: format.combine(format.timestamp(), format.json()),
+              }),
+              new transports.File({
+                filename: 'logs/combined.log',
+                format: format.combine(format.timestamp(), format.json(), myFormat),
+              }),
+            );
+          }
+          if (iterator === 'console') {
+            selectedTransport.push(
+              new transports.Console({
+                format: format.combine(
+                  format.colorize(),
+                  format.splat(),
+                  format.errors({ stack: true }),
+                  format.json(),
+                  format.timestamp({
+                    format: 'YYYY-MM-DD HH:mm:ss',
+                  }),
+                  myFormat,
+                ),
+              }),
+            );
+          }
+        }
+
+        return createLogger({
+          level: configService.get<string>('LOG_LEVEL') || 'info',
+          defaultMeta: {
+            service: configService.getOrThrow<string>('NAME_SERVICE'),
+          },
+          transports: selectedTransport,
+        });
+      },
+      inject: [ConfigService],
+    };
+
+    const loggerServiceProvider = {
+      provide: WinstonLoggerService,
+      useFactory: (logger: Logger) => new WinstonLoggerService(logger),
+      inject: ['WINSTON_LOGGER'],
+    };
+
+    return {
+      module: WinstonModule,
+      imports: [ConfigModule],
+      providers: [winstonProvider, loggerServiceProvider],
+      exports: [winstonProvider, loggerServiceProvider],
+    };
+  }
+}

package/src/modules/logger/winston.service.ts

@@ -0,0 +1,60 @@
+// winston-logger.service.ts
+import { Logger } from 'winston';
+import { IWinstonLogger } from './winston.interface';
+import { TraceLog } from './winston.decorator';
+
+export interface Meta {
+  traceId: string; // Ensures traceId is always present
+  className?: string;
+  methodName?: string;
+  [key: string]: any; // Allows for any number of additional properties
+}
+export class WinstonLoggerService implements IWinstonLogger {
+  constructor(private readonly logger: Logger) {}
+
+  @TraceLog()
+  info(message: string, meta: Meta): void {
+    this.logger.info(message, meta);
+  }
+  @TraceLog()
+  warn(message: string, meta: Meta): void {
+    this.logger.warn(message, meta);
+  }
+  @TraceLog()
+  help(message: string, meta: Meta): void {
+    this.logger.help(message, meta);
+  }
+  @TraceLog()
+  data(message: string, meta: Meta): void {
+    this.logger.data(message, meta);
+  }
+  @TraceLog()
+  debug(message: string, meta: Meta): void {
+    this.logger.debug(message, meta);
+  }
+  prompt(message: string, meta: Meta): void {
+    this.logger.prompt(message, meta);
+  }
+  @TraceLog()
+  http(message: string, meta: Meta): void {
+    this.logger.http(message, meta);
+  }
+  @TraceLog()
+  verbose(message: string, meta: Meta): void {
+    this.logger.verbose(message, meta);
+  }
+  @TraceLog()
+  input(message: string, meta: Meta): void {
+    this.logger.input(message, meta);
+  }
+  @TraceLog()
+  silly(message: string, meta: Meta): void {
+    this.logger.silly(message, meta);
+  }
+  @TraceLog()
+  error(message: string, meta: Meta): void {
+    this.logger.error(message, meta);
+  }
+
+  // Add other methods for different logging levels as needed
+}

package/src/modules/tracer/tracer.middleware.ts

@@ -0,0 +1,40 @@
+import { Inject, Injectable, NestMiddleware } from '@nestjs/common';
+import { randomUUID } from 'crypto';
+import { NextFunction, Request, Response } from 'express';
+export const X_REQUEST_ID_HEADER = 'X-Request-ID';
+export const X_RESPONSE_ID_HEADER = 'X-Response-ID';
+import { ConfigurableModuleBuilder } from '@nestjs/common';
+import { RouteInfo } from '@nestjs/common/interfaces';
+
+interface CtxLocal {
+  local: CtxLocalTraceID;
+}
+interface CtxLocalTraceID {
+  traceId: string;
+}
+type CtxLocalRequest = Request & CtxLocal;
+
+export interface TracingModuleOptions {
+  routes: (string | RouteInfo)[];
+  excludedRoutes?: (string | RouteInfo)[];
+  onRequest?(uuid: string, next: NextFunction): void;
+}
+
+export const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE, ASYNC_OPTIONS_TYPE } =
+  new ConfigurableModuleBuilder<TracingModuleOptions>().build();
+
+@Injectable()
+export class TracerMiddleware implements NestMiddleware {
+  constructor(
+    @Inject(MODULE_OPTIONS_TOKEN)
+    protected readonly options: typeof OPTIONS_TYPE,
+  ) {}
+
+  async use(req: CtxLocalRequest & CtxLocal, res: Response, next: NextFunction) {
+    const { onRequest = (_, next) => next() } = this.options;
+    const uuid = req.header(X_REQUEST_ID_HEADER) ?? randomUUID();
+    req.local = { traceId: uuid };
+    res.setHeader(X_RESPONSE_ID_HEADER, uuid);
+    onRequest(uuid, next);
+  }
+}

package/src/modules/tracer/tracer.module.ts

@@ -0,0 +1,18 @@
+import { Inject, MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
+import { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE, TracerMiddleware } from './tracer.middleware';
+
+@Module({})
+export class TracerModule extends ConfigurableModuleClass implements NestModule {
+  constructor(
+    @Inject(MODULE_OPTIONS_TOKEN)
+    protected readonly options: typeof OPTIONS_TYPE,
+  ) {
+    super();
+  }
+
+  configure(consumer: MiddlewareConsumer) {
+    const config = consumer.apply(TracerMiddleware);
+    if (this.options.excludedRoutes) config.exclude(...this.options.excludedRoutes);
+    config.forRoutes(...this.options.routes);
+  }
+}

package/src/types/auth.ts

@@ -0,0 +1,9 @@
+export type User = {
+  roles: ERoles[];
+  name: string;
+};
+
+export enum ERoles {
+  admin = 'admin',
+  user = 'user',
+}

package/src/types/index.ts

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

package/test/jest-e2e.json

@@ -0,0 +1,9 @@
+{
+  "moduleFileExtensions": ["js", "json", "ts"],
+  "rootDir": ".",
+  "testEnvironment": "node",
+  "testRegex": ".e2e-spec.ts$",
+  "transform": {
+    "^.+\\.(t|j)s$": "ts-jest"
+  }
+}

package/tsconfig.build.json

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

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "ES2021",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": false,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "forceConsistentCasingInFileNames": false,
+    "noFallthroughCasesInSwitch": false
+  }
+}