Lazy.Crud.Builder.Platform 1.1.1

Lazy CRUD Builder

Lazy CRUD is a domain-to-architecture compiler for .NET. You write the domain model: plain entity classes decorated with attributes. The platform compiles that model into a complete, layered aggregate: domain command and event handlers, application services, DTOs and validators, EF Core mappings and repositories, dependency injection, query models, controllers, migrations and a test project per layer. The generated code targets net10.0 and runs on the Lazy.Crud.Builder.* and Lazy.Crud.CrossCutting.* runtime packages, version 1.1.1.

Generated code is treated as an artifact with a contract. Every generated file starts with a marker header that states who owns it, every aggregate keeps a manifest with the hash of every file the generator wrote, and the generator refuses to overwrite a file that was edited outside of it unless you explicitly resolve the conflict. See Generated code policy.

Prerequisites

Read this before you generate anything. Generation requires the following in every mode, including the unattended command-line runner and CI:

• Windows.
• An installed Visual Studio 2022 (17.x) or Visual Studio 2026 (18.x) on any channel (release, preview or Insiders) with the Text Template Transformation component, id Microsoft.VisualStudio.Component.TextTemplating. The templates resolve your entity model through the Visual Studio code model (DTE), so every transformation runs the T4 tooling of the resolved installation inside an embedded, unattended Visual Studio automation session.
• The .NET SDK 10.0.

"Headless" means unattended: no prompt, no window a person has to focus, no clicks. It does not mean Visual Studio is absent. A plain dotnet build never substitutes for transformation. When the toolchain cannot be resolved, the runner fails before transforming anything with diagnostic LC4001 and exit code 3 (PrerequisiteUnavailable). Discovery rules, the selection rule and the override variable are in Toolchain.

Check a machine before starting (the runner ships inside Lazy.Crud.Builder.Templates under tools/net10.0/):

dotnet "$env:USERPROFILE\.nuget\packages\lazy.crud.builder.templates\1.1.1\tools\net10.0\Lazy.Crud.Builder.Platform.Tool.dll" toolchain

Quickstart

The Quickstart takes an empty solution to a generated, compiling aggregate using only the published packages. In short:

1. Create the layer projects of an aggregate and reference the layer packages with GeneratePathProperty="true".
2. Write an entity class with attributes under Aggregates/<Aggregate>Agg/Entities/ in the Domain project.
3. Add src/Mods/lazy.settings and the wrapper templates (DefaultEntities.tt, DefaultCommands.tt).
4. Run the generation runner, then build and test:

dotnet "$env:USERPROFILE\.nuget\packages\lazy.crud.builder.templates\1.1.1\tools\net10.0\Lazy.Crud.Builder.Platform.Tool.dll" generate --solution . --aggregate Products --report artifacts\generate.json
dotnet build
dotnet test

After a restore the runner path is also available to MSBuild as $(LazyCrudToolDll), and dotnet build -p:LazyCrudTransformOnBuild=true invokes it for you. The E2E harness executes this exact path as scenario P7.

What gets generated

One aggregate produces eight layer projects, transformed Domain first, plus one generated test project per layer:

Architecture explains the model, compiler, runtime and artifact roles, what every layer emits, the pipeline order and its invariants.

Packages

All packages share one version, 1.1.1, defined once as LazyCrudVersion in Directory.Build.props, and target net10.0. Every package embeds the platform descriptor at lazycrud/lazycrud.platform.json.

Documentation

Start here:

• Quickstart: empty project to generated, compiling aggregate.
• Architecture: model, compiler, runtime, artifact; layers; pipeline invariants.
• Aggregates, entities and attributes: the declarative model reference.
• Generated code policy: ownership, markers, what is safe to edit.
• Safe customization: change generated behavior without losing it on regeneration.
• Migrations: moving between platform versions, including 1.0.x to 1.1.1.
• Testing: generated test projects, unit tests, the golden test and the harness.
• Compatibility matrix: versions, consumers, mixed pins and host prerequisites.
• Troubleshooting: diagnostics by code and how to read .lazycrud/diagnostics.
• Release guidance and the Changelog.
• Using Lazy CRUD with AI coding agents.

Platform and operations:

• Toolchain: the Visual Studio prerequisite, discovery, selection and the unattended session.
• E2E harness: running the battery and reading its artifacts.
• Clean room: validating the public distribution as an external user receives it.

Frozen contract reference (the fixtures win when prose and fixture disagree):

• Platform descriptor
• Manifest v2
• Marker v2
• Ownership
• Content hash
• Diagnostics

Documents that predate the 1.1.1 relaunch are kept under docs/legacy for history only.

Contracts and fixtures

The shared contracts consumed by the Visual Studio extension, the CLI and AI agents are frozen under contractVersion 1 and published as implementation-generated fixtures:

• In the repository: contracts/fixtures/v1/ (descriptor, manifest-v2.json, manifest-v1-input.json and manifest-v1-migrated.json, markers/*.txt, hash-vectors.json, fixture-index.json) and the JSON Schemas under contracts/schemas/v1/.
• Inside the Lazy.Crud.Builder.Templates package under contracts/.
• From GitHub as raw files, for example https://raw.githubusercontent.com/felipepassion/lazy-crud-builder/main/contracts/fixtures/v1/fixture-index.json, and as the CI artifact lazycrud-contract-fixtures.

Repository layout

License

See LICENSE.