### Start SvelteKit Development Server

Source: https://github.com/immediateplatform/immediate.dev/blob/main/README.md

Commands to initiate the development server for the SvelteKit application. The first command starts the server, while the second additionally opens the application in a new browser tab.

```bash
npm run dev
```

```bash
npm run dev -- --open
```

--------------------------------

### Create New .NET Web Project

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...1]getting-started/[...2]quickstart/+page.md

Initializes a new .NET web application named 'MyApp' and navigates into its directory. This step can be skipped if an existing project is available.

```bash
dotnet new web -n MyApp
cd MyApp
```

--------------------------------

### Add ImmediatePlatform NuGet Packages

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...1]getting-started/[...2]quickstart/+page.md

Adds the core `Immediate.Handlers` NuGet package as a dependency to the project. Optional packages like `Immediate.Validations`, `Immediate.Apis`, and `Immediate.Cache` can also be added for extended functionality.

```bash
dotnet add package Immediate.Handlers

# Optional:
dotnet add package Immediate.Validations
dotnet add package Immediate.Apis
dotnet add package Immediate.Cache
```

--------------------------------

### Register Immediate.Handlers with Dependency Injection

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...1]getting-started/[...2]quickstart/+page.md

Configures the `Immediate.Handlers` services within the .NET dependency injection container by calling `builder.Services.AddHandlers()` in the `Program.cs` file, making handlers available throughout the application.

```csharp
var builder = WebApplication.CreateBuilder();
builder.Services.AddHandlers();

var app = builder.Build();
app.Run();
```

--------------------------------

### Markdown Input for Component Transformation

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/kit-docs/README.md

Provides examples of Markdown syntax that will be processed by the `kit-docs` plugin, demonstrating how images, blockquotes, and custom button containers are represented before transformation into Svelte components.

```markdown
![alt text](https://...)

> This is a blockquote.

!!!button
...
!!!
```

--------------------------------

### Define and Consume a Basic ImmediatePlatform Handler

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...1]getting-started/[...2]quickstart/+page.md

Illustrates the creation of a simple `GetUserQuery` handler that accepts a user ID and returns a `User` record. It also demonstrates how to inject and consume this handler within another class to retrieve data, faking the user for simplicity.

```csharp
[Handler]
public static partial class GetUserQuery
{
	public sealed record Query
	{
		public int UserId { get; set; }
	}

	public sealed record User(int UserId, string Username);

	private static ValueTask<User> HandleAsync(
		Query query,
		CancellationToken token
	)
	{
		var user = new User(query.UserId, "john");

		return ValueTask.FromResult(user);
	}
}
```

```csharp
public sealed class Consumer(GetUserQuery.Handler handler)
{
	public async Task ConsumeAsync(CancellationToken token)
	{
		var response = await handler.HandleAsync(new("John"), token);
		// do something with response
	}
}
```

--------------------------------

### Expose ImmediatePlatform Handler as an API Endpoint

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...1]getting-started/[...2]quickstart/+page.md

Demonstrates how to transform an existing `Immediate.Handlers` handler into a RESTful API endpoint using `Immediate.Apis`. This involves registering the API endpoints in `Program.cs` and applying the `[MapGet]` attribute to the handler class, making it accessible via HTTP.

```csharp
var builder = WebApplication.CreateBuilder();
builder.Services.AddHandlers();

var app = builder.Build();

// <MyApp> here will be the name of your project
app.MapMyAppEndpoints();

app.Run();
```

```csharp
[Handler]
[MapGet("/api/users/{UserId}")]
public static partial class GetUserQuery
{
	// ...
}
```

--------------------------------

### Creating a GET Endpoint with MapGet

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...4]Immediate.Apis/[...1]creating-endpoints/+page.md

This C# code demonstrates how to transform an `Immediate.Handlers` handler into an HTTP GET endpoint by applying the `[MapGet("/users")]` attribute. It defines a `GetUsersQuery` class with a `HandleAsync` method responsible for retrieving a collection of users from a `UsersService`.

```C#
[Handler]
[MapGet("/users")]
public static partial class GetUsersQuery
{
    public record Query;

    private static ValueTask<IEnumerable<User>> HandleAsync(
        Query _,
        UsersService usersService,
        CancellationToken token)
    {
        return usersService.GetUsers();
    }
}
```

--------------------------------

### Transformed Svelte Output from Markdown

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/kit-docs/README.md

Shows the resulting Svelte component structure after the Markdown input (from the previous example) has been processed and transformed by the `kit-docs` plugin, illustrating how Markdown elements map to Svelte components like `Image`, `Blockquote`, and `Button`.

