Run smoke tests for connectivity purposes

selimyanat · selimyanat · commit 20ee9dc0e1da · 2025-03-31T16:26:36.000+02:00
diff --git a/.github/workflows/cd.yml b/.github/workflows/cd.yml
@@ -57,4 +57,16 @@ jobs:
             --cache-from=type=local,src=/tmp/.buildx-cache \
             --cache-to=type=local,dest=/tmp/.buildx-cache \
             --load \
-            ./webapp
+            ./webapp
+          
+      - name: Start docker-compose
+        run: |
+          docker-compose -f docker-compose.yml up -d --build
+
+      - smoke-test:
+        image: curlimages/curl
+        depends_on:
+          - webapp
+          - api
+        entrypoint: >
+          sh -c "sleep 5 && curl -sf http://localhost:3001 || exit 1"
diff --git a/api/src/infrastructure/infrastructure.module.ts b/api/src/infrastructure/infrastructure.module.ts
@@ -2,9 +2,9 @@ import { Module, DynamicModule } from '@nestjs/common';
 import { ConfigModule } from '@nestjs/config';
 import { ShortenUrlRepository } from '../shorten-url/shorten-url.repository';
 import { ShortenUrlRepositoryFactory } from './repository/shorten-url/shorten-url-repository.factory';
-import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
-import { DynamoClientProvider } from './provider/dynamodb-client.provider';
+import { DynamoDbClientProvider } from './provider/dynamo-db-client-provider.service';
 import { RedisClientProvider } from './provider/redis-client.provider';
