ddd-ts-kit 0.0.0-stage → 0.1.0

package/templates/init/platform/http/start-http-server.express.ts.tpl

@@ -0,0 +1,81 @@
+import type { Server } from 'node:http';
+import type { AddressInfo } from 'node:net';
+import express from 'express';
+import { mountExpress } from '@ddd-ts-kit/http/express';
+import type { Application } from '{{alias.platform}}/compose-application.js';
+import type { AppConfig } from '{{alias.platform}}/config/app-config.js';
+{{#if cache.rateLimit}}
+import { refusalFor } from '{{alias.platform}}/http/refusal-for.js';
+{{/if}}
+{{#if docs.any}}
+import { withDocumentation } from '{{alias.platform}}/http/with-documentation.js';
+{{/if}}
+
+export interface HttpServer {
+  /** The port really bound: differs from the configured one when that was 0. */
+  readonly port: number;
+
+  close(): Promise<void>;
+}
+
+/** What the server needs of the application: its routes and what stands at its edge. */
+type Served = Pick<Application, 'routes' | 'boundary'{{#if cache.rateLimit}} | 'rateLimiter' | 'ready'{{/if}}>;
+
+export async function startHttpServer(served: Served, config: AppConfig): Promise<HttpServer> {
+  const app = express();
+
+  app.disable('x-powered-by');
+{{#if cache.rateLimit}}
+  guardTheDoor(app, served, config);
+{{/if}}
+  app.use(express.json());
+{{#if docs.any}}
+  mountExpress(app, withDocumentation(served.routes, config), served.boundary);
+{{/if}}
+{{#unless docs.any}}
+  mountExpress(app, served.routes, served.boundary);
+{{/unless}}
+
+  const server = await listen(app, config.port);
+
+  return { port: boundPort(server), close: () => close(server) };
+}
+{{#if cache.rateLimit}}
+
+/** The readiness probe, then the limiter, before any route. */
+function guardTheDoor(app: express.Express, served: Served, config: AppConfig): void {
+  app.get(
+    '/health/ready',
+    (_request, response) =>
+      void served.ready().then((ready) => response.status(ready ? 200 : 503).json({ status: ready ? 'up' : 'down' })),
+  );
+
+  app.use((request, response, next) => {
+    void refusalFor(served.rateLimiter, config.rateLimit, request.ip).then((refusal) => {
+      if (refusal === undefined) {
+        next();
+      } else {
+        response.status(refusal.problem.status).set(refusal.headers).send(JSON.stringify(refusal.problem));
+      }
+    }, next);
+  });
+}
+{{/if}}
+
+function listen(app: express.Express, port: number): Promise<Server> {
+  return new Promise<Server>((resolve) => {
+    const server = app.listen(port, () => resolve(server));
+  });
+}
+
+function boundPort(server: Server): number {
+  const address: AddressInfo | string | null = server.address();
+
+  return typeof address === 'object' && address !== null ? address.port : 0;
+}
+
+function close(server: Server): Promise<void> {
+  return new Promise<void>((resolve, reject) => {
+    server.close((error) => (error === undefined ? resolve() : reject(error)));
+  });
+}

package/templates/init/platform/http/start-http-server.fastify.ts.tpl

@@ -0,0 +1,59 @@
+import Fastify{{#if cache.rateLimit}}, { type FastifyInstance }{{/if}} from 'fastify';
+import { mountFastify } from '@ddd-ts-kit/http/fastify';
+import type { Application } from '{{alias.platform}}/compose-application.js';
+import type { AppConfig } from '{{alias.platform}}/config/app-config.js';
+{{#if cache.rateLimit}}
+import { refusalFor } from '{{alias.platform}}/http/refusal-for.js';
+{{/if}}
+{{#if docs.any}}
+import { withDocumentation } from '{{alias.platform}}/http/with-documentation.js';
+{{/if}}
+
+export interface HttpServer {
+  /** The port really bound: differs from the configured one when that was 0. */
+  readonly port: number;
+
+  close(): Promise<void>;
+}
+
+/** What the server needs of the application: its routes and what stands at its edge. */
+type Served = Pick<Application, 'routes' | 'boundary'{{#if cache.rateLimit}} | 'rateLimiter' | 'ready'{{/if}}>;
+
+export async function startHttpServer(served: Served, config: AppConfig): Promise<HttpServer> {
+  const app = Fastify();
+
+{{#if cache.rateLimit}}
+  guardTheDoor(app, served, config);
+{{/if}}
+{{#if docs.any}}
+  mountFastify(app, withDocumentation(served.routes, config), served.boundary);
+{{/if}}
+{{#unless docs.any}}
+  mountFastify(app, served.routes, served.boundary);
+{{/unless}}
+  await app.listen({ port: config.port, host: '0.0.0.0' });
+
+  const [address] = app.addresses();
+
+  return { port: address?.port ?? 0, close: () => app.close() };
+}
+{{#if cache.rateLimit}}
+
+/** The readiness probe, then the limiter, before any route. */
+function guardTheDoor(app: FastifyInstance, served: Served, config: AppConfig): void {
+  app.get('/health/ready', async (_request, reply) => {
+    const ready = await served.ready();
+
+    return reply.code(ready ? 200 : 503).send({ status: ready ? 'up' : 'down' });
+  });
+
+  app.addHook('onRequest', async (request, reply) => {
+    const refusal =
+      request.url === '/health/ready' ? undefined : await refusalFor(served.rateLimiter, config.rateLimit, request.ip);
+
+    if (refusal !== undefined) {
+      await reply.code(refusal.problem.status).headers(refusal.headers).send(JSON.stringify(refusal.problem));
+    }
+  });
+}
+{{/if}}

package/templates/init/platform/http/start-http-server.nest.ts.tpl

@@ -0,0 +1,99 @@
+import 'reflect-metadata';
+import { Server } from 'node:http';
+import { NestFactory } from '@nestjs/core';
+import type { Application } from '{{alias.platform}}/compose-application.js';
+import type { AppConfig } from '{{alias.platform}}/config/app-config.js';
+import { createAppModule } from '{{alias.platform}}/http/create-app-module.js';
+{{#if cache.rateLimit}}
+import { refusalFor } from '{{alias.platform}}/http/refusal-for.js';
+{{/if}}
+{{#if docs.any}}
+import { withDocumentation } from '{{alias.platform}}/http/with-documentation.js';
+{{/if}}
+
+export interface HttpServer {
+  /** The port really bound: differs from the configured one when that was 0. */
+  readonly port: number;
+
+  close(): Promise<void>;
+}
+
+/** What the server needs of the application: its routes and what stands at its edge. */
+type Served = Pick<Application, 'routes' | 'boundary'{{#if cache.rateLimit}} | 'rateLimiter' | 'ready'{{/if}}>;
+{{#if cache.rateLimit}}
+
+/** The part of the incoming request and of its response the limiter and the probe need, whatever Nest runs on. */
+interface Incoming {
+  readonly url?: string;
+  readonly socket: { readonly remoteAddress?: string };
+}
+
+interface Outgoing {
+  writeHead(status: number, headers: Readonly<Record<string, string>>): Outgoing;
+
+  end(body: string): void;
+}
+{{/if}}
+
+export async function startHttpServer(served: Served, config: AppConfig): Promise<HttpServer> {
+{{#if docs.any}}
+  const app = await NestFactory.create(createAppModule(withDocumentation(served.routes, config), served.boundary), {
+    logger: ['error', 'warn'],
+  });
+{{/if}}
+{{#unless docs.any}}
+  const app = await NestFactory.create(createAppModule(served.routes, served.boundary), { logger: ['error', 'warn'] });
+{{/unless}}
+
+{{#if cache.rateLimit}}
+  app.use(
+    (request: Incoming, response: Outgoing, next: () => void) =>
+      void guardTheDoor({ served, config }, { request, response, next }),
+  );
+
+{{/if}}
+  await app.listen(config.port);
+
+  return { port: boundPort(app.getHttpServer()), close: () => app.close() };
+}
+{{#if cache.rateLimit}}
+
+interface Door {
+  readonly served: Served;
+  readonly config: AppConfig;
+}
+
+interface Exchange {
+  readonly request: Incoming;
+  readonly response: Outgoing;
+  readonly next: () => void;
+}
+
+/** The readiness probe, then the limiter, before any route. */
+async function guardTheDoor({ served, config }: Door, { request, response, next }: Exchange): Promise<void> {
+  if (request.url === '/health/ready') {
+    const ready = await served.ready();
+
+    response
+      .writeHead(ready ? 200 : 503, { 'content-type': 'application/json' })
+      .end(JSON.stringify({ status: ready ? 'up' : 'down' }));
+
+    return;
+  }
+
+  const refusal = await refusalFor(served.rateLimiter, config.rateLimit, request.socket.remoteAddress);
+
+  if (refusal === undefined) {
+    next();
+  } else {
+    response.writeHead(refusal.problem.status, refusal.headers).end(JSON.stringify(refusal.problem));
+  }
+}
+{{/if}}
+
+// Nest types its HTTP server loosely: the port is read only from what proves to be a Node server.
+function boundPort(server: unknown): number {
+  const address = server instanceof Server ? server.address() : null;
+
+  return typeof address === 'object' && address !== null ? address.port : 0;
+}

package/templates/init/platform/http/with-documentation.ts.tpl

@@ -0,0 +1,20 @@
+import type { Route } from '@ddd-ts-kit/http';
+import { openApiDocsRoutes } from '@ddd-ts-kit/http/docs';
+import { generateOpenApi } from '@ddd-ts-kit/http/openapi';
+import { securitySchemes } from '{{alias.platform}}/auth/security-schemes.js';
+import type { AppConfig } from '{{alias.platform}}/config/app-config.js';
+
+/** Adds the contract and its interactive page next to the routes, unless documentation is switched off (API_DOCS, off in production by default). */
+export function withDocumentation(routes: readonly Route[], config: AppConfig): readonly Route[] {
+  if (!config.docsEnabled) {
+    return routes;
+  }
+
+  const document = generateOpenApi({
+    info: { title: config.serviceName, version: config.serviceVersion },
+    routes,
+    securitySchemes,
+  });
+
+  return [...routes, ...openApiDocsRoutes(document, { ui: '{{docs.ui}}' })];
+}

package/templates/init/platform/job-settings.ts.tpl

@@ -0,0 +1,23 @@
+import type { JobSettings } from '@ddd-ts-kit/kernel';
+
+type Environment = Readonly<Record<string, string | undefined>>;
+
+/**
+ * What configuration changes of each scheduled job, by job name: a job is switched off in one
+ * environment with `JOB_<CONTEXT>_<JOB>_ENABLED=false`, never by a code change.
+ * `ddd-ts-kit generate job` adds a line; a schedule or a timeout read from the environment goes
+ * on the same line. Given a context, only its jobs are kept: an application that hosts one
+ * context is refused the settings of a job it does not declare.
+ */
+export function jobSettings(environment: Environment, context?: string): Readonly<Record<string, JobSettings>> {
+  const settings: Readonly<Record<string, JobSettings>> = {
+    // ddd-ts-kit:jobs
+    // /ddd-ts-kit:jobs
+  };
+
+  if (context === undefined) {
+    return settings;
+  }
+
+  return Object.fromEntries(Object.entries(settings).filter(([name]) => name.startsWith(context + '.')));
+}

package/templates/init/platform/jobs/configured-job-scheduler.ts.tpl

@@ -0,0 +1,43 @@
+import type { JobDefinition, JobDescription, JobRun, JobScheduler, JobSettings } from '@ddd-ts-kit/kernel';
+
+type Run = JobDefinition['run'];
+
+/** What is put around each run from outside (its span): told the job and the context its name starts with. */
+type Observe = (run: Run, job: { readonly name: string; readonly context: string }) => Run;
+
+/**
+ * The scheduler of the platform with the settings of the configuration applied: what
+ * `job-settings.ts` says of a job wins over what its context registered, and a key left
+ * undefined changes nothing. Each run goes through what observes the jobs from outside.
+ */
+export class ConfiguredJobScheduler implements JobScheduler {
+  constructor(
+    private readonly scheduler: JobScheduler,
+    private readonly settings: Readonly<Record<string, JobSettings>>,
+    private readonly observe: Observe,
+  ) {}
+
+  register(job: JobDefinition): void {
+    const written = Object.entries(this.settings[job.name] ?? {}).filter(([, value]) => value !== undefined);
+
+    const run = this.observe(job.run, { name: job.name, context: job.name.split('.')[0] ?? job.name });
+
+    this.scheduler.register({ ...job, ...Object.fromEntries(written), run });
+  }
+
+  start(): Promise<void> {
+    return this.scheduler.start();
+  }
+
+  stop(): Promise<void> {
+    return this.scheduler.stop();
+  }
+
+  runNow(name: string): Promise<JobRun> {
+    return this.scheduler.runNow(name);
+  }
+
+  describe(): readonly JobDescription[] {
+    return this.scheduler.describe();
+  }
+}

package/templates/init/platform/lay-foundations.tsyringe.ts.tpl

@@ -0,0 +1,74 @@
+{{#unless audit.on}}
+import type { OnDecision } from '@ddd-ts-kit/auth';
+{{/unless}}
+import {
+  AsyncLocalStorageExecutionScope,
+  SystemClock,
+  UuidGenerator,
+  type Clock,
+  type ExecutionScope,
+  type IdGenerator,
+  type Logger,
+  type Metrics,
+} from '@ddd-ts-kit/kernel';
+import { traceApplication, type ConsumerTrace, type TracedApplication } from '@ddd-ts-kit/tracing';
+{{#if audit.on}}
+import { createAudit, type Audit } from '{{alias.platform}}/audit/create-audit.js';
+{{/if}}
+{{#unless audit.on}}
+import { logDecisions } from '{{alias.platform}}/auth/log-decisions.js';
+{{/unless}}
+import type { Persistence } from '{{alias.platform}}/database/persistence.js';
+import { createLogger, type LogSettings } from '{{alias.platform}}/observability/create-logger.js';
+import { createMetrics } from '{{alias.platform}}/observability/create-metrics.js';
+
+/**
+ * What exists before any module: built once and handed to the kernel module, so that the buses,
+ * the logger{{#if audit.on}}, the audit sources{{/if}} and every adapter read one execution scope, one clock and one
+ * generator.
+ */
+export interface Foundations {
+  readonly scope: ExecutionScope;
+  readonly clock: Clock;
+  readonly ids: IdGenerator;
+  readonly logger: Logger;
+  readonly metrics: Metrics;
+  /** What observes the application from outside: handed to the kernel module, and to the buses this platform builds itself. */
+  readonly traced: TracedApplication;
+{{#if audit.on}}
+  readonly audit: Audit;
+{{/if}}
+{{#unless audit.on}}
+  /** What every authorization decision is told to: the log, since the audit trail is off. */
+  readonly decisions: OnDecision;
+{{/unless}}
+}
+
+interface Observed {
+  /** Where log entries go; left out, the application writes nothing. */
+  readonly log?: LogSettings;
+  /** Whether a consumed event continues the trace of its publication (the default) or starts one linked to it. */
+  readonly traceConsumers?: ConsumerTrace;
+}
+
+export function layFoundations(persistence: Persistence, options: Observed): Foundations {
+  const scope = new AsyncLocalStorageExecutionScope();
+  const clock = new SystemClock();
+  const ids = new UuidGenerator();
+  const logger = createLogger(scope, options.log);
+
+  return {
+    scope,
+    clock,
+    ids,
+    logger,
+    metrics: createMetrics(),
+    traced: traceApplication({ consumers: options.traceConsumers ?? 'continue' }),
+{{#if audit.on}}
+    audit: createAudit(persistence, { scope, clock, ids }),
+{{/if}}
+{{#unless audit.on}}
+    decisions: logDecisions(logger),
+{{/unless}}
+  };
+}

package/templates/init/platform/observability/create-logger.pino.ts.tpl

@@ -0,0 +1,28 @@
+import { NoopLogger, type ExecutionScope, type LogLevel, type Logger } from '@ddd-ts-kit/kernel';
+import { createPinoLogger } from '@ddd-ts-kit/pino';
+import { traceLogFields } from '@ddd-ts-kit/tracing';
+
+/** Where log entries go. Left out (the tools, the tests), the application writes nothing. */
+export interface LogSettings {
+  readonly level: LogLevel;
+  /** `json` everywhere; `pretty` (through `pino-pretty`, in a worker thread) on a developer's machine only. */
+  readonly format: 'json' | 'pretty';
+  readonly service: string;
+  readonly environment: string;
+  /** Writes `[message removed]` for the message of every logged error that is not a `DomainError`. */
+  readonly scrubMessages: boolean;
+}
+
+/**
+ * pino on the standard output, the credential keys of the kernel redacted. Every line carries
+ * what the execution scope knows of the work in progress (correlation id, origin, actor,
+ * tenant) and the ids of the active trace, so a request is followed from its log lines to its
+ * spans and to its audit entries. `stop()` of the application flushes it, last.
+ */
+export function createLogger(scope: ExecutionScope, settings: LogSettings | undefined): Logger {
+  if (settings === undefined) {
+    return new NoopLogger();
+  }
+
+  return createPinoLogger({ ...settings, fields: () => traceLogFields(scope) });
+}

package/templates/init/platform/observability/create-logger.stdout.ts.tpl

@@ -0,0 +1,36 @@
+import { StdoutLogger } from '@ddd-ts-kit/aspects';
+import { NoopLogger, type ExecutionScope, type LogLevel, type Logger } from '@ddd-ts-kit/kernel';
+import { traceLogFields } from '@ddd-ts-kit/tracing';
+
+/** Where log entries go. Left out (the tools, the tests), the application writes nothing. */
+export interface LogSettings {
+  readonly level: LogLevel;
+  /** `json` only: this logger has no pretty format, and `LOG_FORMAT=pretty` is refused when the configuration is loaded. */
+  readonly format: 'json';
+  readonly service: string;
+  readonly environment: string;
+  /** Writes `[message removed]` for the message of every logged error that is not a `DomainError`. */
+  readonly scrubMessages: boolean;
+}
+
+/**
+ * JSON lines on the standard output, credentials not redacted (`init --logger pino` or
+ * `--logger winston` redacts them and has a pretty format). Every entry carries
+ * what the execution scope knows of the work in progress (correlation id, origin, actor,
+ * tenant) and the ids of the active trace, so a request is followed from its log lines to its
+ * spans and to its audit entries. `stop()` of the application flushes it, last.
+ */
+export function createLogger(scope: ExecutionScope, settings: LogSettings | undefined): Logger {
+  if (settings === undefined) {
+    return new NoopLogger();
+  }
+
+  const { level, service, environment, scrubMessages } = settings;
+
+  return new StdoutLogger({
+    level,
+    base: { service, environment },
+    scrubMessages,
+    fields: () => traceLogFields(scope),
+  });
+}

package/templates/init/platform/observability/create-logger.winston.ts.tpl

@@ -0,0 +1,29 @@
+import { NoopLogger, type ExecutionScope, type LogLevel, type Logger } from '@ddd-ts-kit/kernel';
+import { traceLogFields } from '@ddd-ts-kit/tracing';
+import { createWinstonLogger } from '@ddd-ts-kit/winston';
+
+/** Where log entries go. Left out (the tools, the tests), the application writes nothing. */
+export interface LogSettings {
+  readonly level: LogLevel;
+  /** `json` everywhere; `pretty` on a developer's machine only. */
+  readonly format: 'json' | 'pretty';
+  readonly service: string;
+  readonly environment: string;
+  /** Writes `[message removed]` for the message of every logged error that is not a `DomainError`. */
+  readonly scrubMessages: boolean;
+}
+
+/**
+ * winston on the console, the credential keys of the kernel redacted. Its flush is final:
+ * what is logged after `stop()` of the application is dropped. Every line carries
+ * what the execution scope knows of the work in progress (correlation id, origin, actor,
+ * tenant) and the ids of the active trace, so a request is followed from its log lines to its
+ * spans and to its audit entries. `stop()` of the application flushes it, last.
+ */
+export function createLogger(scope: ExecutionScope, settings: LogSettings | undefined): Logger {
+  if (settings === undefined) {
+    return new NoopLogger();
+  }
+
+  return createWinstonLogger({ ...settings, fields: () => traceLogFields(scope) });
+}

package/templates/init/platform/observability/create-metrics.ts.tpl

@@ -0,0 +1,6 @@
+import { NoopMetrics, type Metrics } from '@ddd-ts-kit/kernel';
+
+// TODO(platform): answer an adapter of the kernel Metrics port (OpenTelemetry, Prometheus) here; until then the series of the bus middlewares and of `timed` are measured by nothing.
+export function createMetrics(): Metrics {
+  return new NoopMetrics();
+}

package/templates/init/platform/platform-test.module.tsyringe.ts.tpl

@@ -0,0 +1,24 @@
+import { defineContextModule } from '@ddd-ts-kit/di';
+{{#if persistence.packagedToken}}
+import { {{persistence.token}} } from '{{persistence.tokenPackage}}';
+{{/if}}
+{{#if persistence.ownDatabase}}
+import { Database } from '{{alias.platform}}/database/database.js';
+{{/if}}
+// ddd-ts-kit:imports
+// /ddd-ts-kit:imports
+
+/** The platform of a handler spec: no storage behind it, so every repository a test touches has to be faked. */
+export const platformTestModule = defineContextModule({
+  name: 'platform',
+  register(builder) {
+    {{#if persistence.hasDatabase}}
+    builder.bind({{persistence.token}}).toFactory(() => {
+      throw new Error('A handler spec has no database: give a fake for the repository it uses.');
+    });
+
+    {{/if}}
+    // ddd-ts-kit:test-bindings
+    // /ddd-ts-kit:test-bindings
+  },
+});

package/templates/init/platform/platform.manual.ts.tpl

@@ -0,0 +1,81 @@
+import type { AspectInfo } from '@ddd-ts-kit/aspects';
+import type { Access } from '@ddd-ts-kit/auth';
+import type {
+  ActorContext,
+  Cache,
+  Clock,
+  DomainEventDispatcher,
+  {{#if errors.sentry}}
+  ErrorReporter,
+  {{/if}}
+  ExecutionScope,
+  IdGenerator,
+  InMemoryCommandBus,
+  InMemoryQueryBus,
+  IntegrationEventPublisher,
+  IntegrationEventSubscriber,
+  JobScheduler,
+  Logger,
+  Metrics,
+  {{#if cache.rateLimit}}
+  RateLimiter,
+  {{/if}}
+} from '@ddd-ts-kit/kernel';
+{{#if audit.on}}
+import type { Audit } from '{{alias.platform}}/audit/create-audit.js';
+{{/if}}
+import type { UseCaseProtection } from '{{alias.platform}}/auth/use-case-protection.js';
+import type { Persistence } from '{{alias.platform}}/database/persistence.js';
+
+/** Wraps an adapter from outside: a span for its kind and, for what leaves the process, the default policy unless it states its own. */
+type Adapt = <T extends object>(instance: T, info: AspectInfo) => T;
+
+/** The technical capabilities every context receives. */
+export interface Platform {
+  /** The in-process buses: contexts register their handlers on them, routes and integration event handlers only see the `CommandBus` and `QueryBus` ports. */
+  readonly commands: InMemoryCommandBus;
+  readonly queries: InMemoryQueryBus;
+  readonly clock: Clock;
+  readonly ids: IdGenerator;
+  readonly domainEvents: DomainEventDispatcher;
+  /** What use cases publish through. */
+  readonly publisher: IntegrationEventPublisher;
+  readonly subscriber: IntegrationEventSubscriber;
+  {{#if broker.external}}
+
+  /** The subscriber of one consuming context: a broker gives each context queues of its own. */
+  subscriberFor(context: string): IntegrationEventSubscriber;
+
+  {{/if}}
+  /** The provider itself: what the outbox relay delivers to. */
+  readonly eventBus: IntegrationEventPublisher;
+  readonly persistence: Persistence;
+  /** Asks the policies about one element, then the authorizer: for the rules that need loaded state. */
+  readonly access: Access;
+  /**
+   * The work in progress (correlation id, actor, tenant), for infrastructure only: audit
+   * columns, tenant scoping, consumed events. Use cases get the actor in their message.
+   */
+  readonly scope: ExecutionScope;
+  /** The actor of the execution scope, for an adapter written against `ActorContext`. */
+  readonly actors: ActorContext;
+  readonly logger: Logger;
+  readonly metrics: Metrics;
+  {{#if errors.sentry}}
+  /** Where what stands around the use cases reports an unexpected failure: the buses, the jobs, the HTTP boundary. A handler throws and never calls it. */
+  readonly errors: ErrorReporter;
+  {{/if}}
+  readonly cache: Cache;
+  {{#if cache.rateLimit}}
+  readonly rateLimiter: RateLimiter;
+  {{/if}}
+  /** Where a context registers its scheduled jobs; the application starts it when this process runs the jobs. */
+  readonly jobs: JobScheduler;
+  readonly adapter: Adapt;
+  /** The same, for an adapter that states its own policy, as aspects or as decorators on its class. */
+  readonly selfGoverned: Adapt;
+  readonly protection: UseCaseProtection;
+  {{#if audit.on}}
+  readonly audit: Audit;
+  {{/if}}
+}