```svelte
<Image href="https://..." alt="alt text" />

<Blockquote>This is a blockquote.</Blockquote>

<Button>...</Button>
```

--------------------------------

### Mark Class for Validation with [Validate] and IValidationTarget

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...3]Immediate.Validation/[...1]creating-validators/+page.md

Apply the `[Validate]` attribute to a class and implement the `IValidationTarget<>` interface to designate it as a target for Immediate.Validations. This setup enables the validation system to automatically process instances of the class, checking for defined validation rules.

```cs
[Validate]
public partial record Query : IValidationTarget<Query>;
```

--------------------------------

### Customizing Endpoint OpenAPI Metadata

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...4]Immediate.Apis/[...2]customizing-endpoints/+page.md

This example shows how to use the `CustomizeEndpoint` method within an Immediate.Apis handler to add additional OpenAPI metadata to an endpoint. This includes specifying expected response types (e.g., `200 OK`, `500 Internal Server Error`), indicating validation problems, and adding tags for better API documentation.

```C#
[Handler]
[MapGet("/users")]
[Authorize(Policies.UserManagement)]
public static partial class GetUsersQuery
{
    internal static void CustomizeEndpoint(IEndpointConventionBuilder endpoint)
        => endpoint
            .Produces<IEnumerable<User>>(StatusCodes.Status200OK)
            .ProducesValidationProblem()
            .ProducesProblem(StatusCodes.Status500InternalServerError)
            .WithTags(nameof(User));

    public record Query;

    private static ValueTask<IEnumerable<User>> HandleAsync(
        Query _,
        UsersService usersService,
        CancellationToken token)
    {
        return usersService.GetUsers();
    }
}
```

--------------------------------

### Reference Other Properties/Methods in Validation Attributes using nameof()

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...3]Immediate.Validation/[...1]creating-validators/+page.md

Illustrates how to reference static methods or properties within validation attributes using the `nameof()` operator, as attributes only accept constant expressions. This example uses `[Match(regex: nameof(AllDigitsRegex))]` to apply a regex defined by a separate method, enabling dynamic validation logic.

```cs
[Validate]
public partial record Query : IValidationTarget<Query>
{
	[GeneratedRegex(@"^\d+$")]
	private static partial Regex AllDigitsRegex();

	[Match(regex: nameof(AllDigitsRegex))]
	public required string Id { get; init; }
}
```

--------------------------------

### Build and Preview SvelteKit Production Application

Source: https://github.com/immediateplatform/immediate.dev/blob/main/README.md

Commands to compile the SvelteKit application into a production-ready build and to preview the generated static files. The deployment process utilizes `@sveltejs/adapter-static`.

```bash
npm run build
```

```bash
npm run preview
```

--------------------------------

### Benchmark Environment Configuration Summary

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...7]benchmarks/[...1]performance-comparisons/+page.md

Provides a summary of the environment used for running the performance benchmarks, including the BenchmarkDotNet version, operating system, CPU specifications, and .NET SDK version. This information is crucial for understanding the context and reproducibility of the reported performance figures.

```text
// * Summary *

BenchmarkDotNet v0.14.0, Windows 11 (10.0.22631.4317/23H2/2023Update/SunValley3)
12th Gen Intel Core i7-12700H, 1 CPU, 20 logical and 14 physical cores
.NET SDK 9.0.100
  [Host]     : .NET 9.0.0 (9.0.24.52809), X64 RyuJIT AVX2
  DefaultJob : .NET 9.0.0 (9.0.24.52809), X64 RyuJIT AVX2
```

--------------------------------

### Define a Command Handler for User Creation (C#)

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...2]Immediate.Handlers/[...1]creating-handlers/+page.md

Shows how to define a command handler using the `[Handler]` attribute for creating a new user. It includes the `Command` record with an `Email` parameter and the `HandleAsync` method for processing the command.

```C#
[Handler]
public static partial class CreateUserCommand
{
    public record Command(string Email);

    private static async ValueTask HandleAsync(
        Command command,
        UsersService usersService,
        CancellationToken token
	)
    {
        await usersService.CreateUser(command.Email);
    }
}
```

--------------------------------

### Register Memory Cache with Dependency Injection

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...5]Immediate.Cache/[...1]creating-a-cache/+page.md

This C# snippet demonstrates how to register the `IMemoryCache` service with the Dependency Injection container in your `Program.cs` file. This is a crucial prerequisite for utilizing `ApplicationCacheBase` as it relies on an `IMemoryCache` instance.

```cs
services.AddMemoryCache();
```

--------------------------------

### Features/Todos/CreateTodo.cs - Initial API Endpoint

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...6]cookbook/[...2]fluent-validation/+page.md

