create-forgeon 0.3.4 → 0.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-forgeon",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "Forgeon project generator CLI",
   "license": "MIT",
   "author": "Forgeon",

package/src/modules/executor.test.mjs

@@ -572,10 +572,9 @@ describe('addModule', () => {
 
       const mainTs = fs.readFileSync(path.join(projectRoot, 'apps', 'api', 'src', 'main.ts'), 'utf8');
       assert.match(mainTs, /ForgeonLoggerService/);
-      assert.match(mainTs, /ForgeonHttpLoggingInterceptor/);
       assert.match(mainTs, /bufferLogs: true/);
       assert.match(mainTs, /app\.useLogger\(app\.get\(ForgeonLoggerService\)\);/);
-      assert.match(mainTs, /app\.useGlobalInterceptors\(app\.get\(ForgeonHttpLoggingInterceptor\)\);/);
+      assert.doesNotMatch(mainTs, /useGlobalInterceptors/);
 
       const apiDockerfile = fs.readFileSync(
         path.join(projectRoot, 'apps', 'api', 'Dockerfile'),
@@ -591,6 +590,13 @@ describe('addModule', () => {
       );
       assert.match(loggerTsconfig, /"extends": "\.\.\/\.\.\/tsconfig\.base\.node\.json"/);
 
+      const loggerModule = fs.readFileSync(
+        path.join(projectRoot, 'packages', 'logger', 'src', 'forgeon-logger.module.ts'),
+        'utf8',
+      );
+      assert.match(loggerModule, /ForgeonHttpLoggingMiddleware/);
+      assert.match(loggerModule, /consumer\.apply\(RequestIdMiddleware, ForgeonHttpLoggingMiddleware\)\.forRoutes\('\*'\);/);
+
       const apiEnv = fs.readFileSync(path.join(projectRoot, 'apps', 'api', '.env.example'), 'utf8');
       assert.match(apiEnv, /LOGGER_LEVEL=log/);
       assert.match(apiEnv, /LOGGER_HTTP_ENABLED=true/);
@@ -957,7 +963,7 @@ describe('addModule', () => {
 
       const mainTs = fs.readFileSync(path.join(projectRoot, 'apps', 'api', 'src', 'main.ts'), 'utf8');
       assert.match(mainTs, /ForgeonLoggerService/);
-      assert.match(mainTs, /ForgeonHttpLoggingInterceptor/);
+      assert.doesNotMatch(mainTs, /ForgeonHttpLoggingInterceptor/);
     } finally {
       fs.rmSync(targetRoot, { recursive: true, force: true });
     }
@@ -1058,7 +1064,7 @@ describe('addModule', () => {
       const mainTs = fs.readFileSync(path.join(projectRoot, 'apps', 'api', 'src', 'main.ts'), 'utf8');
       assert.match(mainTs, /setupSwagger\(app,\s*swaggerConfigService\)/);
       assert.match(mainTs, /app\.useLogger\(app\.get\(ForgeonLoggerService\)\);/);
-      assert.match(mainTs, /app\.useGlobalInterceptors\(app\.get\(ForgeonHttpLoggingInterceptor\)\);/);
+      assert.doesNotMatch(mainTs, /useGlobalInterceptors/);
 
       const apiPackage = fs.readFileSync(path.join(projectRoot, 'apps', 'api', 'package.json'), 'utf8');
       assert.match(apiPackage, /@forgeon\/swagger/);

package/src/modules/logger.mjs

@@ -44,10 +44,14 @@ function patchMain(targetRoot) {
   }
 
   let content = fs.readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n');
+  content = content.replace(
+    "import { ForgeonHttpLoggingInterceptor, ForgeonLoggerService } from '@forgeon/logger';",
+    "import { ForgeonLoggerService } from '@forgeon/logger';",
+  );
   content = ensureLineBefore(
     content,
     "import { NestFactory } from '@nestjs/core';",
-    "import { ForgeonHttpLoggingInterceptor, ForgeonLoggerService } from '@forgeon/logger';",
+    "import { ForgeonLoggerService } from '@forgeon/logger';",
   );
 
   content = content.replace(
@@ -55,12 +59,16 @@ function patchMain(targetRoot) {
     'const app = await NestFactory.create(AppModule, { bufferLogs: true });',
   );
 
+  content = content.replace(
+    /\n\s*app\.useGlobalInterceptors\(app\.get\(ForgeonHttpLoggingInterceptor\)\);\s*/g,
+    '\n',
+  );
+
   if (!content.includes('app.useLogger(app.get(ForgeonLoggerService));')) {
     content = content.replace(
       '  const coreConfigService = app.get(CoreConfigService);',
       `  const coreConfigService = app.get(CoreConfigService);
-  app.useLogger(app.get(ForgeonLoggerService));
-  app.useGlobalInterceptors(app.get(ForgeonHttpLoggingInterceptor));`,
+  app.useLogger(app.get(ForgeonLoggerService));`,
     );
   }
 
@@ -179,6 +187,7 @@ function patchReadme(targetRoot) {
 The logger add-module provides:
 - request id middleware (default header: \`x-request-id\`)
 - HTTP access logs with method/path/status/duration/ip/requestId
+- HTTP access logs are emitted from middleware, so requests rejected by guards (for example 429 from rate-limit) are still logged
 - Nest logger integration via \`app.useLogger(...)\`
 
 It installs independently and intentionally does not add a dedicated API/web probe.

package/templates/module-presets/logger/packages/logger/src/forgeon-logger.module.ts

@@ -1,17 +1,16 @@
 import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
-import { ForgeonHttpLoggingInterceptor } from './http-logging.interceptor';
+import { ForgeonHttpLoggingMiddleware } from './http-logging.middleware';
 import { ForgeonLoggerService } from './forgeon-logger.service';
 import { LoggerConfigModule } from './logger-config.module';
 import { RequestIdMiddleware } from './request-id.middleware';
 
 @Module({
   imports: [LoggerConfigModule],
-  providers: [RequestIdMiddleware, ForgeonLoggerService, ForgeonHttpLoggingInterceptor],
-  exports: [LoggerConfigModule, ForgeonLoggerService, ForgeonHttpLoggingInterceptor],
+  providers: [RequestIdMiddleware, ForgeonHttpLoggingMiddleware, ForgeonLoggerService],
+  exports: [LoggerConfigModule, ForgeonLoggerService],
 })
 export class ForgeonLoggerModule implements NestModule {
   configure(consumer: MiddlewareConsumer): void {
-    consumer.apply(RequestIdMiddleware).forRoutes('*');
+    consumer.apply(RequestIdMiddleware, ForgeonHttpLoggingMiddleware).forRoutes('*');
   }
 }
-

package/templates/module-presets/logger/packages/logger/src/http-logging.middleware.ts

@@ -0,0 +1,74 @@
+import { Injectable, NestMiddleware } from '@nestjs/common';
+import { ForgeonLoggerService } from './forgeon-logger.service';
+import { LoggerConfigService } from './logger-config.service';
+
+type HeaderValue = string | string[] | undefined;
+type HeadersRecord = Record<string, HeaderValue>;
+
+interface RequestLike {
+  method?: string;
+  originalUrl?: string;
+  url?: string;
+  ip?: string;
+  requestId?: string;
+  headers?: HeadersRecord;
+}
+
+interface ResponseLike {
+  statusCode?: number;
+  once?: (event: string, listener: () => void) => void;
+}
+
+type NextFunction = () => void;
+
+@Injectable()
+export class ForgeonHttpLoggingMiddleware implements NestMiddleware {
+  constructor(
+    private readonly logger: ForgeonLoggerService,
+    private readonly loggerConfig: LoggerConfigService,
+  ) {}
+
+  use(request: RequestLike, response: ResponseLike, next: NextFunction): void {
+    if (!this.loggerConfig.httpEnabled) {
+      next();
+      return;
+    }
+
+    const method = request.method ?? 'UNKNOWN';
+    const path = request.originalUrl ?? request.url ?? '/';
+    const ip = request.ip;
+    const requestId =
+      request.requestId ?? this.readHeader(request.headers, this.loggerConfig.requestIdHeader);
+    const startedAt = Date.now();
+
+    if (typeof response.once === 'function') {
+      response.once('finish', () => {
+        this.logger.logHttpRequest({
+          method,
+          path,
+          statusCode: response.statusCode ?? 200,
+          durationMs: Date.now() - startedAt,
+          requestId,
+          ip,
+        });
+      });
+    }
+
+    next();
+  }
+
+  private readHeader(headers: HeadersRecord | undefined, name: string): string | undefined {
+    if (!headers) {
+      return undefined;
+    }
+
+    const value = headers[name.toLowerCase()];
+    if (typeof value === 'string' && value.trim().length > 0) {
+      return value;
+    }
+    if (Array.isArray(value) && typeof value[0] === 'string' && value[0].trim().length > 0) {
+      return value[0];
+    }
+    return undefined;
+  }
+}

package/templates/module-presets/logger/packages/logger/src/index.ts

@@ -3,7 +3,7 @@ export * from './logger-config.loader';
 export * from './logger-config.service';
 export * from './logger-config.module';
 export * from './forgeon-logger.service';
+export * from './http-logging.middleware';
 export * from './http-logging.interceptor';
 export * from './request-id.middleware';
 export * from './forgeon-logger.module';
-