Kako upravljate finske opravile in čakalne vrste?

Question

Accepted Answer

Za **finska opravila** (delo, ki ne bi smelo blokirati HTTP odgovora), se NestJS integrira s **BullMQ** (čakalno vrsto podprto z Redis) prek `@nestjs/bullmq`. Opravila dodate v čakalno vrsto in jih asincrono obdelate v ločenih delavcih — kar drži zahtevke hitre in zanesljivo obravnava težko ali odloženo delo.

## Problem, ki ga rešujejo čakalne vrste

```text
Some work is too slow or shouldn't block the request:
  ✗ sending emails, processing images/video, generating reports, calling slow APIs
  → doing it inline makes the user wait and risks timeouts/failures
  ✓ QUEUE the work → respond immediately → a worker processes it in the background
```

## Vzpostavitev čakalne vrste

```ts
@Module({
  imports: [
    BullModule.forRoot({ connection: { host: "localhost", port: 6379 } }),  // Redis
    BullModule.registerQueue({ name: "email" }),                            // a named queue
  ],
})
export class AppModule {}
```

## Dodajanje opravil v čakalno vrsto (proizvajalec)

```ts
@Injectable()
export class NotificationService {
  constructor(@InjectQueue("email") private emailQueue: Queue) {}

async register(user: User) {
    await this.saveUser(user);
    // queue the email INSTEAD of sending it inline → respond to the user immediately
    await this.emailQueue.add("welcome", { userId: user.id }, {
      attempts: 3,                          // retry up to 3 times on failure
      backoff: { type: "exponential", delay: 5000 },
      delay: 60000,                          // optionally delay the job
    });
  }
}
```

Proizvajalec doda opravilo (z možnostmi kot so ponovni poskusi, zaostajanje, zamuda) in se takoj vrne — uporabnik ne čaka na pošiljanje e-poštnega sporočila.

## Obdelava opravil (delavec/potrošnik)

```ts
@Processor("email")
export class EmailProcessor extends WorkerHost {
  async process(job: Job) {
    switch (job.name) {
      case "welcome":
        await this.sendWelcomeEmail(job.data.userId);   // the actual work, in the background
        break;
    }
  }
}
```

Delavec `@Processor` porabi opravila iz čakalne vrste in dejansko delo opravlja asincrono — ločeno od cikla zahtevek/odgovor (in lahko tudi v ločenem procesu).

## Kaj nudijo čakalne vrste

```text
✓ Async processing — offload slow work, respond to users instantly
✓ Retries & backoff — failed jobs retry automatically (reliability)
✓ Delayed/scheduled jobs — run work later or on a schedule (repeatable jobs)
✓ Rate limiting & concurrency control — bound how fast/many jobs run
✓ Persistence (via Redis) — jobs survive restarts; not lost if the app crashes
✓ Decoupling — producers and workers scale independently
```

## Zakaj je to pomembno

Obdelava finskih opravil s čakalnimi vrstami je bistvena za gradnjo robustnih, odzivnih in razširljivih hrbtenikov — razumevanje NestJS integracije BullMQ je pomembno znanje na vodilni ravni.

Osrednja vrednost je premestitev dela, ki ne bi smelo blokirati HTTP odgovora: pošiljanje e-poštnih sporočil, obdelava slik/videa, ustvarjanje poročil, sinhronizacija podatkov ali klicanje počasnih zunanjih storitev.

Opravila, ki se izvajajo v liniji, prisiljajo uporabnike, da čakajo, tvegajo iztek časa zahtevka in izgubljajo delo, če se ne uspe — medtem ko ga **čakanje v vrsto** omogoča takojšen odgovor, medtem ko ga **delavec** v ozadju zanesljivo obdela.

Poleg asincronega premeščanja delo nudijo čakalne vrste kritične produkcijske funkcije: **samodejne ponovne poskuse z zaostajanjem** (odpornost proti prehodnim napakam), **odložena in načrtovana opravila**, **nadzor hkratnosti/omejitve hitrosti** in **trajnost** (opravila podprta z Redis preživijo sesutja/ponovne zagone, zato se delo ne izgubi).

Tudi **razdružijo** proizvajalce od potrošnikov, kar omogoča neodvisno razširjanje.

Znanje, kako vzpostaviti čakalne vrste, dodati opravila z ustreznimi možnostmi (ponovni poskusi, zamude) in jih obdelati v delavcih, je dragoceno za oblikovanje pravi aplikacij, ki elegantno upravljajo težko ali odloženo delo.

To je pogost in pomemben vzorec v produkcijskih NestJS sistemih in odraža zrelo razumevanje gradnje odzivnih in zanesljivih hrbtenikov, ki gredo onkraj preprostega obravnavanja zahtevek-odgovor.