@lenne.tech/nest-server 11.31.3 → 11.32.0

package/src/core/common/services/brevo.service.spec.ts

@@ -0,0 +1,266 @@
+import { Logger } from '@nestjs/common';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { Brevo, BrevoClient as RealBrevoClient } from '@getbrevo/brevo';
+
+import { BrevoService } from './brevo.service';
+import type { ConfigService } from './config.service';
+
+/**
+ * Type-level contract against the REAL SDK.
+ *
+ * Everything below runs against a hand-written mock, so the mock alone could keep passing after a
+ * breaking SDK upgrade. `sendMail()` is declared `Promise<unknown>`, which gives tsc nothing to
+ * check either. These assertions close that gap: they compile against the installed
+ * `@getbrevo/brevo`, and `pnpm run typecheck:tests` covers `src/**\/*.spec.ts`, so a v7 that
+ * re-introduces a `.body` envelope or renames the request type fails the build here rather than
+ * silently at runtime.
+ */
+type SendFn = RealBrevoClient['transactionalEmails']['sendTransacEmail'];
+/** Awaiting the call must yield the payload itself — v3's `{ response, body }` envelope is gone. */
+type AssertNoEnvelope = Awaited<ReturnType<SendFn>> extends { body: unknown } ? never : true;
+/** The request type the service builds must still be assignable to the SDK's parameter. */
+type AssertRequestType = Brevo.SendTransacEmailRequest extends NonNullable<Parameters<SendFn>[0]> ? true : never;
+// Consumed by an assertion below so the contract cannot be dead-code-eliminated or linted away.
+const sdkContract: [AssertNoEnvelope, AssertRequestType] = [true, true];
+
+/**
+ * Shared handles into the mocked SDK. `vi.hoisted` runs before the `vi.mock` factory below, so the
+ * spies exist by the time the module graph is wired up.
+ */
+const brevoMock = vi.hoisted(() => ({
+  /** Every options object the client was constructed with, in call order. */
+  clientOptions: [] as unknown[],
+  sendTransacEmail: vi.fn(),
+}));
+
+vi.mock('@getbrevo/brevo', () => ({
+  BrevoClient: class {
+    transactionalEmails = { sendTransacEmail: brevoMock.sendTransacEmail };
+
+    constructor(options: unknown) {
+      brevoMock.clientOptions.push(options);
+    }
+  },
+}));
+
+const API_KEY = 'test-api-key';
+const SENDER = { email: 'noreply@test.com', name: 'Test Sender' };
+
+/** Matches the per-send `Idempotency-Key` header without pinning the random UUID. */
+const anyIdempotencyHeaders = { 'Idempotency-Key': expect.any(String) as unknown as string };
+
+/**
+ * Minimal ConfigService double.
+ *
+ * `exclude` can be set independently on the mutable (`config`) and the frozen
+ * (`configFastButReadOnly`) side so the tests can prove which one the service reads.
+ */
+function makeConfigService(
+  options: {
+    exclude?: RegExp;
+    frozenExclude?: RegExp;
+    maxRetries?: number;
+    throwOnError?: boolean;
+    timeoutInSeconds?: number;
+    withBrevo?: boolean;
+  } = {},
+): ConfigService {
+  const { exclude, frozenExclude = exclude, maxRetries, throwOnError, timeoutInSeconds, withBrevo = true } = options;
+  const base = { apiKey: API_KEY, maxRetries, sender: SENDER, throwOnError, timeoutInSeconds };
+  return {
+    config: withBrevo ? { brevo: { ...base, exclude } } : {},
+    configFastButReadOnly: withBrevo ? { brevo: { ...base, exclude: frozenExclude } } : {},
+  } as unknown as ConfigService;
+}
+
+describe('@getbrevo/brevo SDK contract', () => {
+  it('still resolves the payload directly and accepts the request type we build', () => {
+    // The assertion is the COMPILATION of `sdkContract` above, which `pnpm run typecheck:tests`
+    // performs against the really installed SDK. This test body exists so the contract is also
+    // referenced at runtime — otherwise it reads as dead code and invites deletion.
+    expect(sdkContract).toEqual([true, true]);
+  });
+});
+
+describe('BrevoService', () => {
+  let loggerError: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    brevoMock.sendTransacEmail.mockReset();
+    brevoMock.clientOptions.length = 0;
+    loggerError = vi.spyOn(Logger.prototype, 'error').mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    // The spies above are never restored otherwise. File-level isolation contains it today, but a
+    // leaked Logger spy is the kind of thing that only surfaces as an unrelated flake later.
+    vi.restoreAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('throws when the Brevo configuration is missing', () => {
+      expect(() => new BrevoService(makeConfigService({ withBrevo: false }))).toThrow('Brevo configuration not set!');
+    });
+
+    it('does NOT construct the SDK client eagerly', async () => {
+      // The SDK is ~580 CommonJS modules and BrevoService is re-exported from the package barrel,
+      // so a static import would put that cost on every consumer's cold start — including the
+      // majority that never configure Brevo.
+      const service = new BrevoService(makeConfigService());
+      expect(brevoMock.clientOptions).toEqual([]);
+
+      brevoMock.sendTransacEmail.mockResolvedValue({ messageId: '<x@brevo>' });
+      await service.sendMail('user@example.com', 42);
+      expect(brevoMock.clientOptions).toHaveLength(1);
+    });
+
+    it('creates the client with the configured API key and safe request limits', async () => {
+      brevoMock.sendTransacEmail.mockResolvedValue({ messageId: '<x@brevo>' });
+      const service = new BrevoService(makeConfigService());
+      await service.sendMail('user@example.com', 42);
+
+      // The SDK defaults to 2 retries honouring `Retry-After` with a 60 s cap PER attempt and to
+      // no timeout at all. Both send methods are awaited inside request handlers, so those
+      // defaults would let a rate-limited Brevo park a user-facing request for ~2 minutes.
+      expect(brevoMock.clientOptions).toEqual([{ apiKey: API_KEY, maxRetries: 0, timeoutInSeconds: 10 }]);
+    });
+
+    it('honours configured retry and timeout overrides', async () => {
+      brevoMock.sendTransacEmail.mockResolvedValue({ messageId: '<x@brevo>' });
+      const service = new BrevoService(makeConfigService({ maxRetries: 3, timeoutInSeconds: 30 }));
+      await service.sendMail('user@example.com', 42);
+      expect(brevoMock.clientOptions).toEqual([{ apiKey: API_KEY, maxRetries: 3, timeoutInSeconds: 30 }]);
+    });
+
+    it('reuses the client across sends', async () => {
+      brevoMock.sendTransacEmail.mockResolvedValue({ messageId: '<x@brevo>' });
+      const service = new BrevoService(makeConfigService());
+      await service.sendMail('user@example.com', 42);
+      await service.sendMail('other@example.com', 42);
+      expect(brevoMock.clientOptions).toHaveLength(1);
+    });
+  });
+
+  describe('sendMail', () => {
+    it('rejects incomplete input without calling the API', async () => {
+      const service = new BrevoService(makeConfigService());
+      await expect(service.sendMail('', 42)).resolves.toBe(false);
+      await expect(service.sendMail('user@example.com', 0)).resolves.toBe(false);
+      expect(brevoMock.sendTransacEmail).not.toHaveBeenCalled();
+    });
+
+    it('sends template, recipient and params, and returns the response unwrapped', async () => {
+      const response = { messageId: '<mail-1@brevo>' };
+      brevoMock.sendTransacEmail.mockResolvedValue(response);
+      const service = new BrevoService(makeConfigService());
+
+      // Identity check: v6 resolves the payload directly, there is no `.body` envelope any more
+      await expect(service.sendMail('user@example.com', 42, { name: 'Test' })).resolves.toBe(response);
+      expect(brevoMock.sendTransacEmail).toHaveBeenCalledWith({
+        headers: anyIdempotencyHeaders,
+        params: { name: 'Test' },
+        templateId: 42,
+        to: [{ email: 'user@example.com' }],
+      });
+    });
+
+    it('sends a unique Idempotency-Key per call', async () => {
+      // The SDK retries POSTs on 408/429/5xx. Without a key, a retry issued after a delivered
+      // response whose reply was lost sends the mail twice.
+      brevoMock.sendTransacEmail.mockResolvedValue({ messageId: '<x@brevo>' });
+      const service = new BrevoService(makeConfigService());
+      await service.sendMail('user@example.com', 42);
+      await service.sendMail('user@example.com', 42);
+
+      const keys = brevoMock.sendTransacEmail.mock.calls.map(
+        ([request]) => (request as Brevo.SendTransacEmailRequest).headers?.['Idempotency-Key'],
+      );
+      expect(keys[0]).toBeTypeOf('string');
+      expect(keys[0]).not.toBe(keys[1]);
+    });
+
+    it('skips excluded (test) recipients', async () => {
+      const service = new BrevoService(makeConfigService({ exclude: /@test\.com$/i }));
+      await expect(service.sendMail('user@test.com', 42)).resolves.toBe('TEST_USER!');
+      expect(brevoMock.sendTransacEmail).not.toHaveBeenCalled();
+    });
+
+    it('reads the exclude pattern from the mutable config, not the frozen one', async () => {
+      // A frozen RegExp carrying the `g` flag throws on `.test()` (it assigns `lastIndex`).
+      // Reading `exclude` off `configFastButReadOnly` would therefore fail instead of excluding.
+      const service = new BrevoService(
+        makeConfigService({ exclude: /@test\.com$/i, frozenExclude: Object.freeze(/@test\.com$/gi) }),
+      );
+      await expect(service.sendMail('user@test.com', 42)).resolves.toBe('TEST_USER!');
+    });
+
+    it('returns null when the API call fails', async () => {
+      brevoMock.sendTransacEmail.mockRejectedValue(new Error('Brevo down'));
+      const service = new BrevoService(makeConfigService());
+      await expect(service.sendMail('user@example.com', 42)).resolves.toBeNull();
+    });
+
+    it('logs the failure through the Nest logger', async () => {
+      // The whole point of the sibling diagnostics work is that silent failures cost debugging
+      // sessions. Asserting only the `null` return would let the observability half regress.
+      brevoMock.sendTransacEmail.mockRejectedValue(new Error('Brevo down'));
+      const service = new BrevoService(makeConfigService());
+      await service.sendMail('user@example.com', 42);
+      expect(loggerError).toHaveBeenCalledWith(expect.stringContaining('Brevo down'));
+    });
+
+    it('rethrows when throwOnError is enabled', async () => {
+      const service = new BrevoService(makeConfigService({ throwOnError: true }));
+      brevoMock.sendTransacEmail.mockRejectedValue(new Error('Brevo down'));
+      await expect(service.sendMail('user@example.com', 42)).rejects.toThrow('Brevo down');
+    });
+  });
+
+  describe('sendHtmlMail', () => {
+    it('rejects incomplete input without calling the API', async () => {
+      const service = new BrevoService(makeConfigService());
+      await expect(service.sendHtmlMail('', 'Subject', '<p>Hi</p>')).resolves.toBe(false);
+      await expect(service.sendHtmlMail('user@example.com', '', '<p>Hi</p>')).resolves.toBe(false);
+      await expect(service.sendHtmlMail('user@example.com', 'Subject', '')).resolves.toBe(false);
+      expect(brevoMock.sendTransacEmail).not.toHaveBeenCalled();
+    });
+
+    it('sends html, subject and the configured sender, and returns the response unwrapped', async () => {
+      const response = { messageId: '<mail-2@brevo>' };
+      brevoMock.sendTransacEmail.mockResolvedValue(response);
+      const service = new BrevoService(makeConfigService());
+
+      await expect(
+        service.sendHtmlMail('user@example.com', 'Subject', '<p>Hi</p>', { params: { code: '123' } }),
+      ).resolves.toBe(response);
+      expect(brevoMock.sendTransacEmail).toHaveBeenCalledWith({
+        headers: anyIdempotencyHeaders,
+        htmlContent: '<p>Hi</p>',
+        params: { code: '123' },
+        sender: SENDER,
+        subject: 'Subject',
+        to: [{ email: 'user@example.com' }],
+      });
+    });
+
+    it('skips excluded (test) recipients', async () => {
+      const service = new BrevoService(makeConfigService({ exclude: /@test\.com$/i }));
+      await expect(service.sendHtmlMail('user@test.com', 'Subject', '<p>Hi</p>')).resolves.toBe('TEST_USER!');
+      expect(brevoMock.sendTransacEmail).not.toHaveBeenCalled();
+    });
+
+    it('returns null when the API call fails', async () => {
+      brevoMock.sendTransacEmail.mockRejectedValue(new Error('Brevo down'));
+      const service = new BrevoService(makeConfigService());
+      await expect(service.sendHtmlMail('user@example.com', 'Subject', '<p>Hi</p>')).resolves.toBeNull();
+    });
+
+    it('logs the failure through the Nest logger', async () => {
+      brevoMock.sendTransacEmail.mockRejectedValue(new Error('Brevo down'));
+      const service = new BrevoService(makeConfigService());
+      await service.sendHtmlMail('user@example.com', 'Subject', '<p>Hi</p>');
+      expect(loggerError).toHaveBeenCalledWith(expect.stringContaining('Brevo down'));
+    });
+  });
+});

