Unashughulikiaje exceptions katika NestJS?

Question

Accepted Answer

NestJS ina **exception layer iliyojengwa ndani** ambayo hunasa kiotomatiki makosa yasiyoshughulikiwa na kuyabadilisha kuwa HTTP responses sahihi. Unaashiria makosa kwa **kutupa exceptions** (mara nyingi built-in HTTP exception classes), na Nest huziunda kuwa structured JSON responses zenye status code sahihi.

## Kutupa built-in HTTP exceptions

```ts
import { NotFoundException, BadRequestException, UnauthorizedException } from "@nestjs/common";

@Get(":id")
findOne(@Param("id") id: string) {
  const user = this.usersService.findOne(id);
  if (!user) {
    throw new NotFoundException("User not found");   // → 404 with a JSON error body
  }
  return user;
}
```

NestJS hutoa exception classes zinazolingana na HTTP status codes, na kutupa moja huzalisha response sahihi, iliyopangwa kiotomatiki:

```json
{ "statusCode": 404, "message": "User not found", "error": "Not Found" }
```

## Built-in HTTP exceptions zinazojulikana

```text
BadRequestException        → 400
UnauthorizedException      → 401
ForbiddenException         → 403
NotFoundException          → 404
ConflictException          → 409
UnprocessableEntityException → 422
InternalServerErrorException → 500
```

Kuna class kwa kila kosa la kawaida la HTTP — tumia ile inayofaa kuwasilisha status sahihi.

## Ujumbe maalum na HttpException ya jumla

```ts
// custom status + body via the base HttpException
throw new HttpException(
  { status: HttpStatus.FORBIDDEN, error: "custom message" },
  HttpStatus.FORBIDDEN,
);
```

## Custom exception classes

```ts
export class UserNotFoundException extends NotFoundException {
  constructor(id: string) {
    super(`User with id ${id} not found`);   // domain-specific, reusable
  }
}
throw new UserNotFoundException(id);
```

## Makosa yasiyoshughulikiwa huwa 500s

```text
If code throws a non-HttpException error (e.g. a plain Error or an unexpected
exception), NestJS's default exception filter catches it and returns a generic
500 Internal Server Error (without leaking internal details to the client).
```

## Exception filters kwa ubinafsishaji wa kimataifa

```ts
// a custom exception filter customizes how errors are formatted/logged globally
@Catch()
export class AllExceptionsFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    // log, format the response, etc.
  }
}
app.useGlobalFilters(new AllExceptionsFilter());   // apply app-wide
```

Kwa uundaji thabiti wa makosa, logging, au kushughulikia makosa yasiyo ya HTTP, unatumia **exception filters** (kipengele kinachohusiana, cha kiwango cha juu zaidi).

## Kwa nini ni muhimu

Kushughulikia exceptions ipasavyo ni muhimu kwa kujenga API zinazotegemewa, na exception layer iliyojengwa ndani ya NestJS hulifanya hili kuwa safi na thabiti.

Kuelewa jinsi ya **kutupa HTTP exceptions** (`NotFoundException`, `BadRequestException`, n.k.) ni maarifa ya kila siku — ndiyo njia ya kawaida ya kuashiria makosa kwa status codes sahihi na structured, client-friendly JSON responses, bila kuunda error responses kwa mkono katika kila handler.

Framework hunasa hizi kiotomatiki na kuziunda, na hubadilisha kwa usalama makosa yasiyotarajiwa kuwa 500s za jumla bila kuvujisha maelezo ya ndani (muhimu kwa usalama).

Kujua exception classes zinazojulikana, jinsi ya kutupa ujumbe/exceptions maalum, na kuwa **exception filters** zipo kwa ubinafsishaji wa kimataifa (uundaji thabiti, logging) ni msingi kwa kujenga API za NestJS imara na za kitaalamu.

Kushughulikia makosa kwa usafi na uthabiti ni alama ya code bora ya back-end, jambo linalolifanya hili kuwa kipengele cha msingi, kinachotumika mara kwa mara cha framework.