This C# code defines the initial `CreateTodo` handler, an Immediate.Handlers endpoint for creating new todo items. It includes the `Command` record for input and the `HandleAsync` method responsible for persisting the new todo to the database and returning a `Created` response.

```C#
[Handler]
[MapPost("/api/todos")]
public static partial class CreateTodo
{
    public sealed record Command
    {
        public string Name { get; init; } = null!;
        
        public string? Description { get; init; }
    }

    private static async ValueTask<Created<Todo>> HandleAsync(
        Command command,
        ExampleDbContext dbContext,
        CancellationToken ct
    )
    {
        var todo = new Database.Models.Todo
        {
            Name = command.Name,
            Description = command.Description
        };

        await dbContext.Todos.AddAsync(todo, cancellationToken: ct);
        await dbContext.SaveChangesAsync(ct);

        return TypedResults.Created($"/api/todos/{todo.Id}", todo.ToDto());
    }
}
```

--------------------------------

### Consume a Handler via IHandler Interface (C#)

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...2]Immediate.Handlers/[...1]creating-handlers/+page.md

Illustrates how to consume a handler through its `IHandler<TRequest, TResponse>` interface, providing a decoupled way to interact with handlers, especially when direct references are not feasible.

```C#
public class Consumer(IHandler<Query, IEnumerable<User>> handler)
{
	public async Task Consumer(CancellationToken token)
	{
		var response = await handler.HandleAsync(new(), token);
		// do something with response
	}
}
```

--------------------------------

### terminal - Add FluentValidation Packages

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...6]cookbook/[...2]fluent-validation/+page.md

These Bash commands are used to add the necessary FluentValidation NuGet packages to the project. `FluentValidation` provides the core validation framework, and `FluentValidation.DependencyInjectionExtensions` facilitates its integration with .NET's dependency injection system.

```Bash
dotnet add package FluentValidation
dotnet add package FluentValidation.DependencyInjectionExtensions
```

--------------------------------

### Consume a Generated Query Handler (C#)

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...2]Immediate.Handlers/[...1]creating-handlers/+page.md

Demonstrates how a consumer class can inject and use the automatically generated handler (`GetUsersQuery.Handler`) to execute a query and retrieve a response.

```C#
public class Consumer(GetUsersQuery.Handler handler)
{
	public async Task Consumer(CancellationToken token)
	{
		var response = await handler.HandleAsync(new(), token);
		// do something with response
	}
}
```

--------------------------------

### Using Global Svelte Components in Markdown

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/kit-docs/README.md

Illustrates how to integrate and use global Svelte components, such as a `Button`, directly within Markdown files. It shows both direct component usage and how to leverage Markdown container syntax to pass props and dynamic slot elements.

```svelte
<!-- Use the component as-is. -->
<Button />

<!-- Or, use a markdown container. -->
:::button propA="valueA"|propB=10 Default slot content here. :::

<!-- You can pass in dynamic slot elements! -->
<!-- If you omit `tag`, it'll default to `<p>`. -->
:::button (tag=h1&slot=title)=Title Default slot content here. :::
```

--------------------------------

### Register Custom Application Cache with Dependency Injection

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...5]Immediate.Cache/[...1]creating-a-cache/+page.md

This C# snippet illustrates how to register your custom `ApplicationCacheBase` subclass, `GetValueCache`, as a singleton service in the Dependency Injection container. Registering it as a singleton ensures that a single instance is used throughout the application, making it available for injection where needed.

```cs
services.AddSingleton<GetValueCache>();
```

--------------------------------

### Register Handlers with Microsoft.Extensions.DependencyInjection (C#)

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...2]Immediate.Handlers/[...1]creating-handlers/+page.md

Explains how to integrate Immediate.Handlers with Microsoft's DI container by calling `services.AddXxxHandlers()` in `Program.cs`. This method automatically registers all classes marked with `[Handler]` in the assembly, where `Xxx` is derived from the project name.

```C#
// In Program.cs or Startup.cs
builder.Services.AddXxxHandlers(); // Replace Xxx with your project name (e.g., AddWebHandlers, AddApplicationWebHandlers)
```

--------------------------------

### Define a Query Handler for User Retrieval (C#)

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...2]Immediate.Handlers/[...1]creating-handlers/+page.md

Illustrates how to define a query handler using the `[Handler]` attribute for retrieving a collection of `User` objects. It shows the `Query` record and the `HandleAsync` method which takes `Query`, `UsersService`, and `CancellationToken` as parameters.

