ddd-ts-kit 0.0.0-stage → 0.1.1

package/templates/init/platform/auth/http-boundary.ts.tpl

@@ -0,0 +1,92 @@
+import type { Authenticator } from '@ddd-ts-kit/auth';
+{{#if errors.none}}
+import type { ErrorContext, ErrorMapper, RouteAround } from '@ddd-ts-kit/http';
+import type { Clock, ExecutionScope, Logger, Session } from '@ddd-ts-kit/kernel';
+{{/if}}
+{{#if errors.sentry}}
+import { reportHttpErrors, type ErrorContext, type ErrorMapper, type RouteAround } from '@ddd-ts-kit/http';
+import type { Clock, ErrorReporter, ExecutionScope, Logger, Session } from '@ddd-ts-kit/kernel';
+{{/if}}
+import { tracedRoutes } from '@ddd-ts-kit/tracing';
+import { principalOf } from '{{alias.platform}}/auth/principal-of.js';
+
+/** What the HTTP adapter needs at the edge of the application: spread into its mount options, for every route. */
+export interface HttpBoundary {
+  readonly resolvePrincipal: (raw: unknown) => Promise<Session>;
+  /** Every handler runs inside it, with the correlation id, the actor and the session of its request. */
+  readonly executionScope: ExecutionScope;
+  /** The one mapping from the code of a domain error to a status: the server and the contract are given the same. */
+  readonly errorMapper: ErrorMapper;
+  readonly clock: Clock;
+  readonly onError: (error: unknown, context: ErrorContext) => void;
+  /** The span of a request, named by its route template; probes and documentation routes make none. */
+  readonly around: RouteAround;
+}
+
+interface Edge {
+  readonly authenticator: Authenticator;
+  readonly executionScope: ExecutionScope;
+  readonly errorMapper: ErrorMapper;
+  readonly clock: Clock;
+  readonly logger: Logger;
+{{#if errors.sentry}}
+  /** Where a request answered 5xx is reported, unless a bus already reported its failure. */
+  readonly errors: ErrorReporter;
+{{/if}}
+}
+
+/** A request is authenticated once, then handled inside the execution scope, so infrastructure sees who acts and under which correlation. */
+{{#if errors.none}}
+export function httpBoundary({ authenticator, executionScope, errorMapper, clock, logger }: Edge): HttpBoundary {
+{{/if}}
+{{#if errors.sentry}}
+export function httpBoundary({
+  authenticator,
+  executionScope,
+  errorMapper,
+  clock,
+  logger,
+  errors,
+}: Edge): HttpBoundary {
+  const report = reportHttpErrors(errors);
+
+{{/if}}
+  return {
+    resolvePrincipal: principalOf(authenticator),
+    executionScope,
+    errorMapper,
+    clock,
+    around: tracedRoutes(),
+    // The message of the error may quote data: only the code and the route are logged.
+{{#if errors.none}}
+    onError: (_error, context) => {
+      if (context.problem.status < 500) {
+        return;
+      }
+
+      logger.error('request failed', {
+        requestId: context.requestId,
+        correlationId: context.correlationId,
+        operationId: context.operationId,
+        errorCode: context.problem.code,
+      });
+    },
+{{/if}}
+{{#if errors.sentry}}
+    onError: (error, context) => {
+      if (context.problem.status < 500) {
+        return;
+      }
+
+      logger.error('request failed', {
+        requestId: context.requestId,
+        correlationId: context.correlationId,
+        operationId: context.operationId,
+        errorCode: context.problem.code,
+      });
+
+      report(error, context);
+    },
+{{/if}}
+  };
+}

package/templates/init/platform/auth/log-decisions.ts.tpl

@@ -0,0 +1,28 @@
+import type { OnDecision } from '@ddd-ts-kit/auth';
+import type { Logger } from '@ddd-ts-kit/kernel';
+
+/**
+ * Without the audit trail (`stack.audit` is off), every authorization decision still leaves one
+ * log entry: identifiers and codes only, never data. A log is sampled, rotated and lost; turn the
+ * audit trail on for what an auditor must be able to rely on.
+ */
+export function logDecisions(logger: Logger): OnDecision {
+  return (record) => {
+    const { decision, resource } = record;
+
+    const fields = {
+      actorId: record.actorId,
+      permissionId: record.permissionId,
+      allowed: decision.allowed,
+      ...(decision.allowed ? {} : { reason: decision.reason }),
+      ...(resource === undefined ? {} : { resourceType: resource.type, resourceId: resource.id }),
+      ...(record.useCase === undefined ? {} : { useCase: record.useCase }),
+    };
+
+    if (decision.allowed) {
+      logger.info('authorization decision', fields);
+    } else {
+      logger.warn('authorization decision', fields);
+    }
+  };
+}

package/templates/init/platform/auth/offline-authenticator.ts.tpl

@@ -0,0 +1,6 @@
+import { InvalidCredentialError, type Authenticator } from '@ddd-ts-kit/auth';
+
+/** For tools that compose the application without serving it (contract generation): no credential is accepted. */
+export const offlineAuthenticator: Authenticator = {
+  authenticate: () => Promise.reject(new InvalidCredentialError('OFFLINE')),
+};

package/templates/init/platform/auth/permission-mapping.ts.tpl

@@ -0,0 +1,7 @@
+import type { PermissionMapping } from '@ddd-ts-kit/auth/rebac';
+import { permissions } from '{{alias.platform}}/auth/permissions.js';
+
+/** Which permission of the relationship schema each permission of a context stands for. */
+export function permissionMapping(): PermissionMapping {
+  return { context: Object.fromEntries(permissions.all().map((permission) => [permission.id, 'operate'])) };
+}

package/templates/init/platform/auth/permissions.ts.tpl

@@ -0,0 +1,15 @@
+import { PermissionRegistry } from '@ddd-ts-kit/auth';
+{{#if audit.route}}
+import { auditPermissions } from '{{alias.platform}}/audit/audit.permissions.js';
+{{/if}}
+// ddd-ts-kit:imports
+// /ddd-ts-kit:imports
+
+/** Every permission of every context{{#if audit.route}}, and the one of the audit trail{{/if}}: the authorization model is laid out over it. */
+export const permissions = PermissionRegistry.of(
+{{#if audit.route}}
+  auditPermissions,
+{{/if}}
+  // ddd-ts-kit:permission-sets
+  // /ddd-ts-kit:permission-sets
+);

package/templates/init/platform/auth/principal-of.none.ts.tpl

@@ -0,0 +1,21 @@
+import { resolveSession, type Authenticator } from '@ddd-ts-kit/auth';
+import type { Session } from '@ddd-ts-kit/kernel';
+import { developmentActorHeader } from '{{alias.platform}}/auth/development-actor-header.js';
+
+/** Reads the development header of a request and answers its session, derived from the actor it names. */
+export function principalOf(authenticator: Authenticator): (raw: unknown) => Promise<Session> {
+  return (raw) => resolveSession(authenticator, developmentActorOf(raw));
+}
+
+function developmentActorOf(raw: unknown): string | undefined {
+  if (typeof raw !== 'object' || raw === null || !('headers' in raw)) {
+    return undefined;
+  }
+
+  const { headers } = raw;
+
+  const value: unknown =
+    typeof headers === 'object' && headers !== null ? Reflect.get(headers, developmentActorHeader) : undefined;
+
+  return typeof value === 'string' ? value : undefined;
+}

package/templates/init/platform/auth/principal-of.tokens.ts.tpl

@@ -0,0 +1,7 @@
+import { principalResolver, type Authenticator } from '@ddd-ts-kit/auth';
+import type { Session } from '@ddd-ts-kit/kernel';
+
+/** Reads the bearer credential of a request and answers its session: who, since when, how it was authenticated. */
+export function principalOf(authenticator: Authenticator): (raw: unknown) => Promise<Session> {
+  return principalResolver(authenticator);
+}

package/templates/init/platform/auth/relate-system-actors.ts.tpl

@@ -0,0 +1,17 @@
+import type { RelationTuple } from '@ddd-ts-kit/auth/rebac';
+import { relationTuples } from '{{alias.platform}}/auth/relation-tuples.js';
+
+/**
+ * What the application does on its own behalf: the relationships of its system actors, one per
+ * scheduled job whose command is protected (`generate job` adds it). An integration event
+ * handler that sends a protected command needs its line too.
+ */
+const systemRelationships: readonly RelationTuple[] = [
+  // ddd-ts-kit:system-grants
+  // /ddd-ts-kit:system-grants
+];
+
+/** Written when the application starts, before any job runs; writing a tuple that exists changes nothing. */
+export function relateSystemActors(): Promise<void> {
+  return relationTuples.write(systemRelationships);
+}

package/templates/init/platform/auth/relation-tuples.ts.tpl

@@ -0,0 +1,6 @@
+import { SchemaCheckedTupleStore, type RelationTupleStore } from '@ddd-ts-kit/auth/rebac';
+import { createTupleStore } from '{{alias.platform}}/auth/create-tuple-store.js';
+import { relationshipSchema } from '{{alias.platform}}/auth/relationship-schema.js';
+
+/** The relationships the authorizer reads: a tuple that the schema does not know is refused when it is written. */
+export const relationTuples: RelationTupleStore = new SchemaCheckedTupleStore(relationshipSchema, createTupleStore());

package/templates/init/platform/auth/relationship-schema.ts.tpl

@@ -0,0 +1,16 @@
+import { defineSchema, union } from '@ddd-ts-kit/auth/rebac';
+
+/**
+ * One example type: a bounded context and who operates it. Use cases start by naming their
+ * context as the resource (`{ type: 'context', id: '<context>' }`). A system actor (a scheduled
+ * job, an integration event handler) is a subject of type `system`.
+ */
+// TODO(platform): model the elements rights are shared on (documents, folders, teams), name them in the `resource` of each requirement and map each permission to a permission of its type.
+export const relationshipSchema = defineSchema({
+  user: {},
+  system: {},
+  context: {
+    relations: { operator: ['user', 'system'] },
+    permissions: { operate: union('operator') },
+  },
+});

package/templates/init/platform/auth/roles.ts.tpl

@@ -0,0 +1,17 @@
+import type { Grant } from '@ddd-ts-kit/auth';
+
+/**
+ * What each role may do. A grant is a permission of a context (`billingPermissions['invoice.issue']`,
+ * imported from the permissions file of the context), its id, `<context>:*` or `*`. The roles of an
+ * actor come from its credential. Integration event handlers and scheduled jobs act as system
+ * actors, which carry no role: the authorizer gives them `system`, and `generate job` adds there
+ * the permission of the command a job sends.
+ */
+// TODO(platform): replace this starting point by the roles of the organisation.
+export const roles: Readonly<Record<string, readonly Grant[]>> = {
+  admin: ['*'],
+  system: [
+    // ddd-ts-kit:system-grants
+    // /ddd-ts-kit:system-grants
+  ],
+};

package/templates/init/platform/auth/security-schemes.none.ts.tpl

@@ -0,0 +1,4 @@
+import { developmentActorHeader } from '{{alias.platform}}/auth/development-actor-header.js';
+
+/** The scheme routes name in `security`, as the OpenAPI document declares it. */
+export const securitySchemes = { developmentActor: { type: 'apiKey', in: 'header', name: developmentActorHeader } };

package/templates/init/platform/auth/security-schemes.tokens.ts.tpl

@@ -0,0 +1,2 @@
+/** The scheme routes name in `security`, as the OpenAPI document declares it. */
+export const securitySchemes = { bearer: { type: 'http', scheme: 'bearer', bearerFormat: 'JWT' } };

package/templates/init/platform/auth/use-case-protection.ts.tpl

@@ -0,0 +1,38 @@
+import {
+  AuthorizationMap,
+  AuthorizationSetupError,
+  authorizationMiddleware,
+  type Authorizer,
+  type OnDecision,
+  type UseCaseDeclaration,
+} from '@ddd-ts-kit/auth';
+import type { BusMiddleware } from '@ddd-ts-kit/kernel';
+
+/**
+ * The guard both buses ask before any handler. The buses exist before the contexts are wired,
+ * so the declarations arrive afterwards; until then every message is refused.
+ */
+export class UseCaseProtection {
+  private declared: BusMiddleware | undefined;
+
+  constructor(
+    private readonly authorizer: Authorizer,
+    private readonly onDecision: OnDecision,
+  ) {}
+
+  readonly guard: BusMiddleware = (message, next, info) => {
+    if (this.declared === undefined) {
+      throw new AuthorizationSetupError('No use case was declared yet: call declare() once the contexts are wired');
+    }
+
+    return this.declared(message, next, info);
+  };
+
+  declare(useCases: readonly UseCaseDeclaration[]): void {
+    this.declared = authorizationMiddleware({
+      authorizer: this.authorizer,
+      map: new AuthorizationMap(useCases),
+      onDecision: this.onDecision,
+    });
+  }
+}

package/templates/init/platform/buses/create-command-bus.ts.tpl

@@ -0,0 +1,86 @@
+import { loggingMiddleware, metricsMiddleware } from '@ddd-ts-kit/aspects';
+import { UseCaseGuard, type Resolve } from '@ddd-ts-kit/di';
+{{#if errors.none}}
+{{#if cache.relaySignal}}
+import { InMemoryCommandBus, UnitOfWork, unitOfWorkMiddleware, type BusMiddleware } from '@ddd-ts-kit/kernel';
+import { relayWakeUpMiddleware } from '@ddd-ts-kit/redis';
+{{/if}}
+{{#unless cache.relaySignal}}
+import { InMemoryCommandBus, UnitOfWork, unitOfWorkMiddleware } from '@ddd-ts-kit/kernel';
+{{/unless}}
+{{/if}}
+{{#if errors.sentry}}
+{{#if cache.relaySignal}}
+import {
+  ErrorReporter,
+  InMemoryCommandBus,
+  UnitOfWork,
+  errorReportingMiddleware,
+  unitOfWorkMiddleware,
+  type BusMiddleware,
+} from '@ddd-ts-kit/kernel';
+import { relayWakeUpMiddleware } from '@ddd-ts-kit/redis';
+{{/if}}
+{{#unless cache.relaySignal}}
+import {
+  ErrorReporter,
+  InMemoryCommandBus,
+  UnitOfWork,
+  errorReportingMiddleware,
+  unitOfWorkMiddleware,
+} from '@ddd-ts-kit/kernel';
+{{/unless}}
+{{/if}}
+import type { Foundations } from '{{alias.platform}}/lay-foundations.js';
+{{#if cache.relaySignal}}
+import type { RedisServices } from '{{alias.platform}}/redis/open-redis.js';
+
+interface Signalled {
+  readonly redis?: RedisServices;
+}
+{{/if}}
+
+/**
+{{#if errors.none}}
+ * Around every command, outermost first: the log entry and the measure of the use case, the
+{{/if}}
+{{#if errors.sentry}}
+ * Around every command, outermost first: the report of an unexpected failure (a failed commit
+ * included), the log entry and the measure of the use case, the
+{{/if}}
+ * permission, the span of the use case (a refused command never started){{#if cache.relaySignal}}, the wake-up of the outbox relay{{/if}}{{#if audit.on}}, the audit entry{{/if}}, then the unit of work. The guard and the unit of
+ * work are resolved at each command: building the bus must not open anything.{{#if audit.on}} The audit entry
+ * opens the transaction itself, so that the entry of a success commits with the state change
+ * and the entry of a failure survives the rollback.{{/if}}
+ */
+{{#if cache.relaySignal}}
+export function createCommandBus(resolve: Resolve, foundations: Foundations, options: Signalled): InMemoryCommandBus {
+{{/if}}
+{{#unless cache.relaySignal}}
+export function createCommandBus(resolve: Resolve, foundations: Foundations): InMemoryCommandBus {
+{{/unless}}
+  return new InMemoryCommandBus()
+{{#if errors.sentry}}
+    .use((message, next, info) =>
+      errorReportingMiddleware(resolve(ErrorReporter), foundations.scope)(message, next, info),
+    )
+{{/if}}
+    .use(loggingMiddleware(foundations.logger))
+    .use(metricsMiddleware(foundations.metrics))
+    .use((message, next, info) => resolve(UseCaseGuard).check(message, next, info))
+    .use(foundations.traced.useCase)
+{{#if cache.relaySignal}}
+    .use(wakingTheRelay(options.redis))
+{{/if}}
+{{#if audit.on}}
+    .use(foundations.audit.commands)
+{{/if}}
+    .use(unitOfWorkMiddleware({ run: (work) => resolve(UnitOfWork).run(work) }));
+}
+{{#if cache.relaySignal}}
+
+/** Without a Redis protocol server (the tools, most tests) the relay only polls. */
+function wakingTheRelay(redis: RedisServices | undefined): BusMiddleware {
+  return redis === undefined ? (_message, next) => next() : relayWakeUpMiddleware(redis.relaySignal);
+}
+{{/if}}

package/templates/init/platform/buses/create-query-bus.ts.tpl

@@ -0,0 +1,29 @@
+import { loggingMiddleware, metricsMiddleware } from '@ddd-ts-kit/aspects';
+import { UseCaseGuard, type Resolve } from '@ddd-ts-kit/di';
+{{#if errors.none}}
+import { InMemoryQueryBus } from '@ddd-ts-kit/kernel';
+{{/if}}
+{{#if errors.sentry}}
+import { ErrorReporter, InMemoryQueryBus, errorReportingMiddleware } from '@ddd-ts-kit/kernel';
+{{/if}}
+import type { Foundations } from '{{alias.platform}}/lay-foundations.js';
+
+/** Around every query, outermost first: {{#if errors.sentry}}the report of an unexpected failure, {{/if}}its log entry, its measure, the permission, its span{{#if audit.on}}, the audit entry of the reads that leave one{{/if}}. */
+export function createQueryBus(resolve: Resolve, foundations: Foundations): InMemoryQueryBus {
+  return new InMemoryQueryBus()
+{{#if errors.sentry}}
+    .use((message, next, info) =>
+      errorReportingMiddleware(resolve(ErrorReporter), foundations.scope)(message, next, info),
+    )
+{{/if}}
+    .use(loggingMiddleware(foundations.logger))
+    .use(metricsMiddleware(foundations.metrics))
+    .use((message, next, info) => resolve(UseCaseGuard).check(message, next, info))
+{{#if audit.on}}
+    .use(foundations.traced.useCase)
+    .use(foundations.audit.queries);
+{{/if}}
+{{#unless audit.on}}
+    .use(foundations.traced.useCase);
+{{/unless}}
+}

package/templates/init/platform/compose-application.manual.ts.tpl

@@ -0,0 +1,187 @@
+import { installAspectRuntime } from '@ddd-ts-kit/aspects';
+{{#if http.any}}
+import type { Authenticator, UseCaseDeclaration } from '@ddd-ts-kit/auth';
+{{/if}}
+{{#unless http.any}}
+import type { UseCaseDeclaration } from '@ddd-ts-kit/auth';
+{{/unless}}
+{{#if audit.on}}
+import { subscribeAll } from '@ddd-ts-kit/events';
+{{/if}}
+{{#if http.any}}
+import { createErrorMapper, defineRoutes, type Route } from '@ddd-ts-kit/http';
+{{/if}}
+{{#if cache.rateLimit}}
+import type { IntegrationEventPublisher, IntegrationEventSubscriber, Logger, RateLimiter } from '@ddd-ts-kit/kernel';
+{{/if}}
+{{#unless cache.rateLimit}}
+import type { IntegrationEventPublisher, IntegrationEventSubscriber, Logger } from '@ddd-ts-kit/kernel';
+{{/unless}}
+{{#if audit.route}}
+import { auditModule } from '{{alias.platform}}/audit/audit.module.js';
+{{/if}}
+{{#if http.any}}
+import { httpBoundary, type HttpBoundary } from '{{alias.platform}}/auth/http-boundary.js';
+{{/if}}
+{{#if authz.rebac}}
+import { relateSystemActors } from '{{alias.platform}}/auth/relate-system-actors.js';
+{{/if}}
+import { createPlatform, type PlatformOptions } from '{{alias.platform}}/create-platform.js';
+import type { Persistence } from '{{alias.platform}}/database/persistence.js';
+import type { Platform } from '{{alias.platform}}/platform.js';
+// ddd-ts-kit:imports
+// /ddd-ts-kit:imports
+
+interface ContextWiring {
+  readonly name: string;
+  /** What each command and query of the context requires, or that it is public. */
+  readonly useCases: readonly UseCaseDeclaration[];
+{{#if http.any}}
+  readonly routes: readonly Route[];
+{{/if}}
+}
+
+{{#if http.any}}
+export interface ApplicationOptions extends PlatformOptions {
+  /** Who verifies the credential of a request: the real adapter in `main.ts`, a key of their own in the tests. */
+  readonly authenticator: Authenticator;
+}
+{{/if}}
+{{#unless http.any}}
+export type ApplicationOptions = PlatformOptions;
+{{/unless}}
+
+/** Wires one context on the platform. An application hosts all of them here, one alone in `apps/<context>/main.ts`. */
+type ContextModule = (platform: Platform) => ContextWiring;
+
+const everyContext: readonly ContextModule[] = [
+  // ddd-ts-kit:contexts
+  // /ddd-ts-kit:contexts
+];
+
+export interface Application {
+{{#if http.any}}
+  readonly routes: readonly Route[];
+  /** Authenticates every request and runs it inside the execution scope. */
+  readonly boundary: HttpBoundary;
+{{/if}}
+{{#unless http.any}}
+  readonly routes: readonly never[];
+  readonly contexts: readonly ContextWiring[];
+{{/unless}}
+  /** The provider integration events are delivered to. */
+  readonly eventBus: IntegrationEventPublisher;
+  /** Where another context, or a test, listens to what this application publishes. */
+  readonly eventSubscriber: IntegrationEventSubscriber;
+  readonly logger: Logger;
+{{#if cache.rateLimit}}
+  /** What the HTTP server asks before anything else: on the Redis protocol server, or in the memory of the process without one. */
+  readonly rateLimiter: RateLimiter;
+{{/if}}
+{{#if cache.redis}}
+
+  /** Whether what the application depends on answers: the readiness probe of the HTTP server. */
+  ready(): Promise<boolean>;
+
+{{/if}}
+  readonly platform: Platform;
+
+  start(): Promise<void>;
+
+  stop(): Promise<void>;
+}
+
+/** Wires every bounded context on the shared platform. Also used to generate the contracts and by the end-to-end tests. */
+export function composeApplication(
+  persistence: Persistence,
+  options: ApplicationOptions,
+  selection: readonly ContextModule[] = everyContext,
+): Application {
+  const platform = createPlatform(persistence, options);
+  const { logger, metrics, cache, clock } = platform;
+
+  installAspectRuntime({ logger, metrics, cache, clock });
+
+{{#if audit.route}}
+  const contexts = [...selection, auditModule].map((module) => module(platform));
+{{/if}}
+{{#unless audit.route}}
+  const contexts = selection.map((module) => module(platform));
+{{/unless}}
+
+  platform.protection.declare(contexts.flatMap((context) => context.useCases));
+
+  return {
+{{#if http.any}}
+    routes: defineRoutes(...contexts.map((context) => context.routes)),
+    boundary: httpBoundary({
+      authenticator: options.authenticator,
+      executionScope: platform.scope,
+      errorMapper: createErrorMapper(),
+      clock,
+      logger,
+{{#if errors.sentry}}
+      errors: platform.errors,
+{{/if}}
+    }),
+{{/if}}
+{{#unless http.any}}
+    routes: [],
+    contexts,
+{{/unless}}
+    eventBus: platform.eventBus,
+{{#if broker.external}}
+    // Behind a broker a listener has queues of its own, under its own name.
+    eventSubscriber: platform.subscriberFor('observer'),
+{{/if}}
+{{#unless broker.external}}
+    eventSubscriber: platform.subscriber,
+{{/unless}}
+    logger,
+{{#if cache.rateLimit}}
+    rateLimiter: platform.rateLimiter,
+{{/if}}
+{{#if cache.redis}}
+    ready: () => options.redis?.ready() ?? Promise.resolve(true),
+{{/if}}
+    platform,
+    start: () => start(platform, options),
+    stop: () => stop(platform, options),
+  };
+}
+
+/** The consumers first, then the jobs: a job sends commands whose events must find their handlers. */
+async function start(platform: Platform, options: ApplicationOptions): Promise<void> {
+{{#if authz.rebac}}
+  await relateSystemActors();
+
+{{/if}}
+{{#if audit.on}}
+  // The audit trail listens to every declared integration event, under a name of its own.
+{{#if broker.external}}
+  subscribeAll(platform.subscriberFor(platform.audit.consumer), platform.audit.subscriptions);
+{{/if}}
+{{#unless broker.external}}
+  subscribeAll(platform.subscriber, platform.audit.subscriptions);
+{{/unless}}
+{{/if}}
+  await options.events.start();
+
+  if (options.jobs?.start === true) {
+    await platform.jobs.start();
+  }
+}
+
+/**
+ * The jobs first, then the provider{{#if errors.sentry}}; what failed on the way is given two seconds to reach the
+ * tracker{{/if}}; the logger last, flushed by hand since nothing here does it: whatever logs has closed
+ * before, and nothing may log after `stop()` returned.
+ */
+async function stop(platform: Platform, options: ApplicationOptions): Promise<void> {
+  await platform.jobs.stop();
+  await options.events.close();
+{{#if errors.sentry}}
+  await platform.errors.flush(2_000);
+{{/if}}
+  await platform.logger.flush();
+}