chore: correction step 1

Author: fabernovel-fnguyen

src/app.module.ts

@@ -1,9 +1,10 @@
 import { Module } from '@nestjs/common';
 import { AppController } from './app.controller';
 import { AppService } from './app.service';
+import { PokemonModule } from './pokemon/pokemon.module';
 
 @Module({
-  imports: [],
+  imports: [PokemonModule],
   controllers: [AppController],
   providers: [AppService],
 })

src/pokemon/dtos/get-pokemon-by-name.query.ts

@@ -2,7 +2,11 @@ import { ApiProperty } from '@nestjs/swagger';
 import { IsString } from 'class-validator';
 
 export class GetPokemonByNameQuery {
-  @ApiProperty({ type: 'string' })
+  @ApiProperty({
+    type: 'string',
+    description:
+      'pokemon name, must be exact and must be the name of a first-generation pokemon',
+  })
   @IsString()
   name: string;
 }

src/pokemon/dtos/get-pokemon-by-name.response.ts

@@ -0,0 +1,64 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import { IsArray, IsNumber, IsString } from 'class-validator';
+
+class PokemonSpeciesResponse {
+  @ApiProperty({
+    type: 'string',
+    description: 'species name',
+  })
+  @IsString()
+  name: string;
+
+  @ApiProperty({
+    type: 'string',
+    description: 'species URL',
+  })
+  @IsString()
+  url: string;
+}
+
+export class GetPokemonByNameResponse {
+  @ApiProperty({
+    type: 'string',
+    description: 'pokemon name',
+  })
+  @IsString()
+  name: string;
+
+  @ApiProperty({
+    type: 'number',
+    description: 'pokemon ID (from 1 to 151)',
+  })
+  @IsNumber()
+  id: number;
+
+  @ApiProperty({
+    type: 'number',
+    description: 'height',
+  })
+  @IsNumber()
+  height: number;
+
+  @ApiProperty({
+    type: 'number',
+    description: 'weight',
+  })
+  @IsNumber()
+  weight: number;
+
+  @ApiProperty({
+    type: [String],
+    description: 'pokemon ID (from 1 to 151)',
+  })
+  @IsArray()
+  @IsString({ each: true })
+  types: string[];
+
+  @ApiProperty({
+    type: () => PokemonSpeciesResponse,
+    description: 'pokemon species',
+  })
+  @Type(() => PokemonSpeciesResponse)
+  species: PokemonSpeciesResponse;
+}

src/pokemon/pokemon.controller.ts

@@ -1,13 +1,10 @@
-export var pokemonApiUrl = 'http://pokeapi.co/api/v2';
-
 import {
+  BadRequestException,
   Controller,
   Get,
   HttpException,
-  Inject,
+  InternalServerErrorException,
   NotFoundException,
-  Param,
-  Post,
   Query,
   UseInterceptors,
 } from '@nestjs/common';
@@ -16,51 +13,62 @@ import { GetPokemonByNameQuery } from './dtos/get-pokemon-by-name.query';
 import { Pokemon } from './types/pokemon';
 import { AuthInterceptor } from '../auth/auth.interceptor';
 import {
+  ApiBadRequestResponse,
   ApiInternalServerErrorResponse,
+  ApiNotFoundResponse,
   ApiQuery,
   ApiResponse,
   ApiTags,
 } from '@nestjs/swagger';