```C#
[Handler]
public static partial class GetUsersQuery
{
    public record Query;

    private static ValueTask<IEnumerable<User>> HandleAsync(
        Query _,
        UsersService usersService,
        CancellationToken token
	)
    {
        return usersService.GetUsers();
    }
}
```

--------------------------------

### Defining Command with Route and Body Parameters

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...4]Immediate.Apis/[...2]customizing-endpoints/+page.md

This section demonstrates how to define a command class that combines both route parameters and body parameters for PUT/POST requests in Immediate.Apis. It shows the structure of the command with `[FromRoute]` and `[FromBody]` attributes, followed by how to apply `[AsParameters]` to the handler method to correctly bind these parameters.

```C#
public sealed record Command
{
    public sealed record CommandBody
    {
        // props here;
    }
    
    [FromRoute]
    public required int Id { get; init; }
    
    [FromBody]
    public required CommandBody Body { get; init; }
}
```

```C#
private static async ValueTask<Results<NoContent, NotFound>> HandleAsync(
    [AsParameters] Command command,
    ExampleDbContext dbContext,
    CancellationToken ct
) 
{
    // ...
}
```

--------------------------------

### Register C# Behaviors Assembly-Wide

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...2]Immediate.Handlers/[...2]creating-behaviors/+page.md

This C# code demonstrates how to register behaviors globally for an entire assembly using the `[assembly: Behaviors(typeof(...))]` attribute. This makes the specified behavior applicable to all handlers within the assembly unless explicitly overridden by a handler-specific attribute.

```C#
[assembly: Behaviors(
	typeof(LoggingBehavior<,>)
)]
```

--------------------------------

### Initialize SvelteKit Dark/Light Theme

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/app.html

This JavaScript snippet initializes the color scheme for a SvelteKit application. It checks for a saved preference in local storage ('svelteness::color-scheme'), then falls back to the user's system preference ('prefers-color-scheme: dark'). Based on the determined scheme, it dynamically adds or removes the 'dark' class from the document's root element (<html>), enabling CSS-based theme application.

```javascript
const key = 'svelteness::color-scheme'; const scheme = localStorage[key]; const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches; if (scheme === 'dark' || (scheme !== 'light' && prefersDark)) { document.documentElement.classList.add('dark'); } else { document.documentElement.classList.remove('dark'); }
```

--------------------------------

### Define ApplicationCacheBase Subclass for Handler

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...5]Immediate.Cache/[...1]creating-a-cache/+page.md

This C# code defines a `GetValue` handler and a `GetValueCache` class that subclasses `ApplicationCacheBase`. The cache class uses `IMemoryCache` and an `Owned` handler to store and retrieve handler responses, transforming the request into a unique cache key for caching purposes.

```cs
[Handler]
public static partial class GetValue
{
	public sealed record Query(int Value);
	public sealed record Response(int Value);

	private static ValueTask<Response> HandleAsync(
		Query query,
		CancellationToken _
	) => ValueTask.FromResult(new Response(query.Value));
}

public sealed class GetValueCache(
	IMemoryCache memoryCache,
	Owned<IHandler<GetValue.Query, GetValue.Response>> ownedHandler
) : ApplicationCacheBase<GetValue.Query, GetValue.Response>(
	memoryCache,
	ownedHandler
)
{
	protected override string TransformKey(GetValue.Query request) =>
		$"GetValue(query: {request.Value})";
}
```

--------------------------------

### Register Owned Generic Type with Dependency Injection

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...5]Immediate.Cache/[...1]creating-a-cache/+page.md

This C# snippet shows how to register the `Owned<>` generic type as a singleton in the Dependency Injection container. This registration is essential because the `ApplicationCacheBase` constructor expects an `Owned<IHandler<...>>` instance.

```cs
services.AddSingleton(typeof(Owned<>));
```

--------------------------------

### Configure Web Project secrets.json for Application Settings

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...6]cookbook/[...6]fullstack-vsa/+page.md

This JSON snippet outlines the `secrets.json` file structure for the `Web` project. It includes configurations for database connection, Auth0 authentication, feature toggles, and email service settings, providing sensitive application parameters.

```JSON
{
	"DbContextOptions": {
		"ConnectionString": "<blank db>"
	},

	"Auth0": {
		"Domain": "<from-auth0>",
		"ClientId": "<from-auth0>"
	},

	"ProcessFeatureJob": {
		"Enabled": false
	},

	"EmailServiceOptions": {
		"Host": "smtp.sendgrid.net",
		"Port": 587,
		"Username": "apikey",
		"Password": "<from-auth0>",
		"FromEmailAddress": "VSA Template <no-reply@VsaTemplate.com>",
		"AdminEmailAddresses": [
			"Admin User <admin@example.com>"
		]
	}
}
```

