@team-supercharge/oasg 18.0.2 → 18.2.0

package/targets/dotnet-webapi/templates/Project.csproj.mustache

@@ -0,0 +1,61 @@
+<Project Sdk="{{projectSdk}}">
+    <PropertyGroup>
+        <Description>{{packageDescription}}{{^packageDescription}}{{packageName}}{{/packageDescription}}</Description>
+        <Copyright>{{packageCopyright}}</Copyright>
+        <Authors>{{packageAuthors}}</Authors>
+        <TargetFramework>net10.0</TargetFramework>
+        <GenerateDocumentationFile>true</GenerateDocumentationFile>
+        <PreserveCompilationContext>true</PreserveCompilationContext>
+        <Version>{{packageVersion}}</Version>
+        {{#nullableReferenceTypes}}
+        <Nullable>annotations</Nullable>
+        {{/nullableReferenceTypes}}
+        {{#isLibrary}}
+        <OutputType>Library</OutputType>
+        {{/isLibrary}}
+        <AssemblyName>{{packageName}}</AssemblyName>
+        <PackageId>{{packageName}}</PackageId>
+        <UserSecretsId>{{userSecretsGuid}}</UserSecretsId>
+        <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
+        <DockerfileContext>..\..</DockerfileContext>
+        {{#centralizedPackageVersionManagement}}
+        <ManagePackageVersionsCentrally>{{.}}</ManagePackageVersionsCentrally>
+        {{/centralizedPackageVersionManagement}}
+    </PropertyGroup>
+    <ItemGroup>
+        {{#useSeparateModelProject}}
+        <ProjectReference Include="../{{modelPackage}}/{{modelPackage}}.csproj"/>
+        {{/useSeparateModelProject}}
+        {{#useFrameworkReference}}
+        {{#isLibrary}}
+        <FrameworkReference Include="Microsoft.AspNetCore.App" />
+        {{/isLibrary}}
+        {{/useFrameworkReference}}
+        {{^useFrameworkReference}}
+        <PackageReference Include="Microsoft.AspNetCore.App" />
+        {{/useFrameworkReference}}
+        {{^useSeparateModelProject}}
+        <PackageReference Include="Microsoft.Extensions.Configuration.Json" {{#usePackageVersions}}Version="{{aspnetCoreVersion}}.0" {{/usePackageVersions}}/>
+        {{/useSeparateModelProject}}
+        {{#useSwashbuckle}}
+        <PackageReference Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" {{#usePackageVersions}}Version="1.10.8" {{/usePackageVersions}}/>
+        {{#useNewtonsoft}}
+        <PackageReference Include="Swashbuckle.AspNetCore.Newtonsoft" {{#usePackageVersions}}Version="{{swashbuckleVersion}}" {{/usePackageVersions}}/>
+        <PackageReference Include="Swashbuckle.AspNetCore.SwaggerUI" {{#usePackageVersions}}Version="{{swashbuckleVersion}}" {{/usePackageVersions}}/>
+        {{/useNewtonsoft}}
+        {{^useNewtonsoft}}
+        <PackageReference Include="Swashbuckle.AspNetCore" {{#usePackageVersions}}Version="{{swashbuckleVersion}}" {{/usePackageVersions}}/>
+        {{/useNewtonsoft}}
+        <PackageReference Include="Swashbuckle.AspNetCore.Annotations" {{#usePackageVersions}}Version="{{swashbuckleVersion}}" {{/usePackageVersions}}/>
+        {{/useSwashbuckle}}
+        {{^useSwashbuckle}}
+        {{#useNewtonsoft}}
+        <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" {{#usePackageVersions}}Version="{{newtonsoftVersion}}" {{/usePackageVersions}}/>
+        {{/useNewtonsoft}}
+        {{/useSwashbuckle}}
+        <PackageReference Include="JsonSubTypes" {{#usePackageVersions}}Version="1.8.0" {{/usePackageVersions}}/>
+    </ItemGroup>
+    <ItemGroup>
+        <!--<DotNetCliToolReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="{{aspnetCoreVersion}}.0" />-->
+    </ItemGroup>
+</Project>

package/targets/dotnet-webapi-system-text-json/README.md

@@ -0,0 +1,241 @@
+# `dotnet-webapi-system-text-json` — Wolverine implementation
+
+This target generates an ASP.NET Core server-stub **library** exposing every
+operation as a **minimal-API endpoint** (Native-AOT compatible) with
+System.Text.Json source-generated models. By default each endpoint delegates to a
+generated `I{ApiName}` interface you implement. When the
+`withWolverineImplementation` flag is set, the endpoints instead invoke
+[Wolverine](https://wolverinefx.net) **directly** via `IMessageBus.InvokeAsync` —
+there are no `I{ApiName}` interfaces in that mode.
+
+> The examples below assume the package was generated with
+> `packageName = "MyApi"`. Generated request wrappers and the
+> `EndpointRouteBuilderExtensions` live in the `MyApi` namespace; models live in
+> `MyApi.Models`.
+
+## What gets generated (Wolverine mode)
+
+Everything lives in a single `EndpointRouteBuilderExtensions.cs`:
+
+- A **request wrapper** record per operation, bundling every parameter:
+  `AddPetRequest(Pet pet)`, `GetPetByIdRequest(long petId)`,
+  `UploadFileRequest(long petId, string? additionalMetadata, Stream? body)`, …
+  A distinct type per operation, so request/response pairs never collide.
+- **`Map{ApiName}Endpoints(this IEndpointRouteBuilder)`** (one per API, e.g.
+  `MapPetApiEndpoints`) — maps that API's operations as minimal-API endpoints
+  that invoke the request through Wolverine and return the result
+  (`Results.Ok(result)`, or `Results.NoContent()` when there is no response body).
+  Secured operations get `.RequireAuthorization()`.
+- **`MapAll{PackageName}Endpoints(this IEndpointRouteBuilder)`** (e.g.
+  `MapAllMyApiEndpoints`) — calls every `Map{ApiName}Endpoints()`.
+- **`ConfigureWolverineMessaging(this WolverineOptions, string localQueueName = "MyApi")`** —
+  routes every request type in the assembly to a local queue.
+
+A separate `ServiceCollectionExtensions.cs` holds a source-generated
+`{PackageName}JsonSerializerContext` (covering every model, request/response type
+and inline enum) and an **`Add{PackageName}JsonOptions(this IServiceCollection)`**
+extension that registers it on the minimal-API JSON resolver chain — call it in
+Program.cs (required when publishing the host with Native AOT; harmless otherwise).
+
+The `WolverineFx` package reference is added automatically.
+
+---
+
+## Setup
+
+### 1. Enable the option
+
+```json
+{
+  "id": "my-api",
+  "type": "dotnet-webapi-system-text-json",
+  "source": "source-merged",
+  "sourceUrl": "https://api.nuget.org/v3/index.json",
+  "apiKey": "apiKey",
+  "packageName": "MyApi",
+  "withWolverineImplementation": true
+}
+```
+
+### 2. API host setup
+
+Reference the generated package, then wire it up in `Program.cs`:
+
+```csharp
+using Wolverine;
+using MyApi; // generated Map{ApiName}Endpoints / MapAllMyApiEndpoints / ConfigureWolverineMessaging
+
+var builder = WebApplication.CreateBuilder(args);
+builder.Services.AddHttpContextAccessor(); // see "Authentication" below
+builder.Services.AddMyApiJsonOptions();    // register the source-gen JSON context (required for Native AOT)
+
+builder.Host.UseWolverine(opts =>
+{
+    // Route the request types to a local queue.
+    opts.ConfigureWolverineMessaging();
+
+    // Static codegen (see below). Pre-generate with `dotnet run -- codegen write`.
+    opts.CodeGeneration.TypeLoadMode = JasperFx.CodeGeneration.TypeLoadMode.Static;
+
+    // Optional: force every InvokeAsync to run locally (in-process). With this
+    // on, an invocation that would otherwise be sent to a remote transport
+    // throws instead. Turn it on if this service must never make remote calls.
+    // opts.EnableRemoteInvocation = false;
+});
+
+var app = builder.Build();
+
+app.UseAuthentication();
+app.UseAuthorization();
+
+app.MapAllMyApiEndpoints();    // aggregate; or call Map{ApiName}Endpoints() individually
+
+app.Run();
+```
+
+### 3. Static codegen
+
+Setting `opts.CodeGeneration.TypeLoadMode = TypeLoadMode.Static` (above) stops
+Wolverine from compiling handler code at runtime. Pre-generate it as part of your
+build/deploy:
+
+```bash
+dotnet run -- codegen write
+```
+
+(Alternatively, drop that line and reference `WolverineFx.RuntimeCompilation` to
+opt back into runtime Roslyn compilation.)
+
+---
+
+## Usage
+
+### Request handling
+
+Provide a handler for each generated `*Request` type. Wolverine discovers
+handlers by convention (a `Handle`/`HandleAsync` method); the return type must
+match the operation's response model (or `Task`/nothing for no-content
+operations).
+
+```csharp
+using MyApi;        // *Request types
+using MyApi.Models; // Pet, ...
+
+public class PetHandlers
+{
+    // Operation with a response body -> return the response model
+    public Task<Pet> Handle(AddPetRequest request)
+        => Task.FromResult(request.pet);
+
+    public async Task<Pet> Handle(GetPetByIdRequest request)
+        => await _repository.GetAsync(request.petId)
+           ?? throw new PetNotFoundException(request.petId);
+
+    // No-response-body operation -> return Task (the endpoint returns NoContent)
+    public Task Handle(DeletePetRequest request)
+        => _repository.DeleteAsync(request.petId);
+}
+```
+
+### Authentication
+
+Secured operations get `.RequireAuthorization()` on the generated endpoint, so
+authorization is enforced by ASP.NET Core **before** the handler runs. Register
+the matching authentication scheme and authorization policy in the host — e.g.
+for the `api_key` policy emitted for an API-key-secured operation:
+
+```csharp
+builder.Services
+    .AddAuthentication("ApiKey")
+    .AddScheme<AuthenticationSchemeOptions, ApiKeyAuthHandler>("ApiKey", _ => { });
+
+builder.Services.AddAuthorization(options =>
+    options.AddPolicy("api_key", policy => policy.RequireAuthenticatedUser()));
+```
+
+Because `InvokeAsync` runs the handler **in-process** within the request, the
+authenticated user flows through `HttpContext`. Read it in a handler via
+`IHttpContextAccessor` (registered with `AddHttpContextAccessor()` above):
+
+```csharp
+public class GetPetByIdHandler(IHttpContextAccessor http)
+{
+    public async Task<Pet> Handle(GetPetByIdRequest request)
+    {
+        var user = http.HttpContext!.User;            // authenticated principal
+        var tenant = user.FindFirst("tenant")?.Value;
+        return await _repository.GetAsync(request.petId, tenant);
+    }
+}
+```
+
+### Error handling
+
+Wolverine scopes retry rules **per handler** (not on the routing options), so
+`ConfigureWolverineMessaging` sets no retry policy. Opt into fail-fast where you
+want it, on the handler:
+
+```csharp
+using Wolverine;
+using Wolverine.ErrorHandling;
+
+public class GetPetByIdHandler
+{
+    // No retries: a failure surfaces immediately.
+    public static void Configure(HandlerChain chain) => chain.OnAnyException().Discard();
+
+    public Task<Pet> Handle(GetPetByIdRequest request) => /* ... */;
+}
+```
+
+With no retries, a handler exception propagates straight back through
+`InvokeAsync` into the endpoint. Map domain exceptions to HTTP responses
+host-side with an `IExceptionHandler` + ProblemDetails:
+
+```csharp
+public sealed class DomainExceptionHandler(IProblemDetailsService problemDetails)
+    : IExceptionHandler
+{
+    public async ValueTask<bool> TryHandleAsync(
+        HttpContext context, Exception exception, CancellationToken ct)
+    {
+        var status = exception switch
+        {
+            PetNotFoundException => StatusCodes.Status404NotFound,
+            ValidationException  => StatusCodes.Status400BadRequest,
+            _ => 0
+        };
+        if (status == 0) return false; // not a domain error -> let it bubble
+
+        context.Response.StatusCode = status;
+        return await problemDetails.TryWriteAsync(new ProblemDetailsContext
+        {
+            HttpContext = context,
+            ProblemDetails = { Title = exception.Message, Status = status }
+        });
+    }
+}
+```
+
+```csharp
+// Program.cs
+builder.Services.AddProblemDetails();
+builder.Services.AddExceptionHandler<DomainExceptionHandler>();
+// ...
+app.UseExceptionHandler();
+```
+
+---
+
+## Notes & limitations
+
+- **Without the flag**, the same endpoints delegate to a generated `I{ApiName}`
+  interface (resolved from DI) that you implement directly — no Wolverine.
+- **Conflicting request/response pairs** are avoided because every operation gets
+  its own wrapper type (e.g. `AddPetRequest` and `UpdatePetRequest`, even though
+  both wrap a `Pet`).
+- **File uploads:** the wrapper carries the path/query parameters alongside the
+  body, so they reach the handler. The body is a `System.IO.Stream` — fine for
+  the in-process local-queue routing used here, but a `Stream` is not
+  serializable, so if you re-route these requests to a remote transport
+  (RabbitMQ, Azure Service Bus, …) buffer the body to a `byte[]` instead.

package/targets/dotnet-webapi-system-text-json/generate.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+
+source $(dirname "$0")/../common.sh
+source $(dirname "$0")/../dotnet-common.sh
+
+# Pass the Wolverine flag to the generator only when enabled, so the mustache
+# section {{#withWolverineImplementation}} stays falsy otherwise (a string
+# "false" additional-property would read as truthy).
+if [ "${withWolverineImplementation}" = "true" ]; then
+  generatorCustomArgs="$generatorCustomArgs --additional-properties=withWolverineImplementation=true"
+fi
+
+dotnet_generate
+
+# The aggregate minimal-API endpoints file is emitted by a SupportingFiles
+# template (generator-config.json "files"), which can't template its output
+# folder, so it lands at the output root. Move it into the package source dir
+# so it's part of the project.
+endpointsFile="out/$targetId/EndpointRouteBuilderExtensions.cs"
+if [ -f "$endpointsFile" ]; then
+  destFile="out/$targetId/src/$packageName/EndpointRouteBuilderExtensions.cs"
+  mv "$endpointsFile" "$destFile"
+  # The generator only exposes the verb as "HttpGet"/"HttpPost"/..., so the
+  # template emits endpoints.MapHttpGet(...); rewrite to the real minimal-API
+  # method name endpoints.MapGet(...).
+  sed -i.bak 's/\.MapHttp/.Map/g' "$destFile" && rm -f "$destFile.bak"
+fi
+
+# Same for the JSON source-gen context / service-collection extension (SupportingFiles file).
+serviceExtFile="out/$targetId/ServiceCollectionExtensions.cs"
+if [ -f "$serviceExtFile" ]; then
+  mv "$serviceExtFile" "out/$targetId/src/$packageName/ServiceCollectionExtensions.cs"
+fi

package/targets/dotnet-webapi-system-text-json/generator-config.json

@@ -0,0 +1,29 @@
+{
+  "inlineSchemaOptions": {
+    "ARRAY_ITEM_SUFFIX": "",
+    "MAP_ITEM_SUFFIX": "",
+    "SKIP_SCHEMA_REUSE": "true"
+  },
+  "additionalProperties": {
+    "aspnetCoreVersion": "8.0",
+    "operationIsAsync": true,
+    "buildTarget": "library",
+    "generateBody": false,
+    "nullableReferenceTypes": true,
+    "operationResultTask": true,
+    "useNewtonsoft": false,
+    "enumNameSuffix": "Enum",
+    "enumValueSuffix": "",
+    "wolverineVersion": "6.10.0"
+  },
+  "files": {
+    "minimalEndpoints.mustache": {
+      "destinationFilename": "EndpointRouteBuilderExtensions.cs",
+      "templateType": "SupportingFiles"
+    },
+    "serviceCollectionExtensions.mustache": {
+      "destinationFilename": "ServiceCollectionExtensions.cs",
+      "templateType": "SupportingFiles"
+    }
+  }
+}

package/targets/dotnet-webapi-system-text-json/publish.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+source $(dirname "$0")/../common.sh
+source $(dirname "$0")/../dotnet-common.sh
+
+dotnet_publish

package/targets/dotnet-webapi-system-text-json/templates/Project.csproj.mustache

@@ -0,0 +1,66 @@
+<Project Sdk="{{projectSdk}}">
+    <PropertyGroup>
+        <Description>{{packageDescription}}{{^packageDescription}}{{packageName}}{{/packageDescription}}</Description>
+        <Copyright>{{packageCopyright}}</Copyright>
+        <Authors>{{packageAuthors}}</Authors>
+        <TargetFramework>net10.0</TargetFramework>
+        <IsAotCompatible>true</IsAotCompatible>
+        <!-- Statically generate the minimal-API request delegates (interceptors) so the
+             Map*() calls are trim-/AOT-safe instead of reflection-based at runtime.
+             Without this the [RequiresDynamicCode]/[RequiresUnreferencedCode] Map*
+             overloads raise IL3050/IL2026 under the AOT analyzer enabled above. -->
+        <EnableRequestDelegateGenerator>true</EnableRequestDelegateGenerator>
+        <GenerateDocumentationFile>true</GenerateDocumentationFile>
+        <PreserveCompilationContext>true</PreserveCompilationContext>
+        <Version>{{packageVersion}}</Version>
+        {{#nullableReferenceTypes}}
+        <Nullable>annotations</Nullable>
+        {{/nullableReferenceTypes}}
+        {{#isLibrary}}
+        <OutputType>Library</OutputType>
+        {{/isLibrary}}
+        <AssemblyName>{{packageName}}</AssemblyName>
+        <PackageId>{{packageName}}</PackageId>
+        <UserSecretsId>{{userSecretsGuid}}</UserSecretsId>
+        <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
+        <DockerfileContext>..\..</DockerfileContext>
+        {{#centralizedPackageVersionManagement}}
+        <ManagePackageVersionsCentrally>{{.}}</ManagePackageVersionsCentrally>
+        {{/centralizedPackageVersionManagement}}
+    </PropertyGroup>
+    <ItemGroup>
+        {{#withWolverineImplementation}}
+        <PackageReference Include="WolverineFx" Version="{{wolverineVersion}}" />
+        {{/withWolverineImplementation}}
+        {{#useSeparateModelProject}}
+        <ProjectReference Include="../{{modelPackage}}/{{modelPackage}}.csproj"/>
+        {{/useSeparateModelProject}}
+        {{#useFrameworkReference}}
+        {{#isLibrary}}
+        <FrameworkReference Include="Microsoft.AspNetCore.App" />
+        {{/isLibrary}}
+        {{/useFrameworkReference}}
+        {{^useFrameworkReference}}
+        <PackageReference Include="Microsoft.AspNetCore.App" />
+        {{/useFrameworkReference}}
+        {{#useSwashbuckle}}
+        <PackageReference Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" {{#usePackageVersions}}Version="1.10.8" {{/usePackageVersions}}/>
+        {{#useNewtonsoft}}
+        <PackageReference Include="Swashbuckle.AspNetCore.Newtonsoft" {{#usePackageVersions}}Version="{{swashbuckleVersion}}" {{/usePackageVersions}}/>
+        <PackageReference Include="Swashbuckle.AspNetCore.SwaggerUI" {{#usePackageVersions}}Version="{{swashbuckleVersion}}" {{/usePackageVersions}}/>
+        {{/useNewtonsoft}}
+        {{^useNewtonsoft}}
+        <PackageReference Include="Swashbuckle.AspNetCore" {{#usePackageVersions}}Version="{{swashbuckleVersion}}" {{/usePackageVersions}}/>
+        {{/useNewtonsoft}}
+        <PackageReference Include="Swashbuckle.AspNetCore.Annotations" {{#usePackageVersions}}Version="{{swashbuckleVersion}}" {{/usePackageVersions}}/>
+        {{/useSwashbuckle}}
+        {{^useSwashbuckle}}
+        {{#useNewtonsoft}}
+        <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" {{#usePackageVersions}}Version="{{newtonsoftVersion}}" {{/usePackageVersions}}/>
+        {{/useNewtonsoft}}
+        {{/useSwashbuckle}}
+    </ItemGroup>
+    <ItemGroup>
+        <!--<DotNetCliToolReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="{{aspnetCoreVersion}}.0" />-->
+    </ItemGroup>
+</Project>

package/targets/dotnet-webapi-system-text-json/templates/controller.mustache

@@ -0,0 +1,7 @@
+{{>partial_header}}
+// Intentionally empty.
+//
+// This target exposes its operations as minimal-API endpoints instead of MVC
+// controllers (minimal APIs are Native-AOT compatible; MVC controllers are not).
+// See {{packageName}}.EndpointRouteBuilderExtensions.MapAllEndpoints and the
+// generated I{ApiName} interfaces in EndpointRouteBuilderExtensions.cs.

package/targets/dotnet-webapi-system-text-json/templates/endpointParam.mustache

@@ -0,0 +1 @@
+{{#isPathParam}}[FromRoute(Name = "{{baseName}}")] {{/isPathParam}}{{#isQueryParam}}[FromQuery(Name = "{{baseName}}")] {{/isQueryParam}}{{#isHeaderParam}}[FromHeader(Name = "{{baseName}}")] {{/isHeaderParam}}{{#isBodyParam}}[FromBody] {{/isBodyParam}}{{#isFormParam}}[FromForm] {{/isFormParam}}

package/targets/dotnet-webapi-system-text-json/templates/enumClass.mustache

@@ -0,0 +1,24 @@
+
+        /// <summary>
+        /// {{^description}}Gets or Sets {{{name}}}{{/description}}{{{description}}}
+        /// </summary>
+        {{#description}}
+        /// <value>{{{.}}}</value>
+        {{/description}}
+        {{! AOT-safe enum (de)serialization: the source-generated, generic }}
+        {{! JsonStringEnumConverter<T> (no runtime MakeGenericType/Activator) plus the }}
+        {{! per-member JsonStringEnumMemberName below, which maps each value to its wire }}
+        {{! form. The attribute travels with the type, so enums round-trip as strings }}
+        {{! for reflection-based (JIT) hosts and source-generated (AOT) hosts alike. }}
+        [JsonConverter(typeof(JsonStringEnumConverter<{{datatypeWithEnum}}{{^datatypeWithEnum}}{{classname}}{{/datatypeWithEnum}}>))]
+        public enum {{datatypeWithEnum}}{{^datatypeWithEnum}}{{classname}}{{/datatypeWithEnum}}
+        {
+            {{#allowableValues}}{{#enumVars}}
+            /// <summary>
+            /// Enum {{name}} for {{{value}}}
+            /// </summary>
+            {{#isString}}[EnumMember(Value = "{{{value}}}")]
+            [JsonStringEnumMemberName("{{{value}}}")]{{/isString}}
+            {{name}}{{^isString}} = {{{value}}}{{/isString}}{{#isString}} = {{-index}}{{/isString}}{{^-last}},
+            {{/-last}}{{/enumVars}}{{/allowableValues}}
+        }

package/targets/dotnet-webapi-system-text-json/templates/minimalEndpoints.mustache

@@ -0,0 +1,120 @@
+// <auto-generated/>
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Routing;
+{{#withWolverineImplementation}}
+using Microsoft.Extensions.DependencyInjection;
+using Wolverine;
+{{/withWolverineImplementation}}
+using {{packageName}}.Models;
+
+namespace {{packageName}}
+{
+{{^withWolverineImplementation}}
+{{#apiInfo}}
+{{#apis}}
+    /// <summary>
+    /// Application logic for the {{classname}} endpoints. Register an implementation in DI.
+    /// </summary>
+    public interface I{{classname}}
+    {
+{{#operations}}
+{{#operation}}
+        /// <summary>Application logic for the {{operationId}} operation.</summary>
+        Task<IResult> {{operationId}}({{#allParams}}{{>paramType}} {{paramName}}, {{/allParams}}CancellationToken cancellationToken);
+{{/operation}}
+{{/operations}}
+    }
+
+{{/apis}}
+{{/apiInfo}}
+{{/withWolverineImplementation}}
+{{#withWolverineImplementation}}
+{{#apiInfo}}
+{{#apis}}
+{{#operations}}
+{{#operation}}
+    /// <summary>Wolverine request for {{classname}}.{{operationId}}, carrying every parameter.</summary>
+    public record {{operationId}}Request({{#allParams}}{{>paramType}} {{paramName}}{{^-last}}, {{/-last}}{{/allParams}});
+{{/operation}}
+{{/operations}}
+{{/apis}}
+{{/apiInfo}}
+{{/withWolverineImplementation}}
+
+    /// <summary>
+    /// Maps every generated API operation as a minimal-API endpoint.
+{{^withWolverineImplementation}}
+    /// Each endpoint delegates to the matching <c>I{ApiName}</c> implementation from DI.
+{{/withWolverineImplementation}}
+{{#withWolverineImplementation}}
+    /// Each endpoint invokes the request through Wolverine (IMessageBus.InvokeAsync).
+{{/withWolverineImplementation}}
+    /// </summary>
+    public static class EndpointRouteBuilderExtensions
+    {
+{{#apiInfo}}
+{{#apis}}
+        /// <summary>Maps the {{classname}} operations as minimal-API endpoints.</summary>
+        public static IEndpointRouteBuilder Map{{classname}}Endpoints(this IEndpointRouteBuilder endpoints)
+        {
+{{#operations}}
+{{#operation}}
+            endpoints.Map{{httpMethod}}("{{{basePathWithoutHost}}}{{{path}}}",
+                {{#withWolverineImplementation}}async {{/withWolverineImplementation}}({{#allParams}}{{>endpointParam}}{{>paramType}} {{paramName}}, {{/allParams}}[FromServices] {{^withWolverineImplementation}}I{{classname}} handler{{/withWolverineImplementation}}{{#withWolverineImplementation}}IMessageBus messageBus{{/withWolverineImplementation}}, CancellationToken cancellationToken)
+                    => {{^withWolverineImplementation}}handler.{{operationId}}({{#allParams}}{{paramName}}, {{/allParams}}cancellationToken){{/withWolverineImplementation}}{{#withWolverineImplementation}}{{#returnType}}Results.Ok(await messageBus.InvokeAsync<{{{returnType}}}>(new {{operationId}}Request({{#allParams}}{{paramName}}{{^-last}}, {{/-last}}{{/allParams}}), cancellationToken)){{/returnType}}{{^returnType}}await Handle(messageBus, new {{operationId}}Request({{#allParams}}{{paramName}}{{^-last}}, {{/-last}}{{/allParams}}), cancellationToken){{/returnType}}{{/withWolverineImplementation}}){{#hasAuthMethods}}
+                .RequireAuthorization(){{/hasAuthMethods}};
+{{/operation}}
+{{/operations}}
+            return endpoints;
+        }
+
+{{/apis}}
+{{/apiInfo}}
+        /// <summary>Maps the endpoints of every generated API.</summary>
+        public static IEndpointRouteBuilder MapAll{{#lambda.pascalcase}}{{packageName}}{{/lambda.pascalcase}}Endpoints(this IEndpointRouteBuilder endpoints)
+        {
+{{#apiInfo}}
+{{#apis}}
+            endpoints.Map{{classname}}Endpoints();
+{{/apis}}
+{{/apiInfo}}
+            return endpoints;
+        }
+
+{{#withWolverineImplementation}}
+        private static async Task<IResult> Handle<TRequest>(IMessageBus messageBus, TRequest request, CancellationToken cancellationToken)
+        {
+            await messageBus.InvokeAsync(request!, cancellationToken);
+            return Results.NoContent();
+        }
+
+        /// <summary>
+        /// Routes every generated request type (in this assembly) to a local queue.
+        /// </summary>
+        public static WolverineOptions ConfigureWolverineMessaging(this WolverineOptions options, string localQueueName = "{{packageName}}")
+        {
+            options.Publish(rule =>
+            {
+{{#apiInfo}}
+{{#apis}}
+{{#operations}}
+{{#operation}}
+                rule.Message<{{operationId}}Request>();
+{{/operation}}
+{{/operations}}
+{{/apis}}
+{{/apiInfo}}
+                rule.ToLocalQueue(localQueueName);
+            });
+            return options;
+        }
+{{/withWolverineImplementation}}
+    }
+}