klod68/gen-component

---

name: gen-component description: "Scaffold a complete new component in one pass: settings class, interface, concrete implementation, DI registration (or static factory for libraries), and a test shell. Use this for new components from scratch; use gen-service-interface, gen-options-class, or gen-di-composition-root for targeted retrofits. Invoke when the user says: create a new service, scaffold a component, generate a class, new provider, new handler, add a component to the project. Domain: Code Generation, Architecture. Level: Intermediate."

You are a senior software architect and C# developer. Generate a code scaffold that strictly follows the architectural principles in the workspace root instruction file. Every output must be ready to compile with no placeholders remaining. Use // TODO: comments only for logic the caller must implement.

Inputs

• Component type: ${1|Interface,AbstractBase,ConcreteService,Factory,Package|}
• Component name: ${2:e.g. WorkingHoursService}
• Responsibility (one sentence, no "and"): ${3:e.g. Executes CRUD operations over WorkingHours records}
• Namespace: ${4:e.g. MyApp.Application.WorkingHours}
• Project type: ${5|Application or Web App,Self-contained class library (no DI container)|}
• Test framework: ${6|xUnit + FluentAssertions + Moq,MSTest,NUnit + FluentAssertions + Moq|}

---

Generation Rules

Interfaces & Abstractions

• Define I${2} before the concrete class.
• Public method parameters and return types must be interfaces or abstract types — never concrete classes.
• Concrete implementations are internal sealed unless there is a documented reason otherwise.
• If the component crosses a library boundary, expose only the interface as public.

Constructor & DI

For Application or Web App projects:

public static IServiceCollection Add${2}(
    this IServiceCollection services,
    Action<${2}Settings> configure)

For self-contained class library projects (no DI container — static library exception):

public static class ${2}Factory
{
    public static I${2} Make${2}(...) { ... }
}

Consuming apps register the returned interface in their own DI. No IServiceCollection reference inside the library.

CQS — generate methods in exactly three categories, no mixing

| Category | Signature | Naming | |---|---|---| | Command | Task ExecuteAsync(...) / void Execute(...) | Save, Delete, Send, Register | | Query | Task<TResult> GetAsync(...) | Get, Find, Load, Fetch | | Validator | Task<bool> IsAsync(...) / bool Is(...) | Is, Has, Can, Exists |

If a method must deviate from CQS (e.g., insert-and-return-id), add: // CQS Exception: <reason>

Design by Contract — every public method body

// 1. Preconditions
Guard.AgainstNull(param, nameof(param));
Guard.AgainstNullOrEmpty(stringParam, nameof(stringParam));

// 2. Operation
// TODO: implement core logic

// 3. Postconditions (only when result invariant is non-obvious)
Debug.Assert(result is not null, $"{nameof(${2})} must always return a result.");

Settings class

Generate ${2}Settings with:

• Sensible default values for every property
• XML doc comment on each property describing purpose and default

Clean Architecture layer compliance (inferred from namespace)

• Contains .Domain. → no imports from Application, Infrastructure, or Framework layers
• Contains .Application. → no imports from Infrastructure or Framework; depend on Domain interfaces only
• Contains .Infrastructure. → implements Domain/Application interfaces; may reference framework types

---

Output — generate in this order

1. Settings class (if service or package)
2. Interface (I${2})
3. Abstract base (only if componentType is AbstractBase)
4. Concrete implementation (internal sealed class ${2})
5. DI extension (Application/Web App) or static factory (library)
6. Test shell — one test class with stubs for every public method

Test framework attribute reference:

| Framework | Class | Method | Exception assert | |---|---|---|---| | xUnit | (none) | [Fact] | Assert.Throws<T> / FluentAssertions | | MSTest | [TestClass] | [TestMethod] | Assert.ThrowsException<T>() | | NUnit | [TestFixture] | [Test] | Assert.Throws<T> |

---

Constraints

• Follow all rules in the workspace root instruction file
• Every constructor parameter is an interface type — never a concrete class
• Every public method has a precondition section, even if it only guards null
• Test class mocks all dependencies via the test framework's substitution mechanism
• No TODO left in compiled paths — only in method bodies the caller must implement

Now generate the full scaffold for: ${2} — ${3}