Add yaks 01 (before: fake EF DbBase inheritance) and 02 (after: DTOs + mappers) for the next agent

yak/yak-02-after.md

@@ -0,0 +1,62 @@
+# Yak 02 — C# solution: the AFTER situation (plain domain + DTOs + mappers)
+
+## Context
+
+Depends on Yak 01 (solution, `Before/` project, test project already exist).
+Implement the "after" half of the exercise in the existing `After/` project
+and add tests. See `after-dto.mmd` for the diagram:
+
+- `Client`, `Order` — **plain** domain objects, no `DbBase` inheritance,
+  no knowledge of `DbContext`
+- `ClientDto`, `OrderDto` — DTOs carrying the same data **including the
+  relations** (`ClientDto.Orders`, back-references)
+- `Mappers` — hand-written mapping, each way:
+  `ToClientDto`, `FromClientDto`, `ToOrderDto`, `FromOrderDto`
+- `DbContext`/`DbBase` — still exist (persistence layer), but the domain no
+  longer subclasses/leaks them
+- `WebApp` — consumes **only DTOs**
+
+## Rules
+
+- Do NOT modify `Before/` (it's the frozen "before" state).
+- Hand-write the mappers (no AutoMapper) — the mapping code is part of the
+  illustration. Mappers must not mutate their inputs.
+- Keep the fake `DbContext`/`DbBase` for persistence in `After/` (or reuse the
+  idea from `Before/`), but the domain types must not derive from `DbBase`.
+  Persisting a domain object now requires explicit registration (e.g. a
+  `DbContext.Save(client)` that copies into a tracked entity, or registers an
+  adapter) — the direction of dependency is flipped.
+
+## Required tests (AfterTests)
+
+At minimum, mirroring the Before tests where meaningful:
+
+1. `Client`/`Order` do **not** derive from `DbBase`, and (via reflection)
+   expose no `DbContext`-typed property or field — the leak is gone.
+2. Mappers map all scalar fields, in both directions
+   (`Client → ClientDto`, `ClientDto → Client`, same for `Order`).
+3. Mappers map the relations: `Client.Orders` → `ClientDto.Orders`, and the
+   `Order.Client` / `OrderDto.ClientDto` back-references stay consistent.
+4. Round-trip: `FromX(ToX(domain))` equals the original domain state
+   (compare by values, not reference); same for DTO round-trip.
+5. Mappers do not mutate their input (snapshot fields, map, compare).
+6. `WebApp` (after version) methods consume only `ClientDto`/`OrderDto`;
+   assert the `After.WebApp` type references no domain or DbContext type in
+   its public API (reflection over member signatures).
+7. Persistence still works through the fake `DbContext` in the after world.
+
+## Acceptance criteria
+
+- `dotnet build` and `dotnet test` succeed on the full solution
+  (Before + After + tests), 0 warnings.
+- No NuGet packages beyond xUnit's default set.
+- `Before/` project unmodified (diff check).
+- Committed with a message referencing this yak.
+
+## Open questions (answer before starting, defaults in parens)
+
+1. How should the after-world persistence flip look — explicit
+   `ctx.Save(domainObject)` with internal entity/DTO translation, or something
+   else? (explicit Save with translation, minimal)
+2. Are DTOs records (value equality helps round-trip tests) or plain classes?
+   (records)