create-forgeon 0.1.27 → 0.1.30

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"]
+}
+