create-forgeon 0.1.29 → 0.1.30

package/package.json

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

package/src/modules/executor.mjs

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { ensureModuleExists } from './registry.mjs';
 import { writeModuleDocs } from './docs.mjs';
 import { applyI18nModule } from './i18n.mjs';
+import { applyLoggerModule } from './logger.mjs';
 
 function ensureForgeonLikeProject(targetRoot) {
   const requiredPaths = [
@@ -22,6 +23,7 @@ function ensureForgeonLikeProject(targetRoot) {
 
 const MODULE_APPLIERS = {
   i18n: applyI18nModule,
+  logger: applyLoggerModule,
 };
 
 export function applyModulePreset({ moduleId, targetRoot, packageRoot }) {

package/src/modules/executor.test.mjs

@@ -243,4 +243,85 @@ describe('addModule', () => {
       fs.rmSync(targetRoot, { recursive: true, force: true });
     }
   });
+
+  it('applies logger module on top of scaffold without i18n', () => {
+    const targetRoot = mkTmp('forgeon-module-logger-');
+    const projectRoot = path.join(targetRoot, 'demo-logger');
+    const templateRoot = path.join(packageRoot, 'templates', 'base');
+
+    try {
+      scaffoldProject({
+        templateRoot,
+        packageRoot,
+        targetRoot: projectRoot,
+        projectName: 'demo-logger',
+        frontend: 'react',
+        db: 'prisma',
+        i18nEnabled: false,
+        proxy: 'caddy',
+      });
+
+      const result = addModule({
+        moduleId: 'logger',
+        targetRoot: projectRoot,
+        packageRoot,
+      });
+
+      assert.equal(result.applied, true);
+      assert.match(result.message, /applied/);
+      assert.equal(
+        fs.existsSync(path.join(projectRoot, 'packages', 'logger', 'package.json')),
+        true,
+      );
+
+      const apiPackage = fs.readFileSync(path.join(projectRoot, 'apps', 'api', 'package.json'), 'utf8');
+      assert.match(apiPackage, /@forgeon\/logger/);
+      assert.match(apiPackage, /pnpm --filter @forgeon\/logger build/);
+
+      const appModule = fs.readFileSync(path.join(projectRoot, 'apps', 'api', 'src', 'app.module.ts'), 'utf8');
+      assert.match(appModule, /@forgeon\/logger/);
+      assert.match(appModule, /loggerConfig/);
+      assert.match(appModule, /loggerEnvSchema/);
+      assert.match(appModule, /ForgeonLoggerModule/);
+
+      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\)\);/);
+
+      const apiDockerfile = fs.readFileSync(
+        path.join(projectRoot, 'apps', 'api', 'Dockerfile'),
+        'utf8',
+      );
+      assert.match(apiDockerfile, /COPY packages\/logger\/package\.json packages\/logger\/package\.json/);
+      assert.match(apiDockerfile, /COPY packages\/logger packages\/logger/);
+      assert.match(apiDockerfile, /RUN pnpm --filter @forgeon\/logger build/);
+
+      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/);
+      assert.match(apiEnv, /LOGGER_REQUEST_ID_HEADER=x-request-id/);
+
+      const dockerEnv = fs.readFileSync(
+        path.join(projectRoot, 'infra', 'docker', '.env.example'),
+        'utf8',
+      );
+      assert.match(dockerEnv, /LOGGER_LEVEL=log/);
+      assert.match(dockerEnv, /LOGGER_HTTP_ENABLED=true/);
+      assert.match(dockerEnv, /LOGGER_REQUEST_ID_HEADER=x-request-id/);
+
+      const compose = fs.readFileSync(path.join(projectRoot, 'infra', 'docker', 'compose.yml'), 'utf8');
+      assert.match(compose, /LOGGER_LEVEL: \$\{LOGGER_LEVEL\}/);
+      assert.match(compose, /LOGGER_HTTP_ENABLED: \$\{LOGGER_HTTP_ENABLED\}/);
+      assert.match(compose, /LOGGER_REQUEST_ID_HEADER: \$\{LOGGER_REQUEST_ID_HEADER\}/);
+
+      const moduleDoc = fs.readFileSync(result.docsPath, 'utf8');
+      assert.match(moduleDoc, /Logger/);
+      assert.match(moduleDoc, /Status: implemented/);
+    } finally {
+      fs.rmSync(targetRoot, { recursive: true, force: true });
+    }
+  });
 });

