Hummingbird

https://docs.hummingbird.codes/2.0/
Admin
Hummingbird is a lightweight, modern, flexible server framework written in Swift designed to require...
Tokens:593,916
Snippets:6,802
Trust Score:6.8
Update:5 months ago
Show doc for...
Tokens:
Raw
### Hummingbird v1 Application Setup

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/migratingtov2

Example of setting up a basic application in Hummingbird v1.

```swift
let app = Application()
app.router.get { request in
    "hello"
}

```

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

### APIGateway Lambda Setup Example

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdlambda/lambdafunction

Demonstrates how to set up a Lambda function for APIGateway events using a Hummingbird router. This example shows basic GET route configuration and running the lambda service.

```swift
let router = Router(context: BasicLambdaRequestContext<APIGatewayRequest>.self)
router.get { request, context in
    "Hello!"
}
let lambda = LambdaFunction(
    event: APIGatewayRequest.self,
    output: APIGatewayResponse.self,
    router: router
)
try await lambda.runService()
```

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

### MyApp Example Implementation

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/applicationprotocol

An example of how to implement the `ApplicationProtocol` by creating a custom `struct` named `MyApp`. This example demonstrates setting up a simple router and defining the server type.

```APIDOC
## Overview

```swift
struct MyApp: ApplicationProtocol {
    /// The responder will return an `Response` given an `Request` and a context
    var responder: some Responder<BasicRequestContext> {
        let router = Router(context: Context.self)
        router.get("hello") { _,_ in "Hello" }
        return router.buildResponder()
    }
    /// Defines your server type. This is the default value so in
    /// effect is unnecessary
    var server: HTTPChannelBuilder<some ChildChannel> { .http1() }
}
let app = MyApp()
try await app.runService()
```
```

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

### Basic API Gateway Lambda Function Setup

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdlambda/apigatewaylambdafunction

Demonstrates how to set up a basic router for an APIGatewayLambdaFunction. This example shows defining a GET route that returns a simple string response.

```swift
let router = Router(context: BasicLambdaRequestContext<APIGatewayRequest>.self)
router.get {
    request, context in
    "Hello!"
}
let lambda = APIGatewayLambdaFunction(router: router)
try await lambda.runService()
```

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

### Run Local Postgres Database

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/otpauthenticationexample

Use this command to start a local PostgreSQL database for the example.

```bash
docker compose up

```

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

### Hummingbird v2 Application Setup with Router

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/migratingtov2

Example of setting up an application in Hummingbird v2, passing a router during initialization. Routes added after initialization are ignored.

```swift
let router = Router()
router.get { request, context in
    "hello"
}
let app = Application(router: router)

```

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

### init()

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/metricsmiddleware/init%28%29

Initializes the MetricsMiddleware. This is a constructor or setup function.

```APIDOC
## init()

### Description
Initializes the MetricsMiddleware.

### Method
N/A (Constructor/Initializer)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

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

### setup(channel:logger:)

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdtls/tlschannel/setup%28channel%3Alogger%3A%29

Sets up a child channel with TLS and performs base channel setup. Returns an EventLoopFuture for the processed object.

```APIDOC
## setup(channel:logger:)

### Description
Sets up a child channel with TLS and the base channel setup.

### Method Signature
```swift
func setup(
    channel: any Channel,
    logger: Logger
) -> EventLoopFuture<Value>
```

### Parameters
#### channel
- **channel** (any Channel) - Required - The child channel to set up.

#### logger
- **logger** (Logger) - Required - The logger used during the setup process.

### Return Value
- **EventLoopFuture<Value>** - An object to process input/output on the child channel.
```

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

### HummingbirdValkey Integration Example

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdvalkey

This example demonstrates how to integrate Valkey/Redis with a Hummingbird server for storing and retrieving key-value pairs. It shows setting up the Valkey client, the persist driver, defining routes for GET and PUT operations, and adding the Valkey client as a service to the application.

```swift
let valkeyClient = ValkeyClient(
    .hostname(Self.valkeyHostname, port: 6379),
    logger: Logger(label: "Valkey")
)
let persist = ValkeyPersistDriver(client: valkeyClient)
let router = Router()
// return value from valkey database
router.get("{id}") { request, context -> String? in
    let id = try context.parameters.require("id")
    try await persist.get(key: id, as: String.self)
}
// set value in valkey database
router.put("{id}") { request, context -> String? in
    let id = try context.parameters.require("id")
    let value = try request.uri.queryParameters.require("value")
    try await persist.set(key: id, value: value)
}
var app = Application(router: router)
// add Valkey client as service to manage its lifecycle
app.addServices(valkeyClient)
try await app.runService()

```

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

### Define a basic GET route

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/routerguide

Use `on` to define a route with a path and method. This example creates a GET route for '/hello' that returns 'Hello'.

```swift
let router = Router()
router.on("/hello", method: .get) { request, context in
    return "Hello"
}
```

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

### MediaType Example Property

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/mediatype/example

Provides a static property to get an example instance of MediaType.

```APIDOC
## MediaType Example Property

### Description
This static property returns an instance of `MediaType`.

### Method
static var

### Endpoint
N/A (This is a property, not an endpoint)

### Parameters
None

### Request Example
```swift
let mediaTypeExample = MediaType.example
```

### Response
#### Success Response
- **example** (`Self`) - An instance of MediaType.
```

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

### Testing Setup Options

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/applicationprotocol/test%28_%3A_%3A%29

Explanation of the different testing frameworks available through the TestingSetup parameter.

```APIDOC
You can either test using the `.router` test framework which sends requests directly to the router for testing your code or the `.live` or `.ahc` frameworks which both run live servers to pass requests to, but provide a single connection HTTP client or AsyncHTTPClient as a client respectively . The `.router` test framework is quicker and doesn’t require setting up a full server but will only test code run from request generation onwards.
```

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

### AsyncHTTPClient Testing Setup

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdtesting/testingsetup

Sets up a live server and uses the async-http-client for testing. Does not support trailer headers.

```swift
static func ahc(TestHTTPScheme) -> TestingSetup
```

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

### Setup and Test Application Router

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdtesting

Use this snippet to set up a Hummingbird application with a router and then test its routes using the testing framework. It demonstrates how to execute a GET request and assert the response status and body.

```swift
let router = Router()
router.get("test") { _ in
    return "testing"
}
let app = Application(router: router)
try await app.test(.router) { client in
    try await client.execute(uri: "test", method: .GET) { response in
        #expect(response.status == .ok)
        #expect(String(buffer: response.body) == "testing")
    }
}
```

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

### run() Instance Method

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdcore/server/run%28%29

This method starts the server. It is inherited from the Service class and is available on multiple platforms.

```APIDOC
## run()

