Graceful Shutdown

// src/reports/report-worker.service.ts
import {
  BeforeApplicationShutdown,
  Injectable,
  Logger,
  OnApplicationShutdown,
} from '@nestjs/common';
import { Pool } from 'pg';

@Injectable()
export class ReportWorker
  implements BeforeApplicationShutdown, OnApplicationShutdown
{
  private readonly logger = new Logger(ReportWorker.name);
  private readonly pool = new Pool({ connectionString: process.env.DATABASE_URL });
  private readonly running = new Set<Promise<unknown>>();
  private accepting = true;

  enqueue(task: () => Promise<void>): Promise<void> {
    if (!this.accepting) {
      throw new Error('ReportWorker is shutting down');
    }
    const job = task().finally(() => this.running.delete(job));
    this.running.add(job);
    return job;
  }

  // Step 3 of the sequence: the server is still up. Stop taking new work and
  // wait for what has already started.
  async beforeApplicationShutdown(signal: string): Promise<void> {
    this.accepting = false;
    this.logger.log(`${signal}: draining ${this.running.size} job(s)`);
    await Promise.allSettled([...this.running]);
  }

  // Step 5: the HTTP server has closed, so nothing can still need a
  // connection. Only now is it safe to end the pool.
  async onApplicationShutdown(signal: string): Promise<void> {
    await this.pool.end();
    this.logger.log(`${signal}: pool closed`);
  }
}

// src/reports/reports.module.ts
import { Module } from '@nestjs/common';
import { ReportWorker } from './report-worker.service.js';

@Module({
  // Shorthand: the class is both the token other classes ask for and the
  // class Nest instantiates.
  providers: [ReportWorker],
  // Longhand, identical in effect:
  // providers: [{ provide: ReportWorker, useClass: ReportWorker }],
  exports: [ReportWorker],
})
export class ReportsModule {}

// src/health/health.module.ts
import { Module } from '@nestjs/common';
import { TerminusModule } from '@nestjs/terminus';
import { HealthController } from './health.controller.js';

@Module({
  imports: [
    TerminusModule.forRoot({
      // Wait this long after the signal before the application shuts down.
      // Default is 0. Five seconds gives the readiness probe time to fail and
      // the load balancer time to stop routing new requests here.
      gracefulShutdownTimeoutMs: 5_000,
      errorLogStyle: 'json',
    }),
  ],
  controllers: [HealthController],
})
export class HealthModule {}

// src/tasks/rebuild-index.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from '../app.module.js';
import { SearchService } from '../search/search.service.js';

// An application context has no HTTP server: no routes are registered and
// nothing listens. Providers and modules work exactly as they do in a server.
const app = await NestFactory.createApplicationContext(AppModule, {
  logger: ['error', 'warn', 'log'],
});

// Still worth enabling: if the job is cancelled, the container gets SIGTERM
// and the same teardown runs instead of being cut off mid-write.
app.enableShutdownHooks();

try {
  await app.get(SearchService).rebuild();
} finally {
  // Runs onModuleDestroy, beforeApplicationShutdown and onApplicationShutdown
  // with no signal, so the signal parameter arrives undefined. close() does
  // not end the process; the script simply runs out of work afterwards.
  await app.close();
}