--------------------------------

### Features/Todos/CreateTodo.cs - Add Command Validator

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...6]cookbook/[...2]fluent-validation/+page.md

This C# code modifies the `CreateTodo` handler to include a nested `CommandValidator` using FluentValidation. It defines specific validation rules for the `Name` (not empty, max 64 chars) and `Description` (max 4096 chars) properties of the `Command` record.

```C#
[Handler]
[MapPost("/api/todos")]
public static partial class CreateTodo
{
    public sealed record Command
    {
        public string Name { get; init; } = null!;        
        public string? Description { get; init; }
    }

    public sealed class CommandValidator : AbstractValidator<Command>
    {
        public CommandValidator()
        {
            RuleFor(x => x.Name)
                .NotEmpty()
                .MaximumLength(64);

            RuleFor(x => x.Description)
                .MaximumLength(4096);
        }
    }

    // rest of the endpoint omitted for brevity
    // ...
}
```

--------------------------------

### Register C# Behavior on an Individual Handler

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...2]Immediate.Handlers/[...2]creating-behaviors/+page.md

This C# code shows how to apply a specific behavior to an individual handler using the `[Behavior(typeof(...))]` attribute. This allows for fine-grained control over which behaviors apply to which handlers and will disregard any assembly-wide behaviors for that specific handler.

```C#
[Handler]
[Behavior(
	typeof(LoggingBehavior<,>)
)]
public static class GetUsersQuery
{
	// ..
}
```

--------------------------------

### Retrieve Data from Application Cache

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...5]Immediate.Cache/[...1]creating-a-cache/+page.md

This C# code demonstrates how to retrieve a value from an instance of your custom `ApplicationCacheBase` subclass. If a cached value exists for the given request, it will be returned immediately; otherwise, a temporary scope is used to execute the handler, and its result is then stored in the cache.

```cs
var response = await cache.GetValue(request, token);
```

--------------------------------

### Applying Authorization Attributes to Endpoints

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...4]Immediate.Apis/[...2]customizing-endpoints/+page.md

This snippet illustrates how to control access to Immediate.Apis endpoints by applying authorization attributes. It demonstrates the use of `[AllowAnonymous]` to permit unauthenticated access, and mentions support for `[Authorized("Policy")]` for policy-based authorization.

```C#
[Handler]
[MapGet("/users")]
[AllowAnonymous]
public static partial class GetUsersQuery
{
    public record Query;

    private static ValueTask<IEnumerable<User>> HandleAsync(
        Query _,
        UsersService usersService,
        CancellationToken token)
    {
        return usersService.GetUsers();
    }
}
```

--------------------------------

### Import GitHub Button Component (Svelte)

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...6]cookbook/[...6]fullstack-vsa/+page.md

Imports a reusable Svelte component, `GitHubButton`, from the local library path. This component is intended for displaying external links, specifically to GitHub repositories, within the documentation interface.

```Svelte
import GitHubButton from '$lib/components/GitHubButton.svelte';
```

--------------------------------

### Configuring Global Svelte Component Mappings in kit-docs

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/kit-docs/README.md

Demonstrates how to configure the `kitDocsPlugin` in `svelte.config.js` to define custom mappings for global Svelte components. This allows components to be used as inline rules, block rules, or custom Markdown containers, specifying their names, types, and associated rules/markers.

```javascript
kitDocsPlugin({
	markdown: {
		components: [
			// Override inline rule.
			// `Image.svelte` must be a global component.
			{ name: 'Image', type: 'inline', rule: 'image' },
			// Override block rule.
			// `Blockquote.svelte` must be a global component.
			{ name: 'Blockquote', type: 'block', rule: 'blockquote' },
			// Create custom container.
			// `Button.svelte` must be a global component.
			{ name: 'Button', type: 'custom', container: { marker: '!' } }
		]
	}
});
```

--------------------------------

### Boilerplate for Overriding Default CodeFence Component

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/kit-docs/README.md

Presents the minimal Svelte component structure required to override the default `CodeFence` component in `kit-docs`. It defines the expected props (`lang`, `ext`, `code`, `linesCount`, `highlightLines`) and demonstrates how to render the provided code within a styled `div`.

```svelte
<script>
	/** @type {string} */
	export let lang;
	/** @type {string} */
	export let ext;
	/** @type {string} */
	export let code;
	/** @type {number} */
	export let linesCount;
	/** @type {[number, number][]} */
	export let highlightLines = [];
</script>

<div class={`lang-${lang} ext-${ext}`}>
	{@html code}
</div>
```

--------------------------------