package/src/core/common/services/brevo.service.ts

@@ -1,27 +1,50 @@
-import { SendSmtpEmail, TransactionalEmailsApi, TransactionalEmailsApiApiKeys } from '@getbrevo/brevo';
-import { Injectable } from '@nestjs/common';
+import { Injectable, Logger } from '@nestjs/common';
+import { randomUUID } from 'node:crypto';
+
+import type { Brevo, BrevoClient } from '@getbrevo/brevo';
 
 import { ConfigService } from './config.service';
 
 /**
  * Brevo service to send transactional emails
+ *
+ * ## Return contract
+ *
+ * Both send methods resolve to one of four things, and callers on security-critical paths
+ * (verification, password reset, magic link) MUST distinguish them:
+ *
+ * | Value | Meaning |
+ * |-------|---------|
+ * | `false` | Rejected before sending — a required argument was missing |
+ * | `'TEST_USER!'` | Recipient matched `brevo.exclude`, nothing was sent (by design) |
+ * | `null` | The send FAILED. The error was logged, not thrown |
+ * | otherwise | The Brevo `SendTransacEmailResponse` (`{ messageId?, messageIds? }`) |
+ *
+ * A `null` is the one that bites: treating "did not throw" as "was delivered" silently drops mail.
+ * Set `brevo.throwOnError: true` if you would rather have the exception propagate.
  */
 @Injectable()
 export class BrevoService {
   brevoConfig: ConfigService['configFastButReadOnly']['brevo'];
-  private apiInstance: TransactionalEmailsApi;
+  protected readonly logger = new Logger(BrevoService.name);
+  private client: BrevoClient | undefined;
 
   constructor(protected configService: ConfigService) {
     this.brevoConfig = configService.configFastButReadOnly.brevo;
     if (!this.brevoConfig) {
       throw new Error('Brevo configuration not set!');
     }
-    this.apiInstance = new TransactionalEmailsApi();
-    this.apiInstance.setApiKey(TransactionalEmailsApiApiKeys.apiKey, this.brevoConfig.apiKey);
   }
 
   /**
    * Send a transactional email via Brevo
+   *
+   * @param to - Recipient email address
+   * @param templateId - Brevo template id
+   * @param params - Template parameters. These are rendered SERVER-SIDE by the Brevo template
+   *   engine, so any user-controlled value placed here is content-injection surface owned by
+   *   whoever wrote the template — escape it there, or do not pass it.
+   * @returns The Brevo response, `false` on missing input, `'TEST_USER!'` when excluded, `null` on failure
    */
   async sendMail(to: string, templateId: number, params?: object): Promise<unknown> {
     try {
@@ -37,25 +60,31 @@ export class BrevoService {
       }
 
       // Prepare data
-      const sendSmtpEmail: SendSmtpEmail = {
-        params,
+      const request: Brevo.SendTransacEmailRequest = {
+        headers: this.buildIdempotencyHeaders(),
+        // The public signature keeps the wider `object` so existing callers stay source-compatible;
+        // the SDK narrowed its own field to an index-signature type in v6.
+        params: params as Record<string, unknown>,
         templateId,
         to: [{ email: to }],
       };
 
       // Send email
-      const result = await this.apiInstance.sendTransacEmail(sendSmtpEmail);
-      return result.body;
+      const client = await this.getClient();
+      return await client.transactionalEmails.sendTransacEmail(request);
     } catch (error) {
-      console.error(error);
+      return this.handleSendError(error, to);
     }
-
-    // Return null if error
-    return null;
   }
 
   /**
    * Send HTML mail
+   *
+   * @param to - Recipient email address
+   * @param subject - Email subject
+   * @param html - HTML body
+   * @param options - Optional template parameters
+   * @returns The Brevo response, `false` on missing input, `'TEST_USER!'` when excluded, `null` on failure
    */
   async sendHtmlMail(
     to: string,
@@ -76,7 +105,8 @@ export class BrevoService {
       }
 
       // Prepare data
-      const sendSmtpEmail: SendSmtpEmail = {
+      const request: Brevo.SendTransacEmailRequest = {
+        headers: this.buildIdempotencyHeaders(),
         htmlContent: html,
         params: options?.params,
         sender: this.brevoConfig.sender,
@@ -85,12 +115,65 @@ export class BrevoService {
       };
 
       // Send email
-      const result = await this.apiInstance.sendTransacEmail(sendSmtpEmail);
-      return result.body;
+      const client = await this.getClient();
+      return await client.transactionalEmails.sendTransacEmail(request);
     } catch (error) {
-      console.error(error);
+      return this.handleSendError(error, to);
     }
+  }
+
+  /**
+   * Builds the per-send idempotency header.
+   *
+   * The SDK retries POSTs on 408/429/5xx. Without a key, a retry issued after a response that was
+   * actually delivered (but whose reply was lost) sends the mail twice. Brevo deduplicates on
+   * `Idempotency-Key`.
+   *
+   * @returns Custom headers for the send request
+   */
+  protected buildIdempotencyHeaders(): Record<string, unknown> {
+    return { 'Idempotency-Key': randomUUID() };
+  }
 
+  /**
+   * Lazily constructs (and memoises) the Brevo SDK client.
+   *
+   * The import is dynamic on purpose: `@getbrevo/brevo` pulls in ~580 CommonJS modules, and
+   * `BrevoService` is re-exported from the package barrel. A static import would put that cost on
+   * every consumer's cold start, including the majority that never configure Brevo at all.
+   *
+   * @returns The memoised SDK client
+   */
+  protected async getClient(): Promise<BrevoClient> {
+    if (!this.client) {
+      const { BrevoClient: BrevoClientCtor } = await import('@getbrevo/brevo');
+      this.client = new BrevoClientCtor({
+        apiKey: this.brevoConfig.apiKey,
+        // The SDK defaults to 2 retries honouring `Retry-After` with a 60 s cap PER attempt, and to
+        // no timeout at all. Both send methods are awaited inside request handlers, so those
+        // defaults let a rate-limited Brevo park a user-facing request for roughly two minutes.
+        maxRetries: this.brevoConfig.maxRetries ?? 0,
+        timeoutInSeconds: this.brevoConfig.timeoutInSeconds ?? 10,
+      });
+    }
+    return this.client;
+  }
+
+  /**
+   * Logs a failed send through the Nest logger and applies the configured failure policy.
+   *
+   * @param error - The thrown SDK error
+   * @param to - Recipient, for correlation
+   * @returns `null` (the historical contract) unless `brevo.throwOnError` is set
+   * @throws The original error when `brevo.throwOnError` is `true`
+   */
+  protected handleSendError(error: unknown, to: string): null {
+    this.logger.error(
+      `Brevo sendTransacEmail failed for ${to}: ${error instanceof Error ? error.message : String(error)}`,
+    );
+    if (this.brevoConfig.throwOnError) {
+      throw error;
+    }
     // Return null if error
     return null;
   }

package/src/core/modules/better-auth/core-better-auth-email-verification.service.ts

@@ -180,15 +180,25 @@ export class CoreBetterAuthEmailVerificationService {
     if (this.config.brevoTemplateId && this.brevoService) {
       try {
         const appName = this.getAppName();
-        await this.brevoService.sendMail(user.email, this.config.brevoTemplateId, {
+        const result = await this.brevoService.sendMail(user.email, this.config.brevoTemplateId, {
           appName,
           expiresIn: this.formatExpiresIn(this.config.expiresIn),
           link: url,
           name: user.name || user.email.split('@')[0],
         });
-        this.trackSend(user.email);
-        this.logger.debug(`Verification email sent via Brevo to ${this.maskEmail(user.email)}`);
-        return;
+
+        // `sendMail()` swallows SDK errors and resolves to `null` (unless `brevo.throwOnError` is
+        // set), so "did not throw" is NOT "was delivered". Recording a send here on a null would
+        // mark the address as mailed, log success, and skip the SMTP fallback below — leaving the
+        // user with no verification email at all on a Brevo outage or a revoked key.
+        if (result === null) {
+          this.logger.error(`Brevo verification send failed for ${this.maskEmail(user.email)} — falling back to SMTP`);
+          // Deliberately no `return`: fall through to the EmailService path.
+        } else {
+          this.trackSend(user.email);
+          this.logger.debug(`Verification email sent via Brevo to ${this.maskEmail(user.email)}`);
+          return;
+        }
       } catch (error) {
         this.logger.error(
           `Failed to send verification email via Brevo to ${this.maskEmail(user.email)}: ${error instanceof Error ? error.message : 'Unknown error'}`,

package/src/index.ts

@@ -43,6 +43,7 @@ export * from './core/common/helpers/input.helper';
 export * from './core/common/helpers/logging.helper';
 export * from './core/common/helpers/meta.helper';
 export * from './core/common/helpers/model.helper';
+export * from './core/common/helpers/process-diagnostics.helper';
 export * from './core/common/helpers/register-enum.helper';
 export * from './core/common/helpers/scim.helper';
 export * from './core/common/helpers/service.helper';

package/src/main.ts

@@ -9,6 +9,7 @@ import envConfig from './config.env';
 import { FilterArgs } from './core/common/args/filter.args';
 import { buildCorsConfig, isCookiesEnabled, isCorsDisabled } from './core/common/helpers/cookies.helper';
 import { HttpExceptionLogFilter } from './core/common/filters/http-exception-log.filter';
+import { handleFatalBootstrapError, installProcessDiagnostics } from './core/common/helpers/process-diagnostics.helper';
 import { CorePersistenceModel } from './core/common/models/core-persistence.model';
 import { CoreAuthModel } from './core/modules/auth/core-auth.model';
 import { CoreUserModel } from './core/modules/user/core-user.model';
@@ -21,6 +22,11 @@ import { ServerModule } from './server/server.module';
  * Preparations for server start
  */
 async function bootstrap() {
+  // Make the exit reason diagnosable: log unhandled rejections without crashing, log uncaught
+  // exceptions before the restart, and label external termination signals so a silent
+  // "app crashed" always has a reason. See process-diagnostics.helper.ts for the rationale.
+  installProcessDiagnostics();
+
   // Create a new server based on express
   const server = await NestFactory.create<NestExpressApplication>(
     // Include server module, with all necessary modules for the project
@@ -106,9 +112,20 @@ async function bootstrap() {
     jsonDocumentUrl: '/api-docs-json',
   });
 
+  // Drain the event loop on SIGTERM/SIGINT so the process actually exits.
+  //
+  // This is load-bearing in a container, where `docker-entrypoint.sh` runs node under `exec` and it
+  // therefore becomes PID 1. A PID-namespace init is SIGNAL_UNKILLABLE: a userspace signal whose
+  // disposition is the default is silently discarded by the kernel, so re-raising is a no-op there.
+  // Meanwhile the listening HTTP server keeps the event loop non-empty, so nothing exits on its own
+  // and `docker stop` waits out its full grace period before SIGKILL — dropping in-flight requests
+  // and skipping every onModuleDestroy(). enableShutdownHooks() is what closes the app and drains
+  // the loop; installProcessDiagnostics() then correctly defers to it instead of re-raising.
+  server.enableShutdownHooks();
+
   // Start server on configured port
   await server.listen(envConfig.port, envConfig.hostname);
-  console.debug(`Server startet at ${await server.getUrl()}`);
+  console.debug(`Server started at ${await server.getUrl()}`);
 
   // Run command after server init
   if (envConfig.execAfterInit) {
@@ -126,5 +143,7 @@ async function bootstrap() {
   }
 }
 
-// Start server
-bootstrap();
+// Start server. A rejection here is a fatal startup failure (e.g. port already in use, DB
+// unreachable) — surface it and exit rather than let it become a silent unhandledRejection
+// that leaves a zombie process "alive" but listening on nothing.
+bootstrap().catch(handleFatalBootstrapError);