klod68/gen-di-composition-root

---

name: gen-di-composition-root description: "Use when wiring a new application module into the DI container. Generates an IServiceCollection extension method composition root with options validation, safe-copy overload, and convenience helpers. Do NOT use for static black-box libraries — use gen-factory-class instead. Also invoke when the user mentions: DI registration, AddMyModule, composition root, service registration extension. Domain: Code Generation, Dependency Injection. Level: Intermediate."

Generate a DI composition root for the module: ${1:ModuleName}.

Static library check: if this project is a NuGet-distributed class library with no internal DI container, stop here and use /gen-factory-class instead. This prompt applies to: Application, Web App, API, and Module projects only.

Context

• Namespace root: ${2:MyApp}
• Internal services to register (name → interface → lifetime): ${3:e.g. EmailSender → IEmailSender → Scoped, EmailQueue → IEmailQueue → Singleton}
• Options properties (name, type, default, required): ${4:e.g. ConnectionString string required, TimeoutSeconds int 30, EnableRetry bool true}

---

Required output — generate ALL of the following:

1. Options interface + class

${2}.${1}.Configuration.I${1}Options.cs
${2}.${1}.Configuration.${1}Options.cs

• Interface with get; set; properties only
• sealed implementation with sensible defaults
• EnsureValid() method that throws InvalidOperationException with actionable messages for every required property and every out-of-range value
• Matching appsettings.json snippet showing all keys and defaults

2. Extension class

${2}.${1}.Configuration.${1}ServiceCollectionExtensions.cs

public static class ${1}ServiceCollectionExtensions
{
    // Overload 1: Action<TOptions> — most common consumer pattern
    public static IServiceCollection Add${1}(
        this IServiceCollection services,
        Action<${1}Options> configure)

    // Overload 2: pre-built options instance
    public static IServiceCollection Add${1}(
        this IServiceCollection services,
        I${1}Options options)

    // Private core — shared logic
    private static IServiceCollection Add${1}Core(
        IServiceCollection services,
        ${1}Options options)
}

Inside Add${1}Core:

• services.TryAddSingleton<I${1}Options>(options) — register options instance
• services.TryAdd* for each internal service (never overwrite consumer registrations)
• All concrete classes registered as their interface — never as their concrete type

3. Safe-copy pattern (overload 2)

When accepting I${1}Options, copy all properties into a new ${1}Options instance before registering. This prevents mutation after registration and avoids trusting untrusted interface implementations.

---

Rules

• Single public extension method per module — never scatter registrations
• ArgumentNullException.ThrowIfNull on both services and configure / options
• EnsureValid() called eagerly — fail at startup, not at first use
• TryAdd* throughout — never plain Add* (respect consumer registrations)
• Private Core method avoids logic duplication between overloads
• All concrete service implementations are internal sealed
• Options class is public sealed (it crosses the module boundary)

---

Constraints

• Follow all rules in the workspace root instruction file
• No new ConcreteType() for services — DI resolves them
• No direct IServiceProvider access inside the extension method
• Extension method file contains only extension methods — no other logic