Configuration

The Client Builder is designed to be easy to plug into your ASP.NET Core application using dependency injection (IServiceCollection). Its main configuration is handled through the ClientBuilderOptions class — where you:

• Register assemblies to scan.
• Define clients (where generated code goes).
• Add scanning rules.
• Register scaffold modules.

Registration

You configure the Client Builder in your Program.cs or Startup.cs:

builder.Services.AddClientBuilder(options =>
{
    // Add the assemblies you want to scan
    options.AddAssembly("MyApp.Domain");
    options.AddAssembly(typeof(MyApiController).Assembly);

    // Add your clients (output folders for generated code)
    options.AddClient(
        clientId: "web-client",
        clientName: "MyWebClient",
        amountDirectoriesBack: 2,
        "Clients", "WebClient", "src");

    // Add any custom scanning rules
    options.AddScanningRules(new MyCustomScanningRules());

    // Register scaffold modules (optional, if needed)
    options.AddModule<MyCustomModule>();
});

How it works

Step	What it does
AddAssembly	Registers one or more assemblies to be scanned for types, controllers, and DTOs.
AddClient	Defines an output client (like a web app or mobile app) — this sets where generated code should be placed.
AddScanningRules	Adds custom rules for which types/controllers should be included.
AddModule	Registers a code generation module — like a REST API generator, TypeScript generator, etc.

Example: Registering a Client

options.AddClient(
    clientId: "mobile-app",
    clientName: "MyMobileApp",
    amountDirectoriesBack: 3,
    "Clients", "MobileApp", "src");

• clientId — A unique ID for this client (used to link modules).
• clientName — A friendly name (used in logs and generated output).
• amountDirectoriesBack — How many folders back from the current working dir to reach your solution root.
• paths — The relative path from solution root to the client folder.

The result: The Client Builder will generate files into ../../../Clients/MobileApp/src.

Example: Adding a Custom Module

options.AddModule<MyCustomScaffoldModule>(moduleOptions =>
{
    moduleOptions.ClientId = "web-client";
    moduleOptions.Order = 1;
    moduleOptions.Name = "My REST Client Module";
});

How the Options Work

Assemblies

All Types, Controllers, and DTOs are discovered by scanning the assemblies you add:

options.AddAssembly("MyProject.Api");
options.AddAssembly(typeof(MyModel).Assembly);

Scanning Rules

Use IScanningRules to control which classes, enums, or controllers are included:

options.AddScanningRules(new DefaultControllersScanningRules());
options.AddScanningRules(new DefaultElementsScanningRules());

Modules

Modules are building blocks for code generation. A module can:

• Generate a REST client.
• Generate a GraphQL client.
• Produce TypeScript/JavaScript files.
• Any custom output logic.

You can register multiple modules for a single client:

options.AddModule<MyRestClientModule>();
options.AddModule<MyGraphQLClientModule>();

Each module uses the ScaffoldModuleOptions to:

• Define which client it targets.
• Set its execution order.
• Control its name and ID.

Putting It All Together

Full example for your Program.cs:

builder.Services.AddClientBuilder(options =>
{
    // Scan your domain and API projects
    options.AddAssembly("MyApp.Domain");
    options.AddAssembly("MyApp.Api");

    // Add clients
    options.AddClient("web-client", "WebAppClient", 2, "Clients", "Web", "src");
    options.AddClient("mobile-client", "MobileAppClient", 3, "Clients", "Mobile", "src");

    // Add scanning rules
    options.AddScanningRules(new DefaultControllersScanningRules());
    options.AddScanningRules(new DefaultElementsScanningRules());

    // Register modules
    options.AddModule<MyCustomModule>(moduleOptions =>
    {
        moduleOptions.ClientId = "web-client";
        moduleOptions.Order = 1;
    });

    options.AddModule<AnotherCustomModule>(moduleOptions =>
    {
        moduleOptions.ClientId = "mobile-client";
        moduleOptions.Order = 2;
    });
});

---

TIPS

• Always add at least one client — modules must be linked to a client.
• Use amountDirectoriesBack to adjust the path relative to your solution root.
• Add multiple assemblies if your app has separate projects for API, models, or contracts.
• Use [IncludeElementAttribute] to explicitly mark types for inclusion if you want fine-grained control.