crooner

Kind	kit
Capabilities	http file
Categories	web network
Keywords	web framework http server routing sinatra

A Sinatra-inspired web framework for Kit

Files

File	Description
`.editorconfig`	Editor formatting configuration
`.gitignore`	Git ignore rules for build artifacts and dependencies
`.tool-versions`	asdf tool versions (Zig, Kit)
`LICENSE`	MIT license file
`README.md`	This file
`examples/components-demo.kit`	Example: components demo
`examples/csrf-protection.kit`	Example: csrf protection
`examples/filters.kit`	Example: filters
`examples/hello.kit`	Example: hello
`examples/htmx/htmx-demo.kit`	Example: htmx demo
`examples/htmx/public/style.css`	style.css
`examples/http.kit`	Example: http
`examples/middleware.kit`	Example: middleware
`examples/public/app.js`	app.js
`examples/public/style.css`	style.css
`examples/simple-server.kit`	Example: simple server
`examples/static-files.kit`	Example: static files
`examples/tcp.kit`	Example: tcp
`examples/welcome-test.kit`	Example: welcome test
`kit.toml`	Package manifest with metadata and dependencies
`src/components.kit`	Module for components
`src/main.kit`	Crooner error type for typed error handling.
`src/request.kit`	Create an empty request record.
`src/response.kit`	Get the standard text description for an HTTP status code.
`src/router.kit`	Module for router
`src/server.kit`	Module for server
`tests/components.test.kit`	Tests for components
`tests/crooner.test.kit`	Tests for crooner

Architecture

Request Lifecycle

sequenceDiagram participant Client participant Server participant Router participant Middleware participant Handler Client->>Server: HTTP Request Server->>Router: Match Route Router->>Middleware: Before Filters Middleware->>Handler: Route Handler Handler->>Middleware: Response Middleware->>Server: After Filters Server->>Client: HTTP Response

Module Structure

graph TD A[main.kit] --> B[server.kit] A --> C[router.kit] A --> D[request.kit] A --> E[response.kit] A --> F[components.kit] B --> G[TCP/HTTP] F --> H[template]

Dependencies

logging
template

Installation

kit add gitlab.com/kit-lang/packages/kit-crooner.git

Usage

import Kit.Crooner

License

MIT License - see LICENSE for details.

Exported Functions & Types

`CroonerError`

Crooner error type for typed error handling. Variants distinguish between different failure modes.

Variants

CroonerServerError {message}

CroonerConnectionError {message}

CroonerRouteError {message}

CroonerRequestError {message}

`app`

Create a Crooner application with default configuration.

Returns a new application record with empty routes, error handlers, and filters, and a default compact-format logger.

() -> App

app = Crooner.app
  |> Crooner.get "/" fn(req) => {body: "Hello!"}

`app-with-options`

Create a Crooner application with custom logger configuration.

Allows customization of the logger format and request event logging. Supported formats are from the Logging module (CompactFmt, JsonFmt, etc.).

{logger-format: LogFormat, request-events: Bool} -> App

# Enable request events for detailed request logging
app = Crooner.app-with-options {request-events: true}

# Combine with JSON format for production
app = Crooner.app-with-options {logger-format: :json, request-events: true}

`with-logger`

Set or replace the logger on an existing app.

Useful for integrating a custom logger or changing logging configuration after app creation.

App -> Logger -> App

custom-logger = make-default-logger my-config
app = Crooner.app |> Crooner.with-logger custom-logger

`with-request-events`

Enable request-scoped event logging.

When enabled, each request gets a Logging event attached to req.event that accumulates context throughout the request lifecycle. Handlers and filters can add fields to the event, and a single comprehensive log entry is emitted after the response is sent.

App -> App

app = Crooner.app |> Crooner.with-request-events

# In your handler, access the event:
handler = fn(req) =>
  req.event |> Map.insert "user-id" 42
  {status: 200, body: "OK"}

`with-event-format`

Set the format for request event logging.

Controls how request events are formatted when emitted. Use this to match the event format to your application's logging style.

App -> LogFormat -> App

app = Crooner.app
  |> Crooner.with-logger my-logger
  |> Crooner.with-event-format :pretty
  |> Crooner.with-request-events

`get`

Registers a handler function for HTTP GET requests matching the pattern. Patterns can include path parameters using :name syntax.