+import { PokemonNotFoundError } from './types/error';
+import { GetPokemonByNameResponse } from './dtos/get-pokemon-by-name.response';
 
 @Controller('pokemon')
 @ApiTags('pokemon')
 @UseInterceptors(AuthInterceptor)
 export class PokemonController {
   constructor(private pokemonService: PokemonService) {}
 
-  @Post('pokemon')
+  @Get('pokemon')
   @ApiQuery({
     type: GetPokemonByNameQuery,
     description: 'Lookup string for pokemons (match against pokemon name)',
   })
   @ApiResponse({
     status: 200,
-    description: 'Returns pokemons whose name matches a string query param',
+    type: GetPokemonByNameResponse,
+    description:
+      'Returns a pokemon whose name exactly matches the string query param',
+  })
+  @ApiBadRequestResponse({
+    description: 'Returned if query param "name" is empty',
+  })
+  @ApiNotFoundResponse({
+    description:
+      'Returned if no first-generation pokemon was found for this name',
   })
   @ApiInternalServerErrorResponse({
-    description: 'This will never happen, trust me',
+    description: 'Returned if any other error is encountered',
   })
   async GetPokemonByNameController(
-    @Query() name: any,
-  ): Promise<Pokemon | null> {
-    if (name === null) return;
-
-    name == null
-      ? name.trim() != ''
-        ? ((name = name),
-          (pokemonApiUrl = pokemonApiUrl + '/'),
-          (pokemonApiUrl = pokemonApiUrl + name))
-        : ((pokemonApiUrl = pokemonApiUrl + '"?offset=20"'),
-          (pokemonApiUrl = pokemonApiUrl + '&limit=20'))
-      : ((pokemonApiUrl = pokemonApiUrl + '"?offset=20"'),
-        (pokemonApiUrl = pokemonApiUrl + '&limit=20'));
-
-    console.log('Printing name for debug : ', name);
-
-    const myPokemon = await this.pokemonService.findPokemonByNameOrFail(name);
+    @Query('name') name: string,
+  ): Promise<Pokemon> {
+    try {
+      if (name === undefined || name.length === 0) {
+        throw new BadRequestException('Pokemon name cannot be empty');
+      }
 
-    console.log('Printing name for debug : ', myPokemon);
+      const myPokemon = await this.pokemonService.findPokemonByNameOrFail(name);
 
-    return myPokemon;
+      return myPokemon;
+    } catch (error) {
+      if (error instanceof PokemonNotFoundError) {
+        throw new NotFoundException(error);
+      } else if (error instanceof HttpException) {
+        throw error;
+      } else {
+        throw new InternalServerErrorException(error);
+      }
+    }
   }
 }

src/pokemon/pokemon.module.ts

@@ -4,6 +4,6 @@ import { PokemonService } from './pokemon.service';
 
 @Module({
   controllers: [PokemonController],
-  providers: [PokemonService]
+  providers: [PokemonService],
 })
 export class PokemonModule {}

src/pokemon/pokemon.service.ts

@@ -1,19 +1,19 @@
 import { Injectable } from '@nestjs/common';
-import got, { Got } from 'got';
+import got from 'got';
 import { Pokemon } from './types/pokemon';
-import { pokemonApiUrl } from './pokemon.controller';
+
 import { PokemonSpecies } from './types/species';
+import { PokemonNotFoundError, UnexpectedError } from './types/error';
 
+const POKEMON_API_URL = 'http://pokeapi.co/api/v2';
+const FIRST_GENERATION_POKEMON_LAST_ID = 151;
 @Injectable()
 export class PokemonService {
-  private httpClient: Got;
-  constructor() {
-    this.httpClient = got.extend({
-      prefixUrl: pokemonApiUrl,
-      responseType: 'json',
-      throwHttpErrors: false,
-    });
-  }
+  private readonly httpClient = got.extend({
+    prefixUrl: POKEMON_API_URL,
+    responseType: 'json',
+    throwHttpErrors: false,
+  });
 
   async findPokemonByNameOrFail(pokemonName: string): Promise<Pokemon> {
     type GetPokemonResponse = {
@@ -30,7 +30,15 @@ export class PokemonService {
       .then((response) => response.body as unknown as GetPokemonResponse)
       .then((body) => {
         if (!body.id) {
-          return null;
+          throw new PokemonNotFoundError(
+            `No pokemon found for name '${pokemonName}'`,
+          );
+        }
+
+        if (body.id > FIRST_GENERATION_POKEMON_LAST_ID) {
+          throw new PokemonNotFoundError(
+            `Pokemon '${pokemonName}' is not first-generation: ID ${body.id} > ${FIRST_GENERATION_POKEMON_LAST_ID}`,
+          );
         }
 
         const types = body.types
@@ -50,7 +58,11 @@ export class PokemonService {
         };
       })
       .catch((error) => {
-        throw error;
+        if (error instanceof PokemonNotFoundError) {
+          throw error;
+        }
+
+        throw new UnexpectedError(error);
       });
   }
 }

src/pokemon/types/error.ts

@@ -0,0 +1,3 @@
+export class PokemonNotFoundError extends Error {}
+
+export class UnexpectedError extends Error {}