### Add ValidationBehavior to Assembly Behaviors

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...3]Immediate.Validation/[...1]creating-validators/+page.md

To enable Immediate.Validations, register the `ValidationBehavior<,>` in the assembly's default behaviors pipeline using the `[assembly: Behaviors]` attribute. This integrates the validation process into the Immediate.Handlers system, ensuring that validation logic is executed for relevant operations.

```cs
using Immediate.Validations.Shared;

[assembly: Behaviors(
	typeof(ValidationBehavior<,>)
)]
```

--------------------------------

### Implement a C# Behavior for Request Handling

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...2]Immediate.Handlers/[...2]creating-behaviors/+page.md

This C# code defines a `LoggingBehavior` class that inherits from `Behavior<TRequest, TResponse>`. It demonstrates how to inject an `ILogger` and override the `HandleAsync` method to perform actions (like logging) before and after the `Next` handler in the request pipeline. This pattern is useful for implementing cross-cutting concerns such as logging, validation, or error handling.

```C#
public sealed class LoggingBehavior<TRequest, TResponse>(ILogger<LoggingBehavior<TRequest, TResponse>> logger)
	: Behavior<TRequest, TResponse>
{
	public override async ValueTask<TResponse> HandleAsync(TRequest request, CancellationToken cancellationToken)
	{
		logger.LogInformation("LoggingBehavior.Enter");
		var response = await Next(request, cancellationToken);
		logger.LogInformation("LoggingBehavior.Exit");
		return response;
	}
}
```

--------------------------------

### Program.cs - Register Immediate.Handlers Behaviors

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...6]cookbook/[...2]fluent-validation/+page.md

This C# line in `Program.cs` registers all discovered Immediate.Handlers behaviors with the dependency injection container. The `AddBehaviors()` extension method scans the assembly for behaviors registered via assembly attributes, making them available for the handler pipeline.

```C#
// rest of Program.cs omitted for brevity
builder.Services.AddBehaviors();
```

--------------------------------

### Remove Data from Application Cache

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...5]Immediate.Cache/[...1]creating-a-cache/+page.md

This C# code shows how to remove a specific entry from your custom `ApplicationCacheBase` instance based on the provided request key. If a handler is currently running based on this request, it will be cancelled, and any callers waiting for its results will experience a `CancellationToken` cancellation.

```cs
await cache.RemoveValue(request);
```

--------------------------------

### Program.cs - Register FluentValidation Validators

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...6]cookbook/[...2]fluent-validation/+page.md

This C# line in `Program.cs` registers all FluentValidation validators found in the assembly containing `CreateTodo.CommandValidator` with the dependency injection container. `AddValidatorsFromAssemblyContaining` automatically discovers and registers `IValidator` implementations, making them injectable.

```C#
// rest of Program.cs omitted for brevity
builder.Services.AddValidatorsFromAssemblyContaining<CreateTodo.CommandValidator>();
```

--------------------------------

### Apply Built-in Validation Attributes to Properties

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...3]Immediate.Validation/[...1]creating-validators/+page.md

Demonstrates applying specific validation attributes, such as `[GreaterThan(0)]`, to properties within a `[Validate]`-marked class. This allows for fine-grained validation rules beyond automatic null checks for nullable reference types, ensuring data integrity based on predefined constraints.

```cs
[Validate]
public partial record Query : IValidationTarget<Query>
{
	[GreaterThan(0)]
	public required int Id { get; init; }
}
```

--------------------------------

### Update Data in Application Cache

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...5]Immediate.Cache/[...1]creating-a-cache/+page.md

This C# code demonstrates how to explicitly set or update a value in your custom `ApplicationCacheBase` instance. If a handler is currently running based on this request, it will be cancelled, and any callers waiting on the results from this handler will immediately receive the newly updated response.

```cs
await cache.SetValue(request, response);
```

--------------------------------

### SvelteKit Template Placeholders

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/app.html

These are SvelteKit-specific placeholders that indicate where the SvelteKit framework injects the generated HTML for the head and body sections of the page. During server-side rendering or client-side hydration, SvelteKit replaces these directives with the actual content from your Svelte components.

```svelte
%sveltekit.head%

%sveltekit.body%
```

--------------------------------

### Configure MSBuild Secrets.targets for Database Connection

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...6]cookbook/[...6]fullstack-vsa/+page.md

This XML snippet defines the `ScaffoldConnectionString` property within an MSBuild project file. It's used to provide database connection details for the `Scaffold` project, with special encoding for semicolons to avoid MSBuild parsing issues.

