crooner

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

A Sinatra-inspired web framework for Kit

Files

File	Description
`kit.toml`	Package manifest with metadata and dependencies
`src/components.kit`	HTML component helpers and template rendering
`src/main.kit`	Main module - exports all public functions and types
`src/request.kit`	HTTP request parsing and headers
`src/response.kit`	HTTP response building and status codes
`src/router.kit`	URL routing with pattern matching and filters
`src/server.kit`	TCP server and HTTP lifecycle management
`tests/components.test.kit`	Tests for HTML component generation
`tests/crooner.test.kit`	Core framework integration tests
`examples/components-demo.kit`	HTML component and template usage
`examples/csrf-protection.kit`	CSRF token validation middleware
`examples/filters.kit`	Before/after filter pipeline demo
`examples/hello.kit`	Minimal "Hello World" web server
`examples/http.kit`	HTTP client request examples
`examples/middleware.kit`	Custom middleware chain setup
`examples/simple-server.kit`	Basic HTTP server with routes
`examples/static-files.kit`	Serving static files from disk
`examples/tcp.kit`	Low-level TCP socket handling
`examples/welcome-test.kit`	Welcome page response test
`LICENSE`	MIT license file

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: Logging.JsonFmt, 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 = Logging.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 |> Logging.add-field "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 Logging.PrettyFmt
  |> Crooner.with-request-events

`get`

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