### Description
Starts the server. This is an instance method inherited from `Service.run()`.

### Platforms
iOS 17.0+
macOS 14.0+
tvOS 17.0+
visionOS 1.0+
Android 28.0+

### Signature
```swift
func run() async throws
```
```

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

### Install PostgreSQL

Source: https://docs.hummingbird.codes/2.0/tutorials/hummingbird/todos-4-postgres

Use Homebrew to install PostgreSQL on your system.

```bash
> brew install postgresql
```

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

### JobSchedule Overview Example

Source: https://docs.hummingbird.codes/2.0/documentation/jobs/jobschedule

Example of creating a Job Schedule and a scheduler Service.

```APIDOC
## Overview
Create your own Job Schedule and then create a scheduler Service to generate Jobs on a specified JobQueue when the schedule requires it
```swift
let jobSchedule = JobSchedule([
    .init(job: RemoveDeadSessionsJob(), schedule: .weekly(day: .sunday, hour: 4))
])
let serviceGroup = ServiceGroup(
    configuration: .init(
        services: [jobQueue, jobSchedule.scheduler(on: jobQueue)]
    )
)
```
```

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

### Application Initialization and Running

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/application

Demonstrates how to create a router, configure an Application with the router and server, and then run the application service.

```APIDOC
## Application Initialization and Running

### Description
This example shows the basic setup for creating and running a Hummingbird application. It involves defining routes using a `Router`, initializing the `Application` with the router and server configuration, and finally starting the application.

### Code Example
```swift
// create router
let router = Router()
router.get("hello") { _,_ in
    return "hello"
}
// create application
let app = Application(
    router: router,
    server: .http1()    // This is the default value
)
// run application
try await app.runService()
```
```

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

### Define TestingSetup Structure

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdtesting/testingsetup

Defines the basic structure for testing setups.

```swift
struct TestingSetup
```

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

### Define a process to run before lambda starts

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdlambda/lambdafunction/beforelambdastarts%28perform%3A%29

Use this method to add a closure that will be executed before the lambda service starts. This is ideal for setup tasks that require other services to be initialized or completed.

```swift
mutating func beforeLambdaStarts(perform process: @escaping @Sendable async throws -> Void)
```

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

### Configure New Project

Source: https://docs.hummingbird.codes/2.0/tutorials/hummingbird/todos-1-template

Run the configure script to set up your new project. Pressing return on each prompt uses the default value.

```bash
> ./template/configure.sh Todos
Enter your package name: [Todos] > 
Do you want to build an AWS Lambda function? [y/N] > 
Enter your executable name: [App] > 
Do you want to use the OpenAPI generator? [y/N] > 
Include Visual Studio Code snippets: [y/N] > 
```

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

### Navigate to New Project Directory

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/gettingstarted

Change into the newly created project directory after configuration.

```bash
cd MyNewProject
```

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

### Accessing the Default DatabaseMigrationGroup

Source: https://docs.hummingbird.codes/2.0/documentation/postgresmigrations/databasemigrationgroup/default

Use this static property to get the default instance of DatabaseMigrationGroup. This is typically used for standard migration setups.

```swift
static var `default`: `Self` { get }
```

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

### Application Initialization with HTTP1 Server

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdcore/httpserverbuilder/http1%28additionalchannelhandlers%3A%29

Demonstrates how to initialize an `Application` instance using the `http1()` server configuration. This is a common pattern for setting up the server within your application's lifecycle.

```swift
let app = Application(
   router: router,
   server: .http1()
)

```

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

### MediaType.Category Example Property

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/mediatype/category/example

Provides a static computed property 'example' that returns an instance of 'Self'. This is a common pattern for providing default or sample values.

```swift
static var example: `Self` { get }
```

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

### Define Todo Controller Endpoints

Source: https://docs.hummingbird.codes/2.0/tutorials/hummingbird/todos-2-api

Defines the routes for the Todo controller, including GET, POST, and PATCH operations. This setup is part of the `TodoController` class.

```swift
        return RouteCollection(context: AppRequestContext.self)
            .get(":id", use: get)
            .get(use: list)
            .post(use: create)
    }



```

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

### Live Server Testing Setup

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdtesting/testingsetup

Sets up a live server for testing using a single HTTP connection. Supports only HTTP1 and single-threaded execution.

```swift
static var live: TestingSetup
```

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

### Server Initializer

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdcore/server

Initializes a new instance of the Server class. This requires a child channel setup, server configuration, an optional callback for when the server starts, an event loop group, and a logger.

```APIDOC
## init(childChannelSetup: ChildChannel, configuration: ServerConfiguration, onServerRunning: (@Sendable (any Channel) async -> Void)?, eventLoopGroup: any EventLoopGroup, logger: Logger)

### Description
Initialize Server

### Parameters
- **childChannelSetup** (ChildChannel) - Description for childChannelSetup
- **configuration** (ServerConfiguration) - Description for configuration
- **onServerRunning** ((any Channel) async -> Void)? - Optional callback executed when the server starts.
- **eventLoopGroup** (any EventLoopGroup) - The event loop group to use for the server.
- **logger** (Logger) - The logger instance for the server.
```

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

### init()

Source: https://docs.hummingbird.codes/2.0/documentation/jobs/tracingjobmiddleware/init%28%29

Initializes the TracingJobMiddleware.

```APIDOC
## init()

### Description
Initializes the TracingJobMiddleware.

