რა არის middleware NestJS-ში და როგორ განსხვავდება ის guards/interceptors-ისგან?

Question

Accepted Answer

**Middleware** არის ფუნქცია, რომელიც 執행되выполняется **route handler-მდე**, request და response ობიექტებზე წვდომის მქონე — იგივე კონცეფცია, რაც Express middleware. NestJS-ს ასევე აქვს guards, interceptors, pipes და filters, რომელთაგან თითოეული request lifecycle-ის კონკრეტულ წერტილში 執行되ხორცელდება განსხვავებული მიზნით. ხელის თავისუფლება რომელი გამოიყენოთ — ეს მთავარია.

## Middleware — პირველად 執行되ხორცელდება, აქვს req/res

```ts
@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    console.log(`${req.method} ${req.url}`);   // logging, modifying req
    next();                                      // MUST call next() to continue
  }
}

// register in a module
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer.apply(LoggerMiddleware).forRoutes("*");   // apply to routes
  }
}
```

Middleware ყველაზე ადრეულად ExecutionStateხორცელდება, guards/interceptors/pipes-მდე, და მუშაობს raw `req`/`res`-თან — კარგია logging-ისთვის, request modification-ის, CORS-ის და Express-თან თავსებადი კონცერნებისთვის.

## სრული request lifecycle-ის თანმიმდევრობა

```text
Request →
  1. Middleware     (req/res; runs first, Express-style)
  2. Guards         (return true/false → AUTHORIZE or block the request)
  3. Interceptors   (BEFORE the handler)
  4. Pipes          (validate/transform the handler's arguments)
  5. → Route Handler ←
  6. Interceptors   (AFTER the handler — transform the response)
  7. Exception Filters (if an error was thrown anywhere)
→ Response
```

## რისთვის არის თითოეული (სწორი ინსტრუმენტის არჩევა)

```text
Middleware  → general pre-processing with req/res (logging, CORS, raw request work)
Guards      → AUTHORIZATION — decide if a request may proceed (auth, roles)
              (return true = allow, false/throw = block)
Interceptors→ wrap the handler — transform request/response, add logging/caching/timing
              (can run logic BEFORE and AFTER the handler)
Pipes       → VALIDATE/TRANSFORM the handler's input arguments (DTO validation)
Filters     → catch and format EXCEPTIONS into responses
```

მთავარი განსხვავებები: middleware არის ზოგადი Express-სტილის წინამოხმობა; **guards** კონკრეტულად სამოქმედო უფლებას ამართებს (დამატებულ, დაფუძნებულ ადგილად auth-ისთვის, მუხლის მაგივრად middleware-ში ჩალაგებისა); **interceptors** ენახება handler-ის გარშემო, რომ გარდაქმნას responses ან დაამატოს cross-cutting behavior; **pipes** validate input-ს; **filters** errors-ს აქვთ.

## როდის გამოიყენოთ middleware vs guards vs interceptors

```text
Auth check?           → Guard (dedicated, has execution context, returns boolean)
Logging requests?     → Middleware OR an interceptor (interceptor sees the response too)
Transform responses?  → Interceptor (runs after the handler)
Validate a DTO?       → Pipe
Modify raw req early?  → Middleware
```

## რატომ მნიშვნელოვანი

Middleware-ის გაგება და მისი განსხვავება guards, interceptors, pipes და filters-სგან სიარულებს აუცილებელი NestJS აპლიკაციების სწორი სტრუქტურირებისთვის — თითოეულს აქვს სპეციფიკური როლი და ExecutionStateხორცელდება request lifecycle-ის კონკრეტულ წერტილში, და სწორის გამოყენება მივყავართ სუფთა, იდიომატურ კოდამდე.

Middleware საკმარისია ზოგადი Express-სტილის წინამოხმობით raw req/res-სთან.

ჯერ-ჯეროვანი განსხვავებები იმ არის, რომ **guards** არის დამტკიცებული, შესაფერი ადგილი authorization-ისთვის (auth/roles) — უბრალოდ სუფთა, ვიდრე middleware ამ დანიშვულებისთვის — და **interceptors** ენახება handler-ის გარშემო, რომ გარდაქმნას responses და დაამატოს cross-cutting concerns (logging, caching, timing), რომელსაც middleware ვერ აკეთებს დიდი სიმარტივით (რადგან მუშაობს handler-მდე და ბუნებრივად ვერ ხედავს response-ს).

მთელი lifecycle-ის თანმიმდევრობის ცოდნა (middleware → guards → interceptors → pipes → handler → interceptors → filters) და რომელი ინსტრუმენტი შეესაბამება თითოეულ კონცერნს (auth → guard, response transformation → interceptor, validation → pipe, errors → filter) არის NestJS კომპეტენციის ღირსეული მეთოდი და აცილებს საერთო შეცდომას middleware-ის ყველაფრისთვის მოხმარებაზე.

ეს ხშირად გამოცდილი, არქიტექტურულად მნიშვნელოვანი თემა ჩარჩოში.