+import { HealthController } from './monitoring/health.controller';
 
 @Module({
   imports: [ConfigModule],
@@ -13,12 +13,17 @@ export class InfrastructureModule {
   static register(): DynamicModule {
     return {
       module: InfrastructureModule,
+      controllers: [HealthController],
       providers: [
         RedisClientProvider,
-        DynamoClientProvider,
+        DynamoDbClientProvider,
         ShortenUrlRepositoryFactory,
       ],
-      exports: [RedisClientProvider, DynamoDBClient, ShortenUrlRepository],
+      exports: [
+        RedisClientProvider,
+        DynamoDbClientProvider,
+        ShortenUrlRepository,
+      ],
     };
   }
 }
diff --git a/api/src/infrastructure/monitoring/health.controller.ts b/api/src/infrastructure/monitoring/health.controller.ts
@@ -0,0 +1,30 @@
+import { Controller, Get, Inject } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { RedisClientProvider } from '../provider/redis-client.provider';
+import { DynamoDbClientProvider } from '../provider/dynamo-db-client-provider';
+
+@Controller('monitoring')
+export class HealthController {
+  constructor(
+    private readonly configService: ConfigService,
+    private readonly redisClient: RedisClientProvider | null,
+    private readonly dynamoDbClient: DynamoDbClientProvider | null,
+  ) {}
+
+  @Get('/readiness')
+  async readiness(): Promise<{ status: string }> {
+    const usePersistenceStorage = this.configService.get<string>(
+      'USE_PERSISTENT_STORAGE',
+      'true',
+    );
+
+    if (usePersistenceStorage === 'false') {
+      return { status: 'OK' };
+    }
+
+    return (await this.dynamoDbClient.isReady()) &&
+      (await this.redisClient.isReady())
+      ? { status: 'OK' }
+      : { status: 'KO' };
+  }
+}
diff --git a/api/src/infrastructure/provider/dynamo-db-client-provider.ts b/api/src/infrastructure/provider/dynamo-db-client-provider.ts
@@ -0,0 +1,95 @@
+import {
+  Injectable,
+  Logger,
+  OnModuleDestroy,
+  OnModuleInit,
+} from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import {
+  DynamoDBClient,
+  GetItemCommand,
+  PutItemCommand,
+  ListTablesCommand,
+} from '@aws-sdk/client-dynamodb';
+import { fromEnv } from '@aws-sdk/credential-providers';
+import { unmarshall } from '@aws-sdk/util-dynamodb';
+
+@Injectable()
+export class DynamoDbClientProvider implements OnModuleInit, OnModuleDestroy {
+  private dynamoDBClient: DynamoDBClient | null = null;
+
+  constructor(private readonly configService: ConfigService) {}
+
+  async putItem(key: string, value: string, tableName: string): Promise<void> {
+    if (!this.dynamoDBClient)
+      throw new Error('DynamoDB client not initialized');
+
+    await this.dynamoDBClient.send(
+      new PutItemCommand({
+        TableName: tableName,
+        Item: {
+          shortId: { S: key },
+          originalUrl: { S: value },
+          createdAt: { S: new Date().toISOString() },
+        },
+      }),
+    );
+  }
+
+  async getItem(
+    key: string,
+    tableName: string,
+  ): Promise<Record<string, any> | null> {
+    if (!this.dynamoDBClient)
+      throw new Error('DynamoDB client not initialized');
+
+    const result = await this.dynamoDBClient.send(
+      new GetItemCommand({
+        TableName: tableName,
+        Key: { shortId: { S: key } },
+      }),
+    );
+
+    return unmarshall(result.Item);
+  }
+
+  async isReady(): Promise<boolean> {
+    if (!this.dynamoDBClient) return false;
+    try {
+      await this.dynamoDBClient.send(new ListTablesCommand({}));
+      return true;
+    } catch (err) {
+      Logger.error('DynamoDB readiness check failed', err);
+      return false;
+    }
+  }
+
+  async onModuleInit() {
+    const usePersistent = this.configService.get<string>(
+      'USE_PERSISTENT_STORAGE',
+      'false',
+    );
+
+    if (usePersistent === 'false') {
+      Logger.log('🧪 Skipping dynamo connection (non-persistent mode)');
+      return;
+    }
+
+    this.dynamoDBClient = new DynamoDBClient({
+      region: this.configService.get('AWS_REGION', 'local'),
+      endpoint: this.configService.get(
+        'DYNAMO_ENDPOINT',
+        'http://localhost:8000',
+      ),
+      credentials: fromEnv({}),
+    });
+    Logger.log('Connected to dynamodb');
+  }
+
+  async onModuleDestroy() {
+    if (this.dynamoDBClient) {
+      this.dynamoDBClient.destroy();
+      Logger.log('Dynamodb connection closed');
+    }
+  }
+}
diff --git a/api/src/infrastructure/provider/dynamodb-client.provider.ts b/api/src/infrastructure/provider/dynamodb-client.provider.ts
diff --git a/api/src/infrastructure/provider/redis-client.provider.ts b/api/src/infrastructure/provider/redis-client.provider.ts
@@ -21,6 +21,16 @@ export class RedisClientProvider implements OnModuleInit, OnModuleDestroy {
     await this.client.set(key, value, { EX: ttlInSeconds });
   }
 
+  async isReady(): Promise<boolean> {
+    try {
+      await this.client.ping();
+      return true;
+    } catch (error) {
+      Logger.error('Redis client is not ready', error);
+      return false;
+    }
+  }
+
   async onModuleInit() {
     const usePersistent = this.configService.get<string>(
       'USE_PERSISTENT_STORAGE',
@@ -33,7 +43,19 @@ export class RedisClientProvider implements OnModuleInit, OnModuleDestroy {
     }
 
     const redisUrl = this.configService.get<string>('REDIS_URL');
-    this.client = createClient({ url: redisUrl });
+    this.client = createClient({
+      url: redisUrl,
+      socket: {
+        reconnectStrategy: (retries) => {
+          if (retries > 5) {
+            Logger.warn('🔌 Redis reconnect limit reached');
+            return new Error('Stop retrying Redis');
+          }
+          Logger.warn('Redis reconnecting...', retries);
+          return 30_000;
+        },
+      },
+    });
 
     this.client.on('error', (err) =>
       Logger.error('Redis client error', err, 'REDIS_CLIENT'),
diff --git a/api/src/infrastructure/repository/shorten-url/persistent-url-storage.repository.ts b/api/src/infrastructure/repository/shorten-url/persistent-url-storage.repository.ts
@@ -1,13 +1,9 @@
 import { ShortenUrlRepository } from '../../../shorten-url/shorten-url.repository';
-import { Inject, Injectable, Logger } from '@nestjs/common';
+import { Injectable, Logger } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
-import {
-  DynamoDBClient,
-  PutItemCommand,
-  GetItemCommand,
-} from '@aws-sdk/client-dynamodb';
 import { unmarshall } from '@aws-sdk/util-dynamodb';
 import { RedisClientProvider } from '../../provider/redis-client.provider';
+import { DynamoDbClientProvider } from '../../provider/dynamo-db-client-provider.service';
 
 @Injectable()
 export class PersistentUrlStorageRepository implements ShortenUrlRepository {
@@ -18,8 +14,7 @@ export class PersistentUrlStorageRepository implements ShortenUrlRepository {
   constructor(
     private readonly configService: ConfigService,
     private readonly redisClient: RedisClientProvider | null,
-    @Inject(DynamoDBClient)
-    private readonly dynamoDbClient: DynamoDBClient | null,
+    private readonly dynamoDbClient: DynamoDbClientProvider | null,
   ) {
     this.redisTTL = this.configService.get<number>(
       'REDIS_TTL',
@@ -32,17 +27,7 @@ export class PersistentUrlStorageRepository implements ShortenUrlRepository {
     const now = new Date().toISOString();
 
     // Write to DynamoDB
-    await this.dynamoDbClient.send(
-      new PutItemCommand({
-        TableName: this.tableName,
-        Item: {
-          shortId: { S: shortId },
-          originalUrl: { S: originalUrl },
-          createdAt: { S: now },
-        },
-      }),
-    );
-
+    await this.dynamoDbClient.putItem(shortId, originalUrl, this.tableName);
     // Cache in Redis
     await this.redisClient.set(`short:${shortId}`, originalUrl, this.redisTTL);
   }
@@ -58,12 +43,7 @@ export class PersistentUrlStorageRepository implements ShortenUrlRepository {
     Logger.debug(`Cache miss for ${shortId}. Fetching from DynamoDB...`);
 
     // Fall back to DynamoDB
-    const result = await this.dynamoDbClient.send(
-      new GetItemCommand({
-        TableName: this.tableName,
-        Key: { shortId: { S: shortId } },
-      }),
-    );
+    const result = await this.dynamoDbClient.getItem(shortId, this.tableName);
 
     if (!result.Item) return null;
 
diff --git a/api/src/infrastructure/repository/shorten-url/shorten-url-repository.factory.ts b/api/src/infrastructure/repository/shorten-url/shorten-url-repository.factory.ts
@@ -5,6 +5,7 @@ import { ShortenUrlRepository } from '../../../shorten-url/shorten-url.repositor
 import { PersistentUrlStorageRepository } from './persistent-url-storage.repository';
 import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
 import { RedisClientProvider } from '../../provider/redis-client.provider';
+import { DynamoDbClientProvider } from '../../provider/dynamo-db-client-provider.service';
 
 /**
  * Factory provider to select the appropriate repository implementation based on configuration.
@@ -14,8 +15,8 @@ export const ShortenUrlRepositoryFactory: Provider = {
   provide: ShortenUrlRepository,
   useFactory: (
     configService: ConfigService,
-    redisClientService: RedisClientProvider | null,
-    dynamoDbClient: DynamoDBClient | null,
+    redisClientProvider: RedisClientProvider | null,
+    dynamoDbClientProvider: DynamoDbClientProvider | null,
   ) => {
     const usePersistenceStorage = configService.get<string>(
       'USE_PERSISTENT_STORAGE',
@@ -25,12 +26,12 @@ export const ShortenUrlRepositoryFactory: Provider = {
     if (usePersistenceStorage === 'true') {
       return new PersistentUrlStorageRepository(
         configService,
-        redisClientService,
-        dynamoDbClient,
+        redisClientProvider,
+        dynamoDbClientProvider,
       );
     }
 
     return new InMemoryUrlStorageRepository();
   },
-  inject: [ConfigService, RedisClientProvider, DynamoDBClient],
+  inject: [ConfigService, RedisClientProvider, DynamoDbClientProvider],
 };
diff --git a/api/src/main.ts b/api/src/main.ts
@@ -36,7 +36,9 @@ async function bootstrap() {
   );
 
   const port = process.env.PORT || 3000;
-  await app.listen(port).then(() => Logger.log(`Server started on ${port}`));
+  await app
+    .listen(port)
+    .then(() => Logger.log(`API Server started on ${port}`));
 }
 
 bootstrap();
diff --git a/docker-compose.yml b/docker-compose.yml
@@ -75,8 +75,6 @@ services:
       - ./scripts:/scripts
     entrypoint: ["/bin/sh", "-c", "/scripts/init-dynamodb.sh"]
 
-
-
 volumes:
   redis_data:
     driver: local

Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,9 @@ async function bootstrap() {`
`36`	`36`	`);`
`37`	`37`
`38`	`38`	`const port = process.env.PORT \|\| 3000;`
`39`		- await app.listen(port).then(() => Logger.log(`Server started on ${port}`));
	`39`	`+ await app`
	`40`	`+ .listen(port)`
	`41`	+ .then(() => Logger.log(`API Server started on ${port}`));
`40`	`42`	`}`
`41`	`43`
`42`	`44`	`bootstrap();`