Feat/use in memory repo to save url

Use an in-memory repository to save shortened url

Author: selimyanat

.github/workflows/ci.yml

@@ -38,6 +38,8 @@ jobs:
       - name: Create .env file
         run: |
           echo "MACHINE_ID=1" > .env
+          echo "PORT=3000" >> .env
+          echo "SHORTENED_BASE_URL=http://localhost:3000" >> .env
         working-directory: api  # Ensure it is created inside `api/`
 
       - name: Run Tests (API)

api/package.json

@@ -24,6 +24,8 @@
     "@nestjs/config": "4.0.0",
     "@nestjs/core": "10.0.0",
     "@nestjs/platform-express": "10.0.0",
+    "class-transformer": "0.5.1",
+    "class-validator": "0.14.1",
     "reflect-metadata": "0.2.0",
     "rxjs": "7.8.1"
   },

api/src/app.module.ts

@@ -1,9 +1,10 @@
 import { Module } from '@nestjs/common';
 import { ConfigModule } from '@nestjs/config';
 import { ShortenUrlModule } from './shorten-url/shorten-url.module';
+import { InfrastructureModule } from './infrastructure/infrastructure.module';
 
 @Module({
-  imports: [ConfigModule.forRoot(), ShortenUrlModule], // Load environment variables
+  imports: [ConfigModule.forRoot(), InfrastructureModule, ShortenUrlModule], // Load environment variables
   controllers: [],
   providers: [],
 })

api/src/infrastructure/infrastructure.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { InMemoryUrlRepository } from '../infrastructure/repository/in-memory-url.repository';
+
+@Module({
+  imports: [ConfigModule.forRoot()], // Load environment variables
+  controllers: [],
+  providers: [InMemoryUrlRepository],
+})
+export class InfrastructureModule {}

api/src/infrastructure/repository/in-memory-url.repository.ts

@@ -0,0 +1,17 @@
+import { ShortenUrlRepository } from '../../shorten-url/shorten-url.repository';
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class InMemoryUrlRepository implements ShortenUrlRepository {
+  private urls: Map<string, string> = new Map();
+
+  create(url: string, shortenedUrl: string): Promise<void> {
+    this.urls.set(url, shortenedUrl);
+    return Promise.resolve(undefined);
+  }
+
+  findURL(url: string): Promise<string | null> {
+    const shortenedUrl = this.urls.get(url);
+    return Promise.resolve(shortenedUrl);
+  }
+}

api/src/main.ts

@@ -1,8 +1,42 @@
 import { NestFactory } from '@nestjs/core';
 import { AppModule } from './app.module';
+import {
+  BadRequestException,
+  Logger,
+  ValidationError,
+  ValidationPipe,
+} from '@nestjs/common';
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
-  await app.listen(process.env.PORT ?? 3001);
+
+  app.useGlobalPipes(
+    new ValidationPipe({
+      transform: true,
+      exceptionFactory: (validationErrors: ValidationError[] = []) => {
+        Logger.log('error', validationErrors);
+        const formatError = (error: ValidationError) => {
+          if (error.children?.length) {
+            return {
+              field: error.property,
+              errors: error.children.map(formatError),
+            };
+          }
+          return {
+            field: error.property,
+            errors: Object.values(error.constraints ?? {}),
+          };
+        };
+
+        return new BadRequestException(
+          validationErrors.map((error) => formatError(error)),
+        );
+      },
+    }),
+  );
+
+  const port = process.env.PORT || 3000;
+  await app.listen(port).then(() => Logger.log(`Server started on ${port}`));
 }
+
 bootstrap();

api/src/shorten-url/create-shorten-url.dto.ts

@@ -0,0 +1,6 @@
+import { IsString, IsUrl } from 'class-validator';
+
+export class CreateShortenUrlDto {
+  @IsUrl()
+  url: string;
+}

api/src/shorten-url/shorten-url.controller.spec.ts

