ddd-ts-kit 0.0.0-stage → 0.1.0

package/templates/builder/builder.ts.tpl

@@ -0,0 +1,32 @@
+import { Builder, sequence, type Defaults } from '@ddd-ts-kit/testing';
+import { {{aggregate.pascal}} } from '{{alias.context}}/domain/aggregates/{{aggregate.kebab}}.aggregate.js';
+
+interface {{aggregate.pascal}}Ingredients {
+  readonly id: string;
+  readonly bornAt: Date;
+  // TODO(domain): add one ingredient per fact a test may need to choose (a customer, lines, a status reached), each with a valid default below; for the ones no rule depends on, draw the default with `generated((faker) => ...)` of @ddd-ts-kit/testing/faker.
+}
+
+export class {{aggregate.pascal}}Builder extends Builder<{{aggregate.pascal}}Ingredients, {{aggregate.pascal}}> {
+  identifiedBy(id: string): this {
+    return this.with('id', id);
+  }
+
+  bornAt(instant: Date): this {
+    return this.with('bornAt', instant);
+  }
+
+  // TODO(domain): add one method per state a test needs, named in the ubiquitous language and never after a field, for example `issued(): this { return this.with('issued', true); }`, and replay it in `construct` through the public API of {{aggregate.pascal}}.
+
+  protected defaults(): Defaults<{{aggregate.pascal}}Ingredients> {
+    return { id: sequence('{{aggregate.kebab}}'), bornAt: new Date('2026-01-01T00:00:00.000Z') };
+  }
+
+  protected construct(ingredients: {{aggregate.pascal}}Ingredients): {{aggregate.pascal}} {
+    return {{aggregate.pascal}}.create(ingredients.id, ingredients.bornAt);
+  }
+}
+
+export function {{aggregate.article}}{{aggregate.pascal}}(): {{aggregate.pascal}}Builder {
+  return new {{aggregate.pascal}}Builder();
+}

package/templates/command/command.ts.tpl

