create-forgeon 0.3.3 → 0.3.5

package/package.json

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

package/src/modules/executor.test.mjs

@@ -70,10 +70,13 @@ function assertRateLimitWiring(projectRoot) {
     path.join(projectRoot, 'apps', 'api', 'src', 'health', 'health.controller.ts'),
     'utf8',
   );
+  assert.match(healthController, /import \{ Header \} from '@nestjs\/common';/);
+  assert.match(healthController, /@Header\('Cache-Control', 'no-store, no-cache, must-revalidate'\)/);
   assert.match(healthController, /@Get\('rate-limit'\)/);
   assert.match(healthController, /TOO_MANY_REQUESTS/);
 
   const appTsx = fs.readFileSync(path.join(projectRoot, 'apps', 'web', 'src', 'App.tsx'), 'utf8');
+  assert.match(appTsx, /cache: 'no-store'/);
   assert.match(appTsx, /Check rate limit \(click repeatedly\)/);
   assert.match(appTsx, /Rate limit probe response/);
 
@@ -569,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'),
@@ -588,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/);
@@ -954,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 });
     }
@@ -1055,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/src/modules/rate-limit.mjs

@@ -120,8 +120,10 @@ function patchHealthController(targetRoot) {
   }
 
   let content = fs.readFileSync(filePath, 'utf8').replace(/\r\n/g, '\n');
