Co jsou poskytovatelé a služby?

Question

Accepted Answer

V NestJS je **poskytovatel** jakákoliv třída, kterou lze **injektovat** jako závislost, a **služba** je nejčastější druh — třída, která obsahuje **obchodní logiku**. Označení třídy `@Injectable()` ji činí poskytovatelem, který NestJS DI systém může vytvořit a injektovat.

## Definování služby (nejběžnější typ poskytovatele)

```ts
import { Injectable } from "@nestjs/common";

@Injectable()              // marks the class as a provider (injectable)
export class UsersService {
  private users = [];

findAll() { return this.users; }                  // business logic
  findOne(id: string) { return this.users.find(u => u.id === id); }
  create(data) { this.users.push(data); return data; }
}
```

Dekorátor `@Injectable()` říká NestJS, že tato třída se účastní injektáže závislostí — lze ji injektovat do kontrolérů nebo jiných poskytovatelů.

## Injektování služby přes konstruktor

```ts
@Controller("users")
export class UsersController {
  // NestJS sees this parameter and INJECTS a UsersService instance automatically
  constructor(private usersService: UsersService) {}

@Get()
  findAll() {
    return this.usersService.findAll();   // use the injected service
  }
}
```

Deklarujete závislost jako parametr konstruktoru; NestJS vytvoří a dodá instanci — nikdy nepíšete `new UsersService()`.

## Registrace poskytovatelů v modulu

```ts
@Module({
  controllers: [UsersController],
  providers: [UsersService],        // register the provider so DI can resolve it
  exports: [UsersService],          // make it available to OTHER modules that import this one
})
export class UsersModule {}
```

Poskytovatelé musí být zaregistrováni v poli `providers` modulu, aby DI věděl, že o nich existují, a `exports` je sdílí s ostatními moduly.

## Poskytovatelé jsou ve výchozím nastavení singletons

```text
By default, NestJS creates ONE shared instance of each provider (singleton scope)
for the whole application → efficient, shared state.
(Other scopes exist: REQUEST-scoped, TRANSIENT — but singleton is the default.)
```

## Proč oddělit služby od kontrolérů?

```text
Controller → handles HTTP (routing, request/response)
Service    → handles business logic (rules, data access, computations)
→ Separation makes logic REUSABLE (multiple controllers can use one service),
  TESTABLE (test the service in isolation), and ORGANIZED.
```

## Proč na tom záleží

Poskytovatelé a služby jsou ústředním bodem architektury NestJS a jejího návrhu řízeného injektáží závislostí.

Služby obsahují **obchodní logiku** aplikace, oddělené od kontrolérů (které se zabývají pouze problémy HTTP) — toto oddělení obav činí logiku opakovaně použitelnou mezi kontroléry, snadno testovatelnou izolovaně a dobře organizovanou.

Pochopení toho, že `@Injectable()` označuje třídu jako injektovatelný poskytovatel, že poskytovatelé jsou zaregistrováni v modulech a injektováni přes konstruktory (DI vytváří instance pro vás) a že jsou ve výchozím nastavení singletons, je základní každodenní znalost NestJS.

Vzor poskytovatele/služby, kombinovaný s kontroléry a moduly, je páteří každé aplikace NestJS — jeho zvládnutí je nezbytné pro vytváření dobře strukturovaných, udržovatelných backendů a patří mezi první pojmy, které je třeba se naučit v rámci frameworku.