@21jumpclick/nestjs-tools 1.0.0

package/README.md

@@ -0,0 +1,138 @@
+# @21jumpclick/nestjs-tools
+
+Bibliothèque d'outils NestJS pour les projets 21JumpClick, avec un focus sur le logging et les utilitaires RMQ.
+
+## Installation
+
+```bash
+npm install @21jumpclick/nestjs-tools
+```
+
+## Utilisation
+
+### Logging Module
+
+Le module de logging fournit des fonctionnalités de logging avancées avec Pino et des utilitaires pour RabbitMQ.
+
+```typescript
+import { Module } from '@nestjs/common';
+import { LoggingModule } from '@21jumpclick/nestjs-tools';
+
+@Module({
+  imports: [
+    LoggingModule, // Module global - automatiquement disponible partout
+  ],
+})
+export class AppModule {}
+```
+
+### Logging Service
+
+Utilisez le service de logging pour enregistrer les messages RMQ et créer des clients avec logging intégré.
+
+```typescript
+import { Injectable } from '@nestjs/common';
+import { LoggingService } from '@21jumpclick/nestjs-tools';
+
+@Injectable()
+export class MyService {
+  constructor(private readonly loggingService: LoggingService) {}
+
+  async someMethod() {
+    // Logger un message RMQ entrant
+    this.loggingService.logRmqMessage('pattern.name', { data: 'example' });
+
+    // Logger un message RMQ sortant
+    this.loggingService.logRmqOutgoing('pattern.name', { data: 'example' }, {
+      durationMs: 150,
+      status: 'sent'
+    });
+  }
+}
+```
+
+### RMQ Module
+
+Module simplifié pour la configuration des clients RabbitMQ.
+
+```typescript
+import { Module } from '@nestjs/common';
+import { RmqModule } from '@21jumpclick/nestjs-tools';
+
+@Module({
+  imports: [
+    RmqModule.register({
+      name: 'MY_SERVICE',
+      urls: ['amqp://localhost:5672'],
+      queue: 'my_queue',
+      isGlobal: true,
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### Configuration RMQ Avancée
+
+```typescript
+import { Module } from '@nestjs/common';
+import { RmqModule } from '@21jumpclick/nestjs-tools';
+
+@Module({
+  imports: [
+    RmqModule.registerAsync({
+      name: 'MY_SERVICE',
+      useFactory: (configService: ConfigService) => ({
+        urls: configService.get('RMQ_URLS'),
+        queue: configService.get('MY_QUEUE'),
+        queueOptions: {
+          durable: true,
+        },
+        prefetchCount: 20,
+      }),
+      inject: [ConfigService],
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### Interceptors
+
+Interceptors pour le logging automatique des requêtes HTTP et messages RMQ.
+
+```typescript
+import { Module } from '@nestjs/common';
+import { APP_INTERCEPTOR } from '@nestjs/core';
+import { LoggingInterceptor } from '@21jumpclick/nestjs-tools';
+
+@Module({
+  providers: [
+    {
+      provide: APP_INTERCEPTOR,
+      useClass: LoggingInterceptor,
+    },
+  ],
+})
+export class AppModule {}
+```
+
+## Features
+
+- **Logging structuré** avec Pino
+- **Support RMQ** avec logging automatique
+- **Masquage des données sensibles** (passwords, tokens, etc.)
+- **Configuration flexible** pour différents environnements
+- **Interceptors** pour le logging automatique
+- **Types TypeScript** complets
+
+## Configuration
+
+Le module de logging utilise les variables d'environnement suivantes :
+
+- `NODE_ENV`: Détermine si le logging est en mode production ou développement
+- `APP_NAME`: Nom de l'application pour les headers RMQ
+
+## License
+
+UNLICENSED

package/dist/main.js

@@ -0,0 +1,13 @@
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it uses a non-standard name for the exports (exports).
+(() => {
+var exports = __webpack_exports__;
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+})();
+
+/******/ })()
+;

package/lefthook.yml

@@ -0,0 +1,42 @@
+# EXAMPLE USAGE:
+#
+#   Refer for explanation to following link:
+#   https://lefthook.dev/configuration/
+#
+# pre-push:
+#   jobs:
+#     - name: packages audit
+#       tags:
+#         - frontend
+#         - security
+#       run: yarn audit
+#
+#     - name: gems audit
+#       tags:
+#         - backend
+#         - security
+#       run: bundle audit
+#
+# pre-commit:
+#   parallel: true
+#   jobs:
+#     - run: yarn eslint {staged_files}
+#       glob: "*.{js,ts,jsx,tsx}"
+#
+#     - name: rubocop
+#       glob: "*.rb"
+#       exclude:
+#         - config/application.rb
+#         - config/routes.rb
+#       run: bundle exec rubocop --force-exclusion {all_files}
+#
+#     - name: govet
+#       files: git ls-files -m
+#       glob: "*.go"
+#       run: go vet {files}
+#
+#     - script: "hello.js"
+#       runner: node
+#
+#     - script: "hello.go"
+#       runner: go run

package/nest-cli.json

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

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@21jumpclick/nestjs-tools",
+  "version": "1.0.0",
+  "description": "NestJS tools library with logging and other utilities",
+  "author": "21JumpClick",
+  "license": "UNLICENSED",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "nest build",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "start": "nest start",
+    "start:dev": "nest build --webpack --webpackPath webpack-hmr.config.js --watch",
+    "start:debug": "nest start --debug --watch",
+    "start:prod": "node dist/main",
+    "lint": "npx @biomejs/biome check",
+    "lint:fix": "npx @biomejs/biome check --fix",
+    "prepublish": "npm run build"
+  },
+  "dependencies": {
+    "@nestjs/common": "^11.0.7",
+    "@nestjs/core": "^11.0.7",
+    "@nestjs/microservices": "^11.0.7",
+    "nestjs-pino": "^4.5.0",
+    "pino-http": "^11.0.0",
+    "pino-pretty": "^13.1.3",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@nestjs/cli": "^11.0.2",
+    "@nestjs/schematics": "^11.0.0",
+    "@swc/cli": "^0.6.0",
+    "@swc/core": "^1.10.12",
+    "@types/node": "^22.13.0",
+    "lefthook": "^1.10.10",
+    "run-script-webpack-plugin": "^0.2.0",
+    "source-map-support": "^0.5.21",
+    "ts-loader": "^9.5.2",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.7.3",
+    "webpack": "^5.97.1",
+    "webpack-node-externals": "^3.0.0"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^10.0.0 || ^11.0.0",
+    "@nestjs/core": "^10.0.0 || ^11.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './logging';
+export * from './rmq';
+export * from './interceptors';

package/src/interceptors/index.ts

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

package/src/interceptors/logging.interceptor.ts

@@ -0,0 +1,20 @@
+import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from "@nestjs/common";
+import { Observable } from "rxjs";
+import { tap } from "rxjs/operators";
+
+@Injectable()
+export class LoggingInterceptor implements NestInterceptor {
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    const startedAt = Date.now();
+    const request = context.switchToHttp().getRequest();
+    
+    console.log(`Incoming request: ${request.method} ${request.url}`);
+
+    return next.handle().pipe(
+      tap(() => {
+        const durationMs = Date.now() - startedAt;
+        console.log(`Request completed in ${durationMs}ms`);
+      })
+    );
+  }
+}

package/src/logging/index.ts

@@ -0,0 +1,3 @@
+export * from './logging.module';
+export * from './logging.service';
+export * from './rmq-client.interceptor';

package/src/logging/logging.module.ts

@@ -0,0 +1,43 @@
+import { Global, Module } from "@nestjs/common";
+import { LoggerModule } from "nestjs-pino";
+import { LoggingService } from "./logging.service";
+import { RmqClientInterceptor } from "./rmq-client.interceptor";
+
+export interface LoggingModuleOptions {
+  pinoHttp?: any;
+}
+
+@Global()
+@Module({
+  imports: [
+    LoggerModule.forRoot({
+      pinoHttp: {
+        formatters: {
+          level: (label) => ({ level: label.toUpperCase() }),
+        },
+        genReqId: (req) => req.headers["x-request-id"] || crypto.randomUUID(),
+        transport:
+          process.env.NODE_ENV !== "production"
+            ? {
+                target: "pino-pretty",
+                options: {
+                  colorize: true,
+                  levelFirst: true,
+                  translateTime: "HH:MM:ss",
+                  messageFormat: "{context}: {msg}",
+                  ignore: "pid,hostname",
+                },
+              }
+            : undefined,
+        redact: [
+          "req.headers.authorization",
+          "req.body.password",
+          "res.headers.cookie",
+        ],
+      },
+    }),
+  ],
+  providers: [LoggingService, RmqClientInterceptor],
+  exports: [LoggingService, LoggerModule],
+})
+export class LoggingModule {}

package/src/logging/logging.service.ts

@@ -0,0 +1,223 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { ClientProxy, MicroserviceOptions, Transport } from "@nestjs/microservices";
+import { catchError, finalize, Observable, throwError } from "rxjs";
+
+@Injectable()
+export class LoggingService {
+  private readonly rmqLogger = new Logger("RMQ-Traffic");
+
+  logRmqMessage(pattern: string, data: any) {
+    const logData = {
+      transport: "RMQ_IN",
+      pattern,
+      data: this.sanitizeData(data),
+      duration: "0ms",
+      status: "received",
+    };
+
+    this.rmqLogger.log(logData);
+  }
+
+  logRmqOutgoing(
+    pattern: string,
+    data: any,
+    options?: {
+      durationMs?: number;
+      status?: "sent" | "error";
+      error?: unknown;
+    },
+  ) {
+    const logData = {
+      transport: "RMQ_OUT",
+      pattern,
+      data: this.sanitizeData(data),
+      duration:
+        typeof options?.durationMs === "number"
+          ? `${options.durationMs}ms`
+          : "0ms",
+      status: options?.status ?? "sent",
+      ...(options?.error ? { error: this.sanitizeData(options.error) } : {}),
+    };
+
+    this.rmqLogger.log(logData);
+  }
+
+  createLoggedClientProxy(client: ClientProxy, clientName: string): ClientProxy {
+    const logging = this;
+
+    const wrapper: Partial<ClientProxy> = {
+      send<TResult = any, TInput = any>(pattern: any, data: TInput): Observable<TResult> {
+        const startedAt = Date.now();
+        let hadError = false;
+
+        return client.send<TResult, TInput>(pattern, data).pipe(
+          catchError((err) => {
+            hadError = true;
+            const durationMs = Date.now() - startedAt;
+            logging.logRmqOutgoing(`${clientName}:${logging.patternToString(pattern)}`, data, {
+              durationMs,
+              status: "error",
+              error: err,
+            });
+            return throwError(() => err);
+          }),
+          finalize(() => {
+            const durationMs = Date.now() - startedAt;
+            if (!hadError) {
+              logging.logRmqOutgoing(`${clientName}:${logging.patternToString(pattern)}`, data, {
+                durationMs,
+                status: "sent",
+              });
+            }
+          }),
+        );
+      },
+
+      emit<TResult = any, TInput = any>(pattern: any, data: TInput): Observable<TResult> {
+        const startedAt = Date.now();
+        let hadError = false;
+
+        logging.logRmqOutgoing(`${clientName}:${logging.patternToString(pattern)}`, data, {
+          status: "sent",
+        });
+
+        return client.emit<TResult, TInput>(pattern, data).pipe(
+          catchError((err) => {
+            hadError = true;
+            const durationMs = Date.now() - startedAt;
+            logging.logRmqOutgoing(`${clientName}:${logging.patternToString(pattern)}`, data, {
+              durationMs,
+              status: "error",
+              error: err,
+            });
+            return throwError(() => err);
+          }),
+        );
+      },
+
+      connect(): Promise<any> {
+        return client.connect();
+      },
+      close(): any {
+        return client.close();
+      },
+    };
+
+    return new Proxy(client as any, {
+      get(target, prop, receiver) {
+        if (prop in wrapper) {
+          const v = (wrapper as any)[prop];
+          return typeof v === "function" ? v.bind(receiver) : v;
+        }
+        const value = Reflect.get(target, prop, receiver);
+        return typeof value === "function" ? value.bind(target) : value;
+      },
+    }) as ClientProxy;
+  }
+
+  createRmqMicroservice(options: {
+    urls: string[];
+    queue: string;
+    queueOptions?: { durable?: boolean };
+    customDeserializer?: boolean;
+  }): MicroserviceOptions {
+    return {
+      transport: Transport.RMQ,
+      options: {
+        urls: options.urls,
+        queue: options.queue,
+        queueOptions: {
+          durable: true,
+          ...options.queueOptions,
+        },
+        ...(options.customDeserializer && {
+          deserializer: {
+            deserialize: (value: any) => {
+              const pattern =
+                typeof value === "object" && !value.pattern
+                  ? options.queue
+                  : value?.pattern || "unknown";
+              const data = value?.data || value;
+
+              this.logRmqMessage(pattern, data);
+
+              if (typeof value === "object" && !value.pattern) {
+                return { pattern: options.queue, data: value };
+              }
+              return value;
+            },
+          },
+        }),
+      },
+    };
+  }
+
+  createRmqClient(name: string, urls: string[], queue: string): any {
+    return {
+      name,
+      transport: Transport.RMQ,
+      options: {
+        urls,
+        queue,
+        queueOptions: {
+          durable: true,
+        },
+        headers: {
+          origin: process.env.APP_NAME || "unknown",
+        },
+      },
+      serializer: {
+        serialize: (value: any) => {
+          this.logRmqOutgoing(queue, value);
+          return value;
+        },
+      },
+    };
+  }
+
+  private patternToString(pattern: any): string {
+    if (typeof pattern === "string") return pattern;
+    if (typeof pattern === "number") return pattern.toString();
+    try {
+      return JSON.stringify(pattern);
+    } catch {
+      return "[unserializable-pattern]";
+    }
+  }
+
+  private sanitizeData(data: any): any {
+    if (!data) return null;
+
+    const sanitized = JSON.parse(JSON.stringify(data));
+    const sensitiveKeys = [
+      "password",
+      "token",
+      "secret",
+      "key",
+      "authorization",
+    ];
+
+    const maskSensitive = (obj: any): any => {
+      if (typeof obj !== "object" || obj === null) return obj;
+
+      if (Array.isArray(obj)) {
+        return obj.map(maskSensitive);
+      }
+
+      const result: any = {};
+      for (const [key, value] of Object.entries(obj)) {
+        const lowerKey = key.toLowerCase();
+        if (sensitiveKeys.some((sensitive) => lowerKey.includes(sensitive))) {
+          result[key] = "[MASKED]";
+        } else if (typeof value === "object") {
+          result[key] = maskSensitive(value);
+        } else {
+          result[key] = value;
+        }
+      }
+      return result;
+    };
+
+    return maskSensitive(sanitized);
+  }
+}

package/src/logging/rmq-client.interceptor.ts

@@ -0,0 +1,27 @@
+import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from "@nestjs/common";
+import { Observable } from "rxjs";
+import { tap } from "rxjs/operators";
+import { LoggingService } from "../logging/logging.service";
+
+@Injectable()
+export class RmqClientInterceptor implements NestInterceptor {
+  constructor(private readonly loggingService: LoggingService) {}
+
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    const startedAt = Date.now();
+    const pattern = context.getPattern();
+    const data = context.getArgByIndex(0);
+
+    this.loggingService.logRmqMessage(
+      typeof pattern === "string" ? pattern : JSON.stringify(pattern),
+      data
+    );
+
+    return next.handle().pipe(
+      tap(() => {
+        const durationMs = Date.now() - startedAt;
+        console.log(`RMQ message processed in ${durationMs}ms`);
+      })
+    );
+  }
+}

package/src/rmq/index.ts

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

package/src/rmq/rmq.module.ts

@@ -0,0 +1,87 @@
+import { Module } from "@nestjs/common";
+import { ClientsModule, Transport } from "@nestjs/microservices";
+import { LoggingService } from "../logging/logging.service";
+
+export interface RmqModuleOptions {
+  name: string;
+  urls: string[];
+  queue: string;
+  queueOptions?: { durable?: boolean };
+  noAck?: boolean;
+  prefetchCount?: number;
+  isGlobal?: boolean;
+}
+
+@Module({})
+export class RmqModule {
+  static register(options: RmqModuleOptions) {
+    const moduleOptions = {
+      name: options.name,
+      transport: Transport.RMQ,
+      options: {
+        urls: options.urls,
+        queue: options.queue,
+        queueOptions: {
+          durable: true,
+          ...options.queueOptions,
+        },
+        noAck: options.noAck ?? false,
+        prefetchCount: options.prefetchCount ?? 10,
+        headers: {
+          origin: process.env.APP_NAME || "unknown",
+        },
+      },
+    };
+
+    const module = ClientsModule.register([moduleOptions]);
+
+    if (options.isGlobal) {
+      return {
+        ...module,
+        global: true,
+      };
+    }
+
+    return module;
+  }
+
+  static registerAsync(options: RmqModuleOptions & {
+    useFactory: (...args: any[]) => Promise<RmqModuleOptions> | RmqModuleOptions;
+    inject?: any[];
+  }) {
+    const asyncOptions = {
+      name: options.name,
+      useFactory: async (...args: any[]) => {
+        const factoryOptions = await options.useFactory(...args);
+        return {
+          transport: Transport.RMQ,
+          options: {
+            urls: factoryOptions.urls,
+            queue: factoryOptions.queue,
+            queueOptions: {
+              durable: true,
+              ...factoryOptions.queueOptions,
+            },
+            noAck: factoryOptions.noAck ?? false,
+            prefetchCount: factoryOptions.prefetchCount ?? 10,
+            headers: {
+              origin: process.env.APP_NAME || "unknown",
+            },
+          },
+        };
+      },
+      inject: options.inject || [],
+    };
+
+    const module = ClientsModule.registerAsync([asyncOptions]);
+
+    if (options.isGlobal) {
+      return {
+        ...module,
+        global: true,
+      };
+    }
+
+    return module;
+  }
+}

package/src/rmq/rmq.service.ts

@@ -0,0 +1,25 @@
+import { Injectable } from "@nestjs/common";
+import { ClientProxy } from "@nestjs/microservices";
+import { LoggingService } from "../logging/logging.service";
+
+@Injectable()
+export class RmqService {
+  constructor(private readonly loggingService: LoggingService) {}
+
+  createLoggedClientProxy(client: ClientProxy, clientName: string): ClientProxy {
+    return this.loggingService.createLoggedClientProxy(client, clientName);
+  }
+
+  createRmqClient(name: string, urls: string[], queue: string): any {
+    return this.loggingService.createRmqClient(name, urls, queue);
+  }
+
+  createRmqMicroservice(options: {
+    urls: string[];
+    queue: string;
+    queueOptions?: { durable?: boolean };
+    customDeserializer?: boolean;
+  }) {
+    return this.loggingService.createRmqMicroservice(options);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "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,
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "exclude": ["node_modules", "dist"]
+}

package/webpack.config.js

@@ -0,0 +1,24 @@
+const path = require('path');
+
+module.exports = (options, webpack) => {
+  const lazyImports = [
+    '@nestjs/microservices',
+    '@nestjs/websockets',
+    'cache-manager',
+    'class-validator',
+    'class-transformer',
+  ];
+
+  return {
+    ...options,
+    externals: [],
+    plugins: [
+      ...options.plugins,
+      new webpack.IgnorePlugin({
+        checkResource(resource) {
+          return lazyImports.includes(resource);
+        },
+      }),
+    ],
+  };
+};