package/src/modules/logger.mjs

@@ -0,0 +1,241 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { copyRecursive, writeJson } from '../utils/fs.mjs';
+
+function copyFromPreset(packageRoot, targetRoot, relativePath) {
+  const source = path.join(packageRoot, 'templates', 'module-presets', 'logger', relativePath);
+  if (!fs.existsSync(source)) {
+    throw new Error(`Missing logger preset template: ${source}`);
+  }
+  const destination = path.join(targetRoot, relativePath);
+  copyRecursive(source, destination);
+}
+
+function ensureDependency(packageJson, name, version) {
+  if (!packageJson.dependencies) {
+    packageJson.dependencies = {};
+  }
+  packageJson.dependencies[name] = version;
+}
+
+function ensureLineAfter(content, anchorLine, lineToInsert) {
+  if (content.includes(lineToInsert)) {
+    return content;
+  }
+
+  const index = content.indexOf(anchorLine);
+  if (index < 0) {
+    return `${content.trimEnd()}\n${lineToInsert}\n`;
+  }
+
+  const insertAt = index + anchorLine.length;
+  return `${content.slice(0, insertAt)}\n${lineToInsert}${content.slice(insertAt)}`;
+}
+
+function ensureLineBefore(content, anchorLine, lineToInsert) {
+  if (content.includes(lineToInsert)) {
+    return content;
+  }
+
+  const index = content.indexOf(anchorLine);
+  if (index < 0) {
+    return `${content.trimEnd()}\n${lineToInsert}\n`;
+  }
+
+  return `${content.slice(0, index)}${lineToInsert}\n${content.slice(index)}`;
+}
+
+function upsertEnvLines(filePath, lines) {
+  let content = '';
+  if (fs.existsSync(filePath)) {
+    content = fs.readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n');
+  }
+
+  const keys = new Set(
+    content
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => line.split('=')[0]),
+  );
+
+  const append = [];
+  for (const line of lines) {
+    const key = line.split('=')[0];
+    if (!keys.has(key)) {
+      append.push(line);
+    }
+  }
+
+  const next =
+    append.length > 0 ? `${content.trimEnd()}\n${append.join('\n')}\n` : `${content.trimEnd()}\n`;
+  fs.writeFileSync(filePath, next.replace(/^\n/, ''), 'utf8');
+}
+
+function patchApiPackage(targetRoot) {
+  const packagePath = path.join(targetRoot, 'apps', 'api', 'package.json');
+  if (!fs.existsSync(packagePath)) {
+    return;
+  }
+
+  const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+  if (!packageJson.scripts) {
+    packageJson.scripts = {};
+  }
+
+  const loggerBuild = 'pnpm --filter @forgeon/logger build';
+  const currentPredev = packageJson.scripts.predev;
+  if (typeof currentPredev === 'string') {
+    if (!currentPredev.includes(loggerBuild)) {
+      if (currentPredev.includes('pnpm --filter @forgeon/core build')) {
+        packageJson.scripts.predev = currentPredev.replace(
+          'pnpm --filter @forgeon/core build',
+          `pnpm --filter @forgeon/core build && ${loggerBuild}`,
+        );
+      } else {
+        packageJson.scripts.predev = `${loggerBuild} && ${currentPredev}`;
+      }
+    }
+  } else {
+    packageJson.scripts.predev = loggerBuild;
+  }
+
+  ensureDependency(packageJson, '@forgeon/logger', 'workspace:*');
+  writeJson(packagePath, packageJson);
+}
+
+function patchMain(targetRoot) {
+  const filePath = path.join(targetRoot, 'apps', 'api', 'src', 'main.ts');
+  if (!fs.existsSync(filePath)) {
+    return;
+  }
+
+  let content = fs.readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n');
+  content = ensureLineBefore(
+    content,
+    "import { NestFactory } from '@nestjs/core';",
+    "import { ForgeonHttpLoggingInterceptor, ForgeonLoggerService } from '@forgeon/logger';",
+  );
+
+  content = content.replace(
+    'const app = await NestFactory.create(AppModule);',
+    'const app = await NestFactory.create(AppModule, { bufferLogs: true });',
+  );
+
+  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));`,
+    );
+  }
+
+  fs.writeFileSync(filePath, `${content.trimEnd()}\n`, 'utf8');
+}
+
+function patchAppModule(targetRoot) {
+  const filePath = path.join(targetRoot, 'apps', 'api', 'src', 'app.module.ts');
+  if (!fs.existsSync(filePath)) {
+    return;
+  }
+
+  let content = fs.readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n');
+
+  content = ensureLineAfter(
+    content,
+    "import { dbPrismaConfig, dbPrismaEnvSchema, DbPrismaModule } from '@forgeon/db-prisma';",
+    "import { ForgeonLoggerModule, loggerConfig, loggerEnvSchema } from '@forgeon/logger';",
+  );
+
+  content = content.replace(
+    'load: [coreConfig, dbPrismaConfig, i18nConfig],',
+    'load: [coreConfig, dbPrismaConfig, i18nConfig, loggerConfig],',
+  );
+  content = content.replace(
+    'load: [coreConfig, dbPrismaConfig],',
+    'load: [coreConfig, dbPrismaConfig, loggerConfig],',
+  );
+  content = content.replace(
+    'validate: createEnvValidator([coreEnvSchema, dbPrismaEnvSchema, i18nEnvSchema]),',
+    'validate: createEnvValidator([coreEnvSchema, dbPrismaEnvSchema, i18nEnvSchema, loggerEnvSchema]),',
+  );
+  content = content.replace(
+    'validate: createEnvValidator([coreEnvSchema, dbPrismaEnvSchema]),',
+    'validate: createEnvValidator([coreEnvSchema, dbPrismaEnvSchema, loggerEnvSchema]),',
+  );
+
+  content = ensureLineAfter(content, '    CoreErrorsModule,', '    ForgeonLoggerModule,');
+
+  fs.writeFileSync(filePath, `${content.trimEnd()}\n`, 'utf8');
+}
+
+function patchApiDockerfile(targetRoot) {
+  const dockerfilePath = path.join(targetRoot, 'apps', 'api', 'Dockerfile');
+  if (!fs.existsSync(dockerfilePath)) {
+    return;
+  }
+
+  let content = fs.readFileSync(dockerfilePath, 'utf8').replace(/\r\n/g, '\n');
+
+  content = ensureLineAfter(
+    content,
+    'COPY packages/db-prisma/package.json packages/db-prisma/package.json',
+    'COPY packages/logger/package.json packages/logger/package.json',
+  );
+  content = ensureLineAfter(
+    content,
+    'COPY packages/db-prisma packages/db-prisma',
+    'COPY packages/logger packages/logger',
+  );
+
+  content = content.replace(/^RUN pnpm --filter @forgeon\/logger build\r?\n?/gm, '');
+  content = ensureLineBefore(
+    content,
+    'RUN pnpm --filter @forgeon/api prisma:generate',
+    'RUN pnpm --filter @forgeon/logger build',
+  );
+
+  fs.writeFileSync(dockerfilePath, `${content.trimEnd()}\n`, 'utf8');
+}
+
+function patchCompose(targetRoot) {
+  const composePath = path.join(targetRoot, 'infra', 'docker', 'compose.yml');
+  if (!fs.existsSync(composePath)) {
+    return;
+  }
+
+  let content = fs.readFileSync(composePath, 'utf8').replace(/\r\n/g, '\n');
+  if (!content.includes('LOGGER_LEVEL: ${LOGGER_LEVEL}')) {
+    content = content.replace(
+      /^(\s+API_PREFIX:.*)$/m,
+      `$1
+      LOGGER_LEVEL: \${LOGGER_LEVEL}
+      LOGGER_HTTP_ENABLED: \${LOGGER_HTTP_ENABLED}
+      LOGGER_REQUEST_ID_HEADER: \${LOGGER_REQUEST_ID_HEADER}`,
+    );
+  }
+
+  fs.writeFileSync(composePath, `${content.trimEnd()}\n`, 'utf8');
+}
+
+export function applyLoggerModule({ packageRoot, targetRoot }) {
+  copyFromPreset(packageRoot, targetRoot, path.join('packages', 'logger'));
+  patchApiPackage(targetRoot);
+  patchMain(targetRoot);
+  patchAppModule(targetRoot);
+  patchApiDockerfile(targetRoot);
+  patchCompose(targetRoot);
+
+  upsertEnvLines(path.join(targetRoot, 'apps', 'api', '.env.example'), [
+    'LOGGER_LEVEL=log',
+    'LOGGER_HTTP_ENABLED=true',
+    'LOGGER_REQUEST_ID_HEADER=x-request-id',
+  ]);
+
+  upsertEnvLines(path.join(targetRoot, 'infra', 'docker', '.env.example'), [
+    'LOGGER_LEVEL=log',
+    'LOGGER_HTTP_ENABLED=true',
+    'LOGGER_REQUEST_ID_HEADER=x-request-id',
+  ]);
+}
+

package/src/modules/registry.mjs

@@ -7,6 +7,14 @@ const MODULE_PRESETS = {
     description: 'Backend/frontend i18n wiring with locale contracts and translation resources.',
     docFragments: ['00_title', '10_overview', '20_scope', '90_status_implemented'],
   },
+  logger: {
+    id: 'logger',
+    label: 'Logger',
+    category: 'observability',
+    implemented: true,
+    description: 'Structured API logger with request id middleware and HTTP logging interceptor.',
+    docFragments: ['00_title', '10_overview', '20_scope', '90_status_implemented'],
+  },
   'jwt-auth': {
     id: 'jwt-auth',
     label: 'JWT Auth',

package/templates/module-fragments/logger/00_title.md

@@ -0,0 +1,6 @@
+# {{MODULE_LABEL}}
+
+- Id: `{{MODULE_ID}}`
+- Category: `{{MODULE_CATEGORY}}`
+- Status: {{MODULE_STATUS}}
+

package/templates/module-fragments/logger/10_overview.md

@@ -0,0 +1,10 @@
+## Overview
+
+Adds API logging primitives with a dedicated logger package.
+
+Included parts:
+- `@forgeon/logger` package
+- request-id middleware (`x-request-id` by default)
+- HTTP logging interceptor for request/response timing
+- env-driven logger config (`LOGGER_LEVEL`, `LOGGER_HTTP_ENABLED`, `LOGGER_REQUEST_ID_HEADER`)
+

package/templates/module-fragments/logger/20_scope.md

@@ -0,0 +1,11 @@
+## Applied Scope
+
+- Adds `packages/logger` workspace package
+- Wires logger config schema into API `ConfigModule` validation/load
+- Registers logger module in `AppModule`
+- Enables Nest app logger and global HTTP logging interceptor in `main.ts`
+- Updates API `predev` script to build logger package
+- Updates API Docker build stages to include `@forgeon/logger`
+- Adds logger env keys to `apps/api/.env.example` and `infra/docker/.env.example`
+- Passes logger env keys through `infra/docker/compose.yml`
+

package/templates/module-fragments/logger/90_status_implemented.md

@@ -0,0 +1,4 @@
+## Status
+
+Implemented and applied by `create-forgeon add logger`.
+

package/templates/module-presets/logger/packages/logger/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@forgeon/logger",
+  "version": "0.1.0",
+  "private": true,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@nestjs/common": "^11.0.1",
+    "@nestjs/config": "^4.0.2",
+    "rxjs": "^7.8.1",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.7",
+    "typescript": "^5.7.3"
+  }
+}
+

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

@@ -0,0 +1,17 @@
+import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
+import { ForgeonHttpLoggingInterceptor } from './http-logging.interceptor';
+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],
+})
+export class ForgeonLoggerModule implements NestModule {
+  configure(consumer: MiddlewareConsumer): void {
+    consumer.apply(RequestIdMiddleware).forRoutes('*');
+  }
+}
+

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

@@ -0,0 +1,51 @@
+import { ConsoleLogger, Injectable, LogLevel } from '@nestjs/common';
+import { LoggerConfigService } from './logger-config.service';
+import type { LoggerLevel } from './logger-env.schema';
+
+interface HttpLogEntry {
+  method: string;
+  path: string;
+  statusCode: number;
+  durationMs: number;
+  requestId?: string;
+  ip?: string;
+}
+
+function resolveLogLevels(level: LoggerLevel): LogLevel[] {
+  switch (level) {
+    case 'error':
+      return ['error'];
+    case 'warn':
+      return ['error', 'warn'];
+    case 'log':
+      return ['error', 'warn', 'log'];
+    case 'debug':
+      return ['error', 'warn', 'log', 'debug'];
+    case 'verbose':
+      return ['error', 'warn', 'log', 'debug', 'verbose'];
+    default:
+      return ['error', 'warn', 'log'];
+  }
+}
+
+@Injectable()
+export class ForgeonLoggerService extends ConsoleLogger {
+  constructor(private readonly loggerConfig: LoggerConfigService) {
+    super('ForgeonApi');
+    this.setLogLevels(resolveLogLevels(this.loggerConfig.level));
+  }
+
+  logHttpRequest(entry: HttpLogEntry): void {
+    if (!this.loggerConfig.httpEnabled) {
+      return;
+    }
+
+    this.log(
+      JSON.stringify({
+        event: 'http.request',
+        ...entry,
+      }),
+    );
+  }
+}
+

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

@@ -0,0 +1,90 @@
+import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
+import { Observable, tap } from 'rxjs';
+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;
+}
+
+@Injectable()
+export class ForgeonHttpLoggingInterceptor implements NestInterceptor {
+  constructor(
+    private readonly logger: ForgeonLoggerService,
+    private readonly loggerConfig: LoggerConfigService,
+  ) {}
+
+  intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
+    if (context.getType<'http'>() !== 'http') {
+      return next.handle();
+    }
+
+    if (!this.loggerConfig.httpEnabled) {
+      return next.handle();
+    }
+
+    const http = context.switchToHttp();
+    const request = http.getRequest<RequestLike>();
+    const response = http.getResponse<ResponseLike>();
+
+    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();
+
+    return next.handle().pipe(
+      tap({
+        next: () => {
+          this.logger.logHttpRequest({
+            method,
+            path,
+            statusCode: response.statusCode ?? 200,
+            durationMs: Date.now() - startedAt,
+            requestId,
+            ip,
+          });
+        },
+        error: () => {
+          this.logger.logHttpRequest({
+            method,
+            path,
+            statusCode: response.statusCode ?? 500,
+            durationMs: Date.now() - startedAt,
+            requestId,
+            ip,
+          });
+        },
+      }),
+    );
+  }
+
+  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

@@ -0,0 +1,9 @@
+export * from './logger-env.schema';
+export * from './logger-config.loader';
+export * from './logger-config.service';
+export * from './logger-config.module';
+export * from './forgeon-logger.service';
+export * from './http-logging.interceptor';
+export * from './request-id.middleware';
+export * from './forgeon-logger.module';
+

package/templates/module-presets/logger/packages/logger/src/logger-config.loader.ts

@@ -0,0 +1,20 @@
+import { registerAs } from '@nestjs/config';
+import { LoggerLevel, parseLoggerEnv } from './logger-env.schema';
+
+export const LOGGER_CONFIG_NAMESPACE = 'logger';
+
+export interface LoggerConfigValues {
+  level: LoggerLevel;
+  httpEnabled: boolean;
+  requestIdHeader: string;
+}
+
+export const loggerConfig = registerAs(LOGGER_CONFIG_NAMESPACE, (): LoggerConfigValues => {
+  const env = parseLoggerEnv(process.env);
+  return {
+    level: env.LOGGER_LEVEL,
+    httpEnabled: env.LOGGER_HTTP_ENABLED,
+    requestIdHeader: env.LOGGER_REQUEST_ID_HEADER.toLowerCase(),
+  };
+});
+

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

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { LoggerConfigService } from './logger-config.service';
+
+@Module({
+  imports: [ConfigModule],
+  providers: [LoggerConfigService],
+  exports: [LoggerConfigService],
+})
+export class LoggerConfigModule {}
+

package/templates/module-presets/logger/packages/logger/src/logger-config.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { LOGGER_CONFIG_NAMESPACE, LoggerConfigValues } from './logger-config.loader';
+
+@Injectable()
+export class LoggerConfigService {
+  constructor(private readonly configService: ConfigService) {}
+
+  get level(): LoggerConfigValues['level'] {
+    return this.configService.getOrThrow<LoggerConfigValues['level']>(
+      `${LOGGER_CONFIG_NAMESPACE}.level`,
+    );
+  }
+
+  get httpEnabled(): boolean {
+    return this.configService.getOrThrow<boolean>(`${LOGGER_CONFIG_NAMESPACE}.httpEnabled`);
+  }
+
+  get requestIdHeader(): string {
+    return this.configService.getOrThrow<string>(`${LOGGER_CONFIG_NAMESPACE}.requestIdHeader`);
+  }
+}
+

package/templates/module-presets/logger/packages/logger/src/logger-env.schema.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+
+const loggerLevelSchema = z.enum(['error', 'warn', 'log', 'debug', 'verbose']);
+
+export const loggerEnvSchema = z
+  .object({
+    LOGGER_LEVEL: loggerLevelSchema.default('log'),
+    LOGGER_HTTP_ENABLED: z.coerce.boolean().default(true),
+    LOGGER_REQUEST_ID_HEADER: z.string().trim().min(1).default('x-request-id'),
+  })
+  .passthrough();
+
+export type LoggerLevel = z.infer<typeof loggerLevelSchema>;
+export type LoggerEnv = z.infer<typeof loggerEnvSchema>;
+
+export function parseLoggerEnv(input: Record<string, unknown>): LoggerEnv {
+  return loggerEnvSchema.parse(input);
+}
+

package/templates/module-presets/logger/packages/logger/src/request-id.middleware.ts

@@ -0,0 +1,52 @@
+import { Injectable, NestMiddleware } from '@nestjs/common';
+import { randomUUID } from 'node:crypto';
+import { LoggerConfigService } from './logger-config.service';
+
+type HeaderValue = string | string[] | undefined;
+type HeadersRecord = Record<string, HeaderValue>;
+
+interface RequestLike {
+  headers: HeadersRecord;
+  requestId?: string;
+}
+
+interface ResponseLike {
+  setHeader?: (name: string, value: string) => void;
+}
+
+@Injectable()
+export class RequestIdMiddleware implements NestMiddleware {
+  constructor(private readonly loggerConfig: LoggerConfigService) {}
+
+  use(req: RequestLike, res: ResponseLike, next: () => void): void {
+    const headerName = this.loggerConfig.requestIdHeader;
+    const requestId = this.readHeader(req.headers, headerName) ?? randomUUID();
+
+    req.requestId = requestId;
+    req.headers[headerName] = requestId;
+    if (typeof res.setHeader === 'function') {
+      res.setHeader(headerName, requestId);
+    }
+
+    next();
+  }
+
+  private readHeader(headers: HeadersRecord | undefined, name: string): string | undefined {
+    if (!headers) {
+      return undefined;
+    }
+
+    const normalized = name.toLowerCase();
+    const value = headers[normalized];
+    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/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../../../../tsconfig.base.node.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist",
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"]
+}
+