### Method
(Not specified, likely a constructor or initialization function)

### Endpoint
N/A

### Parameters
N/A

### Request Example
```
init()
```

### Response
N/A
```

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

### Create and Run Hummingbird Application

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/application

Demonstrates how to create a router, instantiate an Application with the router and server configuration, and then run the application.

```swift
// create router
let router = Router()
router.get("hello") { _,_ in
    return "hello"
}
// create application
let app = Application(
    router: router,
    server: .http1()    // This is the default value
)
// run application
try await app.runService()

```

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

### RouterBuilder Initialization Example

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdrouter

Demonstrates how to initialize a RouterBuilder with middleware, routes, and route groups.

```APIDOC
## RouterBuilder Initialization

### Description
Initialize a `RouterBuilder` with middleware, routes, and route groups using a result builder.

### Usage
```swift
let router = RouterBuilder(context: BasicRouterRequestContext.self) {
    CORSMiddleware()
    Route(.get, "health") { _,_ in
        HTTPResponse.Status.ok
    }
    RouteGroup("user") {
        BasicAuthenticationMiddleware()
        Route(.post, "login") { request, context in
            // Login logic
            ...
        }
    }
}
```

### Parameters
- `context`: The `RouterRequestContext` type to use.
- `builder`: A closure that defines the routes and middleware.
```

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

### Create Helper Functions for API Calls

Source: https://docs.hummingbird.codes/2.0/tutorials/hummingbird/todos-3-testing

Create helper functions for all API calls to streamline test writing. This example shows the `create` function and the beginning of a `get` function, which handles retrieving a specific todo by its ID.

```swift
@Suite
struct AppTests {
    struct CreateRequest: Encodable {
        let title: String
        let order: Int?
    }


    func create(title: String, order: Int? = nil, client: some TestClientProtocol) async throws -> Todo {
        let request = CreateRequest(title: title, order: order)
        let buffer = try JSONEncoder().encodeAsByteBuffer(request, allocator: ByteBufferAllocator())
        return try await client.execute(uri: "/todos", method: .post, body: buffer) { response in
            #expect(response.status == .created)
            return try JSONDecoder().decode(Todo.self, from: response.body)
        }
    }


