@opengroundplan/core 0.1.1

package/templates/architectures/cqrs/files/docs/architecture/cqrs.python.md

@@ -0,0 +1,107 @@
+# CQRS — {{ solutionName | title }} (Python)
+
+> Use a different model to update information than the model you use to read it.
+> — Martin Fowler, [*CQRS*](https://martinfowler.com/bliki/CQRS.html)
+
+That sentence is the whole pattern. Everything below is a consequence of it.
+
+## The one rule
+
+> **The query side may not import the command side.**
+
+A query handler that loads an aggregate to build a DTO has re-merged the two models and
+deleted the only benefit this pattern offers. If a query needs data an aggregate holds, the
+answer is a new read model, not an import.
+
+## Layout
+
+CQRS is scoped to **one bounded context** — `{{ contextName | title }}` — not to the project.
+Fowler is explicit that it "should only be used on specific portions of a system (a
+BoundedContext) and not the system as a whole." Other packages stay plain CRUD until one of
+them earns the split.
+
+```
+src/{{ solutionName | snake }}/{{ contextName | snake }}/
+  domain/          aggregates and their invariants — the write model
+  commands/        one handler per task; loads an aggregate, calls it, saves it
+  queries/         one handler per screen; SQL straight into a read model
+  read_models/     frozen dataclasses with no behaviour, one shape per screen
+.importlinter
+```
+
+| Package | Holds | May import |
+|---|---|---|
+| `domain` | Aggregates — the write model | nothing from the other three |
+| `commands` | One handler per task | `domain` |
+| `queries` | One handler per screen | `read_models` |
+| `read_models` | Per-screen DTOs | nothing from the other three |
+
+Python has the thinnest CQRS ecosystem of the supported stacks, and that is fine: the pattern
+is small enough to hand-roll, and the four `Protocol` classes shipped here are all the
+machinery it needs. Reach for a framework only if you later split the stores.
+
+## Commands return nothing
+
+`CommandHandler.handle` is annotated `-> None`. A command that returns data has become a query.
+Generate ids on the caller so a command never needs a return value to hand one back.
+
+Name commands after the task the user performs — `BookHotelRoom`, not `SetReservationStatus`.
+A command named after a field is a CRUD update that learned new vocabulary.
+
+## You do not need a second database
+
+Azure documents "separate models in a single data store" as the **foundational** level of this
+pattern, and that is what this layout gives you: both sides talk to the same store, the write
+side through aggregates, the read side through SQL. There is no eventual consistency here and
+nothing to synchronize.
+
+Splitting the *stores* is a separate, much larger decision. It buys eventual consistency for
+your entire UX, and you must then design every screen for users acting on stale data. Do that
+only when you have measured the asymmetry that justifies it.
+
+You also do not need event sourcing. Fowler: *"Strictly CQRS isn't really about events."*
+
+## The boundary check
+
+Run `lint-imports`. `.importlinter` declares two `forbidden` contracts, and a violated contract
+exits non-zero:
+
+1. **`query-side-is-independent`** — `queries` and `read_models` may not import `domain` or
+   `commands`.
+2. **`command-side-ignores-projections`** — `domain` and `commands` may not import `queries` or
+   `read_models`. Projections are stale by construction; a decision made from one is a decision
+   made on stale data.
+
+import-linter follows transitive imports, so routing a forbidden import through a third module
+does not hide it.
+
+Wire `lint-imports` into CI next to the linter. A check that only runs locally is a check that
+does not run.
+
+## What is not enforced mechanically
+
+Real rules with no automated gate. These are review's job:
+
+- **Commands are task-shaped.** Nothing can tell `SetReservationStatus` from `BookHotelRoom`.
+- **Commands do not return data.** `-> None` is a hint; nothing fails a build over it unless
+  you also run mypy or pyright in strict mode. Doing so is recommended.
+- **The split stays inside one context.** Sprouting `commands`/`queries` packages everywhere is
+  the documented way this pattern fails, and nothing here prevents it.
+- **Read models are per-screen, not shared.** One `OrderDto` reused by six screens is a
+  canonical model growing back.
+
+## Running it
+
+`import-linter` is already in this project's dev dependency group, so it installs with
+everything else. Run the contracts and wire the same command into CI:
+
+```
+lint-imports
+```
+
+## Sources
+
+- Martin Fowler, [*CQRS*](https://martinfowler.com/bliki/CQRS.html) — the definition, the
+  BoundedContext scoping, and the productivity warning.
+- Microsoft Learn, [*CQRS pattern*](https://learn.microsoft.com/en-us/azure/architecture/patterns/cqrs)
+  — the single-store foundational level, and when not to use the pattern at all.

package/templates/architectures/cqrs/files/eslint.config.cqrs.mjs

@@ -0,0 +1,29 @@
+// Editor-time half of the boundary check. Spread it into eslint.config.mjs:
+//
+//   import cqrs from './eslint.config.cqrs.mjs';
+//   export default [...cqrs, /* the rest of your config */];
+//
+// `npm run check:cqrs` stays the authority: it needs no linter, resolves relative imports,
+// and runs in CI whether or not this file was ever wired up.
+const SOURCE = '/**/*.{js,mjs,cjs,ts,tsx}';
+
+const forbid = (patterns, message) => ({
+  'no-restricted-imports': ['error', { patterns: [{ group: patterns, message }] }],
+});
+
+export default [
+  {
+    files: [`**/queries${SOURCE}`, `**/read-models${SOURCE}`],
+    rules: forbid(
+      ['**/domain/**', '**/commands/**'],
+      'The query side may not import the command side. Read the store and return a DTO.',
+    ),
+  },
+  {
+    files: [`**/domain${SOURCE}`, `**/commands${SOURCE}`],
+    rules: forbid(
+      ['**/read-models/**', '**/queries/**'],
+      'The command side may not read a projection — projections are stale by construction.',
+    ),
+  },
+];

package/templates/architectures/cqrs/files/pyproject.toml

@@ -0,0 +1,2 @@
+[dependency-groups]
+dev = ["import-linter==2.13"]

package/templates/architectures/cqrs/files/scripts/check-cqrs-boundaries.mjs

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+// Fails when the query side imports the command side, or the command side reads a projection.
+// Zero dependencies on purpose: the bases disagree on linter (ESLint vs Biome), so this check
+// must work without editing whichever config the base already owns.
+import { readdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+
+/** The only place these names are written. Environment overrides them per repo. */
+const defaults = {
+  sourceDir: 'src',
+  domainSegment: 'domain',
+  commandsSegment: 'commands',
+  queriesSegment: 'queries',
+  readModelsSegment: 'read-models',
+  extensions: '.ts,.tsx,.mts,.cts,.js,.jsx,.mjs,.cjs',
+};
+
+const sourceDir = toPosix(process.env.CQRS_SOURCE_DIR || defaults.sourceDir);
+const extensions = new Set((process.env.CQRS_EXTENSIONS || defaults.extensions).split(','));
+
+const SIDES = {
+  domain: process.env.CQRS_DOMAIN_SEGMENT || defaults.domainSegment,
+  commands: process.env.CQRS_COMMANDS_SEGMENT || defaults.commandsSegment,
+  queries: process.env.CQRS_QUERIES_SEGMENT || defaults.queriesSegment,
+  readModels: process.env.CQRS_READ_MODELS_SEGMENT || defaults.readModelsSegment,
+};
+
+/** Segment name back to its role, so the classifier is one lookup rather than four comparisons. */
+const ROLE_OF_SEGMENT = new Map(Object.entries(SIDES).map(([role, segment]) => [segment, role]));
+
+// Each rule is the boundary stated as code. Prose versions get violated.
+const RULES = [
+  {
+    from: ['queries', 'readModels'],
+    to: ['domain', 'commands'],
+    message: 'the query side may not import the command side — read the store and return a DTO',
+  },
+  {
+    from: ['domain', 'commands'],
+    to: ['readModels'],
+    message: 'the command side may not read a projection — projections are stale by construction',
+  },
+];
+
+const SPECIFIER_PATTERNS = [
+  /\bfrom\s*['"]([^'"]+)['"]/g,
+  /\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+  /\brequire\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+  /\bimport\s+['"]([^'"]+)['"]/g,
+];
+
+function toPosix(value) {
+  return value.split(path.sep).join('/');
+}
+
+async function listFiles(dir) {
+  const found = [];
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return found;
+  }
+
+  for (const entry of entries) {
+    const child = `${dir}/${entry.name}`;
+    if (entry.isDirectory()) found.push(...(await listFiles(child)));
+    else if (extensions.has(path.extname(entry.name))) found.push(child);
+  }
+  return found;
+}
+
+function specifiersIn(source) {
+  const found = new Set();
+  for (const pattern of SPECIFIER_PATTERNS) {
+    for (const match of source.matchAll(pattern)) found.add(match[1]);
+  }
+  return found;
+}
+
+/** The role a path belongs to. Innermost wins, so `queries/handlers/domain-ish` is not misread. */
+function roleOfPath(posixPath) {
+  let role = null;
+  for (const segment of posixPath.split('/')) {
+    const found = ROLE_OF_SEGMENT.get(segment);
+    if (found) role = found;
+  }
+  return role;
+}
+
+/** Relative specifiers carry no role segment of their own, so resolve them first. */
+function roleOfSpecifier(specifier, fromFile) {
+  const normalized = toPosix(specifier);
+  if (normalized.startsWith('.')) {
+    return roleOfPath(path.posix.normalize(path.posix.join(path.posix.dirname(fromFile), normalized)));
+  }
+  // Bare and aliased specifiers are read as written; one with no role segment is external.
+  return roleOfPath(normalized);
+}
+
+async function findViolations() {
+  const violations = [];
+
+  for (const file of await listFiles(sourceDir)) {
+    const owner = roleOfPath(file);
+    if (owner === null) continue;
+
+    for (const specifier of specifiersIn(await readFile(file, 'utf8'))) {
+      const target = roleOfSpecifier(specifier, file);
+      if (target === null || target === owner) continue;
+
+      for (const rule of RULES) {
+        if (rule.from.includes(owner) && rule.to.includes(target)) {
+          violations.push(`${file}: ${SIDES[owner]} imports "${specifier}" (${SIDES[target]}) — ${rule.message}`);
+        }
+      }
+    }
+  }
+
+  return violations;
+}
+
+const violations = await findViolations();
+if (violations.length > 0) {
+  console.error(`CQRS boundary violations (${violations.length}):`);
+  for (const violation of violations) console.error(`  ${violation}`);
+  console.error('\nSee docs/architecture/cqrs.node.md.');
+  process.exit(1);
+}
+
+console.log(`CQRS boundaries hold: nothing under ${sourceDir} crosses the command/query split.`);

package/templates/architectures/cqrs/files/src/__contextName.kebab__/commands/index.ts

@@ -0,0 +1,15 @@
+// Command side for the {{ contextName | title }} context: intent in, nothing out.
+// A handler loads an aggregate from domain/, calls one method on it, and saves it.
+
+/** Name commands after the task the user performs, never after the row they edit. */
+export interface Command {
+  readonly type: string;
+}
+
+/**
+ * Returns void on purpose — a command that returns data has become a query.
+ * Generate ids on the caller so it never needs a return value to learn one.
+ */
+export interface CommandHandler<TCommand extends Command> {
+  handle(command: TCommand): Promise<void>;
+}

package/templates/architectures/cqrs/files/src/__contextName.kebab__/domain/index.ts

@@ -0,0 +1,10 @@
+// Write model for the {{ contextName | title }} context. Aggregates live here and nowhere else.
+// Nothing under queries/ or read-models/ may import this file — that boundary is the pattern.
+
+/** An aggregate is the consistency boundary a command is allowed to change. */
+export interface AggregateRoot<TId> {
+  readonly id: TId;
+}
+
+/** Raised by an aggregate when a command is not valid against current state. */
+export class DomainError extends Error {}

package/templates/architectures/cqrs/files/src/__contextName.kebab__/queries/index.ts

@@ -0,0 +1,13 @@
+// Query side for the {{ contextName | title }} context: straight to the store, no domain model.
+// A handler here runs SQL (or hits a read replica) and shapes a read-models/ DTO.
+
+/** Queries name the screen or report they feed, not the tables they touch. */
+export interface Query<TResult> {
+  readonly type: string;
+  /** Phantom marker: keeps TResult in the type so a handler cannot be paired with the wrong DTO. */
+  readonly __result?: TResult;
+}
+
+export interface QueryHandler<TQuery extends Query<TResult>, TResult> {
+  handle(query: TQuery): Promise<TResult>;
+}

package/templates/architectures/cqrs/files/src/__contextName.kebab__/read-models/index.ts

@@ -0,0 +1,7 @@
+// DTOs the query side returns. Shaped for one screen each — denormalize freely, that is the point.
+// These are not domain types: no behaviour, no invariants, no reuse from the command side.
+
+/** Read models are projections of a store, so every one carries how stale it may be. */
+export interface ReadModel {
+  readonly asOf: string;
+}

package/templates/architectures/cqrs/files/src/__solutionName.dot__.Abstractions/AssemblyMarker.cs

@@ -0,0 +1,9 @@
+using System.Reflection;
+
+namespace {{ solutionName | dot }}.Abstractions;
+
+// Anchors this assembly so the boundary tests never depend on a string name a rename would break.
+public static class AssemblyMarker
+{
+    public static Assembly Assembly => typeof(AssemblyMarker).Assembly;
+}

package/templates/architectures/cqrs/files/src/__solutionName.dot__.Abstractions/ICommandHandler.cs

@@ -0,0 +1,12 @@
+namespace {{ solutionName | dot }}.Abstractions;
+
+/// Marker for a task the user performs. Name it BookHotelRoom, not SetReservationStatus.
+public interface ICommand;
+
+// No TResult on purpose: a command that returns data has become a query. Generate ids on the
+// caller so a handler never needs a return value to hand one back.
+public interface ICommandHandler<in TCommand>
+    where TCommand : ICommand
+{
+    Task HandleAsync(TCommand command, CancellationToken cancellationToken = default);
+}

package/templates/architectures/cqrs/files/src/__solutionName.dot__.Abstractions/IQueryHandler.cs

@@ -0,0 +1,10 @@
+namespace {{ solutionName | dot }}.Abstractions;
+
+/// A query names the screen or report it feeds, not the tables it touches.
+public interface IQuery<TResult>;
+
+public interface IQueryHandler<in TQuery, TResult>
+    where TQuery : IQuery<TResult>
+{
+    Task<TResult> HandleAsync(TQuery query, CancellationToken cancellationToken = default);
+}

package/templates/architectures/cqrs/files/src/__solutionName.dot__.Abstractions/__solutionName.dot__.Abstractions.csproj

@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <RootNamespace>{{ solutionName | dot }}.Abstractions</RootNamespace>
+    <AssemblyName>{{ solutionName | dot }}.Abstractions</AssemblyName>
+  </PropertyGroup>
+
+  <!-- Contracts only. Both sides reference this, so anything added here is added to both —
+       which is why no aggregate and no DTO may ever live in this project. -->
+
+</Project>

package/templates/architectures/cqrs/files/src/__solutionName.dot__.__contextName.pascal__.Commands/AssemblyMarker.cs

@@ -0,0 +1,9 @@
+using System.Reflection;
+
+namespace {{ solutionName | dot }}.{{ contextName | pascal }}.Commands;
+
+// Anchors this assembly so the boundary tests never depend on a string name a rename would break.
+public static class AssemblyMarker
+{
+    public static Assembly Assembly => typeof(AssemblyMarker).Assembly;
+}

package/templates/architectures/cqrs/files/src/__solutionName.dot__.__contextName.pascal__.Commands/Handlers/.gitkeep

@@ -0,0 +1,2 @@
+# One ICommandHandler per command. Load an aggregate, call one method on it, save it.
+# Validation that needs the current state belongs on the aggregate, not here.

package/templates/architectures/cqrs/files/src/__solutionName.dot__.__contextName.pascal__.Commands/__solutionName.dot__.__contextName.pascal__.Commands.csproj

@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <RootNamespace>{{ solutionName | dot }}.{{ contextName | pascal }}.Commands</RootNamespace>
+    <AssemblyName>{{ solutionName | dot }}.{{ contextName | pascal }}.Commands</AssemblyName>
+  </PropertyGroup>
+
+  <!-- The Domain reference is asserted by the boundary tests: without it the "command path"
+       is just another CRUD path wearing the pattern's vocabulary. -->
+  <ItemGroup>
+    <ProjectReference Include="../{{ solutionName | dot }}.{{ contextName | pascal }}.Domain/{{ solutionName | dot }}.{{ contextName | pascal }}.Domain.csproj" />
+    <ProjectReference Include="../{{ solutionName | dot }}.Abstractions/{{ solutionName | dot }}.Abstractions.csproj" />
+  </ItemGroup>
+
+</Project>

package/templates/architectures/cqrs/files/src/__solutionName.dot__.__contextName.pascal__.Domain/Aggregates/.gitkeep

@@ -0,0 +1,2 @@
+# Aggregates: the consistency boundary a single command is allowed to change.
+# Only the Commands project may reference the types in this folder.

package/templates/architectures/cqrs/files/src/__solutionName.dot__.__contextName.pascal__.Domain/AssemblyMarker.cs

@@ -0,0 +1,9 @@
+using System.Reflection;
+
+namespace {{ solutionName | dot }}.{{ contextName | pascal }}.Domain;
+
+// Anchors this assembly so the boundary tests never depend on a string name a rename would break.
+public static class AssemblyMarker
+{
+    public static Assembly Assembly => typeof(AssemblyMarker).Assembly;
+}

package/templates/architectures/cqrs/files/src/__solutionName.dot__.__contextName.pascal__.Domain/__solutionName.dot__.__contextName.pascal__.Domain.csproj

@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <RootNamespace>{{ solutionName | dot }}.{{ contextName | pascal }}.Domain</RootNamespace>
+    <AssemblyName>{{ solutionName | dot }}.{{ contextName | pascal }}.Domain</AssemblyName>
+  </PropertyGroup>
+
+  <!-- Deliberately no ProjectReference: the write model depends on nothing, least of all on a
+       projection. tests/*.ArchitectureTests fails the build if that ever changes. -->
+
+</Project>

package/templates/architectures/cqrs/files/src/__solutionName.dot__.__contextName.pascal__.Queries/AssemblyMarker.cs

@@ -0,0 +1,9 @@
+using System.Reflection;
+
+namespace {{ solutionName | dot }}.{{ contextName | pascal }}.Queries;
+
+// Anchors this assembly so the boundary tests never depend on a string name a rename would break.
+public static class AssemblyMarker
+{
+    public static Assembly Assembly => typeof(AssemblyMarker).Assembly;
+}

package/templates/architectures/cqrs/files/src/__solutionName.dot__.__contextName.pascal__.Queries/Handlers/.gitkeep

@@ -0,0 +1,2 @@
+# One IQueryHandler per screen or report. Run the SQL, project straight into a ReadModels type.
+# No aggregate, no repository, no domain service — the compiler cannot even see them from here.

package/templates/architectures/cqrs/files/src/__solutionName.dot__.__contextName.pascal__.Queries/ReadModels/.gitkeep

@@ -0,0 +1,2 @@
+# DTOs shaped for one screen each. Denormalize freely — that is the point of a read model.
+# Records with no behaviour. If one grows a method with a rule in it, it belongs in Domain.

package/templates/architectures/cqrs/files/src/__solutionName.dot__.__contextName.pascal__.Queries/__solutionName.dot__.__contextName.pascal__.Queries.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <RootNamespace>{{ solutionName | dot }}.{{ contextName | pascal }}.Queries</RootNamespace>
+    <AssemblyName>{{ solutionName | dot }}.{{ contextName | pascal }}.Queries</AssemblyName>
+  </PropertyGroup>
+
+  <!-- Abstractions only. Add your data-access package (Dapper, Npgsql, EF with NoTracking) here;
+       a ProjectReference to *.Domain or *.Commands fails tests/*.ArchitectureTests. -->
+  <ItemGroup>
+    <ProjectReference Include="../{{ solutionName | dot }}.Abstractions/{{ solutionName | dot }}.Abstractions.csproj" />
+  </ItemGroup>
+
+</Project>

package/templates/architectures/cqrs/files/src/__solutionName.snake__/__contextName.snake__/__init__.py

@@ -0,0 +1,6 @@
+"""The {{ contextName | title }} bounded context.
+
+CQRS is scoped to this package, not to the whole project. `commands` and `domain` are the
+write side; `queries` and `read_models` are the read side, and the read side never imports
+the write side. `.importlinter` fails the build when it does.
+"""

package/templates/architectures/cqrs/files/src/__solutionName.snake__/__contextName.snake__/commands/__init__.py

@@ -0,0 +1,15 @@
+"""Command side: intent in, nothing out.
+
+A handler loads an aggregate from `domain`, calls one method on it, and saves it. Name
+commands after the task the user performs, never after the row they edit.
+"""
+
+from typing import Protocol, TypeVar
+
+TCommand = TypeVar("TCommand", contravariant=True)
+
+
+class CommandHandler(Protocol[TCommand]):
+    """Returns None on purpose — a command that returns data has become a query."""
+
+    async def handle(self, command: TCommand) -> None: ...

package/templates/architectures/cqrs/files/src/__solutionName.snake__/__contextName.snake__/domain/__init__.py

@@ -0,0 +1,9 @@
+"""Write model: aggregates and the invariants they enforce.
+
+Only `commands` may import this package. A query that needs one of these types needs a
+read model instead.
+"""
+
+
+class DomainError(Exception):
+    """Raised by an aggregate when a command is not valid against current state."""

package/templates/architectures/cqrs/files/src/__solutionName.snake__/__contextName.snake__/queries/__init__.py

@@ -0,0 +1,14 @@
+"""Query side: straight to the store, no domain model.
+
+A handler here runs SQL (or hits a read replica) and shapes a `read_models` dataclass.
+Importing `domain` or `commands` from this package fails `lint-imports`.
+"""
+
+from typing import Protocol, TypeVar
+
+TQuery = TypeVar("TQuery", contravariant=True)
+TResult = TypeVar("TResult", covariant=True)
+
+
+class QueryHandler(Protocol[TQuery, TResult]):
+    async def handle(self, query: TQuery) -> TResult: ...

package/templates/architectures/cqrs/files/src/__solutionName.snake__/__contextName.snake__/read_models/__init__.py

@@ -0,0 +1,14 @@
+"""DTOs the query side returns. Shaped for one screen each — denormalize freely.
+
+These are not domain types: no behaviour, no invariants, no reuse from the command side.
+"""
+
+from dataclasses import dataclass
+from datetime import datetime
+
+
+@dataclass(frozen=True)
+class ReadModel:
+    """Projections are stale by construction, so every one carries how stale it may be."""
+
+    as_of: datetime

package/templates/architectures/cqrs/files/tests/ArchitectureTests/ArchitectureTests.csproj

@@ -0,0 +1,33 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <!-- xUnit v3 test projects are executables. TargetFramework comes from Directory.Build.props. -->
+    <OutputType>Exe</OutputType>
+    <!-- Folder and file are fixed so `dotnet sln add tests/ArchitectureTests` resolves without
+         globbing, which the .NET CLI does not do. The assembly still carries the solution name. -->
+    <AssemblyName>{{ solutionName | dot }}.ArchitectureTests</AssemblyName>
+    <RootNamespace>{{ solutionName | dot }}.ArchitectureTests</RootNamespace>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+    <!-- CA1707 polices public API naming; underscored test names are the convention here. -->
+    <NoWarn>$(NoWarn);CA1707</NoWarn>
+  </PropertyGroup>
+
+  <!-- Versions come from Directory.Packages.props; both .NET bases turn central package
+       management on, so no version belongs here. -->
+  <ItemGroup>
+    <PackageReference Include="xunit.v3" />
+    <PackageReference Include="xunit.runner.visualstudio" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" />
+  </ItemGroup>
+
+  <!-- References all three on purpose: a test cannot assert on an assembly it cannot load, and
+       `dotnet sln add` follows these to pull every project into the solution with it.
+       This project is the one place where seeing both sides is allowed. -->
+  <ItemGroup>
+    <ProjectReference Include="../../src/{{ solutionName | dot }}.Ordering.Domain/{{ solutionName | dot }}.Ordering.Domain.csproj" />
+    <ProjectReference Include="../../src/{{ solutionName | dot }}.Ordering.Commands/{{ solutionName | dot }}.Ordering.Commands.csproj" />
+    <ProjectReference Include="../../src/{{ solutionName | dot }}.Ordering.Queries/{{ solutionName | dot }}.Ordering.Queries.csproj" />
+  </ItemGroup>
+
+</Project>