Mene su saka sadarwa?

Question

Accepted Answer

**Saka sadarwa** sun warkatse aiwatarwa na gaduje-maigida, suna ba ku damar gudanatawa watsit **kafin da kuma bayan** haka — kuma suna iya canza bubuwa ko mayawa. An samu wahayi daga ilimin aiki-jiya, kuma an fi aiki da su don abubuwan da ke faruwa cikin duk mahimmin sansani kamar shiryawa, jiyar mayawa, ajiye bayani, da lokaci.}

## Tsarin: kafin da kuma bayan ta hanyar RxJS

```ts
@Injectable()
export class LoggingInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    console.log("Before handler");          // runs BEFORE the route handler
    const now = Date.now();

return next.handle().pipe(               // next.handle() = invoke the handler
      tap(() => console.log(`After: ${Date.now() - now}ms`)),   // runs AFTER
    );
  }
}
```

Saka sadarwa tana aiwatar `intercept()`. Rubutu kafin `next.handle()` yana gudana **kafin** maigida; `next.handle()` yana buga RxJS `Observable` na mayawa, kuma masu aiki kamar `tap`/`map` suna ba ku damar aiki akan mayawa **bayan** maigida ya gama.

## Canzawa mayawa (aiki da aka fi amfani da shi)

```ts
@Injectable()
export class TransformInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler) {
    return next.handle().pipe(
      map(data => ({ success: true, data, timestamp: new Date().toISOString() })),
      // wraps EVERY response in a consistent envelope: { success, data, timestamp }
    );
  }
}
```

Ta amfani da `map`, saka sadarwa tana iya canza sauye kowane mayawa — alal misali tunkarar kowane mayawa a cikin daidaita jiki, wando mai yawa don daidaitar ilmanin API.

## Wasu amfani masu karfi

```ts
// caching — return a cached response, skipping the handler entirely
// timeout — fail requests taking too long
return next.handle().pipe(timeout(5000));

// error mapping — transform exceptions
return next.handle().pipe(catchError(err => throwError(() => new BadGatewayException())));

// excluding fields (serialization) — ClassSerializerInterceptor strips @Exclude() fields
```

```text
Common interceptor uses:
  ✓ Logging / timing requests (before + after)
  ✓ Transforming responses (consistent envelopes, field exclusion)
  ✓ Caching responses
  ✓ Adding timeouts
  ✓ Mapping/handling errors
```

## Amfani da saka sadarwa

```ts
@UseInterceptors(LoggingInterceptor)   // method or controller level
app.useGlobalInterceptors(new TransformInterceptor());   // global
```

## Saka sadarwa da iska da gadi

```text
Middleware  → runs BEFORE everything, with raw req/res (can't easily touch the response)
Guard       → AUTHORIZATION decision (allow/block) before the handler
Interceptor → wraps the handler — runs BEFORE and AFTER, can TRANSFORM the response
```

Abun da ya bayyana: saka sadarwa tana iya gudanatawa **bayan** maigida kuma **canza mayawa** — wanda iska da gadi ba za su iya yi haka cikin sauyi ba.

## Me ya shafi

Saka sadarwa abin aiki ne mai karfi na NestJS don sarrafa **abubuwan da ke faruwa cikin duk mahimmin sansani** sauyi, kuma arziki ta musamman — gudanatawa watsit **kafin da kuma bayan** maigida, kuma canza mayawa — sai su ne kayan aiki daidai don bukatun da iska da gadi ba za su shaidanci ba.
\