get original url from shortened url

Author: selimyanat

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

@@ -10,8 +10,15 @@ export class InMemoryUrlRepository implements ShortenUrlRepository {
     return Promise.resolve(undefined);
   }
 
-  findURL(url: string): Promise<string | null> {
+  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,
+    );
+    return Promise.resolve(originalUrl || null);
+  }
 }

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

@@ -31,11 +31,32 @@ export class RedisUrlRepository
   }
 
   async create(url: string, shortenedUrl: string): Promise<void> {
-    await this.redisClient.set(url, shortenedUrl, { EX: this.redisTTL });
+    // 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}`,
+      {
+        EX: this.redisTTL,
+      },
+    );
+  }
+
+  async findShortenedURL(shortenedUrl: string): Promise<string | null> {
+    return await this.redisClient.get(`shortenedUrl:${shortenedUrl}`);
   }
 
-  async findURL(url: string): Promise<string | null> {
-    return await this.redisClient.get(url);
+  async findOriginalURL(originalUrl: string): Promise<string | null> {
+    return await this.redisClient.get(`originalUrl:${originalUrl}`);
   }
 
   async onModuleInit() {

api/src/infrastructure/repository/repository.provider.ts

@@ -9,7 +9,6 @@ import { RedisUrlRepository } from './redis-url.repository';
  */
 export const RepositoryProvider: Provider = {
   // TODO: Use a constant for the key
-  //provide: 'ShortenUrlRepository',
   provide: ShortenUrlRepository,
   useFactory: (configService: ConfigService) => {
     const persistenceType = configService.get<string>(

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

@@ -0,0 +1,40 @@
+import { ShortenUrlController } from './shorten-url.controller';
+import { GetOriginalUrlController } from './get-original-url.controller';
+import { Test, TestingModule } from '@nestjs/testing';
+import { ConfigModule } from '@nestjs/config';
+import { ShortenUrlModule } from './shorten-url.module';
+
+describe('ShortenUrl controller', () => {
+  let shortenUrlController: ShortenUrlController;
+  let underTest: GetOriginalUrlController;
+
+  beforeEach(async () => {
+    const app: TestingModule = await Test.createTestingModule({
+      imports: [await ConfigModule.forRoot(), ShortenUrlModule],
+    }).compile();
+
+    shortenUrlController = app.get<ShortenUrlController>(ShortenUrlController);
+    underTest = app.get<GetOriginalUrlController>(GetOriginalUrlController);
+  });
+
+  describe('getOriginalUrl', () => {
+    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';
+
+      // Use the shorten URL controller to create the shortened URL
+      const shortenedResponse = await shortenUrlController.shortenUrl({
+        url: longUrl,
+      });
+      const shortenedUrl = shortenedResponse.shortenedUrl;
+
+      // Now retrieve the original URL using GetOriginalUrlController
+      const response = await underTest.getOriginalUrl({
+        shortenedUrl: shortenedUrl,
+      });
+
+      expect(response).not.toBeNull();
+      expect(response.originalUrl).toBe(longUrl);
+    });
+  });
+});

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

@@ -0,0 +1,19 @@
+import { Body, Controller, Get } from '@nestjs/common';
+import { GetOriginalUrlDto } from './get-original-url.dto';
+import { ShortenUrlUsecase } from './shorten-url.usecase';
+import { GetOriginalUrlUsecase } from './get-original-url.usecase';
+
+@Controller('/shorten-url')
+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 };
+  }
+}

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

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

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

@@ -0,0 +1,14 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { ShortenUrlRepository } from './shorten-url.repository';
+
+@Injectable()
+export class GetOriginalUrlUsecase {
+  constructor(
+    @Inject('ShortenUrlRepository')
+    private readonly shortenUrlRepository: ShortenUrlRepository,
+  ) {}
+
+  async getOriginalUrl(shortenedUrl: string): Promise<string | null> {
+    return await this.shortenUrlRepository.findOriginalURL(shortenedUrl);
+  }
+}

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

@@ -5,20 +5,23 @@ import { ShortenUrlUsecase } from './shorten-url.usecase';
 import { ShortenUrlIdGeneratorService } from './shorten-url.id-generator.service';
 import { InfrastructureModule } from '../infrastructure/infrastructure.module';
 import { ShortenUrlRepository } from './shorten-url.repository';
+import { GetOriginalUrlUsecase } from './get-original-url.usecase';
+import { GetOriginalUrlController } from './get-original-url.controller';
 
 @Module({
   imports: [
     ConfigModule, // ✅ Ensure ConfigModule is available
     InfrastructureModule.register(), // ✅ Register InfrastructureModule dynamically
   ],
-  controllers: [ShortenUrlController],
+  controllers: [ShortenUrlController, GetOriginalUrlController],
   providers: [
     {
       provide: 'ShortenUrlRepository',
       useExisting: ShortenUrlRepository, // ✅ Use injected provider
     },
     ShortenUrlIdGeneratorService,
     ShortenUrlUsecase,
+    GetOriginalUrlUsecase,
   ],
 })
 export class ShortenUrlModule {}

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

@@ -1,5 +1,7 @@
 export abstract class ShortenUrlRepository {
-  abstract findURL(url: string): Promise<string | null>;
+  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,9 +27,8 @@ export class ShortenUrlUsecase {
   }
 
   async shortenUrl(originalURL: string): Promise<string> {
-    const existingShortenedUrl = await this.shortenUrlRepository.findURL(
-      originalURL,
-    );
+    const existingShortenedUrl =
+      await this.shortenUrlRepository.findShortenedURL(originalURL);
 
     if (existingShortenedUrl) {
       return existingShortenedUrl;