redirect request with shorted url to original url

Author: selimyanat

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

@@ -10,11 +10,6 @@ export class InMemoryUrlRepository implements ShortenUrlRepository {
     return Promise.resolve(undefined);
   }
 
-  findShortenedURL(url: string): Promise<string | null> {
-    const shortenedUrl = this.urls.get(url);
-    return Promise.resolve(shortenedUrl);
-  }
-
   findOriginalURL(shortenedUrl: string): Promise<string | null> {
     const originalUrl = Array.from(this.urls.keys()).find(
       (key) => this.urls.get(key) === shortenedUrl,

api/src/infrastructure/repository/redis-url.repository.ts

@@ -14,9 +14,9 @@ export class RedisUrlRepository
 {
   private readonly DEFAULT_TTL = 100;
 
-  private redisClient: RedisClientType;
+  private readonly redisTTL: number;
 
-  private redisTTL: number;
+  private redisClient: RedisClientType;
 
   constructor(private readonly configService: ConfigService) {
     const redisUrl = this.configService.get<string>('REDIS_URL');
@@ -31,17 +31,6 @@ export class RedisUrlRepository
   }
 
   async create(url: string, shortenedUrl: string): Promise<void> {
-    // Use two keys to allow both forward and reverse lookup because:
-    // Efficient retrieval (O(1) time complexity)
-    // No need to scan all keys
-    // Reduces query complexity
-    await this.redisClient.set(
-      `originalUrl:${url}`,
-      `shortenedUrl: ${shortenedUrl}`,
-      {
-        EX: this.redisTTL,
-      },
-    ); // 1 day expiry
     await this.redisClient.set(
       `shortenedUrl: ${shortenedUrl}`,
       `originalUrl: ${url}`,
@@ -51,10 +40,6 @@ export class RedisUrlRepository
     );
   }
 
-  async findShortenedURL(shortenedUrl: string): Promise<string | null> {
-    return await this.redisClient.get(`shortenedUrl:${shortenedUrl}`);
-  }
-
   async findOriginalURL(originalUrl: string): Promise<string | null> {
     return await this.redisClient.get(`originalUrl:${originalUrl}`);
   }

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

@@ -17,7 +17,7 @@ describe('ShortenUrl controller', () => {
     underTest = app.get<GetOriginalUrlController>(GetOriginalUrlController);
   });
 
-  describe('getOriginalUrl', () => {
+  describe('Redirect to original url', () => {
     it('should return the original URL for a given shortened URL', async () => {
       const longUrl =
         'https://zapper.xyz/very-long-url/very-long-url/very-long-url';
@@ -26,15 +26,26 @@ describe('ShortenUrl controller', () => {
       const shortenedResponse = await shortenUrlController.shortenUrl({
         url: longUrl,
       });
+
+      // Extract the slug from the shortened URL
       const shortenedUrl = shortenedResponse.shortenedUrl;
+      const slug = shortenedUrl.split('/').pop();
 
       // Now retrieve the original URL using GetOriginalUrlController
-      const response = await underTest.getOriginalUrl({
-        shortenedUrl: shortenedUrl,
-      });
+      const response = await underTest.getOriginalUrl(slug);
 
-      expect(response).not.toBeNull();
-      expect(response.originalUrl).toBe(longUrl);
+      // TODO check with an integration / e2e test the redirection code (302)
+      expect(response).toEqual({ url: longUrl });
     });
   });
+
+  it('should return 404 if the shortened URL is not found', async () => {
+    const redirect = jest.fn();
+    const res = { redirect } as any;
+
+    const slug = 'does-not-exist';
+    await expect(underTest.getOriginalUrl(slug)).rejects.toThrow(
+      'Shortened URL "does-not-exist" not found',
+    );
+  });
 });

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

@@ -1,19 +1,24 @@
-import { Body, Controller, Get } from '@nestjs/common';
-import { GetOriginalUrlDto } from './get-original-url.dto';
-import { ShortenUrlUsecase } from './shorten-url.usecase';
+import {
+  Controller,
+  Get,
+  NotFoundException,
+  Param,
+  Redirect,
+} from '@nestjs/common';
 import { GetOriginalUrlUsecase } from './get-original-url.usecase';
 
-@Controller('/shorten-url')
+@Controller()
 export class GetOriginalUrlController {
   constructor(private readonly getOriginalUrlUsecase: GetOriginalUrlUsecase) {}
 
-  @Get()
-  async getOriginalUrl(
-    @Body() request: GetOriginalUrlDto,
-  ): Promise<{ originalUrl: string }> {
-    const originalUrl = await this.getOriginalUrlUsecase.getOriginalUrl(
-      request.shortenedUrl,
-    );
-    return { originalUrl };
+  @Get(':slug')
+  @Redirect(undefined, 302)
+  async getOriginalUrl(@Param('slug') slug: string) {
+    const originalUrl = await this.getOriginalUrlUsecase.getOriginalUrl(slug);
+    if (!originalUrl) {
+      throw new NotFoundException(`Shortened URL "${slug}" not found`);
+    }
+    // Use temporary redirect to original URL so that we can capture analytics
+    return { url: originalUrl };
   }
 }

api/src/shorten-url/get-original-url.usecase.ts

@@ -9,6 +9,8 @@ export class GetOriginalUrlUsecase {
   ) {}
 
   async getOriginalUrl(shortenedUrl: string): Promise<string | null> {
-    return await this.shortenUrlRepository.findOriginalURL(shortenedUrl);
+    // TODO: reconstruct the URL ? or store only the shorted path ??
+    const url = 'http://localhost:3000/' + shortenedUrl;
+    return await this.shortenUrlRepository.findOriginalURL(url);
   }
 }

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

@@ -1,6 +1,4 @@
 export abstract class ShortenUrlRepository {
-  abstract findShortenedURL(url: string): Promise<string | null>;
-
   abstract create(url: string, shortenedUrl: string): Promise<void>;
 
   abstract findOriginalURL(shortenedUrl: string): Promise<string | null>;

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

@@ -27,12 +27,6 @@ export class ShortenUrlUsecase {
   }
 
   async shortenUrl(originalURL: string): Promise<string> {
-    const existingShortenedUrl =
-      await this.shortenUrlRepository.findShortenedURL(originalURL);
-
-    if (existingShortenedUrl) {
-      return existingShortenedUrl;
-    }
     const id = this.idGenerator.generateId();
     const encodedId = this.encodeBase62(Number(id));
     const shortenedUrl = this.shortenedBaseUrl + '/' + encodedId;
@@ -51,13 +45,4 @@ export class ShortenUrlUsecase {
     }
     return encoded;
   }
-
-  private getBaseUrl(url: string): string {
-    try {
-      const parsedUrl = new URL(url);
-      return `${parsedUrl.protocol}//${parsedUrl.hostname}`;
-    } catch (error) {
-      throw new Error(`Invalid URL: ${url}`);
-    }
-  }
 }