NestJS — service facades

// src/facade/report.service.ts — the service class IS the facade.
// One class-level @AtollService marks EVERY method for offload under
// ReportService.<method> task ids — no per-method decorators, no
// dispatch code anywhere in the class.
import { Inject, Injectable } from '@nestjs/common';
import { threadId } from 'node:worker_threads';
import { AtollService } from '@atolljs/nestjs/decorators';
import { incidentsMemory, REGIONS, SEVERITIES, STATUSES,
         type Incident } from '@atolljs/incidents';
import { ScanTelemetry } from '../shared/scan-telemetry.service';

const OPEN = STATUSES.indexOf('open');
const rec = {} as Incident;

@Injectable()
@AtollService({ pool: 'reports' })
export class ReportService {
  // Real DI — resolves inside the worker's own Nest context.
  constructor(@Inject(ScanTelemetry) private readonly telemetry: ScanTelemetry) {}

  execSummary() {
    this.telemetry.note('execSummary');
    const conn = incidentsMemory.lists.incidents;
    // …one zero-copy scan of 1M shared records → aggregated object…
    return { total: conn.recordCount, /* bySeverity, topOpenRegion, … */ };
  }

  regionReport(region: string) { /* parameterized scan → object */ }

  workerInfo() {
    // Proof of context: threadId > 0 in a worker, telemetry is
    // this worker's own DI'd instance.
    return { threadId, scans: this.telemetry.scans, lastTask: this.telemetry.lastTask };
  }
}

// src/facade/dashboard.service.ts — a plain main-thread service with
// ZERO atoll imports. It injects the facade like any provider; every
// call it makes is a worker dispatch under the hood.
import { Inject, Injectable } from '@nestjs/common';
import { ReportService } from './report.service';

@Injectable()
export class DashboardService {
  constructor(@Inject(ReportService) private readonly reports: ReportService) {}

  async overview() {
    // One HTTP response composed from two EXECUTE_TASK dispatches —
    // the consumer sees ordinary async methods.
    const [summary, worker] = await Promise.all([
      this.reports.execSummary(),
      this.reports.workerInfo(),
    ]);
    return { ...summary, generatedBy: worker };
  }
}

// src/facade/facade.module.ts — the application boundary, imported by
// the main app AND bootstrapped inside each 'reports' worker. The pool
// is message-only: it shares the incidents pool's buffer via
// withSharedBuffer rather than allocating a second one — two pools,
// one buffer, so the scans below read the same 1M records.
import { Module } from '@nestjs/common';
import { Worker } from 'node:worker_threads';
import { AtollModule, getAtollPool } from '@atolljs/nestjs';
import { withSharedBuffer } from '@atolljs/node';

@Module({
  imports: [
    AtollModule.registerPool({
      name: 'reports',
      worker: withSharedBuffer(
        () => new Worker(new URL('./facade.worker.ts', import.meta.url)),
        () => getAtollPool('incidents')?.sharedBuffer, // lazy — respawns too
      ),
      poolSize: 2,
    }),
  ],
  providers: [ScanTelemetry, ReportService, DashboardService],
  exports: [ReportService, DashboardService, AtollModule],
})
export class FacadeAtollModule {}

// src/facade/facade.worker.ts — the whole worker entry:
//   import { runAtollWorker } from '@atolljs/nestjs/worker';
//   import { bindSharedBuffer } from '@atolljs/node';
//   import { FacadeAtollModule } from './facade.module';
//   void (async () => {
//     await bindSharedBuffer();              // incidents pool's buffer
//     await runAtollWorker(FacadeAtollModule); // real DI inside the worker
//   })();

// src/facade/report.controller.ts — no atoll imports at all. The
// boundary is invisible end to end: controller → service → facade →
// worker, and back with a plain Promise.
import { Controller, Get, Inject, Param } from '@nestjs/common';
import { DashboardService } from './dashboard.service';
import { ReportService } from './report.service';

@Controller('api/reports')
export class ReportController {
  constructor(
    @Inject(DashboardService) private readonly dashboard: DashboardService,
    @Inject(ReportService) private readonly reports: ReportService,
  ) {}

  @Get('overview')
  overview() {
    return this.dashboard.overview();   // service→service→worker
  }

  @Get('region/:region')
  region(@Param('region') region: string) {
    return this.reports.regionReport(region); // parameterized dispatch
  }

  @Get('worker')
  worker() {
    return this.reports.workerInfo();   // which worker answered
  }
}

// The contract form binds only the methods a ServiceContract declares —
// dispatch happens under the contract's own taskIds (and carries its zod
// schemas for arg/result validation):
@Injectable()
@AtollService(incidentsRpc, { pool: 'incidents' })
export class IncidentsRpc {
  seedIncidents() { /* … */ }          // → task id 'incidents.seedIncidents'
  computeMetrics() { /* … */ }         // → 'incidents.computeMetrics'
  // methods NOT in the contract are untouched — they run wherever
  // they're invoked, on either side
}