```XML
<?xml version="1.0" encoding="UTF-8"?>
<Project>

	<PropertyGroup>
		<ScaffoldConnectionString>Server=<server>%3BUser=<user>%3BPassword=<password>%3Bapp=VsaTemplate.scaffold</ScaffoldConnectionString>
	</PropertyGroup>

</Project>
```

--------------------------------

### Configure ASP.NET Core ProblemDetails for ValidationException

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...3]Immediate.Validation/[...4]handling-failures/+page.md

This C# code snippet demonstrates how to configure ASP.NET Core's `ProblemDetails` middleware to specifically handle `ValidationException`. It maps the errors from a `ValidationException` into a `ValidationProblemDetails` object, returning a 400 Bad Request status. A generic fallback for other exceptions is also included, returning a 500 Internal Server Error.

```cs
builder.Services.AddProblemDetails(ConfigureProblemDetails);

public static void ConfigureProblemDetails(ProblemDetailsOptions options) =>
	options.CustomizeProblemDetails = c =>
	{
		if (c.Exception is null)
			return;

		c.ProblemDetails = c.Exception switch
		{
			ValidationException ex => new ValidationProblemDetails(
				ex
					.Errors
					.GroupBy(x => x.PropertyName, StringComparer.OrdinalIgnoreCase)
					.ToDictionary(
						x => x.Key,
						x => x.Select(x => x.ErrorMessage).ToArray(),
						StringComparer.OrdinalIgnoreCase
					)
			)
			{
				Status = StatusCodes.Status400BadRequest,
			},

			// other exception handling as desired

			var ex => new ProblemDetails
			{
				Detail = "An error has occurred.",
				Status = StatusCodes.Status500InternalServerError,
			},
		};

		c.HttpContext.Response.StatusCode =
			c.ProblemDetails.Status
			?? StatusCodes.Status500InternalServerError;
	};
```

--------------------------------

### Add Constraints to a C# Behavior

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...2]Immediate.Handlers/[...2]creating-behaviors/+page.md

This C# code illustrates how to add generic type constraints (`where TRequest : IRequestConstraint` and `where TResponse : IResponseConstraint`) to a behavior. These constraints ensure that the behavior is only applied to requests and responses that implement the specified interfaces, allowing for conditional behavior application based on type compatibility during pipeline generation.

```C#
public sealed class LoggingBehavior<TRequest, TResponse>
	: Behavior<TRequest, TResponse>
	where TRequest : IRequestConstraint
	where TResponse : IResponseConstraint
```

--------------------------------

### Infrastructure/Behaviors/ValidationBehavior - Custom Validation Behavior

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...6]cookbook/[...2]fluent-validation/+page.md

This C# class implements a `ValidationBehavior` for Immediate.Handlers. It intercepts requests, aggregates validation failures from all registered `IValidator<TRequest>` instances, and throws a `ValidationException` if any validation errors are present, ensuring input data integrity.

```C#
public sealed class ValidationBehavior<TRequest, TResponse>(
    IEnumerable<IValidator<TRequest>> validators
) : Behavior<TRequest, TResponse>
{
    public override async ValueTask<TResponse> HandleAsync(TRequest request, CancellationToken cancellationToken)
    {
        var context = new ValidationContext<TRequest>(request);
        var failures = validators
            .Select(x => x.Validate(context))
            .SelectMany(x => x.Errors)
            .Where(x => x is not null)
            .ToList();

        if (failures.Any())
        {
            throw new ValidationException(failures);
        }

        return await Next(request, cancellationToken).ConfigureAwait(false);
    }
}
```

--------------------------------

### Query.cs - Extending Validation with AdditionalValidations Method

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...3]Immediate.Validation/[...3]extending-validation-classes/+page.md

This C# code defines a `Query` record that implements `IValidationTarget<Query>` and includes a static `AdditionalValidations` method. This method demonstrates how to add custom validation rules, such as conditionally validating `Id` based on the `Enabled` status using `GreaterThanAttribute.ValidateProperty`, or manually creating and adding `ValidationError` instances to the `ValidationResult` object.

```C#
[Validate]
public partial record Query : IValidationTarget<Query>
{
	public required bool Enabled { get; init; }
	public required int Id { get; init; }

	private static void AdditionalValidations(
		ValidationResult errors,
		Query target
	)
	{
		if (target.Enabled)
		{
			// Use a lambda to use the default message or override message;
			// the message will be templated in the same way as attribute validations.
			errors.Add(
				() => GreaterThanAttribute.ValidateProperty(
					target.Id,
					0
				)
			);
		}

		if (false)
		{
			// Manually create a `ValidationError` and add it to the `ValidationResult`.
			errors.Add(
				new ValidationError()
				{
					PropertyName = "ExampleProperty",
					ErrorMessage = "Example Message"
				}
			)
		}
	}
}
```

