Merge pull request AgesEmpire#422 from BethelDev-io/fix/373-371-372-370-backend-gaps

Fix/373 371 372 370 backend gaps

Author: Mathews-25

src/app.module.ts

@@ -49,6 +49,8 @@ import { MarketIntelligenceModule } from './market-intelligence/market-intellige
 import { DocumentationModule } from './documentation/documentation.module';
 import { CompetitionsModule } from './competitions/competitions.module';
 import { NftModule } from './nft/nft.module';
+import { HealthModule } from './health/health.module';
+import { RateLimitModule } from './common/rate-limit.module';
  feature/295-discord-community-integration
 import { DiscordBotModule } from './integrations/discord/discord-bot.module';
 
@@ -159,6 +161,8 @@ import { AutomationModule } from './integrations/automation-platforms/automation
     DocumentationModule,
     CompetitionsModule,
     NftModule,
+    HealthModule,
+    RateLimitModule,
  feature/295-discord-community-integration
     DiscordBotModule,
 

src/common/guards/rate-limit.guard.ts

@@ -5,6 +5,7 @@ import {
   HttpException,
   HttpStatus,
   Inject,
+  Logger,
 } from '@nestjs/common';
 import { Reflector } from '@nestjs/core';
 import { CACHE_MANAGER } from '@nestjs/cache-manager';