@@ -0,0 +1,27 @@
+{{#if access.protected}}
+import { AuthorizedCommand } from '@ddd-ts-kit/kernel';
+{{#if style.declared}}
+import { Requires } from '@ddd-ts-kit/kernel/declarations';
+{{access.useCasePermissionsImport}}
+{{/if}}
+
+{{#if style.declared}}
+@{{access.decoration}}
+{{/if}}
+export class {{name.pascal}}Command extends AuthorizedCommand<{{command.result}}> {
+  // TODO(domain): declare the input of "{{name.words}}" as a constructor with the actor first, then readonly primitives and ids, for example `constructor(actor: Actor, readonly customerId: string) { super(actor); }`; the handler turns them into value objects.
+}
+{{/if}}
+{{#if access.public}}
+import { Command } from '@ddd-ts-kit/kernel';
+{{#if style.declared}}
+import { Public } from '@ddd-ts-kit/kernel/declarations';
+{{/if}}
+
+{{#if style.declared}}
+@Public()
+{{/if}}
+export class {{name.pascal}}Command extends Command<{{command.result}}> {
+  // TODO(domain): declare the input of "{{name.words}}" as a constructor with readonly primitives and ids, for example `constructor(readonly customerId: string) { super(); }`; the handler turns them into value objects.
+}
+{{/if}}

package/templates/command/handler.declared.ts.tpl

@@ -0,0 +1,36 @@
+{{#if command.hasAggregate}}
+import { Clock, IdGenerator } from '@ddd-ts-kit/kernel';
+import { CommandHandler } from '@ddd-ts-kit/kernel/declarations';
+import { {{aggregate.pascal}} } from '{{alias.context}}/domain/aggregates/{{aggregate.kebab}}.aggregate.js';
+import { {{aggregate.pascal}}Repository } from '{{alias.context}}/domain/repositories/{{aggregate.kebab}}.repository.js';
+import { {{name.pascal}}Command } from '{{alias.context}}/application/commands/{{name.kebab}}/{{name.kebab}}.command.js';
+
+@CommandHandler({{name.pascal}}Command, [{{aggregate.pascal}}Repository, IdGenerator, Clock])
+export class {{name.pascal}}Handler implements CommandHandler<{{name.pascal}}Command> {
+  constructor(
+    private readonly {{aggregate.camel}}Repository: {{aggregate.pascal}}Repository,
+    private readonly ids: IdGenerator,
+    private readonly clock: Clock,
+  ) {}
+
+  async execute(command: {{name.pascal}}Command): Promise<string> {
+    // TODO(domain): decide what "{{name.words}}" does to a {{aggregate.pascal}}: either it gives birth to one (keep `create`, pass the facts of `command` as value objects), or it changes an existing one (load it with `findById`, throw a not-found DomainError, call ONE intention method). The events it records leave with the save: nothing else to do here.
+    const target = {{aggregate.pascal}}.create(this.ids.next(), this.clock.now());
+
+    await this.{{aggregate.camel}}Repository.save(target);
+
+    return target.id;
+  }
+}
+{{/if}}
+{{#unless command.hasAggregate}}
+import { CommandHandler } from '@ddd-ts-kit/kernel/declarations';
+import { {{name.pascal}}Command } from '{{alias.context}}/application/commands/{{name.kebab}}/{{name.kebab}}.command.js';
+
+@CommandHandler({{name.pascal}}Command)
+export class {{name.pascal}}Handler implements CommandHandler<{{name.pascal}}Command> {
+  async execute(command: {{name.pascal}}Command): Promise<void> {
+    // TODO(domain): name the repository of the aggregate "{{name.words}}" acts on in the dependency list and receive it in the constructor (rerun with --aggregate <Name> --force to get it declared), load or create the aggregate from `command`, call its intention method and save it (its events leave with the save); the unit of work is opened by the command bus.
+  }
+}
+{{/unless}}

package/templates/command/handler.spec.buses.ts.tpl

@@ -0,0 +1,87 @@
+import { describe, expect, it } from '{{tests.module}}';
+{{#if access.protected}}
+import { AuthorizationMap, RoleBasedAuthorizer, authorizationMiddleware, requires } from '@ddd-ts-kit/auth';
+import { anActor } from '@ddd-ts-kit/auth/testing';
+{{/if}}
+import { createTestBuses } from '@ddd-ts-kit/testing';
+{{#if access.protected}}
+import { {{context.camel}}Permissions } from '{{alias.context}}/application/authorization/{{context.kebab}}.permissions.js';
+{{/if}}
+import { {{name.pascal}}Command } from '{{alias.context}}/application/commands/{{name.kebab}}/{{name.kebab}}.command.js';
+import { {{name.pascal}}Handler } from '{{alias.context}}/application/commands/{{name.kebab}}/{{name.kebab}}.handler.js';
+{{#if command.hasAggregate}}
+import { Fake{{aggregate.pascal}}Repository } from '{{alias.context}}/test/fakes/{{aggregate.kebab}}.repository.fake.js';
+{{/if}}
+{{#if access.protected}}
+
+const holders = authorizationMiddleware({
+  authorizer: new RoleBasedAuthorizer({
+    roles: { holder: [{{context.camel}}Permissions['{{access.permission}}']] },
+  }),
+  map: AuthorizationMap.of(requires({{name.pascal}}Command, {{context.camel}}Permissions['{{access.permission}}'])),
+});
+
+const holder = anActor().withRole('holder').build();
+{{/if}}
+
+describe('{{name.title}}', () => {
+  {{#if command.hasAggregate}}
+  it('saves the {{aggregate.words}} and answers its identifier', async () => {
+    const { commandBus, {{aggregate.camel}}Repository } = arrange();
+
+    const id = await commandBus.execute(new {{name.pascal}}Command({{access.holder}}));
+
+    expect(id).toBe('{{aggregate.kebab}}-1');
+    expect(await {{aggregate.camel}}Repository.findById(id)).toBeDefined();
+  });
+  {{/if}}
+  {{#unless command.hasAggregate}}
+  it('completes without answering anything', async () => {
+    const { commandBus } = arrange();
+    const command = new {{name.pascal}}Command({{access.holder}});
+
+    await expect(commandBus.execute(command)).resolves.toBeUndefined();
+  });
+  {{/unless}}
+  {{#if access.protected}}
+
+  it('is refused to an actor who does not hold the permission {{access.permission}}', async () => {
+    const { commandBus } = arrange();
+    const command = new {{name.pascal}}Command(anActor().build());
+
+    await expect(commandBus.execute(command)).rejects.toMatchObject({ code: 'FORBIDDEN' });
+  });
+  {{/if}}
+
+  {{#if command.hasAggregate}}
+  // TODO(domain): replace each entry below by a test named after the business behaviour of "{{name.words}}": arrange with the builders of test/builders and the fakes, execute through the bus, assert the stored {{aggregate.words}}, the facts announced with the save (`domainEvents.on('<name>', ...)` registered in `arrange`) and the answer.
+  it.todo('applies the business decision to the {{aggregate.words}}');
+  {{/if}}
+  {{#unless command.hasAggregate}}
+  // TODO(domain): replace each entry below by a test named after the business behaviour of "{{name.words}}": arrange with builders and fakes of its ports, execute through the bus, assert the outcome.
+  it.todo('applies the business decision to the aggregate');
+  {{/unless}}
+  it.todo('refuses the command when a business rule is violated, with the expected error code');
+  it.todo('saves and publishes nothing when the command is refused');
+});
+
+function arrange() {
+  {{#if command.hasAggregate}}
+  const { commandBus, clock, ids, dispatching, domainEvents } = createTestBuses({ idPrefix: '{{aggregate.kebab}}' });
+  // As the application hands it to the handler: the save announces the events of the {{aggregate.words}} to `domainEvents`.
+  const {{aggregate.camel}}Repository = dispatching(new Fake{{aggregate.pascal}}Repository());
+
+  const handler = new {{name.pascal}}Handler({{aggregate.camel}}Repository, ids, clock);
+
+  commandBus{{spec.guard}}.register({{name.pascal}}Command, handler);
+
+  return { commandBus, {{aggregate.camel}}Repository, domainEvents };
+  {{/if}}
+  {{#unless command.hasAggregate}}
+  const { commandBus } = createTestBuses();
+
+  commandBus{{spec.guard}}.register({{name.pascal}}Command, new {{name.pascal}}Handler());
+
+  return { commandBus };
+  {{/unless}}
+}

package/templates/command/handler.spec.tsyringe.ts.tpl

@@ -0,0 +1,102 @@
+import { describe, expect, it } from '{{tests.module}}';
+import { RoleBasedAuthorizer } from '@ddd-ts-kit/auth';
+import { authorizationModule } from '@ddd-ts-kit/auth/di';
+{{#if access.protected}}
+import { anActor } from '@ddd-ts-kit/auth/testing';
+{{/if}}
+{{#if command.hasAggregate}}
+{{spec.diWithFake}}
+{{/if}}
+{{#unless command.hasAggregate}}
+{{spec.diPlain}}
+{{/unless}}
+{{spec.contextImports}}
+import { platformTestModule } from '{{alias.platform}}/platform-test.module.js';
+{{#if access.protected}}
+import { {{context.camel}}Permissions } from '{{alias.context}}/application/authorization/{{context.kebab}}.permissions.js';
+{{/if}}
+import { {{name.pascal}}Command } from '{{alias.context}}/application/commands/{{name.kebab}}/{{name.kebab}}.command.js';
+{{#if command.hasAggregate}}
+import { {{aggregate.pascal}}Repository } from '{{alias.context}}/domain/repositories/{{aggregate.kebab}}.repository.js';
+import { Fake{{aggregate.pascal}}Repository } from '{{alias.context}}/test/fakes/{{aggregate.kebab}}.repository.fake.js';
+{{/if}}
+{{#if access.protected}}
+
+const holders = authorizationModule({
+  authorizer: new RoleBasedAuthorizer({
+    roles: { holder: [{{context.camel}}Permissions['{{access.permission}}']] },
+  }),
+});
+
+const holder = anActor().withRole('holder').build();
+{{/if}}
+{{#if access.public}}
+
+const authorization = authorizationModule({ authorizer: new RoleBasedAuthorizer({ roles: {} }) });
+{{/if}}
+
+describe('{{name.title}}', () => {
+{{#if command.hasAggregate}}
+  it('saves the {{aggregate.words}} and answers its identifier', async () => {
+    const { application, {{aggregate.camel}}Repository } = {{spec.await}}arrange();
+
+    const id = await application.commandBus.execute(new {{name.pascal}}Command({{access.holder}}));
+
+    expect(id).toBe('{{aggregate.kebab}}-1');
+    expect(await {{aggregate.camel}}Repository.findById(id)).toBeDefined();
+  });
+{{/if}}
+{{#unless command.hasAggregate}}
+  it('completes without answering anything', async () => {
+    const { application } = {{spec.await}}arrange();
+    const command = new {{name.pascal}}Command({{access.holder}});
+
+    await expect(application.commandBus.execute(command)).resolves.toBeUndefined();
+  });
+{{/unless}}
+{{#if access.protected}}
+
+  it('is refused to an actor who does not hold the permission {{access.permission}}', async () => {
+    const { application } = {{spec.await}}arrange();
+    const command = new {{name.pascal}}Command(anActor().build());
+
+    await expect(application.commandBus.execute(command)).rejects.toMatchObject({ code: 'FORBIDDEN' });
+  });
+{{/if}}
+
+{{#if command.hasAggregate}}
+  // TODO(domain): replace each entry below by a test named after the business behaviour of "{{name.words}}": arrange with the builders of test/builders and the fakes, execute through the bus, assert the stored {{aggregate.words}}, the facts announced with the save (`application.domainEvents.on('<name>', ...)` before executing), `application.eventBus.published` and the answer.
+  it.todo('applies the business decision to the {{aggregate.words}}');
+{{/if}}
+{{#unless command.hasAggregate}}
+  // TODO(domain): replace each entry below by a test named after the business behaviour of "{{name.words}}": arrange with builders and fakes of its ports (`fakes: [fake(Port, aFake)]`), execute through the bus, assert the outcome.
+  it.todo('applies the business decision to the aggregate');
+{{/unless}}
+  it.todo('refuses the command when a business rule is violated, with the expected error code');
+  it.todo('saves and publishes nothing when the command is refused');
+});
+
+{{spec.async}}function arrange() {
+{{#if spec.assembles}}
+  const context = {{spec.context}};
+
+{{/if}}
+{{#if command.hasAggregate}}
+  const {{aggregate.camel}}Repository = new Fake{{aggregate.pascal}}Repository();
+
+  const application = createTestApplication({
+    modules: [{{spec.modules}}],
+    fakes: [fake({{aggregate.pascal}}Repository, {{aggregate.camel}}Repository)],
+    idPrefix: '{{aggregate.kebab}}',
+  });
+
+  return { application, {{aggregate.camel}}Repository };
+{{/if}}
+{{#unless command.hasAggregate}}
+  const application = createTestApplication({
+    modules: [{{spec.modules}}],
+  });
+
+  return { application };
+{{/unless}}
+}

package/templates/command/handler.ts.tpl

@@ -0,0 +1,33 @@
+{{#if command.hasAggregate}}
+import type { Clock, CommandHandler, IdGenerator } from '@ddd-ts-kit/kernel';
+import { {{aggregate.pascal}} } from '{{alias.context}}/domain/aggregates/{{aggregate.kebab}}.aggregate.js';
+import type { {{aggregate.pascal}}Repository } from '{{alias.context}}/domain/repositories/{{aggregate.kebab}}.repository.js';
+import type { {{name.pascal}}Command } from '{{alias.context}}/application/commands/{{name.kebab}}/{{name.kebab}}.command.js';
+
+export class {{name.pascal}}Handler implements CommandHandler<{{name.pascal}}Command> {
+  constructor(
+    private readonly {{aggregate.camel}}Repository: {{aggregate.pascal}}Repository,
+    private readonly ids: IdGenerator,
+    private readonly clock: Clock,
+  ) {}
+
+  async execute(command: {{name.pascal}}Command): Promise<string> {
+    // TODO(domain): decide what "{{name.words}}" does to a {{aggregate.pascal}}: either it gives birth to one (keep `create`, pass the facts of `command` as value objects), or it changes an existing one (load it with `findById`, throw a not-found DomainError, call ONE intention method). The events it records leave with the save: nothing else to do here.
+    const target = {{aggregate.pascal}}.create(this.ids.next(), this.clock.now());
+
+    await this.{{aggregate.camel}}Repository.save(target);
+
+    return target.id;
+  }
+}
+{{/if}}
+{{#unless command.hasAggregate}}
+import type { CommandHandler } from '@ddd-ts-kit/kernel';
+import type { {{name.pascal}}Command } from '{{alias.context}}/application/commands/{{name.kebab}}/{{name.kebab}}.command.js';
+
+export class {{name.pascal}}Handler implements CommandHandler<{{name.pascal}}Command> {
+  async execute(command: {{name.pascal}}Command): Promise<void> {
+    // TODO(domain): receive the repository of the aggregate "{{name.words}}" acts on in the constructor (rerun with --aggregate <Name> --force to get it wired), load or create the aggregate from `command`, call its intention method and save it (its events leave with the save); the unit of work is opened by the command bus.
+  }
+}
+{{/unless}}

package/templates/command/wiring.manual.tpl

@@ -0,0 +1,14 @@
+@@imports
+{{access.manualImport}}
+{{access.permissionsImport}}
+import { {{name.pascal}}Command } from '{{alias.context}}/application/commands/{{name.kebab}}/{{name.kebab}}.command.js';
+import { {{name.pascal}}Handler } from '{{alias.context}}/application/commands/{{name.kebab}}/{{name.kebab}}.handler.js';
+@@registrations
+{{#if command.hasAggregate}}
+platform.commands.register({{name.pascal}}Command, new {{name.pascal}}Handler({{aggregate.camel}}Repository, platform.ids, platform.clock), { context: '{{context.kebab}}' });
+{{/if}}
+{{#unless command.hasAggregate}}
+platform.commands.register({{name.pascal}}Command, new {{name.pascal}}Handler(), { context: '{{context.kebab}}' });
+{{/unless}}
+@@authorization
+{{access.manualDeclaration}}

package/templates/command/wiring.tsyringe.tpl

@@ -0,0 +1,15 @@
+@@imports
+{{#if command.hasAggregate}}
+import { Clock, IdGenerator } from '@ddd-ts-kit/kernel';
+import { {{aggregate.pascal}}Repository } from '{{alias.context}}/domain/repositories/{{aggregate.kebab}}.repository.js';
+{{/if}}
+{{access.permissionsImport}}
+import { {{name.pascal}}Command } from '{{alias.context}}/application/commands/{{name.kebab}}/{{name.kebab}}.command.js';
+import { {{name.pascal}}Handler } from '{{alias.context}}/application/commands/{{name.kebab}}/{{name.kebab}}.handler.js';
+@@registrations
+{{#if command.hasAggregate}}
+builder.command({{name.pascal}}Command){{access.declaration}}.handledBy({{name.pascal}}Handler, [{{aggregate.pascal}}Repository, IdGenerator, Clock]);
+{{/if}}
+{{#unless command.hasAggregate}}
+builder.command({{name.pascal}}Command){{access.declaration}}.handledBy({{name.pascal}}Handler);
+{{/unless}}

package/templates/context/CONTEXT.md.tpl

@@ -0,0 +1,46 @@
+# {{context.title}}
+
+## Purpose
+
+{{doc.purpose}}
+
+## Classification
+
+{{doc.classification}}
+
+TODO(domain): say in one sentence why this context is {{doc.classification}}.
+
+## Ubiquitous language
+{{doc.glossaryHint}}
+| Term | Meaning | Not to be confused with |
+|---|---|---|{{doc.glossaryRows}}
+
+## Aggregates
+
+<!-- ddd-ts-kit:aggregates -->
+<!-- /ddd-ts-kit:aggregates -->
+
+## Published events
+
+<!-- ddd-ts-kit:events -->
+<!-- /ddd-ts-kit:events -->
+
+## Permissions
+
+<!-- ddd-ts-kit:permissions -->
+<!-- /ddd-ts-kit:permissions -->
+
+## Scheduled jobs
+
+<!-- ddd-ts-kit:jobs -->
+<!-- /ddd-ts-kit:jobs -->
+
+## Relationships
+
+<!-- ddd-ts-kit:relationships -->
+<!-- /ddd-ts-kit:relationships -->
+
+## Reference
+
+<!-- ddd-ts-kit:reference -->
+<!-- /ddd-ts-kit:reference -->

package/templates/context/module.manual.ts.tpl

@@ -0,0 +1,34 @@
+import type { UseCaseDeclaration } from '@ddd-ts-kit/auth';
+{{#if http.any}}
+import type { Route } from '@ddd-ts-kit/http';
+{{/if}}
+import type { Platform } from '{{alias.platform}}/platform.js';
+// ddd-ts-kit:imports
+// /ddd-ts-kit:imports
+
+export interface {{context.pascal}}Wiring {
+  readonly name: string;
+  readonly useCases: readonly UseCaseDeclaration[];
+  {{#if http.any}}
+  readonly routes: readonly Route[];
+  {{/if}}
+}
+
+export function {{context.camel}}Module(platform: Platform): {{context.pascal}}Wiring {
+  // ddd-ts-kit:registrations
+  // /ddd-ts-kit:registrations
+
+  return {
+    name: '{{context.kebab}}',
+    useCases: [
+      // ddd-ts-kit:authorization
+      // /ddd-ts-kit:authorization
+    ],
+    {{#if http.any}}
+    routes: [
+      // ddd-ts-kit:routes
+      // /ddd-ts-kit:routes
+    ],
+    {{/if}}
+  };
+}

package/templates/context/module.tsyringe.ts.tpl

@@ -0,0 +1,15 @@
+import { defineContextModule } from '@ddd-ts-kit/di';
+// ddd-ts-kit:imports
+// /ddd-ts-kit:imports
+
+export const {{context.camel}}Module = defineContextModule({
+  name: '{{context.kebab}}',
+  register(builder) {
+    // ddd-ts-kit:registrations
+    // /ddd-ts-kit:registrations
+  },
+  onStart({ resolve }) {
+    // ddd-ts-kit:start
+    // /ddd-ts-kit:start
+  },
+});

package/templates/context/permission-set.tpl

@@ -0,0 +1,4 @@
+@@imports
+import { {{context.camel}}Permissions } from '{{alias.context}}/application/authorization/{{context.kebab}}.permissions.js';
+@@permission-sets
+{{context.camel}}Permissions,

package/templates/context/permission.tpl

@@ -0,0 +1,2 @@
+@@permissions
+'{{access.permission}}': { description: '{{access.description}}' },

package/templates/context/permissions.spec.ts.tpl

@@ -0,0 +1,14 @@
+import { describe, expect, it } from '{{tests.module}}';
+import type { Permission } from '@ddd-ts-kit/auth';
+import { {{context.camel}}Permissions } from '{{alias.context}}/application/authorization/{{context.kebab}}.permissions.js';
+
+describe('The permissions of {{context.kebab}}', () => {
+  it('belong to {{context.kebab}}, each under an identifier of its own and with a description', () => {
+    const permissions: readonly Permission[] = Object.values({{context.camel}}Permissions);
+    const identifiers = permissions.map((permission) => permission.id);
+
+    expect(new Set(identifiers).size).toBe(identifiers.length);
+    expect(permissions.filter((permission) => permission.context !== '{{context.kebab}}')).toEqual([]);
+    expect(permissions.filter((permission) => permission.description.trim() === '')).toEqual([]);
+  });
+});

package/templates/context/permissions.ts.tpl

@@ -0,0 +1,6 @@
+import { definePermissions } from '@ddd-ts-kit/auth';
+
+export const {{context.camel}}Permissions = definePermissions('{{context.kebab}}', {
+  // ddd-ts-kit:permissions
+  // /ddd-ts-kit:permissions
+});

package/templates/context/published-language-index.ts.tpl

@@ -0,0 +1 @@
+export {};

package/templates/context/routes.spec.ts.tpl

@@ -0,0 +1,14 @@
+import { describe, expect, it } from '{{tests.module}}';
+import { InMemoryCommandBus, InMemoryQueryBus } from '@ddd-ts-kit/kernel';
+import { {{context.camel}}Routes } from '{{alias.context}}/presentation/http/{{context.kebab}}.routes.js';
+
+describe('The routes of {{context.kebab}}', () => {
+  it('answer each method and path once, each under an operation of its own', () => {
+    const routes = {{context.camel}}Routes(new InMemoryCommandBus(), new InMemoryQueryBus());
+    const endpoints = routes.map((route) => `${route.method} ${route.path}`);
+    const operations = routes.map((route) => route.operationId);
+
+    expect(new Set(endpoints).size).toBe(endpoints.length);
+    expect(new Set(operations).size).toBe(operations.length);
+  });
+});

package/templates/context/routes.ts.tpl

@@ -0,0 +1,11 @@
+import type { Route } from '@ddd-ts-kit/http';
+import type { CommandBus, QueryBus } from '@ddd-ts-kit/kernel';
+// ddd-ts-kit:imports
+// /ddd-ts-kit:imports
+
+export function {{context.camel}}Routes(commands: CommandBus, queries: QueryBus): readonly Route[] {
+  return [
+    // ddd-ts-kit:routes
+    // /ddd-ts-kit:routes
+  ];
+}

package/templates/context/wiring.declared.tpl

@@ -0,0 +1,13 @@
+@@imports
+{{#if assembly.barrel}}
+import * as {{context.camel}}Declarations from '{{alias.context}}/{{context.kebab}}.declarations.js';
+{{/if}}
+{{#if http.any}}
+import { {{context.camel}}Routes } from '{{alias.context}}/presentation/http/{{context.kebab}}.routes.js';
+{{/if}}
+@@contexts
+{{assembled.module}},
+{{#if http.any}}
+@@routes
+{{context.camel}}Routes,
+{{/if}}

package/templates/context/wiring.manual.tpl

@@ -0,0 +1,4 @@
+@@imports
+import { {{context.camel}}Module } from '{{alias.context}}/{{context.kebab}}.module.js';
+@@contexts
+{{context.camel}}Module,

package/templates/context/wiring.tsyringe.tpl

@@ -0,0 +1,11 @@
+@@imports
+import { {{context.camel}}Module } from '{{alias.context}}/{{context.kebab}}.module.js';
+{{#if http.any}}
+import { {{context.camel}}Routes } from '{{alias.context}}/presentation/http/{{context.kebab}}.routes.js';
+{{/if}}
+@@contexts
+{{context.camel}}Module,
+{{#if http.any}}
+@@routes
+{{context.camel}}Routes,
+{{/if}}

package/templates/docs/context-map.md.tpl

@@ -0,0 +1,23 @@
+# Context map
+
+The diagram and the table are generated by `npx ddd-ts-kit docs` from `ddd-ts-kit.config.json`
+and the `CONTEXT.md` files. Everything outside the markers is written by the team and kept.
+
+<!-- ddd-ts-kit:context-map -->
+<!-- /ddd-ts-kit:context-map -->
+
+## Reading guide
+
+TODO(domain): three lines on how the contexts collaborate for the main business flow.
+
+## Why these boundaries
+
+TODO(domain): for each boundary that was debated, the argument that settled it (language, autonomy, consistency), in two or three sentences.
+
+## Relationship notes
+
+TODO(domain): for every pattern other than published-language, why it was chosen and what it costs.
+
+## Known tensions
+
+TODO(domain): boundaries suspected to be wrong, with the signal that would trigger a split or a merge.

package/templates/docs/integration-readme.md.tpl

@@ -0,0 +1,27 @@
+# Integration
+
+`event-catalog.md` and `asyncapi.json` in this folder are generated by `npm run docs:generate`
+from the event declarations; `openapi/openapi.json` from the route definitions. This file is
+written by the team and answers what the generated files cannot.
+
+## Delivery guarantees
+
+TODO(domain): at-least-once, ordering (none across aggregates unless stated here), what a consumer must tolerate.
+
+## Provider
+
+{{integration.strategy}}
+
+TODO(domain): which event bus adapter runs in each environment, retry and dead-letter policy, how to replay.
+
+## Versioning policy
+
+TODO(domain): additive inside a version, a new version otherwise; how long an old version stays published and how its retirement is announced.
+
+## Flows
+
+TODO(domain): one short Mermaid sequenceDiagram per business flow that crosses contexts, naming the events in order and the eventual-consistency window users may notice.
+
+## External integrations
+
+TODO(domain): for each outside system, the port, the adapter, the anti-corruption layer, the failure behaviour (timeout, retry, fallback) and where its credentials are configured (never their value).

package/templates/domain-error/domain-error.spec.ts.tpl

@@ -0,0 +1,12 @@
+import { describe, expect, it } from '{{tests.module}}';
+import { DomainError } from '@ddd-ts-kit/kernel';
+import { {{name.pascal}}Error } from '{{alias.context}}/domain/errors/{{name.kebab}}.error.js';
+
+describe('{{name.pascal}}Error', () => {
+  it('carries its stable code', () => {
+    const error = new {{name.pascal}}Error();
+
+    expect(error).toBeInstanceOf(DomainError);
+    expect(error.code).toBe('{{error.code}}');
+  });
+});

package/templates/domain-error/domain-error.ts.tpl

@@ -0,0 +1,10 @@
+import { DomainError } from '@ddd-ts-kit/kernel';
+
+export class {{name.pascal}}Error extends DomainError {
+  readonly code = '{{error.code}}';
+
+  constructor() {
+    // TODO(domain): take as parameters the facts that explain the refusal (which {{context.words}} rule, which value) and write a message a domain expert would recognise; the code above is the stable contract.
+    super('{{name.title}}.');
+  }
+}

package/templates/domain-event/domain-event.spec.ts.tpl

@@ -0,0 +1,11 @@
+import { describe, expect, it } from '{{tests.module}}';
+import { {{event.pascal}} } from '{{alias.context}}/domain/events/{{event.kebab}}.event.js';
+
+describe('{{event.pascal}}', () => {
+  it('is named after the context, the aggregate and the fact', () => {
+    const event = new {{event.pascal}}('{{aggregate.kebab}}-1', new Date('2026-01-01T00:00:00.000Z'));
+
+    expect(event.name).toBe('{{event.name}}');
+    expect(event.aggregateId).toBe('{{aggregate.kebab}}-1');
+  });
+});

package/templates/domain-event/domain-event.ts.tpl

@@ -0,0 +1,11 @@
+import type { DomainEvent } from '@ddd-ts-kit/kernel';
+
+export class {{event.pascal}} implements DomainEvent {
+  readonly name = '{{event.name}}';
+
+  constructor(
+    readonly aggregateId: string,
+    readonly occurredAt: Date,
+    // TODO(domain): add as readonly parameters the facts a reaction needs to know about "{{event.words}}" (value objects or primitives, never the aggregate itself).
+  ) {}
+}