    func get(id: UUID, client: some TestClientProtocol) async throws -> Todo? {
        try await client.execute(uri: "/todos/\(id)", method: .get) { response in
            // either the get request returned an 200 status or it didn't return a Todo
            #expect(response.status == .ok || response.body.readableBytes == 0)
            if response.body.readableBytes > 0 {
                return try JSONDecoder().decode(Todo.self, from: response.body)

```

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

### Define App Structure and Arguments

Source: https://docs.hummingbird.codes/2.0/tutorials/hummingbird/mongokitten-1-setup

Set up the main App struct conforming to AsyncParsableCommand and AppArguments, defining server options.

```swift
import ArgumentParser
import Hummingbird
import Logging


@main
struct App: AsyncParsableCommand, AppArguments {
    @Option(name: .shortAndLong)
    var hostname: String = "127.0.0.1"


    @Option(name: .shortAndLong)
    var port: Int = 8080


    @Option(name: .shortAndLong)
    var logLevel: Logger.Level?


    func run() async throws {
        let app = try await buildApplication(self)
        try await app.runService()
    }
}


/// Extend `Logger.Level` so it can be used as an argument
#if hasFeature(RetroactiveAttribute)
    extension Logger.Level: @retroactive ExpressibleByArgument {}
#else
    extension Logger.Level: ExpressibleByArgument {}
#endif

```

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

### Test Application with Router Framework

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/applicationprotocol/test%28_%3A_%3A%29

Use the `.router` testing framework to send requests directly to the router for quick testing of code from request generation onwards. This example demonstrates testing a GET request to a '/hello' route.

```swift
let router = Router()
router.get("/hello") { _ in
    return "hello"
}
let app = Application(router: router)
app.test(.router) { client in
    // does my app return "hello" in the body for this route
    client.execute(uri: "/hello", method: .GET) { response in
        XCTAssertEqual(String(buffer: response.body), "hello")
    }
}
```

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

### Create and Configure RouterGroup

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/routergroup

Demonstrates creating a RouterGroup with the path 'todos' and adding various HTTP methods (GET, PUT, DELETE) to specific routes, including those with an ID parameter. This example shows how to define a set of related API endpoints.

```swift
app.router
.group("todos")
.get(use: todoController.list)
.put(use: todoController.create)
.get(":id", use: todoController.get)
.put(":id", use: todoController.update)
.delete(":id", use: todoController.delete)
```

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

### Application Initialization with HTTP/2 Upgrade

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdcore/httpserverbuilder/http2upgrade%28tlsconfiguration%3Aadditionalchannelhandlers%3A%29

Demonstrates how to initialize an `Application` instance using the `http2Upgrade` builder. This is typically done during application startup.

```swift
let app = Application(
    router: router,
    server: .http2Upgrade(tlsConfiguration: tlsConfiguration)
)
```

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

### Testing a Lambda Function with Router Framework

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdlambda/lambdafunctionprotocol/test%28loglevel%3A_%3A%29

This example demonstrates how to test a Lambda function using the .router framework. It sets up a router, defines a GET endpoint, creates a Lambda function, and then uses the test client to execute a request and assert the response.

```swift
let router = Router(context: Context.self)
router.get("hello") { request, _ in
    return "Hello"
}
let lambda = LambdaFunction(router: router)
try await lambda.test { client in
    try await client.execute(uri: "/hello", method: .get) { response in
        XCTAssertEqual(response.body, "Hello")
    }
}
```

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

### init(windowSize:minimumResponseSizeToCompress:zlibCompressionLevel:zlibMemoryLevel:)

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdcompression/responsecompressionmiddleware/init%28windowsize%3Aminimumresponsesizetocompress%3Azlibcompressionlevel%3Azlibmemorylevel%3A%29

Initializes the ResponseCompressionMiddleware with specified compression configurations.

```APIDOC
## init(windowSize:minimumResponseSizeToCompress:zlibCompressionLevel:zlibMemoryLevel:)

### Description
Initializes the ResponseCompressionMiddleware with specified compression configurations.

### Parameters
#### Parameters
- **windowSize** (Int) - Optional - Compression window size. Defaults to 32768.
- **minimumResponseSizeToCompress** (Int) - Optional - Minimum size of response before applying compression. Defaults to 1024.
- **zlibCompressionLevel** (ZlibConfiguration.CompressionLevel) - Optional - Zlib compression level. Defaults to .defaultCompressionLevel.
- **zlibMemoryLevel** (ZlibConfiguration.MemoryLevel) - Optional - Amount of memory to allocated for compression state. Defaults to .defaultMemoryLevel.

### Code Example
```swift
init(
    windowSize: Int = 32768,
    minimumResponseSizeToCompress: Int = 1024,
    zlibCompressionLevel: ZlibConfiguration.CompressionLevel = .defaultCompressionLevel,
    zlibMemoryLevel: ZlibConfiguration.MemoryLevel = .defaultMemoryLevel
)
```
```

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

### Define a GET route using shortcut

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/routerguide

Use the `get` shortcut for defining GET routes. This is equivalent to the `on` method with `.get`.

```swift
let router = Router()
router.get("/hello") { request, context in
    return "Hello"
}
```

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

### Get(_:builder:)

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdrouter/get%28_%3Abuilder%3A%29

Creates a GET Route using the `RouteBuilder` result builder. This function allows for the definition of GET routes with associated middleware.

```APIDOC
## Get(_:builder:)

### Description
Create a GET Route using the `RouteBuilder` result builder.

### Function Signature
```swift
func Get<M0, Context>(
    _ routerPath: RouterPath = "",
    @RouteBuilder<Context> builder: () -> M0
) -> Route<_RouteHandlerMiddleware<M0>, Context>
where M0 : MiddlewareProtocol,
      Context : RouterRequestContext,
      Context == M0.Context,
      M0.Input == Request,
      M0.Output == Response
```

### Parameters

- **routerPath** (`RouterPath`)
  - Route path, relative to group route is defined in. Defaults to an empty string.

- **builder** (`@RouteBuilder<Context> () -> M0`)
  - Result builder used to build Route middleware.
```

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

### init(queueName:)

Source: https://docs.hummingbird.codes/2.0/documentation/jobs/tracingjobmiddleware/init%28queuename%3A%29

Initializes the TracingJobMiddleware with a specified queue name.

```APIDOC
## init(queueName:)

### Description
Initializes the TracingJobMiddleware with a specified queue name.

### Method
Initializer

### Parameters
#### Path Parameters
- **queueName** (String) - Required - The name of the queue to associate with this middleware.
```

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

### Use Shortcut for GET Route

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/routerbuilderguide

Demonstrates the shortcut function `Get` for defining a GET route, which is equivalent to using `Route(.get, ...)`.

```swift
Route(.get, "health") { _,_ in
    HTTPResponse.Status.ok
}

```

```swift
Get("health") { _,_ in
    HTTPResponse.Status.ok
}

```

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

### Build Server Instance

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdcore/http1channel/server%28configuration%3Aonserverrunning%3Aeventloopgroup%3Alogger%3A%29

Use this method to construct a server instance. Provide the server configuration, an optional closure to run when the server is active, the event loop group, and a logger.

```swift
func server(
    configuration: ServerConfiguration,
    onServerRunning: (@Sendable (any Channel) async -> Void)? = nil,
    eventLoopGroup: any EventLoopGroup,
    logger: Logger
) -> any Service
```

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

### init()

Source: https://docs.hummingbird.codes/2.0/documentation/jobs/metricsjobmiddleware/init%28%29

Initializes the MetricsJobMiddleware.

```APIDOC
## init()

### Description
Initializes the MetricsJobMiddleware.

### Method
initializer

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

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

### Setup Valkey Job Queue

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/jobsguide

Initialize a JobQueue using the Valkey driver. Ensure you have a configured Valkey client and logger.

```swift
let jobQueue = JobQueue(
    .valkey(
        valkeyClient, 
        configuration: .init(queueName: "MyQueue"),
        logger: logger
    ), 
    logger: logger
)
```

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

### Define Get Todo Endpoint

Source: https://docs.hummingbird.codes/2.0/tutorials/hummingbird/todos-2-api

Implements the `get` endpoint for retrieving a single todo item by its ID. It requires the ID from the request parameters and calls the repository's `get` method.

```swift
    /// Get todo endpoint
    func get(request: Request, context: some RequestContext) async throws -> Todo? {
        let id = try context.parameters.require("id", as: UUID.self)
        return try await self.repository.get(id: id)
    }


    /// Get list of todos endpoint
    func list(request: Request, context: some RequestContext) async throws -> [Todo] {
        return try await self.repository.list()
    }


    struct CreateRequest: Decodable {
        let title: String
        let order: Int?
    }
    /// Create todo endpoint
    func create(request: Request, context: some RequestContext) async throws -> EditedResponse<Todo> {
        let request = try await request.decode(as: CreateRequest.self, context: context)
        let todo = try await self.repository.create(title: request.title, order: request.order, urlPrefix: "http://localhost:8080/todos/")
        return EditedResponse(status: .created, response: todo)
    }
}

```

```
        return RouteCollection(context: AppRequestContext.self)
            .get(":id", use: get)
            .get(use: list)
            .post(use: create)
    }

```
```

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

### Application Initialization with HTTP/2 Upgrade

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdcore/httpserverbuilder/http2upgrade%28tlschannelconfiguration%3Aconfiguration%3A%29

Demonstrates how to initialize an `Application` instance using the `http2Upgrade` builder. This is typically done during application startup to configure the server to handle HTTP/2 connections with TLS.

```swift
let app = Application(
    router: router,
    server: .http2Upgrade(configuration: .init(tlsConfiguration: tlsConfiguration))
)
```

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

### init(_:configuration:logger:)

Source: https://docs.hummingbird.codes/2.0/documentation/jobsvalkey/valkeyjobqueue/init%28_%3Aconfiguration%3Alogger%3A%29

Initializes a new instance of ValkeyJobQueue.

```APIDOC
## init(_:configuration:logger:)

### Description
Initialize Valkey job queue

### Parameters
#### Parameters
- **valkeyClient** (ValkeyClient) - Description: Valkey client
- **configuration** (Configuration) - Description: Configuration. Defaults to `.init()`.
- **logger** (Logger) - Description: Logger used by ValkeyJobQueue
```

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

### get

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/routecollection/routermethods-implementations

GET path for async closure returning type conforming to ResponseGenerator.

```APIDOC
## get

### Description
GET path for async closure returning type conforming to ResponseGenerator.

### Method
func get(RouterPath, use: @Sendable (Request, Context) async throws -> some ResponseGenerator) -> Self
```

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

### Initialize LocalFileSystem FileProvider

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/localfilesystem/init%28rootfolder%3Athreadpool%3Alogger%3A%29

Use this initializer to set up the LocalFileSystem FileProvider. It requires the root folder path, a NIOThreadPool for file loading operations, and a Logger for output.

```swift
init(
    rootFolder: String,
    threadPool: NIOThreadPool,
    logger: Logger
)
```

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

### Get fontWoff MediaType

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/mediatype/fontwoff

Access the static property to get the fontWoff MediaType.

```swift
static var fontWoff: `Self` { get }
```

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

### Create a Basic Router with Fluent API

Source: https://docs.hummingbird.codes/2.0/tutorials/hummingbird/fluent-1-galaxy

Demonstrates setting up a simple router using the fluent interface. This is useful for defining basic application routes.

```javascript
import { Router } from "@hummingbird/core";

export function createRouter() {
    const router = new Router();

    router.get("/", () => {
        return "Hello!"
    })
    return router
}
```

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

### Get applicationOdt MediaType

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/mediatype/applicationodt

Access the static property to get the applicationOdt MediaType.

```swift
static var applicationOdt: `Self` { get }
```

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

### init()

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/environment/init%28%29

Initializes the Hummingbird environment by reading configuration from environment variables.

```APIDOC
## init()

### Description
Initializes the Hummingbird environment from environment variables.

### Method
Function Call

### Endpoint
N/A (SDK function)

### Parameters
None

### Request Example
```
init()
```

### Response
None explicitly documented.
```

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

### init(_:)

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdrouter/routerbuilderoptions/init%28_%3A%29-32y6j

Initializes a new instance of HummingbirdRouter from a sequence.

```APIDOC
## init(_:)

### Description
Initializes a new instance of HummingbirdRouter by taking a sequence of elements.

### Signature
```swift
init<S>(_ sequence: S) where S : Sequence, Self.Element == S.Element
```

### Parameters
- `sequence`: A sequence of elements to initialize the router with.
```

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

### BasicAuthenticator Example

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdauth/authenticatormiddleware

An example implementation of `AuthenticatorMiddleware` using basic username and password authentication.

```APIDOC
## BasicAuthenticator Example

A simple username, password authenticator could be implemented as follows. If the authenticator is successful it returns a `User` struct, otherwise it returns `nil`.

```swift
struct BasicAuthenticator<Context: AuthRequestContext>: AuthenticatorMiddleware {
    func authenticate(request: Request, context: Context) async throws -> User? {
        // Basic authentication info in the "Authorization" header, is accessible
        // via request.headers.basic
        guard let basic = request.headers.basic else { return nil }
        // check if user exists in the database
        guard let user = try await database.getUserWithUsername(basic.username) else {
            return nil
        }
        // verify password against password hash stored in database. If valid
        // return the user. HummingbirdAuth provides an implementation of Bcrypt
        // This should be run on the thread pool as it is a long process.
        return try await context.threadPool.runIfActive {
            if Bcrypt.verify(basic.password, hash: user.passwordHash) {
                return user
            }
            return nil
        }
    }
}
```
```

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

### Initialize Application with TLS Server

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdcore/httpserverbuilder/tls%28_%3Aconfiguration%3A%29

Example of initializing an Application with a TLS-enabled server. This configuration includes a custom asynchronous verification callback for TLS certificates.

```swift
let app = Application(
  router: router,
  server: .tls(.http1(), configuration: .init(
       tlsConfiguration: tlsConfiguration,
       customAsyncVerificationCallback: { certificates in .certificateVerified }
  ))
)
```

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

### starts(with:) Method Signature

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/routerpath/starts%28with%3A%29

This is the method signature for starts(with:). It is available when the Element conforms to Equatable.

```swift
func starts<PossiblePrefix>(with possiblePrefix: PossiblePrefix) -> Bool where PossiblePrefix : Sequence, Self.Element == PossiblePrefix.Element
```

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

### starts(with:by:)

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/routerpath/starts%28with%3Aby%3A%29

Checks if the sequence starts with the given `possiblePrefix` using a custom equivalence closure `areEquivalent`.

```APIDOC
## starts(with:by:)

### Description
Checks if the sequence begins with the specified `possiblePrefix`. The `areEquivalent` closure is used to determine if elements from the sequence and the prefix are considered equivalent.

### Method Signature
```swift
func starts<PossiblePrefix>(
    with possiblePrefix: PossiblePrefix,
    by areEquivalent: (Self.Element, PossiblePrefix.Element) throws -> Bool
) rethrows -> Bool where PossiblePrefix : Sequence
```

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```swift
// Example usage (assuming 'mySequence' and 'myPrefix' are defined)
let startsWithPrefix = mySequence.starts(with: myPrefix, by: ==)
```

### Response
#### Success Response (Bool)
- **Returns**: `true` if the sequence starts with the `possiblePrefix`, `false` otherwise.

#### Response Example
```json
{
  "example": true
}
```
```

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

### Execute GET Request

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdtesting/testclient

Performs a GET request to the specified path with given headers. Returns a TestClient.Response.

```swift
func get(_ path: String, headers: HTTPFields) async throws -> TestClient.Response
```

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

### init(directory:withExtension:)

Source: https://docs.hummingbird.codes/2.0/documentation/mustache/mustachelibrary/init%28directory%3Awithextension%3A%29

Initializes the library by loading all Mustache templates from the specified directory. Templates are registered using their filename (without extension) as the key. The search is recursive, and templates in subfolders are prefixed with their subfolder path.

```APIDOC
## init(directory:withExtension:)

### Description
Initializes the Mustache library with contents of a folder, searching for files with a specific extension.

### Method
`init`

### Parameters
#### Path Parameters
- **directory** (String) - Required - Directory to look for mustache templates.
- **withExtension extension** (String) - Optional - Extension of files to look for. Defaults to "mustache".

### Discussion
Each template is registered with the name of the file minus its extension. The search through the folder is recursive and templates in subfolders will be registered with the name `subfolder/template`.
```

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

### init(address:serverName:backlog:reuseAddress:availableConnectionsDelegate:)

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/applicationconfiguration/init%28address%3Aservername%3Abacklog%3Areuseaddress%3Aavailableconnectionsdelegate%3A%29

Initializes the Application configuration with options for server binding, name, connection backlog, address reuse, and a delegate for managing available connections.

```APIDOC
## init(address:serverName:backlog:reuseAddress:availableConnectionsDelegate:)

### Description
Initializes the Application configuration with specified parameters.

### Parameters
#### address
Bind address for the server. Defaults to `.hostname()`.

#### serverName
Server name to be returned in the “server” header. Optional.

#### backlog
The maximum length for the queue of pending connections. Defaults to 256. If the queue is full when a connection request arrives, the client may receive an error with an indication of ECONNREFUSE.

#### reuseAddress
Allows the socket to be bound to an address that is already in use. Defaults to `true`.

#### availableConnectionsDelegate
An object that decides when to accept new connections. Use `MaximumAvailableConnections` to set the maximum allowed connections. Optional.
```

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

### Example Usage of ChildRequestContext

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/childrequestcontext

Provides an example of how to implement the ChildRequestContext protocol in a custom struct, demonstrating the initializer.

```APIDOC
## Example Implementation

```swift
struct MyRequestContext: ChildRequestContext {
    init(context: MyParentRequestContext) throws {
        self.coreContext = context.coreContext
    }
}
```
```

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

### get

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/routergroup/routermethods-implementations

Defines a GET route for a given path. The handler is an asynchronous closure that returns a type conforming to ResponseGenerator.

```APIDOC
## get

### Description
GET path for async closure returning type conforming to ResponseGenerator.

### Method
`func get(RouterPath, use: @Sendable (Request, Context) async throws -> some ResponseGenerator) -> Self`

### Parameters
* `RouterPath`: The path for the GET route.
* `use`: An asynchronous closure that handles the request and returns a `ResponseGenerator`.
```

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

### Get applicationSwf MediaType

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/mediatype/applicationswf

Access the static property to get the applicationSwf MediaType. This is used for identifying SWF files.

```swift
static var applicationSwf: `Self` { get }
```

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

### init(client:migrations:groups:logger:dryRun:)

Source: https://docs.hummingbird.codes/2.0/documentation/postgresmigrations/databasemigrationservice/init%28client%3Amigrations%3Agroups%3Alogger%3Adryrun%3A%29

Initializes the DatabaseMigrationService. This function sets up the service with a PostgreSQL client, a set of database migrations to apply, an optional list of migration groups, a logger instance, and a flag to indicate if it's a dry run.

```APIDOC
## init(client:migrations:groups:logger:dryRun:)

### Description
Initializes the DatabaseMigrationService with the provided configuration.

### Method
Initializer

### Parameters
#### Path Parameters
- **client** (PostgresClient) - Required - The PostgreSQL client instance to use for database operations.
- **migrations** (DatabaseMigrations) - Required - The collection of database migrations to be applied.
- **groups** ([DatabaseMigrationGroup]) - Optional - A list of specific migration groups to apply. Defaults to an empty list if not provided.
- **logger** (Logger) - Required - An instance of a logger for recording migration events and errors.
- **dryRun** (Bool) - Required - A boolean flag. If true, the service will simulate the migration process without making any actual changes to the database.
```

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

### Get applicationPptx MediaType

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/mediatype/applicationpptx

Access the static property to get the applicationPptx MediaType. This is used to identify PowerPoint files.

```swift
static var applicationPptx: `Self` { get }
```

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

### Initialize Postgres Job Queue

Source: https://docs.hummingbird.codes/2.0/documentation/jobspostgres

Sets up the Postgres job queue driver with client, migrations, configuration, and logger. Ensure PostgresNIO and PostgresMigrations are imported.

```swift
import JobsPostgres
import PostgresNIO
import ServiceLifecycle


let postgresClient = PostgresClient(...)
let postgresMigrations = DatabaseMigrations()
let jobQueue = JobQueue(
    .postgres(
        client: postgresClient,
        migrations: postgresMigrations,
        configuration: .init(
            pollTime: .milliseconds(50),
            queueName: "MyJobQueue"
        ),
        logger: logger
    ), 
    logger: logger
)

```

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

### Curl Response Example

Source: https://docs.hummingbird.codes/2.0/tutorials/hummingbird/todos-1-template

Example output from curl showing a successful HTTP 200 response with 'Hello!' content.

```http
HTTP/1.1 200 OK
Content-Type: text/plain; charset=utf-8
Content-Length: 6
Date: Mon, 05 Jan 2026 11:29:04 GMT
Server: template


Hello!
```

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

### Define GET Route

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/routermethods

Defines a GET route for a specific path. The route is handled by an asynchronous closure that returns a `ResponseGenerator`.

```swift
func get(_: RouterPath, use: @Sendable (Request, Context) async throws -> some ResponseGenerator) -> Self
```

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

### Initialize and Apply Migrations for PostgresJobQueue

Source: https://docs.hummingbird.codes/2.0/documentation/jobspostgres/postgresjobqueue

Demonstrates how to initialize the PostgresJobQueue and apply database migrations before the server starts. Ensure migrations are applied to build the necessary database tables.

```swift
let migrations = PostgresMigrations()
let jobqueue = await JobQueue(
    PostgresQueue(
        client: postgresClient,
        migrations: postgresMigrations,
        configuration: configuration,
        logger: logger
   ),
   numWorkers: numWorkers,
   logger: logger
)
var app = Application(...)
app.beforeServerStarts {
    try await migrations.apply(client: postgresClient, logger: logger, dryRun: applyMigrations)
}
```

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

### Get applicationDocx MediaType

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/mediatype/applicationdocx

Access the static property to get the application/docx MediaType instance. This is used to identify Word documents.

```swift
static var applicationDocx: `Self` { get }
```

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

### init()

Source: https://docs.hummingbird.codes/2.0/documentation/postgresmigrations/databasemigrations/init%28%29

Initializes a DatabaseMigrations object.

```APIDOC
## init()

### Description
Initialize a DatabaseMigrations object.

### Method
N/A (This is a constructor or initialization method)

### Endpoint
N/A

### Parameters
N/A

### Request Example
```
init()
```

### Response
N/A (Initialization typically modifies internal state or returns an instance)

```

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

### Install PostgreSQL using Homebrew

Source: https://docs.hummingbird.codes/2.0/tutorials/hummingbird/todos-4-postgres

Installs PostgreSQL on macOS using the Homebrew package manager. This command is typically run in the terminal.

```bash
brew install postgresql
```

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

### setup(channel:logger:)

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdcore/http1channel/setup%28channel%3Alogger%3A%29

Sets up a child channel for HTTP1 communication. It takes a channel and a logger as input and returns an EventLoopFuture containing the object to process input/output on the child channel.

```APIDOC
## setup(channel:logger:)

### Description
Sets up a child channel for HTTP1.

### Method Signature
```swift
func setup(
    channel: any Channel,
    logger: Logger
) -> EventLoopFuture<Value>
```

### Parameters
#### channel
Child channel

#### logger
Logger used during setup

### Return Value
Object to process input/output on child channel
```

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

### Live Server Setup for Testing

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdtesting/testingsetup/live

Use this static property to set up a live server for testing. It establishes a single connection to the server and supports only HTTP1. Note that the client is single-threaded; use `.ahc(_:)` for multi-threaded execution.

```swift
static var live: TestingSetup { get }
```

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

### starts(with:by:) Method Signature

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/routerpath/starts%28with%3Aby%3A%29

This is the method signature for starts(with:by:) as inherited from Sequence. It takes a possible prefix and a closure to determine equivalence between elements.

```swift
func starts<PossiblePrefix>(
    with possiblePrefix: PossiblePrefix,
    by areEquivalent: (Self.Element, PossiblePrefix.Element) throws -> Bool
) rethrows -> Bool where PossiblePrefix : Sequence
```

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

### init(client:migrations:tidyUpFrequency:logger:)

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdpostgres/postgrespersistdriver/init%28client%3Amigrations%3Atidyupfrequency%3Alogger%3A%29

Initializes the PostgresPersistDriver with the necessary components for database persistence and migration management.

```APIDOC
## init(client:migrations:tidyUpFrequency:logger:)

### Description
Initializes the PostgresPersistDriver.

### Method
`init`

### Parameters
#### Path Parameters
- **client** (PostgresClient) - Required - Postgres client
- **migrations** (DatabaseMigrations) - Required - `DatabaseMigrations` array to add persist migrations
- **tidyUpFrequency** (Duration) - Optional - How frequently cleanup expired database entries should occur. Defaults to `.seconds(600)`.
- **logger** (Logger) - Required - Logger used by persist
```

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

### starts(with:)

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/routerpath/starts%28with%3A%29

Checks if the RouterPath starts with a given possible prefix. This method is inherited from `Sequence.starts(with:)` and requires that the element type conforms to `Equatable`.

```APIDOC
## starts(with:)

### Description
Checks if the sequence begins with the elements of a given sequence.

### Method Signature
```swift
func starts<PossiblePrefix>(with possiblePrefix: PossiblePrefix) -> Bool where PossiblePrefix : Sequence, Self.Element == PossiblePrefix.Element
```

### Constraints
Available when `Element` conforms to `Equatable`.
```

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

### setup(channel:logger:)

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdwebsocket/http1websocketupgradechannel/setup%28channel%3Alogger%3A%29

Sets up a channel to accept HTTP1 with a WebSocket upgrade. This method is part of the HTTP1WebSocketUpgradeChannel in HummingbirdWebSocket.

```APIDOC
## setup(channel:logger:)

### Description
Setup channel to accept HTTP1 with a WebSocket upgrade.

### Signature
```swift
func setup(
    channel: Channel,
    logger: Logger
) -> EventLoopFuture<Value>
```

### Parameters
#### Path Parameters
- **channel** (Channel) - Child channel
- **logger** (Logger) - Logger used by upgrade

### Return Value
Negotiated result future
```

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

### init(fileProvider:urlBasePath:cacheControl:searchForIndexHtml:)

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/filemiddleware/init%28fileprovider%3Aurlbasepath%3Acachecontrol%3Asearchforindexhtml%3A%29

Creates a FileMiddleware instance with a custom FileProvider, allowing configuration of URL base path, cache control, and index.html searching.

```APIDOC
## init(fileProvider:urlBasePath:cacheControl:searchForIndexHtml:)

### Description
Create FileMiddleware using custom `FileProvider`.

### Parameters

`fileProvider`

File provider

`urlBasePath`

Prefix to remove from request URL

`cacheControl`

What cache control headers to include in response

`searchForIndexHtml`

Should we look for index.html in folders
```

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

### Define Processes to Run Before Server Start

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/application/processesrunbeforeserverstart

This property accepts a closure that returns Void asynchronously and can throw errors. It is executed before the server starts.

```swift
var processesRunBeforeServerStart: [@Sendable () async throws -> Void] { get }
```

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

### Query All Kittens using GET

Source: https://docs.hummingbird.codes/2.0/tutorials/hummingbird/mongokitten-1-setup

This curl command retrieves a list of all kittens currently stored in the database. It sends a GET request to the /kittens endpoint.

```bash
> curl -i localhost:8080/kittens

```

```bash
> curl -i localhost:8080/kittens

```

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

### Set up Fluent with SQLite and a Basic Route

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdfluent

Configure a Fluent instance with an SQLite database and set up a router to fetch a Todo item by ID. This snippet demonstrates basic ORM integration.

```swift
let fluent = Fluent()
// add sqlite database
fluent.databases.use(.sqlite(.file("db.sqlite")), as: .sqlite)


// add router with one route to return a Todo type
let router = Router()
router.get("todo/{id}") { request, context in
    let id = try await context.parameters.require("id", as: UUID.self)
    return Todo.find(id, on: fluent.db())
}


var app = Application(router: router)
// add fluent as a service to manage its lifecycle
app.addServices(fluent)
try await app.runService()

```

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

### Create GET Route with RouteBuilder

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdrouter/get%28_%3Abuilder%3A%29

Use this function to define a GET route using the `RouteBuilder` result builder. It allows for the construction of route middleware.

```swift
func Get<M0, Context>(
    _ routerPath: RouterPath = "",
    @RouteBuilder<Context> builder: () -> M0
) -> Route<_RouteHandlerMiddleware<M0>, Context> where M0 : MiddlewareProtocol, Context : RouterRequestContext, Context == M0.Context, M0.Input == Request, M0.Output == Response
```

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

### dotEnv(_:)

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/environment/dotenv%28_%3A%29

Creates an Environment instance initialized from a specified .env file. Defaults to '.env' if no path is provided.

```APIDOC
## dotEnv(_:)

### Description
Create Environment initialised from the `.env` file

### Method Signature
```swift
static func dotEnv(_ dotEnvPath: String = ".env") async throws -> Environment
```

### Parameters
#### Path Parameters
- **dotEnvPath** (String) - Optional - The path to the `.env` file. Defaults to ".env".
```

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

### Expected Section End Error Example

Source: https://docs.hummingbird.codes/2.0/documentation/mustache/mustachetemplate/error/expectedsectionend

This example demonstrates the syntax that triggers the expectedSectionEnd error in Mustache templates. Ensure all sections are properly closed.

```mustache
case expectedSectionEnd
```

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

### Setup Valkey Job Queue

Source: https://docs.hummingbird.codes/2.0/documentation/jobsvalkey

Initializes the Valkey job queue with a specific client and configuration including queue name and polling time.

```swift
import JobsValkey
import ServiceLifecycle
import Valkey


let valkeyClient = ValkeyClient(...)
let jobQueue = JobQueue(
    .valkey(
        valkeyClient,
        configuration: .init(
            queueName: "MyJobQueue",
            pollTime: .milliseconds(50)
        )
    ), 
    logger: logger
)

```

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

### Illegal Token in Inherit Section Example

Source: https://docs.hummingbird.codes/2.0/documentation/mustache/mustachetemplate/error/illegaltokeninsideinheritsection

This example demonstrates a case where an illegal token is present within an inherit section of a Mustache template, leading to an error.

```mustache
case illegalTokenInsideInheritSection
```

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

### Apply Migrations Before Server Starts

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/migrationsguide

Apply migrations using the `beforeServerStarts` hook to ensure the database is ready before the server accepts connections. Use `dryRun: true` for a supervised check.

```swift
var app = Application(router: router)
// add postgres client as a service to ensure it is active
app.addServices(postgresClient)
app.beforeServerStarts {
    try await migrations.apply(client: postgresClient, logger: logger, dryRun: true)
}
```

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

### init(router:server:configuration:services:onServerRunning:eventLoopGroupProvider:logger:)

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/application/init%28router%3Aserver%3Aconfiguration%3Aservices%3Aonserverrunning%3Aeventloopgroupprovider%3Alogger%3A%29

Initializes a new Hummingbird Application instance. This is the primary entry point for setting up your web server.

```APIDOC
## init(router:server:configuration:services:onServerRunning:eventLoopGroupProvider:logger:)

### Description
Initialize new Application

### Parameters

`router`
    
Router used to generate responses from requests

`server`
    
Server child channel setup (http1, http2, http1WithWebSocketUpgrade etc)

`configuration`
    
Application configuration

`services`
    
List of Services for Application to add to its internal ServiceGroup

`onServerRunning`
    
Function called once the server is running

`eventLoopGroupProvider`
    
Where to get our EventLoopGroup

`logger`
    
Logger application uses
```

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

### Add a process to run before server starts

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbird/application/beforeserverstarts%28perform%3A%29

Use this method to register a process that needs to run before the server has started. The process is a closure that can perform asynchronous operations.

```swift
mutating func beforeServerStarts(perform process: @escaping @Sendable () async throws -> Void)
```

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

### GET Request with Headers

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdtesting/testclient/get%28_%3Aheaders%3A%29

Use this method to perform an HTTP GET request to a specified URI, optionally including custom headers. The default value for headers is an empty dictionary.

```swift
func get(
    _ uri: String,
    headers: HTTPFields = [:]) async throws -> TestClient.Response
```

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

### Configure Hummingbird Project

Source: https://docs.hummingbird.codes/2.0/tutorials/hummingbird/fluent-1-galaxy

Run the configure script to set up your new project. Press return to accept default values for package name, executable name, and VS Code snippets.

```bash
> ./template/configure.sh TodosFluent
Enter your package name: [TodosFluent] > 
Enter your executable name: [App] > 
Include Visual Studio Code snippets: [Y/n] > 

```

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

### Create GET Route with Handler Closure

Source: https://docs.hummingbird.codes/2.0/documentation/hummingbirdrouter/handle

Creates a GET Route using a closure as the handler. The handler takes a Request and Context, and returns a RouteOutput. Ensure the handler is Sendable.

```swift
func Get<RouteOutput, Context>(RouterPath, handler: @Sendable (Request, Context) async throws -> RouteOutput) -> Route<_RouteHandlerClosure<RouteOutput, Context>, Context>
```
Tokens:
Raw