--------------------------------

### AssemblyAttributes.cs - Register Validation Behavior

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...6]cookbook/[...2]fluent-validation/+page.md

This C# snippet shows how to register the custom `ValidationBehavior` using an assembly-level attribute. The `[assembly: Behaviors]` attribute allows Immediate.Handlers to automatically discover and apply this behavior to relevant handlers within the project.

```C#
using FluentValidationExample.Infrastructure.Behaviors; // your namespace here;
using Immediate.Handlers.Shared;

[assembly: Behaviors(
    typeof(ValidationBehavior<,>)
)]
```

--------------------------------

### Transforming Handler Results to HTTP Status Codes

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...4]Immediate.Apis/[...2]customizing-endpoints/+page.md

This snippet demonstrates how to transform the result of an Immediate.Apis handler into a different type, specifically `Results<>`, to enable returning various HTTP status codes directly from the handler. This allows for more granular control over the HTTP response based on the handler's outcome.

```C#
[Handler]
[MapGet("/users")]
[Authorize(Policies.UserManagement)]
public static partial class GetUsersQuery
{
    internal static Results<Ok<IEnumerable<User>>, NotFound> TransformResult(IEnumerable<User> result)
    {
        return TypedResults.Ok(result);
    }

    public record Query;

    private static ValueTask<IEnumerable<User>> HandleAsync(
        Query _,
        UsersService usersService,
        CancellationToken token
    )
    {
        return usersService.GetUsers();
    }
}
```

--------------------------------

### Configure ProblemDetails for Validation Exception Handling in C#

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...6]cookbook/[...2]fluent-validation/+page.md

This C# code snippet demonstrates how to extend the `AddProblemDetails` configuration in `Program.cs` to specifically handle `ValidationException`. It maps validation errors into a `ValidationProblemDetails` object, grouping errors by property name and setting the HTTP status code to `400 Bad Request`. Other unhandled exceptions are mapped to a generic `ProblemDetails` with a `500 Internal Server Error` status.

```C#
// rest of Program.cs omitted for brevity

builder.Services.AddProblemDetails(options =>
    options.CustomizeProblemDetails = c =>
    {
        if (c.Exception is null)
            return;

        c.ProblemDetails = c.Exception switch
        {
            ValidationException ex => new ValidationProblemDetails(
                ex
                    .Errors
                    .GroupBy(x => x.PropertyName, StringComparer.OrdinalIgnoreCase)
                    .ToDictionary(
                        x => x.Key,
                        x => x.Select(e => e.ErrorMessage).ToArray(),
                        StringComparer.OrdinalIgnoreCase
                    )
            )
            {
                Status = StatusCodes.Status400BadRequest,
            },

            // other exception handling as desired goes here

            _ => new ProblemDetails
            {
                Detail = "An error has occurred.",
                Status = StatusCodes.Status500InternalServerError,
            },
        };

        c.HttpContext.Response.StatusCode = c.ProblemDetails.Status ?? StatusCodes.Status500InternalServerError;
    });
```

--------------------------------

### Configure Swashbuckle Custom Schema IDs in C#

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...4]Immediate.Apis/[...3]swashbuckle-support/+page.md

This C# code snippet demonstrates how to configure Swashbuckle's `AddSwaggerGen` method to generate unique schema IDs. By using `options.CustomSchemaIds(x => x.FullName?.Replace("+", ".", StringComparison.Ordinal))`, it modifies the default schema ID generation to replace '+' characters (often found in nested class names like `OuterClass+InnerClass`) with '.' characters. This prevents `InvalidOperationException` errors caused by duplicate schema IDs when multiple types with the same simple name exist in different namespaces, particularly common with `Immediate.Handlers`.

```C#
builder.Services.AddSwaggerGen(options =>
{
    options.CustomSchemaIds(x => x.FullName?.Replace("+", ".", StringComparison.Ordinal));
});
```

--------------------------------

### Applying Custom Validation Message to an Integer Property

Source: https://github.com/immediateplatform/immediate.dev/blob/main/src/routes/docs/[...3]Immediate.Validation/[...2]custom-messages/+page.md

This C# code snippet demonstrates how to apply a custom validation message to an integer property using the `GreaterThanAttribute`. It shows how to use the `Message` property to define a custom error message that includes template parameters like '{PropertyName}' and '{ComparisonValue}' for dynamic content.

```cs
[Validate]
public partial record Query : IValidationTarget<Query>
{
	[GreaterThan(0, Message = "'{PropertyName}' must be greater than '{ComparisonValue}'")]
	public required int Id { get; init; }
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.