Cad iad an providers agus na seirbhísí?

Question

Accepted Answer

I NestJS, is **provider** aon rang a is féidir a **bhreiseadh** mar spleáchas, agus is **seirbhís** an cineál is coitianta — rang a bhíonn **loighic ghnó** ann. Má chuireamar an `@Injectable()` ornáiditheoir ar rang, bímid ina provider a is féidir le córas DI NestJS a chruthú agus a bhreiseadh.

## Seirbhís a shainmhíniú (an provider is coitianta)

```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; }
}
```

Insíonn an `@Injectable()` ornáiditheoir do NestJS go bhfuil páirt ag an rang seo in ionchuir spleáchais — is féidir a bhreiseadh i rialaithe nó i bproviders eile.

## Seirbhís a bhreiseadh trí an tógálaí

```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
  }
}
```

Déantar an spleáchas a dhearbhú mar pharaiméadar an tógálaí; cruthaíonn NestJS agus soláthraíonn sé an sampla — ní scríobhfaidh tú `new UsersService()` riamh.

## Providers a chlárú i modúl

```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 {}
```

Caithfear providers a chlárú in eagar `providers` an mhodúil ionas go bhfaigheann an DI eolas fúthu, agus roinneann `exports` iad le modúil eile.

## Is singletons iad na providers de réir a chéile

```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.)
```

## Cén fáth a scaradh ar sheirbhísí ó rialaithe?

```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.
```

## Cén fáth is dóigh leis an ábhar seo

Is croílár ailtireachta NestJS iad na providers agus na seirbhísí agus a dhearadh atá tiomáinte ag ionchuir spleáchais.

Bíonn an **loighic ghnó** an fheidhmchlár i seirbhísí, scartha ó rialaithe (nach ndéanann ach ghnéithe HTTP) — déanann an scaradh seo a bhaineann le drochúchuir an loighic athúsáidte idir rialaithe, inbhraisteoirí go fóill i ndíchealadh, agus oiriúnach go maith.

A thuiscint go marcálann `@Injectable()` rang mar provider inchurtha, go bhfuil providers cláraithe i modúil agus á bhreiseadh trí thógálaithe (an DI a chruthú na sampla do tú), agus gur singletons iad de réir a chéile, is eolas bunúsach laethúil NestJS a bhíonn ann.

Is droichead ailtireachta gach feidhmchlár NestJS an patrún provider/seirbhís, in éineacht le rialaithe agus modúil — tá sé ríthábhachtach a bheith ar an taobh is fearr, tógálaí ar ais go maith agus coimeádann a ndéantar — agus tá sé ar dhlúth chéadchéimeanna i nfoghlaim an chreat.