@@ -18,6 +19,7 @@ interface RateLimitInfo {
 
 @Injectable()
 export class RateLimitGuard implements CanActivate {
+  private readonly logger = new Logger(RateLimitGuard.name);
   private readonly limits = {
     [RateLimitTier.PUBLIC]: { limit: 100, window: 15 * 60 },
     [RateLimitTier.AUTHENTICATED]: { limit: 1000, window: 15 * 60 },
@@ -141,12 +143,9 @@ export class RateLimitGuard implements CanActivate {
   }
 
   private logViolation(identifier: string, tier: RateLimitTier, limit: number): void {
-    console.warn({
-      type: 'rate_limit_violation',
-      identifier,
-      tier,
-      limit,
-      timestamp: new Date().toISOString(),
-    });
+    this.logger.warn(
+      `Rate limit exceeded: identifier=${identifier} tier=${tier} limit=${limit}`,
+      { type: 'rate_limit_violation', identifier, tier, limit, timestamp: new Date().toISOString() },
+    );
   }
 }

src/health/health.controller.ts

@@ -1,4 +1,4 @@
-import { Controller, Get } from '@nestjs/common';
+import { Controller, Get, OnApplicationBootstrap, Logger } from '@nestjs/common';
 import {
   HealthCheck,
   HealthCheckService,
@@ -12,7 +12,9 @@ import {
 } from './indicators';
 
 @Controller('health')
-export class HealthController {
+export class HealthController implements OnApplicationBootstrap {
+  private readonly logger = new Logger(HealthController.name);
+
   constructor(
     private health: HealthCheckService,
     private stellarHealth: StellarHealthIndicator,
@@ -21,6 +23,32 @@ export class HealthController {
     private redisHealth: RedisHealthIndicator,
   ) { }
 
+  async onApplicationBootstrap(): Promise<void> {
+    const maxRetries = 5;
+    const retryDelayMs = 3000;
+
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        await this.health.check([
+          () => this.databaseHealth.isHealthy('database'),
+          () => this.redisHealth.isHealthy('cache'),
+        ]);
+        this.logger.log('Startup health check passed: database and cache are ready');
+        return;
+      } catch (err) {
+        this.logger.warn(
+          `Startup health check attempt ${attempt}/${maxRetries} failed: ${(err as Error).message}`,
+        );
+        if (attempt < maxRetries) {
+          await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+        } else {
+          this.logger.error('Critical dependencies unavailable after max retries — aborting startup');
+          process.exit(1);
+        }
+      }
+    }
+  }
+
   @Get()
   @HealthCheck()
   async check(): Promise<HealthCheckResult> {

src/main.ts

@@ -60,6 +60,17 @@ async function bootstrap() {
   // Enable compression
   app.use((compression as any)(compressionConfig));
 
+  // Track in-flight requests for graceful drain
+  let inFlightRequests = 0;
+  app.use((_req: any, _res: any, next: () => void) => {
+    inFlightRequests++;
+    _res.on('finish', () => { inFlightRequests--; });
+    _res.on('close', () => { inFlightRequests--; });
+    next();
+  });
+
+  app.enableShutdownHooks();
+
   // Global pipes
   app.useGlobalPipes(
     new SanitizationPipe(),
@@ -134,9 +145,27 @@ async function bootstrap() {
   });
 
   process.on('SIGTERM', async () => {
-    logger.info('SIGTERM signal received: closing HTTP server');
-    await sentryService.flush();
+    logger.info('SIGTERM received: starting graceful shutdown');
+
+    // Stop accepting new connections
     await app.close();
+
+    // Drain in-flight requests (max 30 s)
+    const drainTimeout = 30_000;
+    const drainStart = Date.now();
+    while (inFlightRequests > 0 && Date.now() - drainStart < drainTimeout) {
+      logger.info(`Draining ${inFlightRequests} in-flight request(s)…`);
+      await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+
+    if (inFlightRequests > 0) {
+      logger.warn(`Shutdown forced with ${inFlightRequests} request(s) still in-flight`);
+    } else {
+      logger.info('All in-flight requests drained. Shutdown complete.');
+    }
+
+    await sentryService.flush();
+    process.exit(0);
   });
 }
 

src/rate-limit/rate-limit.guard.ts

@@ -0,0 +1,4 @@
+// Re-exports the canonical rate-limit guard from common/guards.
+// Issue #372: API gateway rate limiting entry point.
+export { RateLimitGuard } from '../common/guards/rate-limit.guard';
+export { RateLimitTier, RateLimit, RateLimitConfig, RATE_LIMIT_KEY } from '../common/decorators/rate-limit.decorator';

test/graceful-shutdown.spec.ts

@@ -0,0 +1,45 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { INestApplication } from '@nestjs/common';
+import { AppModule } from '../src/app.module';
+
+describe('Graceful Shutdown (#373)', () => {
+  let app: INestApplication;
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    app = module.createNestApplication();
+    app.enableShutdownHooks();
+    await app.init();
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  it('should close the application cleanly without throwing', async () => {
+    await expect(app.close()).resolves.not.toThrow();
+  });
+
+  it('should drain in-flight counter correctly', () => {
+    let inFlight = 0;
+    const mockReq = {};
+    const mockRes: any = { on: jest.fn((event, cb) => { if (event === 'finish') cb(); }) };
+    const next = jest.fn(() => { inFlight++; });
+
+    // Simulate the middleware
+    const middleware = (_req: any, res: any, n: () => void) => {
+      inFlight++;
+      res.on('finish', () => { inFlight--; });
+      res.on('close', () => { inFlight--; });
+      n();
+    };
+
+    inFlight = 0;
+    middleware(mockReq, mockRes, () => {});
+    // finish event fires immediately via mock
+    expect(inFlight).toBe(0);
+  });
+});

test/health.controller.spec.ts

@@ -0,0 +1,80 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { HealthController } from '../src/health/health.controller';
+import { HealthCheckService } from '@nestjs/terminus';
+import {
+  DatabaseHealthIndicator,
+  RedisHealthIndicator,
+  StellarHealthIndicator,
+  SorobanHealthIndicator,
+} from '../src/health/indicators';
+
+const mockHealthCheck = jest.fn();
+const mockDbHealth = { isHealthy: jest.fn() };
+const mockRedisHealth = { isHealthy: jest.fn() };
+const mockStellarHealth = { isHealthy: jest.fn() };
+const mockSorobanHealth = { isHealthy: jest.fn() };
+
+describe('HealthController (#370)', () => {
+  let controller: HealthController;
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [HealthController],
+      providers: [
+        { provide: HealthCheckService, useValue: { check: mockHealthCheck } },
+        { provide: DatabaseHealthIndicator, useValue: mockDbHealth },
+        { provide: RedisHealthIndicator, useValue: mockRedisHealth },
+        { provide: StellarHealthIndicator, useValue: mockStellarHealth },
+        { provide: SorobanHealthIndicator, useValue: mockSorobanHealth },
+      ],
+    }).compile();
+
+    controller = module.get(HealthController);
+  });
+
+  it('should pass startup health check when DB and cache are healthy', async () => {
+    mockHealthCheck.mockResolvedValue({ status: 'ok', info: {}, error: {}, details: {} });
+    await expect(controller.onApplicationBootstrap()).resolves.not.toThrow();
+    expect(mockHealthCheck).toHaveBeenCalledTimes(1);
+  });
+
+  it('should retry and exit if dependencies remain unhealthy', async () => {
+    const exitSpy = jest.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+    mockHealthCheck.mockRejectedValue(new Error('DB unavailable'));
+
+    // Speed up retries
+    jest.useFakeTimers();
+    const bootstrapPromise = controller.onApplicationBootstrap();
+    // Advance through all retry delays (5 retries × 3000ms)
+    for (let i = 0; i < 5; i++) {
+      await Promise.resolve();
+      jest.advanceTimersByTime(3000);
+    }
+    await bootstrapPromise.catch(() => {});
+    jest.useRealTimers();
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
+    exitSpy.mockRestore();
+  });
+
+  it('GET /health should check all indicators', async () => {
+    mockHealthCheck.mockResolvedValue({ status: 'ok', info: {}, error: {}, details: {} });
+    await controller.check();
+    expect(mockHealthCheck).toHaveBeenCalledWith(expect.arrayContaining([
+      expect.any(Function),
+      expect.any(Function),
+      expect.any(Function),
+      expect.any(Function),
+    ]));
+  });
+
+  it('GET /health/readiness should check DB and cache only', async () => {
+    mockHealthCheck.mockResolvedValue({ status: 'ok', info: {}, error: {}, details: {} });
+    await controller.readiness();
+    expect(mockHealthCheck).toHaveBeenCalledWith(expect.arrayContaining([
+      expect.any(Function),
+      expect.any(Function),
+    ]));
+  });
+});

test/logger.service.spec.ts

@@ -0,0 +1,63 @@
+import { LoggerService } from '../src/common/logger/logger.service';
+import { ConfigService } from '@nestjs/config';
+import * as winston from 'winston';
+
+describe('LoggerService structured JSON logging (#371)', () => {
+  let logger: LoggerService;
+  let winstonSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    const configService = {
+      get: (key: string, defaultVal?: any) => {
+        const map: Record<string, any> = {
+          'app.nodeEnv': 'production',
+          'app.logger.level': 'info',
+          'app.logger.directory': '/tmp/logs',
+          'app.logger.maxFiles': '14d',
+          'app.logger.maxSize': '20m',
+        };
+        return map[key] ?? defaultVal;
+      },
+    } as unknown as ConfigService;
+
+    logger = new LoggerService(configService);
+  });
+
+  it('should instantiate without errors in production mode', () => {
+    expect(logger).toBeDefined();
+  });
+
+  it('should redact sensitive fields', () => {
+    const internalLogger = (logger as any).logger as winston.Logger;
+    const writeSpy = jest.spyOn(internalLogger, 'info');
+
+    logger.info('test message', { password: 'secret123', userId: 'abc' });
+
+    expect(writeSpy).toHaveBeenCalledWith(
+      'test message',
+      expect.objectContaining({ password: '[REDACTED]', userId: 'abc' }),
+    );
+  });
+
+  it('should log errors with stack trace', () => {
+    const internalLogger = (logger as any).logger as winston.Logger;
+    const errorSpy = jest.spyOn(internalLogger, 'error');
+    const err = new Error('boom');
+
+    logger.error('something failed', err);
+
+    expect(errorSpy).toHaveBeenCalledWith(
+      'something failed',
+      expect.objectContaining({
+        error: expect.objectContaining({ message: 'boom', stack: expect.any(String) }),
+      }),
+    );
+  });
+
+  it('should handle circular references without throwing', () => {
+    const circular: any = { a: 1 };
+    circular.self = circular;
+
+    expect(() => logger.info('circular test', circular)).not.toThrow();
+  });
+});