Cad iad scagairí eisceachtúil?

Question

Accepted Answer

**Scagairí eisceachtúil** a thugann duit rialú iomlán ar an gcaoi ar dhéantar earráidí a **ghabháil agus a thraschur ina freagraí**. Suíonn siad ag deireadh an timthriall iarratas, ag gabháil d'eisceachtúil a chaitear in áit ar bith san iarratas agus ag ligean duit formáid fhreagra an earráid, stádas, agus logáil a shaincheapadh.

## Scagaire eisceachtúil bunúsach

```ts
import { ExceptionFilter, Catch, ArgumentsHost, HttpException } from "@nestjs/common";

@Catch(HttpException)                    // catch HttpExceptions specifically
export class HttpExceptionFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    const request = ctx.getRequest();
    const status = exception.getStatus();

// build a CUSTOM error response shape
    response.status(status).json({
      statusCode: status,
      timestamp: new Date().toISOString(),
      path: request.url,
      message: exception.message,
    });
  }
}
```

Sonraíonn an deiceannóir `@Catch()` cén cineál eisceachtúla a bhaisteann an scagaire seo, agus faigheann an modh `catch()` an eisceachtúl agus an comhthéacs araon — ag ligean duit aon fhreagra a theastaíonn ort a chruthú.

## Gach eisceachtúl a ghabháil (lena n-áirítear neamh-HTTP)

```ts
@Catch()                                 // no argument = catch EVERYTHING
export class AllExceptionsFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const status = exception instanceof HttpException
      ? exception.getStatus()
      : 500;                              // unknown errors → 500
    // log the full error internally, return a safe message to the client
    this.logger.error(exception);
    ctx.getResponse().status(status).json({ statusCode: status, message: "..." });
  }
}
```

Baisteann scagaire le `@Catch()` (gan argóint) gach eisceachtúl — an áit ar chóir duit earráidí gan choinne a logáil agus a bheith cinnte go dtugann fiú earráidí neamh-HTTP freagra geal, sábhálte ar ais (gan stóir-rian a scaoileadh chuig an ngréasáin).

## Scagairí a chur i bhfeidhm

```ts
@UseFilters(HttpExceptionFilter)         // method or controller level
export class UsersController {}

app.useGlobalFilters(new AllExceptionsFilter());   // GLOBAL — app-wide, most common
```

Is gnách go gcuirtear scagairí i bhfeidhm **go domhanda** chun formáid earráid dhocht a fhorchuimilt ar fud an API.

## Cén fáth a úsáidtear scagairí eisceachtúil?

```text
✓ Consistent error response format across ALL endpoints (a standard shape)
✓ Centralized error LOGGING (log every error in one place)
✓ Handle non-HTTP errors safely (turn unexpected errors into clean 500s)
✓ Hide internal details from clients (no leaked stack traces — security)
✓ Add context (request path, timestamp, correlation IDs) to error responses
```

## Scagairí i gcoinne eisceachtúil a chaitheamh

```text
Throwing exceptions (NotFoundException, etc.) → SIGNALS an error with a status
Exception filters → control HOW those errors are FORMATTED/logged into responses
→ You throw exceptions in your code; filters customize the resulting response globally.
```

## Cén fáth a bhí ann

Is gné thábhachtach de NestJS iad scagairí eisceachtúil chun APIanna láidir, gairmiúil a thógáil le **láimhseáil earráide dhocht, rialaithe**.

Cé go raibh an sraith eisceachtúil ionsuite de NestJS ag iompar eisceachtúil a chaitear ar fhreagraí HTTP cheana féin, tugann scagairí eisceachtúil rialú iomlán duit chun an iompar sin a shaincheapadh — rud a bhí tábhachtach do roinnt imní fíor: **cruth freagra earráide docht** a fhorchuimilt ar fud gach críochphointe (ionas go bhfaigheann cliant earráidí sa bhformáid chéanna i gcónaí), **logáil earráide a dhéanamh lárnach** (gach earráid a ghabháil in aon áit amháin seachas foluainfhuisithe i subchéimeanna gréine), a **láimhseáil earráidí neamh-HTTP gan choinne** (iad a athrú go 500í geal in ionad imeall nó sonraí a scaoileadh), agus **slándáil** (stóraí istigh a cheilt agus sonraí mothúchánach ó chliaint fad is a logáiltear iad go hinmheánach).

Is patrún caighdeánach é scagaire "catch-all" domhanda agus eisceachtúil HTTP sonracha a chaitheamh i do chód chun láimhseáil earráide grádaithe táirgthe.

Tá tuiscint ar an uair agus conas scagairí a úsáid (seachas eisceachtúil a chaitheamh go simplí), agus iad a chur i bhfeidhm go domhanda ar son choibhneasachta, ina thréith de chuid feidhmchlár NestJS dea-bhraistinte agus ag léiriú cleachtas dhroim ar ais in aibéanna timpeall ar an imní minic-fhorghafa ach criticiúil láimhseáil earráide.