@@ -1,17 +1,14 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { ShortenUrlController } from './shorten-url.controller';
-import { ShortenUrlUsecase } from './shorten-url.usecase';
-import { ShortenUrlIdGeneratorService } from './shorten-url.id-generator.service';
 import { ConfigModule } from '@nestjs/config';
+import { ShortenUrlModule } from './shorten-url.module';
 
 describe('ShortenUrl controller', () => {
   let underTest: ShortenUrlController;
 
   beforeEach(async () => {
     const app: TestingModule = await Test.createTestingModule({
-      imports: [await ConfigModule.forRoot()],
-      controllers: [ShortenUrlController],
-      providers: [ShortenUrlIdGeneratorService, ShortenUrlUsecase],
+      imports: [await ConfigModule.forRoot(), ShortenUrlModule],
     }).compile();
 
     underTest = app.get<ShortenUrlController>(ShortenUrlController);
@@ -21,13 +18,13 @@ describe('ShortenUrl controller', () => {
     it('should return a valid Base62 short URL with 10 chars length', async () => {
       const longUrl =
         'https://zapper.xyz/very-long-url/very-long-url/very-long-url';
-      const shortenedUrl = await underTest.shortenUrl(longUrl); // Assuming it's async
+      const response = await underTest.shortenUrl({ url: longUrl });
 
       // Extract the unique ID part of the URL
-      const urlPattern = /^https:\/\/zapper\.xyz\/([A-Za-z0-9]{10})$/;
-      const match = shortenedUrl.match(urlPattern);
+      const urlPattern = /^http:\/\/localhost:3000\/([A-Za-z0-9]{10})$/;
+      const match = response?.shortenedUrl.match(urlPattern);
 
-      expect(shortenedUrl).not.toBeNull();
+      expect(response).not.toBeNull();
       expect(match).not.toBeNull(); // Ensure it matches the pattern
       expect(match![1].length).toBe(10); // Validate the ID part has 10 characters
     });

api/src/shorten-url/shorten-url.controller.ts

@@ -1,12 +1,19 @@
-import { Controller, Post } from '@nestjs/common';
+import { Body, Controller, Logger, Post } from '@nestjs/common';
 import { ShortenUrlUsecase } from './shorten-url.usecase';
+import { CreateShortenUrlDto } from './create-shorten-url.dto';
 
 @Controller('/shorten-url')
 export class ShortenUrlController {
   constructor(private readonly shortenUrlUsecase: ShortenUrlUsecase) {}
 
   @Post()
-  shortenUrl(url: string): string {
-    return this.shortenUrlUsecase.createTinyURL('https://zapper.xyz');
+  async shortenUrl(
+    @Body() request: CreateShortenUrlDto,
+  ): Promise<{ shortenedUrl: string }> {
+    Logger.log(`Received url ${request.url} to shorten`);
+    const shortenedUrl = await this.shortenUrlUsecase.createTinyURL(
+      request.url,
+    );
+    return { shortenedUrl };
   }
 }

api/src/shorten-url/shorten-url.module.ts

@@ -3,10 +3,16 @@ import { ConfigModule } from '@nestjs/config';
 import { ShortenUrlController } from './shorten-url.controller';
 import { ShortenUrlUsecase } from './shorten-url.usecase';
 import { ShortenUrlIdGeneratorService } from './shorten-url.id-generator.service';
+import { InMemoryUrlRepository } from '../infrastructure/repository/in-memory-url.repository';
+import { InfrastructureModule } from '../infrastructure/infrastructure.module';
 
 @Module({
-  imports: [ConfigModule.forRoot()], // Load environment variables
+  imports: [ConfigModule.forRoot(), InfrastructureModule], // Load environment variables
   controllers: [ShortenUrlController],
-  providers: [ShortenUrlIdGeneratorService, ShortenUrlUsecase],
+  providers: [
+    { provide: 'ShortenUrlRepository', useClass: InMemoryUrlRepository },
+    ShortenUrlIdGeneratorService,
+    ShortenUrlUsecase,
+  ],
 })
 export class ShortenUrlModule {}