encapsulate the url in an URL object

Author: selimyanat

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

@@ -5,14 +5,14 @@ import { Injectable, Logger } from '@nestjs/common';
 export class InMemoryUrlRepository implements ShortenUrlRepository {
   private urls: Map<string, string> = new Map();
 
-  create(url: string, shortenedUrl: string): Promise<void> {
-    this.urls.set(url, shortenedUrl);
+  create(url: string, encodedUrl: string): Promise<void> {
+    this.urls.set(url, encodedUrl);
     return Promise.resolve(undefined);
   }
 
-  findOriginalURL(shortenedUrl: string): Promise<string | null> {
+  findOriginalURL(encodedUrl: string): Promise<string | null> {
     const originalUrl = Array.from(this.urls.keys()).find(
-      (key) => this.urls.get(key) === shortenedUrl,
+      (key) => this.urls.get(key) === encodedUrl,
     );
     return Promise.resolve(originalUrl || null);
   }

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

@@ -30,18 +30,18 @@ export class RedisUrlRepository
     );
   }
 
-  async create(url: string, shortenedUrl: string): Promise<void> {
+  async create(url: string, encodedUrl: string): Promise<void> {
     await this.redisClient.set(
-      `shortenedUrl: ${shortenedUrl}`,
+      `encodedUrl: ${encodedUrl}`,
       `originalUrl: ${url}`,
       {
         EX: this.redisTTL,
       },
     );
   }
 
-  async findOriginalURL(originalUrl: string): Promise<string | null> {
-    return await this.redisClient.get(`originalUrl:${originalUrl}`);
+  async findOriginalURL(encodedUrl: string): Promise<string | null> {
+    return await this.redisClient.get(`encodedUrl:${encodedUrl}`);
   }
 
   async onModuleInit() {

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

@@ -11,7 +11,8 @@ export class CreateShortenUrlController {
     @Body() request: CreateShortenUrlDto,
   ): Promise<{ shortenedUrl: string }> {
     // TODO perhaps it is worth converting the URL from string to URL object
-    const shortenedUrl = await this.shortenUrlUsecase.shortenUrl(request.url);
-    return { shortenedUrl };
+    const url = new URL(request.url);
+    const shortenedUrl = await this.shortenUrlUsecase.shortenUrl(url);
+    return { shortenedUrl: shortenedUrl.toString() };
   }
 }

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

@@ -26,11 +26,11 @@ export class CreateShortenUrlUsecase {
       this.configService.get<string>('SHORTENED_BASE_URL');
   }
 
-  async shortenUrl(originalURL: string): Promise<string> {
+  async shortenUrl(originalURL: URL): Promise<URL> {
     const id = this.idGenerator.generateId();
-    const encodedId = this.encodeBase62(Number(id));
-    const shortenedUrl = this.shortenedBaseUrl + '/' + encodedId;
-    await this.shortenUrlRepository.create(originalURL, shortenedUrl);
+    const encodedUrl = this.encodeBase62(Number(id));
+    await this.shortenUrlRepository.create(originalURL.toString(), encodedUrl);
+    const shortenedUrl = new URL(encodedUrl, this.shortenedBaseUrl);
     return shortenedUrl;
   }
 

api/src/shorten-url/redirect-to-original-url/redirect-to-original-url-controller.spec.ts

@@ -44,9 +44,6 @@ describe('Redirect to original url controller', () => {
   });
 
   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.redirectToOriginalUrl(slug)).rejects.toThrow(
       'Shortened URL "does-not-exist" not found',

api/src/shorten-url/redirect-to-original-url/redirect-to-original-url.controller.ts

@@ -23,6 +23,6 @@ export class RedirectToOriginalUrlController {
       throw new NotFoundException(`Shortened URL "${slug}" not found`);
     }
     // Use temporary redirect to original URL so that we can capture analytics
-    return { url: originalUrl };
+    return { url: originalUrl.toString() };
   }
 }

api/src/shorten-url/redirect-to-original-url/redirect-to-original-url.usecase.ts

@@ -8,9 +8,8 @@ export class RedirectToOriginalUrlUsecase {
     private readonly shortenUrlRepository: ShortenUrlRepository,
   ) {}
 
-  async redirectToOriginalUrl(slug: string): Promise<string | null> {
-    // TODO: reconstruct the URL ? or store only the shorted path ??
-    const url = 'http://localhost:3000/' + slug;
-    return await this.shortenUrlRepository.findOriginalURL(url);
+  async redirectToOriginalUrl(slug: string): Promise<URL | null> {
+    const originalUrl = await this.shortenUrlRepository.findOriginalURL(slug);
+    return originalUrl ? new URL(originalUrl) : null;
   }
 }

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

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