+  content = ensureImportLine(content, "import { Header } from '@nestjs/common';");
   if (!content.includes("@Get('rate-limit')")) {
     const method = `
+  @Header('Cache-Control', 'no-store, no-cache, must-revalidate')
   @Get('rate-limit')
   getRateLimitProbe() {
     return {

package/src/modules/sync-integrations.mjs

@@ -24,6 +24,25 @@ const PRISMA_AUTH_MIGRATION_TEMPLATE = path.join(
   '0002_auth_refresh_token_hash',
 );
 
+const AUTH_PERSISTENCE_STRATEGIES = [
+  {
+    id: 'db-prisma',
+    capability: 'db-adapter',
+    providerLabel: 'db-prisma',
+    participants: ['jwt-auth', 'db-adapter'],
+    relatedModules: ['jwt-auth', 'db-prisma'],
+    description: [
+      'Patch AppModule to wire AUTH_REFRESH_TOKEN_STORE to the current db-adapter implementation (today: PrismaAuthRefreshTokenStore)',
+      'Add apps/api/src/auth/prisma-auth-refresh-token.store.ts',
+      'Extend Prisma User model with refreshTokenHash and add migration 0002_auth_refresh_token_hash',
+      'Update JWT auth README note to reflect db-adapter-backed refresh-token persistence',
+    ],
+    isDetected: (detected) => detected.dbPrisma,
+    isPending: isAuthPersistencePending,
+    apply: syncJwtDbPrisma,
+  },
+];
+
 function ensureLineAfter(content, anchorLine, lineToInsert) {
   if (content.includes(lineToInsert)) {
     return content;
@@ -97,15 +116,10 @@ const INTEGRATION_GROUPS = [
     title: 'Auth Persistence Integration',
     participants: ['jwt-auth', 'db-adapter'],
     relatedModules: ['jwt-auth', 'db-prisma'],
-    description: [
-      'Patch AppModule to wire AUTH_REFRESH_TOKEN_STORE to the current db-adapter implementation (today: PrismaAuthRefreshTokenStore)',
-      'Add apps/api/src/auth/prisma-auth-refresh-token.store.ts',
-      'Extend Prisma User model with refreshTokenHash and add migration 0002_auth_refresh_token_hash',
-      'Update JWT auth README note to reflect db-adapter-backed refresh-token persistence',
-    ],
-    isAvailable: (detected) => detected.jwtAuth && detected.dbPrisma,
-    isPending: (rootDir) => isAuthPersistencePending(rootDir),
-    apply: syncJwtDbPrisma,
+    description: (detected) => getAuthPersistenceDescription(detected),
+    isAvailable: (detected) => detected.jwtAuth && hasSingleAuthPersistenceStrategy(detected),
+    isPending: (rootDir, detected) => isAuthPersistencePendingForDetected(rootDir, detected),
+    apply: applyAuthPersistenceSync,
   },
   {
     id: 'auth-rbac-claims',
@@ -141,6 +155,52 @@ function detectModules(rootDir) {
   };
 }
 
+function resolveAuthPersistenceStrategy(detected) {
+  const matched = AUTH_PERSISTENCE_STRATEGIES.filter((strategy) => strategy.isDetected(detected));
+  if (matched.length === 0) {
+    return { kind: 'none' };
+  }
+  if (matched.length > 1) {
+    return { kind: 'conflict', strategies: matched };
+  }
+  return { kind: 'single', strategy: matched[0] };
+}
+
+function hasSingleAuthPersistenceStrategy(detected) {
+  return resolveAuthPersistenceStrategy(detected).kind === 'single';
+}
+
+function getAuthPersistenceDescription(detected) {
+  const resolved = resolveAuthPersistenceStrategy(detected);
+  if (resolved.kind === 'single') {
+    return [...resolved.strategy.description];
+  }
+  return [
+    'Use the current db-adapter provider strategy to wire refresh-token persistence.',
+    'A supported db-adapter provider must be installed before this integration can apply.',
+  ];
+}
+
+function isAuthPersistencePendingForDetected(rootDir, detected) {
+  const resolved = resolveAuthPersistenceStrategy(detected);
+  if (resolved.kind !== 'single') {
+    return false;
+  }
+  return resolved.strategy.isPending(rootDir);
+}
+
+function applyAuthPersistenceSync({ rootDir, packageRoot, changedFiles }) {
+  const detected = detectModules(rootDir);
+  const resolved = resolveAuthPersistenceStrategy(detected);
+  if (resolved.kind === 'none') {
+    return { applied: false, reason: 'no supported db-adapter provider detected' };
+  }
+  if (resolved.kind === 'conflict') {
+    return { applied: false, reason: 'multiple db-adapter providers detected' };
+  }
+  return resolved.strategy.apply({ rootDir, packageRoot, changedFiles });
+}
+
 function getGroupParticipants(group) {
   return Array.isArray(group.participants) && group.participants.length > 0
     ? group.participants
@@ -155,6 +215,13 @@ function getGroupRelatedModules(group) {
     : getGroupParticipants(group);
 }
 
+function getGroupDescription(group, detected) {
+  if (typeof group.description === 'function') {
+    return group.description(detected);
+  }
+  return Array.isArray(group.description) ? group.description : [];
+}
+
 function syncJwtDbPrisma({ rootDir, packageRoot, changedFiles }) {
   const appModulePath = path.join(rootDir, 'apps', 'api', 'src', 'app.module.ts');
   const schemaPath = path.join(rootDir, 'apps', 'api', 'prisma', 'schema.prisma');
@@ -381,7 +448,7 @@ export function syncIntegrations({ targetRoot, packageRoot, groupIds = null }) {
   const detected = detectModules(rootDir);
   const summary = [];
   const available = INTEGRATION_GROUPS.filter(
-    (group) => group.isAvailable(detected) && group.isPending(rootDir),
+    (group) => group.isAvailable(detected) && group.isPending(rootDir, detected),
   );
   const selected = Array.isArray(groupIds)
     ? available.filter((group) => groupIds.includes(group.id))
@@ -391,7 +458,7 @@ export function syncIntegrations({ targetRoot, packageRoot, groupIds = null }) {
     summary.push({
       id: group.id,
       title: group.title,
-      modules: group.modules,
+      modules: getGroupParticipants(group),
       result: group.apply({ rootDir, packageRoot, changedFiles }),
     });
   }
@@ -402,7 +469,7 @@ export function syncIntegrations({ targetRoot, packageRoot, groupIds = null }) {
       id: group.id,
       title: group.title,
       modules: [...getGroupParticipants(group)],
-      description: [...group.description],
+      description: [...getGroupDescription(group, detected)],
     })),
     changedFiles: [...changedFiles].sort().map((filePath) => path.relative(rootDir, filePath)),
   };
@@ -414,7 +481,7 @@ export function scanIntegrations({ targetRoot, relatedModuleId = null }) {
   const available = INTEGRATION_GROUPS.filter(
     (group) =>
       group.isAvailable(detected) &&
-      group.isPending(rootDir) &&
+      group.isPending(rootDir, detected) &&
       (!relatedModuleId || getGroupRelatedModules(group).includes(relatedModuleId)),
   );
   return {
@@ -422,7 +489,7 @@ export function scanIntegrations({ targetRoot, relatedModuleId = null }) {
       id: group.id,
       title: group.title,
       modules: [...getGroupParticipants(group)],
-      description: [...group.description],
+      description: [...getGroupDescription(group, detected)],
     })),
   };
 }

package/templates/base/apps/web/src/App.tsx

@@ -13,7 +13,10 @@ export default function App() {
   const [networkError, setNetworkError] = useState<string | null>(null);
 
   const requestProbe = async (url: string, init?: RequestInit): Promise<ProbeResult> => {
-    const response = await fetch(url, init);
+    const response = await fetch(url, {
+      ...(init ?? {}),
+      cache: 'no-store',
+    });
     let body: unknown = null;
 
     try {

package/templates/base/scripts/forgeon-sync-integrations.mjs

@@ -45,6 +45,15 @@ ALTER TABLE "User"
 ADD COLUMN "refreshTokenHash" TEXT;
 `;
 
+const AUTH_PERSISTENCE_STRATEGIES = [
+  {
+    id: 'db-prisma',
+    providerLabel: 'db-prisma',
+    isDetected: (detected) => detected.dbPrisma,
+    apply: syncJwtDbPrisma,
+  },
+];
+
 function detectModules(rootDir) {
   const appModulePath = path.join(rootDir, 'apps', 'api', 'src', 'app.module.ts');
   const appModuleText = fs.existsSync(appModulePath) ? fs.readFileSync(appModulePath, 'utf8') : '';
@@ -74,6 +83,17 @@ function ensureLineAfter(content, anchorLine, lineToInsert) {
   return `${content.slice(0, insertAt)}\n${lineToInsert}${content.slice(insertAt)}`;
 }
 
+function resolveAuthPersistenceStrategy(detected) {
+  const matched = AUTH_PERSISTENCE_STRATEGIES.filter((strategy) => strategy.isDetected(detected));
+  if (matched.length === 0) {
+    return { kind: 'none' };
+  }
+  if (matched.length > 1) {
+    return { kind: 'conflict', strategies: matched };
+  }
+  return { kind: 'single', strategy: matched[0] };
+}
+
 function syncJwtDbPrisma({ rootDir, changedFiles }) {
   const appModulePath = path.join(rootDir, 'apps', 'api', 'src', 'app.module.ts');
   const schemaPath = path.join(rootDir, 'apps', 'api', 'prisma', 'schema.prisma');
@@ -290,16 +310,21 @@ function run() {
   const changedFiles = new Set();
   const detected = detectModules(rootDir);
   const summary = [];
+  const authPersistence = resolveAuthPersistenceStrategy(detected);
 
-  if (detected.jwtAuth && detected.dbPrisma) {
+  if (detected.jwtAuth && authPersistence.kind === 'single') {
     summary.push({
-      feature: 'jwt-auth + db-adapter (current provider: db-prisma)',
-      result: syncJwtDbPrisma({ rootDir, changedFiles }),
+      feature: `jwt-auth + db-adapter (current provider: ${authPersistence.strategy.providerLabel})`,
+      result: authPersistence.strategy.apply({ rootDir, changedFiles }),
     });
   } else {
+    const reason =
+      authPersistence.kind === 'conflict'
+        ? 'multiple db-adapter providers detected'
+        : 'required components are not both available';
     summary.push({
       feature: 'jwt-auth + db-adapter (current provider: db-prisma)',
-      result: { applied: false, reason: 'required components are not both available' },
+      result: { applied: false, reason },
     });
   }
 

package/templates/module-presets/i18n/apps/web/src/App.tsx

@@ -27,7 +27,8 @@ export default function App() {
 
   const requestProbe = async (path: string, init?: RequestInit): Promise<ProbeResult> => {
     const response = await fetch(`/api${path}${toLangQuery(locale)}`, {
-      ...init,
+      ...(init ?? {}),
+      cache: 'no-store',
       headers: {
         ...(init?.headers ?? {}),
         'Accept-Language': locale,

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';
-