@ingenioz-it/caits 0.6.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ingenioz-it/caits",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "CAITS (Clean Architecture In TypeScript): the technical base of a Marko project with a backend and a frontend.",
   "keywords": [
     "clean-architecture",

package/quality/architecture/facts.mjs

@@ -10,7 +10,13 @@
 /** Each fact that a rule points at has the number of its line in the file, from 1. */
 /** @typedef {{ name: string | null; kind: string; line: number }} Export an exported name, its kind, and its line */
 /** @typedef {{ name: string | null; readonly: boolean; value: string | null; asConst: boolean; line: number }} Property a property of a class */
-/** @typedef {{ name: string | null; exported: boolean; extends: string | null; implements: string[]; properties: Property[]; line: number }} Class */
+/** @typedef {{ name: string | null; text: string }} TypeName a type that a signature names: its name when it is a name (`Note`), and its text */
+/**
+ * A method of a class, and what it returns: each type of its return type, out of `Promise<…>` and of the unions (`Promise<A | B>` names A
+ * and B), or null when it has no return type.
+ * @typedef {{ name: string | null; returns: TypeName[] | null; line: number }} Method
+ */
+/** @typedef {{ name: string | null; exported: boolean; extends: string | null; implements: string[]; properties: Property[]; methods: Method[]; line: number }} Class */
 /**
  * An item of `export default [ … ]`: the names that its chain calls, its text, the name that the first call takes first (`when(Event, …)`
  * takes Event), the class of each `new X(…)` in it, and its line.
@@ -120,8 +126,17 @@ function exportsOf(node, lineOf) {
   return [{ name: declaration.id?.name, kind: DECLARATION_KINDS[declaration.type] ?? declaration.type, line }];
 }
 
-/** @type {(node: Node, exported: boolean, lineOf: (node: Node) => number) => Class} */
-const classOf = (node, exported, lineOf) => ({
+/** The types that a return type names: those of a union, and the type of a Promise. @type {(type: Node, text: string) => TypeName[]} */
+const typeNamesOf = (type, text) => {
+  if (type.type === "TSUnionType") return type.types.flatMap((/** @type {Node} */ member) => typeNamesOf(member, text));
+  const reference = type.type === "TSTypeReference" && type.typeName.type === "Identifier" ? type.typeName.name : null;
+  const [promised, ...others] = (type.typeArguments ?? type.typeParameters)?.params ?? [];
+  if (reference === "Promise" && promised && others.length === 0) return typeNamesOf(promised, text);
+  return [{ name: reference, text: text.slice(type.start, type.end) }];
+};
+
+/** @type {(node: Node, exported: boolean, lineOf: (node: Node) => number, text: string) => Class} */
+const classOf = (node, exported, lineOf, text) => ({
   name: node.id?.name ?? null,
   exported,
   extends: nameOf(node.superClass),
@@ -133,6 +148,11 @@ const classOf = (node, exported, lineOf) => ({
     asConst: member.value?.type === "TSAsExpression" && member.value.typeAnnotation?.typeName?.name === "const",
     line: lineOf(member)
   })),
+  methods: node.body.body.filter((/** @type {Node} */ member) => (member.type === "MethodDefinition" || member.type === "ClassMethod") && member.kind === "method" && !member.static && !member.computed)
+    .map((/** @type {Node} */ member) => {
+      const returnType = (member.value ?? member).returnType?.typeAnnotation;
+      return { name: keyOf(member), returns: returnType ? typeNamesOf(returnType, text) : null, line: lineOf(member) };
+    }),
   line: lineOf(node)
 });
 
@@ -142,7 +162,7 @@ const classOf = (node, exported, lineOf) => ({
  * - exports: each exported name, with its kind (class, interface, type, const, function, enum, specifier, default, all);
  * - defaultArray: the items of `export default [ … ]`, with the calls of each item (`bind(X).to(Y)` calls bind, to), the name that the first
  *   call takes first (X), and the classes that the item builds, or null;
- * - classes: the classes, with what they extend and implement, and their properties;
+ * - classes: the classes, with what they extend and implement, their properties, and the return types of their methods;
  * - constructed: the class of each `new X(…)`;
  * - calls: each call, with the value of its arguments that are strings (null for the others);
  * - objectTypes: the value of each `type: "…"` of an object literal;
@@ -209,7 +229,7 @@ export function factsOf(program, text, comments = []) {
         });
       }
     }
-    if (node.type === "ClassDeclaration") facts.classes.push(classOf(node, exportedClasses.has(node), lineOf));
+    if (node.type === "ClassDeclaration") facts.classes.push(classOf(node, exportedClasses.has(node), lineOf, text));
     if (node.type === "NewExpression") {
       facts.constructed.push(nameOf(node.callee));
       facts.lines.constructed.push(lineOf(node));

package/quality/architecture/project.mjs

@@ -190,16 +190,18 @@ export function portOf(path) {
 }
 
 /**
- * An adapter, or its test: {context}/infra/{folder}/{file}. It implements the port named after its folder.
+ * An adapter, or its test: {context}/infra/{folder}/{file}. Its port is in the folder of the same name in the domain, domain/port/{folder}/:
+ * the module of that folder that is not its contract, whatever its name. The module is null when the domain has no such port.
  * @param {string} path
- * @returns {{ folder: string; test: boolean; port: string; portModule: string } | null}
+ * @param {Set<string>} paths
+ * @returns {{ folder: string; test: boolean; portModule: string | null } | null}
  */
-export function adapterOf(path) {
+export function adapterOf(path, paths) {
   const match = /^(src\/(?:backend|frontend)\/[^/]+)\/infra\/([a-z0-9-]+)\/([^/]+)$/.exec(path);
   if (!match) return null;
   const [, context, folder, name] = match;
-  const port = pascal(folder);
-  return { folder, test: name.endsWith(".test.ts"), port, portModule: `${context}/domain/port/${folder}/${port}` };
+  const port = [...paths].sort().map(portOf).find(found => found !== null && !found.contract && found.module.startsWith(`${context}/domain/port/${folder}/`));
+  return { folder, test: name.endsWith(".test.ts"), portModule: port?.module ?? null };
 }
 
 /** The contexts whose frontend a file takes: `frontendOf($global, "notes")` takes the frontend of notes. @type {(file: File) => string[]} */
@@ -216,7 +218,7 @@ export const LISTS = { domain: "domain", application: "application", presentatio
 
 /**
  * Whether a list of quality/imports.mjs holds an import of a package: the package, the module or the Node API itself, or a folder of
- * modules that holds it (`@ingenioz-it/caits/messaging/*` holds `@ingenioz-it/caits/messaging/Input`).
+ * modules that holds it (`@ingenioz-it/caits/messaging/*` holds `@ingenioz-it/caits/messaging/EventPublisher`).
  * @param {string} specifier
  * @param {string[]} list
  */

package/src/di/createBackend.ts

@@ -3,8 +3,7 @@ import type { Token } from "../Token.js";
 import { BackendEventBus, type Published } from "../messaging/BackendEventBus.js";
 import { ContextMap, type Envelope, type Translation } from "../messaging/ContextMap.js";
 import { EventPublisher } from "../messaging/EventPublisher.js";
-import { InProcessMessageBus } from "../messaging/InProcessMessageBus.js";
-import type { Input } from "../messaging/Input.js";
+import { InProcessMessageBus, UnknownInputError } from "../messaging/InProcessMessageBus.js";
 import { MessageBus } from "../messaging/MessageBus.js";
 import { ReportError, reportToConsole } from "../messaging/ReportError.js";
 import { bind, Container, type Binding, type Concrete } from "./Container.js";
@@ -40,11 +39,13 @@ export function createBackend(modules: BackendModules, options: BackendOptions =
   const owners = new Map<unknown, Context>();
   const listeners = new Set<(event: DomainEvent) => void>();
 
-  const ownerOf = (owned: Class): Context => {
+  /** The context of an input DTO, or of a controller: the error of an input is that of the message bus, which names the fix. */
+  const ownerOf = (owned: Class, refusal: () => Error): Context => {
     const context = owners.get(owned);
-    if (!context) throw new Error(`No context owns ${owned.name}`);
+    if (!context) throw refusal();
     return context;
   };
+  const ownerOfInput = (input: object): Context => ownerOf(input.constructor as Class, () => new UnknownInputError(input.constructor.name));
 
   /** The container of a request, and its message bus: each input DTO gets a new handler. */
   const requestOf = ({ container, useCases, shares }: Context, request: RequestContext) => {
@@ -58,8 +59,8 @@ export function createBackend(modules: BackendModules, options: BackendOptions =
     return { scope, bus };
   };
 
-  const send = async <Output>(input: Input<Output>, request: RequestContext = SYSTEM): Promise<Output> =>
-    requestOf(ownerOf(input.constructor as Class), request).bus.send(input);
+  const send = async (input: object, request: RequestContext = SYSTEM): Promise<unknown> =>
+    requestOf(ownerOfInput(input), request).bus.send(input);
 
   /**
    * An event that a handler publishes, in its context: the events of shared that the lines of its map that share give go to the shared
@@ -83,7 +84,7 @@ export function createBackend(modules: BackendModules, options: BackendOptions =
     event: line.event,
     inputs: (event: never, envelope: Envelope) => {
       const inputs = line.inputs(event, envelope);
-      const foreign = inputs.find(input => ownerOf(input.constructor as Class) !== contexts.get(name));
+      const foreign = inputs.find(input => ownerOfInput(input) !== contexts.get(name));
       if (foreign) throw new Error(`the context map of ${name} gives ${foreign.constructor.name}, an input of another context: a context map gives the inputs of its own context`);
       return inputs;
     }
@@ -119,7 +120,8 @@ export function createBackend(modules: BackendModules, options: BackendOptions =
     send,
     /** The controller of a context, built for a request. */
     controller: <C>(controller: abstract new (...args: never[]) => C, request: RequestContext = SYSTEM): C =>
-      requestOf(ownerOf(controller), request).scope.create(controller as unknown as Concrete<C>),
+      requestOf(ownerOf(controller, () => new Error(`No context has the controller ${controller.name}: write it in the folder of its use case, as <use-case>.<name>.controller.ts`)), request)
+        .scope.create(controller as unknown as Concrete<C>),
     /** Publishes an event of shared on the shared bus. */
     publish: (event: DomainEvent, request: RequestContext = SYSTEM) => { eventBus.publish(event, request); },
     redeliver: (published: Published) => { eventBus.redeliver(published.event, published.envelope); },

package/src/di/declareDependencies.js

@@ -9,12 +9,14 @@
  */
 
 /**
- * The code that a module needs after its own, for the containers:
+ * The code that a module needs after its own, for the containers and the message buses:
  * - after each class that has a constructor, the dependencies of the constructor (DEPENDENCIES in Container.ts): the name of each
  *   parameter, if it is optional, and the token of its type when the type has a value of the same name, declared in the module or
  *   imported from a relative path, from a shortcut of the project (#…, which a package.json or a tsconfig.json maps to a folder) or from
  *   one of the packages given (a port and its token, or a class: the kernel gives EventPublisher, DataDirectory…). The token is read only
  *   when the container needs it, thus a cycle between modules does no harm. The name of the type goes with its token, for the errors;
+ * - after each class that has an execute method, the value of the type of its first parameter, found the same way (INPUT in
+ *   discover.ts): the input DTO of a handler, which the message bus gives it;
  * - the name of each token declared without one: the name of its constant.
  * The names are text: the minifier can rename the code.
  * @param {string} code
@@ -31,6 +33,8 @@ export function declareDependencies(code, filename, parse, packages) {
   const values = new Set();
   /** @type {{ name: string; parameters: readonly ESTree.ParamPattern[] }[]} */
   const classes = [];
+  /** @type {{ name: string; input: ESTree.ParamPattern }[]} */
+  const executes = [];
   /** @type {string[]} */
   const tokens = [];
 
@@ -57,9 +61,12 @@ export function declareDependencies(code, filename, parse, packages) {
       values.add(declaration.id.name);
       const constructor = declaration.body.body.find(member => member.type === "MethodDefinition" && member.kind === "constructor");
       if (constructor?.type === "MethodDefinition") classes.push({ name: declaration.id.name, parameters: constructor.value.params });
+      const execute = declaration.body.body.find(member => member.type === "MethodDefinition" && member.kind === "method" && !member.static && !member.computed
+        && member.key.type === "Identifier" && member.key.name === "execute");
+      const input = execute?.type === "MethodDefinition" ? execute.value.params[0] : undefined;
+      if (input) executes.push({ name: declaration.id.name, input });
     }
   }
-  if (classes.length === 0 && tokens.length === 0) return undefined;
 
   /** @type {Map<string, string>} */
   const namespaces = new Map();
@@ -75,8 +82,7 @@ export function declareDependencies(code, filename, parse, packages) {
   };
   /** @type {(parameter: ESTree.ParamPattern, index: number) => string} */
   const dependencyOf = (parameter, index) => {
-    const inner = parameter.type === "TSParameterProperty" ? parameter.parameter : parameter;
-    const pattern = inner.type === "AssignmentPattern" ? inner.left : inner;
+    const { inner, pattern } = partsOf(parameter);
     const name = pattern.type === "Identifier" ? pattern.name : `#${index}`;
     const typed = tokenOf(pattern.typeAnnotation?.typeAnnotation);
     const optional = inner.type === "AssignmentPattern" || pattern.optional === true;
@@ -84,9 +90,23 @@ export function declareDependencies(code, filename, parse, packages) {
   };
 
   const declarations = classes.map(({ name, parameters }) => `${name}[Symbol.for("kernel.dependencies")] = [${parameters.map(dependencyOf).join(", ")}];`);
+  const inputs = executes.flatMap(({ name, input }) => {
+    const typed = tokenOf(partsOf(input).pattern.typeAnnotation?.typeAnnotation);
+    return typed ? [`${name}[Symbol.for("kernel.input")] = () => ${typed.token};`] : [];
+  });
   const imports = [...namespaces].map(([source, alias]) => `import * as ${alias} from ${JSON.stringify(source)};`);
   const names = tokens.map(name => `${name}.name = ${JSON.stringify(name)};`);
-  return [...imports, ...declarations, ...names].join("\n");
+  const lines = [...imports, ...declarations, ...inputs, ...names];
+  return lines.length > 0 ? lines.join("\n") : undefined;
+}
+
+/**
+ * A parameter, without what TypeScript adds around it (`private readonly`), and its pattern, without its default value.
+ * @param {ESTree.ParamPattern} parameter
+ */
+function partsOf(parameter) {
+  const inner = parameter.type === "TSParameterProperty" ? parameter.parameter : parameter;
+  return { inner, pattern: inner.type === "AssignmentPattern" ? inner.left : inner };
 }
 
 /** @type {(name: ESTree.ModuleExportName) => string} */

package/src/di/discover.ts

@@ -1,5 +1,4 @@
 import type { Translation } from "../messaging/ContextMap.js";
-import { Input } from "../messaging/Input.js";
 import type { Binding } from "./Container.js";
 
 export type Class = abstract new (...args: never[]) => unknown;
@@ -21,6 +20,22 @@ export function single<T>(found: T[], what: string): T {
   return found[0];
 }
 
+/** Where the plugin of the kernel writes the input DTO of a handler (see declareDependencies.js). */
+export const INPUT = Symbol.for("kernel.input");
+
+/**
+ * The use case of a handler: the handler, and the input DTO that its execute takes. The plugin of the kernel reads the class from the
+ * type of the parameter, as it reads the ports from the types of the constructor.
+ */
+export function useCaseOf(path: string, module: Record<string, unknown>): UseCase {
+  const handler = single(classesOf(module), `${path} declares one handler`);
+  const input = (handler as { [INPUT]?: () => unknown })[INPUT]?.();
+  if (typeof input !== "function") {
+    throw new Error(`${path}: ${handler.name}.execute names no input DTO. Give its parameter the type of the input DTO, the class that the use case receives.`);
+  }
+  return { input: input as Class, handler };
+}
+
 /**
  * The lines of a context map, as its file gives them: the kernel refuses, when it starts, a map that is not a list of lines, rather than
  * lose what it holds without a word. `isLine` tells a line of the side.
@@ -40,10 +55,10 @@ const isTranslation = ({ shares, event, inputs, events }: Partial<Record<string,
 
 /**
  * Turns the modules found in the backend folder (src/backend by default) into the contexts of the backend: a handler serves the input
- * DTO of its use-case folder, and the context map of a context gives the events of shared that it hears and those of its own that it
+ * DTO that its execute takes, and the context map of a context gives the events of shared that it hears and those of its own that it
  * shares.
  */
-export function discover(found: { bindings: Record<string, readonly Binding[]>; dtos: Modules; handlers: Modules; controllers: Modules; maps: Record<string, Translation[]> }): BackendModules {
+export function discover(found: { bindings: Record<string, readonly Binding[]>; handlers: Modules; controllers: Modules; maps: Record<string, Translation[]> }): BackendModules {
   const contexts: Record<string, ContextModules> = {};
   const context = (path: string) => contexts[contextOf(path)] ??= { bindings: [], useCases: [], controllers: [], map: [] };
   let shared: readonly Binding[] = [];
@@ -52,12 +67,7 @@ export function discover(found: { bindings: Record<string, readonly Binding[]>;
     if (contextOf(path) === "shared") shared = bindings;
     else context(path).bindings = bindings;
   }
-  for (const [path, module] of Object.entries(found.handlers)) {
-    const dto = path.replace(".handler.ts", ".dto.ts");
-    const input = single(classesOf(found.dtos[dto] ?? {}).filter(type => type.prototype instanceof Input), `${dto} declares one input DTO`);
-    const handler = single(classesOf(module), `${path} declares one handler`);
-    context(path).useCases.push({ input, handler });
-  }
+  for (const [path, module] of Object.entries(found.handlers)) context(path).useCases.push(useCaseOf(path, module));
   for (const [path, module] of Object.entries(found.controllers)) context(path).controllers.push(...classesOf(module));
   for (const [path, map] of Object.entries(found.maps)) {
     if (contextOf(path) === "shared") throw new Error(`the backend context shared hears no other context: it has no context map (${path})`);

package/src/di/discoverFrontends.ts

@@ -1,8 +1,7 @@
-import { Input } from "../messaging/Input.js";
 import type { Line } from "../messaging/FrontendContextMap.js";
 import type { StoreDefinition } from "../state/createStore.js";
 import type { Binding } from "./Container.js";
-import { classesOf, linesIn, single, type UseCase } from "./discover.js";
+import { linesIn, useCaseOf, type UseCase } from "./discover.js";
 
 /**
  * A context of the frontend: its bindings, its use cases, its store (none for a context without a use case: its views and its
@@ -20,12 +19,11 @@ const isLine = ({ shares, event, events }: Partial<Record<string, unknown>>) =>
 
 /**
  * Turns the modules found in the frontend folder (src/frontend by default) into the contexts of the frontend: a context has a di.ts,
- * a store at most, and its context map if it hears the context shared or shares events with it; a handler serves the input DTO of its
- * use-case folder.
+ * a store at most, and its context map if it hears the context shared or shares events with it; a handler serves the input DTO that
+ * its execute takes.
  */
 export function discoverFrontends(found: {
   bindings: Record<string, readonly Binding[]>;
-  dtos: Modules;
   handlers: Modules;
   stores: Record<string, StoreDefinition<unknown, unknown>>;
   maps: Record<string, readonly Line[]>;
@@ -46,9 +44,7 @@ export function discoverFrontends(found: {
   for (const [path, module] of Object.entries(found.handlers)) {
     const context = contexts[contextOf(path)];
     if (!context) throw new Error(`${path} belongs to a frontend without a di.ts`);
-    const dto = path.replace(".handler.ts", ".dto.ts");
-    const input = single(classesOf(found.dtos[dto] ?? {}).filter(type => type.prototype instanceof Input), `${dto} declares one input DTO`);
-    context.useCases.push({ input, handler: single(classesOf(module), `${path} declares one handler`) });
+    context.useCases.push(useCaseOf(path, module));
   }
   for (const [name, context] of Object.entries(contexts)) {
     if (context.useCases.length > 0 && !context.store) {

package/src/di/discovered.ts

@@ -1,6 +1,6 @@
 /// <reference path="../virtual-modules.d.ts" />
-import { bindings, dtos, handlers, controllers, maps } from "virtual:kernel/backend";
+import { bindings, handlers, controllers, maps } from "virtual:kernel/backend";
 import { discover } from "./discover.js";
 
 /** Every context of the backend: its di.ts, its use cases, its controllers and its context map. The plugin of the kernel finds them. */
-export const discovered = discover({ bindings, dtos, handlers, controllers, maps });
+export const discovered = discover({ bindings, handlers, controllers, maps });

package/src/di/discoveredFrontends.ts

@@ -1,6 +1,6 @@
 /// <reference path="../virtual-modules.d.ts" />
-import { bindings, dtos, handlers, maps, stores } from "virtual:kernel/frontend";
+import { bindings, handlers, maps, stores } from "virtual:kernel/frontend";
 import { discoverFrontends } from "./discoverFrontends.js";
 
 /** Every context of the frontend: its di.ts, its use cases, its store and its context map. The plugin of the kernel finds them. */
-export const discoveredFrontends = discoverFrontends({ bindings, dtos, handlers, stores, maps });
+export const discoveredFrontends = discoverFrontends({ bindings, handlers, stores, maps });

package/src/messaging/BackendEventBus.ts

@@ -1,6 +1,5 @@
 import type { DomainEvent } from "../DomainEvent.js";
 import type { ContextMap, Envelope } from "./ContextMap.js";
-import type { Input } from "./Input.js";
 import type { ReportError } from "./ReportError.js";
 
 export type Published = { readonly event: DomainEvent; readonly envelope: Envelope };
@@ -18,7 +17,7 @@ export class BackendEventBus {
 
   constructor(private readonly options: {
     map: ContextMap;
-    send: (input: Input<unknown>, envelope: Envelope) => Promise<unknown>;
+    send: (input: object, envelope: Envelope) => Promise<unknown>;
     nextEventId: () => string;
     reportError: ReportError;
   }) {}
@@ -48,7 +47,7 @@ export class BackendEventBus {
 
   private async deliver(event: DomainEvent, envelope: Envelope): Promise<void> {
     await nextTurn();
-    let inputs: Input<unknown>[];
+    let inputs: object[];
     try {
       inputs = this.options.map.inputsFor(event, envelope);
     } catch (error) {

package/src/messaging/ContextMap.ts

@@ -1,5 +1,4 @@
 import type { DomainEvent } from "../DomainEvent.js";
-import type { Input } from "./Input.js";
 
 /** What the shared bus adds to an event it carries: an id of its own, and the correlation id of the request that published it. */
 export type Envelope = { readonly eventId: string; readonly correlationId: string };
@@ -11,14 +10,14 @@ type EventClass<E> = abstract new (...args: never[]) => E;
  * input DTOs of the context, or an event of the context that it shares, which becomes events of the context shared.
  */
 export type Translation =
-  | { readonly shares: false; readonly event: EventClass<DomainEvent>; readonly inputs: (event: never, envelope: Envelope) => Input<unknown>[] }
+  | { readonly shares: false; readonly event: EventClass<DomainEvent>; readonly inputs: (event: never, envelope: Envelope) => object[] }
   | { readonly shares: true; readonly event: EventClass<DomainEvent>; readonly events: (event: never) => DomainEvent[] };
 
 /**
  * A line that hears the context shared: when this event of shared comes on the shared bus, the handlers of the context execute these
  * input DTOs. A context map names only its own context and the context shared: two contexts never name each other.
  */
-export function when<E extends DomainEvent>(event: EventClass<E>, inputs: (event: E, envelope: Envelope) => Input<unknown>[]): Translation {
+export function when<E extends DomainEvent>(event: EventClass<E>, inputs: (event: E, envelope: Envelope) => object[]): Translation {
   return { shares: false, event, inputs };
 }
 
@@ -35,7 +34,7 @@ export class ContextMap {
   constructor(private readonly translations: Translation[]) {}
 
   /** The input DTOs that the lines that hear this event of shared give, none when no line hears it. */
-  inputsFor(event: DomainEvent, envelope: Envelope): Input<unknown>[] {
+  inputsFor(event: DomainEvent, envelope: Envelope): object[] {
     return this.translations.flatMap(translation => !translation.shares && event instanceof translation.event ? translation.inputs(event as never, envelope) : []);
   }
 

package/src/messaging/Controller.ts

@@ -1,4 +1,3 @@
-import type { Input } from "./Input.js";
 import type { MessageBus } from "./MessageBus.js";
 import { reportToConsole, type ReportError } from "./ReportError.js";
 
@@ -68,7 +67,7 @@ export function problem(status: number, slug: string, title: string, detail?: st
 }
 
 /** Turns a request into an input DTO, sends it to the message bus of the request, and turns the output or the error into a response. */
-export abstract class Controller<Dto extends Input<Output>, Output> {
+export abstract class Controller<Dto extends object, Output> {
   constructor(private bus: MessageBus, private reportError: ReportError = reportToConsole) {}
 
   protected abstract toDto(request: Request): Dto | Promise<Dto>;
@@ -92,7 +91,7 @@ export abstract class Controller<Dto extends Input<Output>, Output> {
     try {
       let output: Output;
       try {
-        output = await this.bus.send(await this.toDto(request));
+        output = await this.bus.send(await this.toDto(request)) as Output;
       } catch (error) {
         return await this.toErrorResponse(error, request);
       }

package/src/messaging/InProcessMessageBus.ts

@@ -1,12 +1,10 @@
-import type { Input } from "./Input.js";
 import type { MessageBus } from "./MessageBus.js";
 
-export type OutputOf<I> = I extends Input<infer Output> ? Output : never;
-type InputClass<I extends Input<unknown>> = abstract new (...args: never[]) => I;
+type InputClass<I> = abstract new (...args: never[]) => I;
 
 export class UnknownInputError extends Error {
   constructor(readonly inputName: string) {
-    super(`No handler subscribes to ${inputName}`);
+    super(`No handler takes ${inputName}: write one next to its DTO, in <use-case>.handler.ts, with execute(input: ${inputName})`);
     this.name = "UnknownInputError";
   }
 }
@@ -22,14 +20,14 @@ export class DuplicateHandlerError extends Error {
 export class InProcessMessageBus implements MessageBus {
   private handlers = new Map<unknown, (input: never) => unknown>();
 
-  subscribe<I extends Input<unknown>>(input: InputClass<I>, handler: (input: I) => OutputOf<I> | Promise<OutputOf<I>>): void {
+  subscribe<I extends object>(input: InputClass<I>, handler: (input: I) => unknown): void {
     if (this.handlers.has(input)) throw new DuplicateHandlerError(input.name);
     this.handlers.set(input, handler);
   }
 
-  async send<Output>(input: Input<Output>): Promise<Output> {
+  async send(input: object): Promise<unknown> {
     const handler = this.handlers.get(input.constructor);
     if (!handler) throw new UnknownInputError(input.constructor.name);
-    return (await handler(input as never)) as Output;
+    return await handler(input as never);
   }
 }

package/src/messaging/MessageBus.ts

@@ -1,12 +1,11 @@
 import { Token } from "../Token.js";
-import type { Input } from "./Input.js";
 
 /**
  * Where a controller or a store sends an input DTO: the message bus gives it to the handler of its class, and gives back the output of
  * the handler.
  */
 export interface MessageBus {
-  send<Output>(input: Input<Output>): Promise<Output>;
+  send(input: object): Promise<unknown>;
 }
 
 export const MessageBus = new Token<MessageBus>();

package/src/state/createStore.ts

@@ -1,5 +1,4 @@
 import type { EventSubscriber } from "../messaging/EventSubscriber.js";
-import type { Input } from "../messaging/Input.js";
 import type { MessageBus } from "../messaging/MessageBus.js";
 import { reportToConsole, type ReportError } from "../messaging/ReportError.js";
 
@@ -9,7 +8,7 @@ export interface StoreDefinition<S, E> {
   /** The state after the event. */
   reduce(state: S, event: E): S;
   /** The input DTO that the event asks the store to send to the message bus, or undefined. It reads the state before the event. */
-  send(state: S, event: E): Input<unknown> | undefined;
+  send(state: S, event: E): object | undefined;
 }
 
 export interface Store<S> {

package/src/testing/backend/application.ts

@@ -2,7 +2,7 @@ import { test as base } from "vitest";
 import { createTestApplication, type TestApplication } from "./applications.js";
 
 /** Everything an application test of the backend imports: the test of a use case, written as a scenario. */
-export { afterAll, afterEach, beforeAll, beforeEach, describe, expect, vi } from "vitest";
+export { afterAll, afterEach, assert, beforeAll, beforeEach, describe, expect, vi } from "vitest";
 export { applicationScenario } from "./applicationScenario.js";
 export type { TestApplication } from "./applications.js";
 

package/src/testing/backend/applicationScenario.ts

@@ -1,19 +1,18 @@
 import { expect } from "vitest";
 import type { DomainEvent } from "../../DomainEvent.js";
-import type { Input } from "../../messaging/Input.js";
 import type { TestApplication } from "./applications.js";
 
-type Result<Output> = { output: Output } | { error: unknown };
+type Result = { output: unknown } | { error: unknown };
 
 /**
  * An application test, written as a presentation test: the input DTO, the events the handler publishes, then the output DTO or the error
  * that the message bus gives. The events are checked only when the test says which ones it expects.
  */
-export class ApplicationScenario<Output> {
+export class ApplicationScenario {
   private readonly expected: DomainEvent[] = [];
   private checksEvents = false;
 
-  constructor(private readonly app: TestApplication, private readonly dto: Input<Output>) {}
+  constructor(private readonly app: TestApplication, private readonly dto: object) {}
 
   expectItToPublish(event: DomainEvent): this {
     this.expected.push(event);
@@ -26,7 +25,7 @@ export class ApplicationScenario<Output> {
     return this;
   }
 
-  async expectTheOutputToBe(output: Output): Promise<void> {
+  async expectTheOutputToBe(output: object): Promise<void> {
     const from = this.app.published.length;
     const result = await this.run();
     if ("error" in result) throw result.error;
@@ -42,7 +41,7 @@ export class ApplicationScenario<Output> {
     expect(result.error).toStrictEqual(error);
   }
 
-  private async run(): Promise<Result<Output>> {
+  private async run(): Promise<Result> {
     try {
       return { output: await this.app.send(this.dto) };
     } catch (error) {
@@ -56,5 +55,5 @@ export class ApplicationScenario<Output> {
 }
 
 export const applicationScenario = (app: TestApplication) => ({
-  givenTheDto: <Output>(dto: Input<Output>) => new ApplicationScenario(app, dto)
+  givenTheDto: (dto: object) => new ApplicationScenario(app, dto)
 });

package/src/testing/backend/context-map.ts

@@ -5,7 +5,7 @@ import { createTestBackendApplication, type TestBackendApplication } from "./app
  * Everything a test of the context map imports. `test` checks what the `ContextMap` gives: the input DTOs for an event of shared
  * (`inputsFor`), the events of shared for an event of the context (`eventsFor`).
  */
-export { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test, vi } from "vitest";
+export { afterAll, afterEach, assert, beforeAll, beforeEach, describe, expect, test, vi } from "vitest";
 export { ContextMap } from "../../messaging/ContextMap.js";
 export type { TestBackendApplication } from "./applications.js";
 

package/src/testing/backend/integration.ts

@@ -2,7 +2,7 @@ import { createBackend } from "../../di/createBackend.js";
 import { discovered } from "../../di/discovered.js";
 
 /** Everything an integration test imports: flows of the context map again, with the real infra implementations. */
-export { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test, vi } from "vitest";
+export { afterAll, afterEach, assert, beforeAll, beforeEach, describe, expect, test, vi } from "vitest";
 
 /** The whole backend, built from the di.ts of the contexts only: the real infra implementations, as in production. */
 export const productionBackend = () => createBackend(discovered);

package/src/testing/frontend/applicationScenario.ts

@@ -1,5 +1,4 @@
 import { expect } from "vitest";
-import type { Input } from "../../messaging/Input.js";
 import type { TestApplication } from "./applications.js";
 
 /**
@@ -10,7 +9,7 @@ import type { TestApplication } from "./applications.js";
 export class ApplicationScenario implements PromiseLike<void> {
   private readonly expected: object[] = [];
 
-  constructor(private readonly app: TestApplication, private readonly dto: Input<void>) {}
+  constructor(private readonly app: TestApplication, private readonly dto: object) {}
 
   expectItToPublish(event: object): this {
     this.expected.push(event);
@@ -32,5 +31,5 @@ export class ApplicationScenario implements PromiseLike<void> {
 }
 
 export const applicationScenario = (app: TestApplication) => ({
-  givenTheDto: (dto: Input<void>) => new ApplicationScenario(app, dto)
+  givenTheDto: (dto: object) => new ApplicationScenario(app, dto)
 });

package/src/testing/frontend/applications.ts

@@ -4,7 +4,7 @@ import type { Binding } from "../../di/Container.js";
 import { createFrontendWithBus } from "../../di/createFrontend.js";
 import { discoveredFrontends } from "../../di/discoveredFrontends.js";
 import type { Fetcher } from "../../di/Fetcher.js";
-import type { Input } from "../../messaging/Input.js";
+import { UnknownInputError } from "../../messaging/InProcessMessageBus.js";
 import type { Token } from "../../Token.js";
 
 /** The test.di.ts of each context that has one: the bindings that replace, in tests, those that reach outside the browser. */
@@ -37,7 +37,7 @@ export function createTestApplication() {
 
   const ownerOf = (input: object): string => {
     const name = Object.keys(discoveredFrontends).find(context => discoveredFrontends[context].useCases.some(({ input: type }) => type === input.constructor));
-    if (name === undefined) throw new Error(`No context handles ${input.constructor.name}`);
+    if (name === undefined) throw new UnknownInputError(input.constructor.name);
     return name;
   };
 
@@ -50,7 +50,7 @@ export function createTestApplication() {
 
   return {
     /** Sends an input DTO to the message bus of the context that handles it. */
-    send: <Output>(input: Input<Output>): Promise<Output> => frontend(ownerOf(input)).bus.send(input),
+    send: (input: object): Promise<unknown> => frontend(ownerOf(input)).bus.send(input),
     /** The dependency with this token, built now if no handler needed it before. */
     get: <T>(token: Token<T>): T => {
       const found = holders(token);