Mike

https://ire4ever1190.github.io/mike/stable/
Admin
Mike is a lightweight web framework for building small applications and APIs in Nim with intuitive...
Tokens:61,845
Snippets:481
Trust Score:8.3
Update:7 months ago
Show doc for...
Tokens:
Raw
### Basic Routing with GET and POST in Mike

Source: https://ire4ever1190.github.io/mike/stable/mike.html

Demonstrates how to define basic routes for GET and POST requests using the Mike framework. It shows how to import the library, define handlers for specific paths and verbs, and start the server. The `ctx` variable is implicitly available for accessing request and response details.

```nim
import mike
"/hello" -> get:
  # `ctx` is an implicit variable that provides access to the
  # request/response
  ctx.send "Hello!"

"/data" -> post:
  echo ctx.body

run() # This starts the server. You can specify the port
```

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

### Start Mike Server

Source: https://ire4ever1190.github.io/mike/stable/mike/dsl.html

Starts the Mike web server. This procedure should be called after all routes and middleware have been configured. It accepts optional parameters for port, threads, and bind address.

```nim
proc run(port: int = 8080; threads: Natural = 0; bindAddr: string = "0.0.0.0") {. ...gcsafe, raises: [Exception, OSError, ValueError, KeyError], tags: [RootEffect, WriteIOEffect, ReadIOEffect, TimeEffect], forbids: [].}
```

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

### Start Streaming

Source: https://ire4ever1190.github.io/mike/stable

Initiates a streaming response.

```APIDOC
## POST /start-streaming

### Description
Begins sending the response body as a stream, allowing for continuous data transfer.

### Method
POST

### Endpoint
/start-streaming

### Parameters
#### Request Body
- **ctx** (Context) - Required - The request context.
- **contentLength** (int) - Optional - The total length of the content if known.

### Request Example
```json
{
  "ctx": "<context_object>",
  "contentLength": 1024
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates success or failure of the operation.

#### Response Example
```json
{
  "status": "success"
}
```
```

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

### Define Parameter Start Character

Source: https://ire4ever1190.github.io/mike/stable/mike/router.html

Defines the character ':' used to indicate the start of a dynamic parameter in a URL path. For example, '/users/:id'.

```nim
paramStart = ':'
```

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

### Define Route Parameter Start Constant

Source: https://ire4ever1190.github.io/mike/stable/theindex.html

Declares `paramStart` as a constant within the router module. This might indicate the starting marker for route parameters.

```nim
const paramStart
```

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

### Example Usage of urlForm

Source: https://ire4ever1190.github.io/mike/stable/mike/bodyParsers/form.html

Demonstrates how to use the urlForm procedure to access form parameters in a web request handler. It shows how to retrieve a 'name' parameter from the parsed form data for both GET and POST requests.

```nim
import mike

"/form" -> get:
  let form = ctx.urlForm
  ctx.send form["name"]

"/form" -> post: # Works for POST requests also
  let form = ctx.urlForm
  ctx.send form["name"]
```

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

### Start Server-Sent Events (SSE)

Source: https://ire4ever1190.github.io/mike/stable

Initiates a Server-Sent Events stream.

```APIDOC
## POST /start-sse

### Description
Establishes a connection for sending Server-Sent Events (SSE) from the server to the client.

### Method
POST

### Endpoint
/start-sse

### Parameters
#### Request Body
- **ctx** (Context) - Required - The request context.
- **retry** (int) - Optional - The reconnection time in milliseconds (defaults to 3000).

### Request Example
```json
{
  "ctx": "<context_object>",
  "retry": 5000
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates success or failure of the operation.

#### Response Example
```json
{
  "status": "success"
}
```
```

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

### Start Streaming

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers/context.html

Sends the initial headers and prepares the client for streaming content. Optionally allows specifying the content length.

```APIDOC
## POST /websites/ire4ever1190_github_io_mike_stable/startStreaming

### Description
Sends everything but the body to the client. Allows you to start streaming content to the client.

### Method
POST

### Endpoint
/websites/ire4ever1190_github_io_mike_stable/startStreaming

### Parameters
#### Path Parameters
- **ctx** (Context) - Required - The context object for the request.
- **contentLength** (integer) - Optional - The total length of the content to be streamed.

### Request Example
```json
{
  "ctx": "<context_object>",
  "contentLength": 1024
}
```

### Response
#### Success Response (200)
This endpoint does not return a specific response body upon success, but it prepares for streaming.

#### Response Example
(No specific response body example, prepares for streaming)
```

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

### Start Server-Sent Events (SSE)

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers.html

Allows you to start sending server-sent events to the client. Includes an option to set the reconnection retry interval.

```APIDOC
## POST /websites/ire4ever1190_github_io_mike_stable/startSSE

### Description
Allows you to start sending server-sent events to the client. Includes an option to set the reconnection retry interval.

### Method
POST

### Endpoint
/websites/ire4ever1190_github_io_mike_stable/startSSE

### Parameters
#### Path Parameters
None

#### Query Parameters
- **retry** (integer) - Optional - How quickly in milliseconds the client should try and reconnect. Defaults to 3000ms.

#### Request Body
None

### Request Example
```json
{
  "retry": 5000
}
```

### Response
#### Success Response (200)
- **message** (string) - Indicates successful start of SSE.

#### Response Example
```json
{
  "message": "Server-Sent Events started successfully."
}
```
```

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

### Start Chunking Response

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers.html

Allows you to start sending chunks back to the client. Use this if streaming a large response to the client.

```APIDOC
## POST /websites/ire4ever1190_github_io_mike_stable/startChunking

### Description
Allows you to start sending chunks back to the client. Use this if streaming a large response to the client.

### Method
POST

### Endpoint
/websites/ire4ever1190_github_io_mike_stable/startChunking

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{}
```

### Response
#### Success Response (200)
- **message** (string) - Indicates successful start of chunking.

#### Response Example
```json
{
  "message": "Chunking started successfully."
}
```
```

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

### Start Streaming Response

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers.html

Sends headers and initiates streaming of content to the client. Allows for specifying the content length.

```APIDOC
## POST /websites/ire4ever1190_github_io_mike_stable/startStreaming

### Description
Sends everything but the body to the client. Allows you to start streaming content to the client.

### Method
POST

### Endpoint
/websites/ire4ever1190_github_io_mike_stable/startStreaming

### Parameters
#### Path Parameters
None

#### Query Parameters
- **contentLength** (integer) - Optional - The total length of the content to be streamed.

#### Request Body
None

### Request Example
```json
{
  "contentLength": 1024
}
```

### Response
#### Success Response (200)
- **message** (string) - Indicates successful start of streaming.

#### Response Example
```json
{
  "message": "Streaming started successfully."
}
```
```

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

### Start Server-Sent Events

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers/context.html

Starts a Server-Sent Events (SSE) stream. Allows configuring the retry interval for the client to reconnect.

```nim
proc startSSE(ctx: Context; retry = 3000)
```

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

### Get Supported Compression Formats

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers/context.html

Returns the supported compression formats for the current request context. This is typically derived from the `Accept-Encoding` header.

```nim
proc supportedCompression(ctx: Context): Option[CompressedDataFormat]
```

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

### Start Chunking

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers/context.html

Allows the initiation of sending response data in chunks to the client, suitable for large responses.

```APIDOC
## POST /websites/ire4ever1190_github_io_mike_stable/startChunking

### Description
Allows you to start sending chunks back to the client. Use this if streaming a large response to the client.

### Method
POST

### Endpoint
/websites/ire4ever1190_github_io_mike_stable/startChunking

### Parameters
#### Path Parameters
- **ctx** (Context) - Required - The context object for the request.

### Request Example
```json
{
  "ctx": "<context_object>"
}
```

### Response
#### Success Response (200)
This endpoint does not return a specific response body upon success, but it enables chunked responses.

#### Response Example
(No specific response body example, enables chunked responses)
```

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

### Start Streaming Response

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers/context.html

Begins a streaming response. Optionally, the total `Content-Length` can be specified.

```nim
proc startStreaming(ctx: Context; contentLength = none(int))
```

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

### Get HTTP Method using helpers and request

Source: https://ire4ever1190.github.io/mike/stable

Retrieves the HTTP method (e.g., GET, POST) of the incoming request. Both 'helpers' and 'request' modules provide this functionality.

```nim
proc httpMethod(ctx: Context): HttpMethod
```

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

### Example Usage of servePublic Macro

Source: https://ire4ever1190.github.io/mike/stable/mike/public.html

Demonstrates how to use the servePublic macro to serve files from the 'public/' directory under the '/static' URL path. It also shows how to rename files, specifically mapping the root path to 'index.html'.

```nim
import mike
servePublic("public/", "/static")
# Files inside public folder are now accessible at static/
# e.g. index.html inside public/ will be at url http://localhost/static/index.html

# You can also rename files so they can be accepted at a different path
servePublic("/", "/static", renames = {
  "": "index.html" # / will return /static/index.html (If no other handler handles it)
})
```

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

### Get Request Range

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers/context.html

Extracts the start and finish values for a requested byte range from the HTTP request headers. Returns an Option[int] tuple for start and finish.

```nim
proc requestRange(ctx: Context): tuple[start, finish: Option[int]]
```

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

### Get Supported Compression

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers/context.html

Retrieves information about the compression formats supported by the current context. Returns 'none' if no compression is supported.

```APIDOC
## GET /websites/ire4ever1190_github_io_mike_stable/supportedCompression

### Description
Returns the compression that is supported by the context. If it doesn't support any compression then `none` is returned.

### Method
GET

### Endpoint
/websites/ire4ever1190_github_io_mike_stable/supportedCompression

### Parameters
#### Path Parameters
- **ctx** (Context) - Required - The context object for the request.

### Request Example
```json
{
  "ctx": "<context_object>"
}
```

### Response
#### Success Response (200)
- **Option[CompressedDataFormat]** - The supported compression format, or 'none' if none are supported.

#### Response Example
```json
{
  "supportedCompression": "gzip"
}
```
OR
```json
{
  "supportedCompression": "none"
}
```
```

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

### Run Server Procedure

Source: https://ire4ever1190.github.io/mike/stable/theindex.html

Defines a `run` procedure to start the web server. It accepts optional port, threads, and bind address configurations.

```nim
proc run(port: int = 8080; threads: Natural = 0; bindAddr: string = "0.0.0.0")
```

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

### Start Chunking

Source: https://ire4ever1190.github.io/mike/stable

Initiates chunked transfer encoding for the response.

```APIDOC
## POST /start-chunking

### Description
Begins sending the response body in chunks, typically used for large responses or streaming data.

### Method
POST

### Endpoint
/start-chunking

### Parameters
#### Request Body
- **ctx** (Context) - Required - The request context.

### Request Example
```json
{
  "ctx": "<context_object>"
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates success or failure of the operation.

#### Response Example
```json
{
  "status": "success"
}
```
```

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

### Start Server-Sent Events (SSE)

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers/context.html

Initiates sending Server-Sent Events (SSE) to the client. Allows configuration of the reconnection retry interval.

```APIDOC
## POST /websites/ire4ever1190_github_io_mike_stable/startSSE

### Description
Allows you to start sending server sent events to the client.

### Method
POST

### Endpoint
/websites/ire4ever1190_github_io_mike_stable/startSSE

### Parameters
#### Path Parameters
- **ctx** (Context) - Required - The context object for the request.
- **retry** (integer) - Optional - How quickly in milliseconds the client should try and reconnect. Defaults to 3000.

### Request Example
```json
{
  "ctx": "<context_object>",
  "retry": 5000
}
```

### Response
#### Success Response (200)
This endpoint does not return a specific response body upon success, but it initiates SSE communication.

#### Response Example
(No specific response body example, initiates SSE communication)
```

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

### startSSE

Source: https://ire4ever1190.github.io/mike/stable/theindex.html

Starts Server-Sent Events (SSE) with an optional retry interval.

```APIDOC
## startSSE

### Description
Starts Server-Sent Events (SSE) with an optional retry interval.

### Method
Not Applicable (Procedure Overloads)

### Endpoint
Not Applicable (Procedure Overloads)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```nim
startSSE(ctx, retry = 5000)
```

### Response
#### Success Response (200)
Starts SSE.

#### Response Example
None
```

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

### Use 'name' pragma for Header Parameter Mapping

Source: https://ire4ever1190.github.io/mike/stable/mike/ctxhooks.html

Demonstrates how to use the 'name' pragma in Nim to map a handler parameter to a different header name. This example maps the 'auth' parameter to the 'Authorization' header.

```nim
import mike/ctxhooks
import mike

"/people" -> get(auth {.name: "Authorization".}: Header[string]):
  echo auth
  ctx.send "Something"
```

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

### Get All Request Headers using helpers and request

Source: https://ire4ever1190.github.io/mike/stable

Retrieves all headers from the request context as an HttpHeaders object. This provides a convenient way to access all header key-value pairs. Both 'helpers' and 'request' modules implement this.

```nim
proc headers(ctx: Context): HttpHeaders
```

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

### Start Response Chunking

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers/context.html

Initiates chunked transfer encoding for the response. This allows sending the response body in multiple parts without knowing the total size beforehand.

```nim
proc startChunking(ctx: Context)
```

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

### startStreaming

Source: https://ire4ever1190.github.io/mike/stable/theindex.html

Starts a streaming response with an optional content length.

```APIDOC
## startStreaming

### Description
Starts a streaming response with an optional content length.

### Method
Not Applicable (Procedure Overloads)

### Endpoint
Not Applicable (Procedure Overloads)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```nim
startStreaming(ctx, contentLength = 1024)
```

### Response
#### Success Response (200)
Starts streaming.

#### Response Example
None
```

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

### Range Request Information

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers/context.html

Retrieves the start and end positions for a range request.

```APIDOC
## GET /requestRange

### Description
Returns start and end positions for a range request. Range requests are still valid if either start or finish don't exist. But if both don't exist then the request is invalid. This currently only supports single range requests.

### Method
GET

### Endpoint
/requestRange

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **start** (Option[int]) - The start position of the range, if specified.
- **finish** (Option[int]) - The finish position of the range, if specified.

#### Response Example
```json
{
  "start": {"value": 0},
  "finish": {"value": 100}
}
```
```

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

### Get Handler Information using macroutils

Source: https://ire4ever1190.github.io/mike/stable

Retrieves information about a handler, including its path and associated AST nodes (info, body). This is useful for introspection and metaprogramming within the framework.

```nim
proc getHandlerInfo(path: string; info, body: NimNode): HandlerInfo
```

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

### Range Request Handling

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers.html

Retrieves the start and end positions for a range request, which is used for partial content delivery.

```APIDOC
## GET /requestRange

### Description
Returns start and end positions for a range request. Range requests are still valid if either start or finish don't exist. But if both don't exist then the request is invalid. This currently only supports single range requests.

### Method
GET

### Endpoint
/requestRange

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **start** (Option[int]) - The starting position of the range, if specified.
- **finish** (Option[int]) - The ending position of the range, if specified.

#### Response Example
```json
{
  "start": {
    "value": 100
  },
  "finish": {
    "value": 500
  }
}
```
```

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

### Get All Request Headers - Nim

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers/request.html

Retrieves all headers associated with the request. The return type is HttpHeaders.

```nim
proc headers(ctx: Context): HttpHeaders {....raises: [], tags: [], forbids: []}

```

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

### Create New Context in Nim

Source: https://ire4ever1190.github.io/mike/stable/mike/context.html

Creates and returns a new Context object, initialized with the provided Request object. This is the starting point for managing request-specific data.

```nim
proc newContext(req: Request): Context {....raises: [], tags: [], forbids: [].}
```

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

### Authentication Procedures in Mike

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers.html

Provides functions for handling authentication, including Basic authentication, retrieving authentication schemes, and extracting bearer tokens. It also includes a function to get authentication details for manual checking.

```nim
func `$`(x: AuthScheme): string {.inline, ...raises: [], tags: [], forbids: [].}

proc addHeader(ctx: Context; key, value: string) {....raises: [KeyError], tags: [], forbids: [].}

func allowsBody(ctx: Context): bool {.inline, ...raises: [], tags: [], forbids: [].}

proc authScheme(ctx: Context): Option[string] {....raises: [KeyError], tags: [], forbids: [].}

proc basicAuth(ctx: Context; username, password: string; realm = "Enter details"): Authorization {
    ...raises: [UnAuthorisedError, KeyError, BadRequestError, ValueError],
    tags: [], forbids: [].}

proc basicAuthDetails(ctx: Context; realm = "Enter details"): tuple[
    username, password: string] {....raises: [UnAuthorisedError, KeyError,
    BadRequestError, ValueError], tags: [], forbids: [].}

proc bearerToken(ctx: Context): string {
    ...raises: [UnAuthorisedError, KeyError, BadRequestError], tags: [],
    forbids: [].}

func fromRequest[T: AuthScheme](ctx: Context; name: string; _: typedesc[T]): T

func fromRequest[T: Option[AuthScheme]](ctx: Context; name: string;
                                        _: typedesc[T]): T
```

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

### Get Range Request Positions (Nim)

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers.html

Retrieves the start and finish positions for a range request. Range requests are considered valid even if only one of the positions is present. However, if both are missing, the request is invalid. This procedure currently only supports single range requests.

```Nim
proc requestRange(ctx: Context): tuple[start, finish: Option[int]] {
    ...raises: [KeyError, ValueError], tags: [], forbids: [].
}
```

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

### Server Execution

Source: https://ire4ever1190.github.io/mike/stable

Details the procedure for running the web server.

```APIDOC
## Server Execution

### Description
Procedure to start and run the web server.

### Procedure

- **run**
  - **Description**: Starts the web server on the specified port and address.
  - **Parameters**:
    - `port` (int) - The port to listen on (default: 8080).
    - `threads` (Natural) - The number of threads to use (default: 0).
    - `bindAddr` (string) - The address to bind to (default: "0.0.0.0").
```

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

### Get All Request Headers by Key - Nim

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers/request.html

Retrieves all values for a given header key. This is useful when a request might contain multiple headers with the same key. Returns an empty sequence if the header does not exist. May raise a KeyError.

```nim
proc getHeaders(ctx: Context; key: string): seq[string] {....raises: [KeyError],
    tags: [], forbids: []}

```

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

### Multiple HTTP Verb Handling in Mike

Source: https://ire4ever1190.github.io/mike/stable/mike.html

Shows how to assign multiple HTTP verbs to a single route declaration in Mike using square brackets. It also demonstrates how to use `any` for a verb to match all HTTP methods and how to apply `before` handlers to multiple verbs.

```nim
import mike
"/multihandler" -> [post, get]:
  ctx.send "You sen't either a GET or POST request"
# Can also be used with positions by prefixing the brackets
"/multihandler" -> before[post, get]:
  ctx.send "This is running before the example given before"
```

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

### Implement Custom Form Parsing for DateTime

Source: https://ire4ever1190.github.io/mike/stable/mike/ctxhooks.html

Provides an example of a custom 'fromForm' hook in Nim that parses a string into a 'DateTime' object using a specific format. This hook is then used to handle a 'DateTime' field within a form submission.

```nim
import mike/ctxhooks
import times
import mike

proc fromForm(formVal: string, _: typedesc[DateTime]): DateTime = 
  result = formVal.parse("yyyy-MM-dd")

type
  SomeForm = object
    fullName: string
    dob: DateTime # The hook will be called for this

"/person" -> post(data: Form[SomeForm]):
  echo data
```

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

### Chained Route Handlers (Before, Main, After) in Mike

Source: https://ire4ever1190.github.io/mike/stable/mike.html

Illustrates how to use chained handlers for a single route in Mike. It shows the usage of `before`, main, and `after` handlers, which execute sequentially. If an exception occurs in any handler, the chain stops.

```nim
import mike
# Order of declaration doesn't matter
"/something" -> beforeGet:
  echo "Handler that runs before main handler"

"/something" -> get:
  echo "Main handler for /something"

"/something" -> afterGet:
  echo "Handler that runs after main handler"
```

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

### Get RootRef Data from Context in Nim

Source: https://ire4ever1190.github.io/mike/stable/mike/context.html

Retrieves a RootRef type T from the context. This procedure is used to get custom data that has been added to the context. It returns nil if the data is not found.

```nim
proc `[]`[T: RootRef](ctx: Context; _: typedesc[T]): T

**Example:**
```nim
import mike
type
  Account = ref object of RootObj
    balance: int
    id: string

"/^path" -> beforeGet:
  if ctx.hasHeader("accountID"):
    # Just create default account. This could instead be loaded
    # from the database
    ctx &= Account(
      balance: 9,
      id: ctx.getHeader("accountID")
    )

"/account" -> get:
  let data = ctx[Account]
  if data != nil:
    ctx.send "Hello " & data.id
  else:
    ctx.send(Http404)
```
```

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

### Initialize Cookie using cookies

Source: https://ire4ever1190.github.io/mike/stable

Creates a new cookie with various options, including expiration, domain, path, security flags, and SameSite policy. Supports initialization with or without an expiration date, and with a max age.

```nim
proc initCookie(name, value: string; expires: DateTime; domain = ""; path = "/"; secure = false; httpOnly = false; sameSite = Lax): SetCookie
proc initCookie(name, value: string; domain = ""; path = "/"; secure = false; httpOnly = false; sameSite = Lax): SetCookie
proc initCookie(name, value: string; maxAge: TimeInterval; domain = ""; path = "/"; secure = false; httpOnly = false; sameSite = Lax): SetCookie
```

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

### Retrieve All Request Headers using helpers and request

Source: https://ire4ever1190.github.io/mike/stable

Fetches all values associated with a given header key from the request context. Returns a sequence of strings. Both 'helpers' and 'request' modules offer this capability.

```nim
proc getHeaders(ctx: Context; key: string): seq[string]
```

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

### Get Status

Source: https://ire4ever1190.github.io/mike/stable

Retrieves the HTTP status code of the response.

```APIDOC
## GET /status

### Description
Gets the current HTTP status code associated with the response.

### Method
GET

### Endpoint
/status

### Parameters
#### Query Parameters
- **ctx** (Context) - Required - The request context.

### Request Example
```
GET /status?ctx=<context_object>
```

### Response
#### Success Response (200)
- **HttpCode** - The HTTP status code (e.g., 200, 404, 500).

#### Response Example
```json
{
  "code": 200
}
```
```

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

### Parse Range Request (Nim)

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers/context.html

Extracts the start and finish byte positions from a Range header in an HTTP request. Supports single range requests and returns `Option[int]` for start and finish, indicating validity even if one is missing. An invalid request occurs if both are missing.

```nim
proc requestRange(ctx: Context): tuple[start, finish: Option[int]] {
    ...raises: [KeyError, ValueError], tags: [], forbids: []}


     Returns start and end positions for a range request. Range requests are still valid if either start or finish don't exist. But if both don't exist then the request is invalid. This currently only supports single range requests Source Edit
```

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

### Setting Response Headers and Sending JSON in Mike

Source: https://ire4ever1190.github.io/mike/stable/mike.html

Demonstrates how to set custom headers and send JSON responses using the Mike framework. It shows setting single and multiple header values, and both sending JSON directly and setting it as a response property.

```nim
import mike

"/extraheaders" -> get:
  # You can set headers
  ctx.setHeader("key", "value")
  # We don't call send explicitly but Mike will still send the header

  # Headers can have multiple values associated with them
  ctx.addHeader("key", "Another value")

type
  Person = object
    name: string
    age: int

"/json" -> get:
  let resp = Person(name: "John Doe", age: 42)
  # send has overloads but context itself also has some setters
  # which means you can either send the JSON or just add it to the
  # response while you add other stuff
  ctx.json = resp # This just sets the response but doesn't send it
  ctx.send(resp)  # This sends the response which means you are done
  # Both cases have correct headers set
```

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

### status

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers/response.html

Gets the current HTTP status code of the response.

```APIDOC
## GET /websites/ire4ever1190_github_io_mike_stable/helpers/response/status

### Description
Retrieves the current HTTP status code associated with the response context.

### Method
GET

### Endpoint
/websites/ire4ever1190_github_io_mike_stable/helpers/response/status

### Parameters
#### Path Parameters
None

#### Query Parameters
- **ctx** (Context) - Required - The context object.

### Request Example
```json
{
  "ctx": "<context_object>"
}
```

### Response
#### Success Response (200)
- **status** (HttpCode | int) - The current HTTP status code.

#### Response Example
```json
{
  "status": 200
}
```
```

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

### Advanced Routing with Parameters and Wildcards in Mike

Source: https://ire4ever1190.github.io/mike/stable/mike.html

Explains how to define routes with parameters and wildcards in Mike. It covers `:param` for capturing parts of the URL, `*` for matching entire segments, and `^param` for capturing the rest of the path. Captured parameters are accessible via `ctx.pathParams`.

```nim
import mike
"/person/:id" -> get:
  ctx.send "Person has ID " & ctx.pathParams["id"]

# More contrained matches are matched first
"/person/admin" -> get:
  ctx.send "This is the admin"

# /delete/<anything here>/something would match
"/delete/*/something" -> delete:
  ctx.send "I will delete that"

"/^something" -> get: # This will run before every GET request
  echo "[GET] ", ctx.pathParams["path"]

"/file/^path" -> get:
  await ctx.sendFile ctx.pathParams["path"]
```

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

### Authentication Utilities

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers.html

Procedures for handling authentication schemes and credentials.

```APIDOC
## Authentication Utilities

### Description
Functions to manage authentication schemes, retrieve credentials, and perform authentication checks.

### Procedures

#### `authScheme(ctx: Context): Option[string]`

- **Description**: Returns the authentication scheme used in the request as an `Option[string]`. Raises a `KeyError` if the authentication header is malformed.
- **Method**: N/A (Procedure)
- **Endpoint**: N/A

#### `basicAuth(ctx: Context; username, password: string; realm = "Enter details"): Authorization`

- **Description**: Authenticates the user with HTTP Basic authentication. If authentication fails, it sends back a challenge to authenticate. Use `basicAuthDetails` if you want to manually check username and password.
- **Raises**: `UnAuthorisedError`, `KeyError`, `BadRequestError`, `ValueError`.
- **Example**:
  ```nim
  import mike

  "/admin" -> get:
    discard ctx.basicAuth("admin", "superPassword")
    # If code gets to this point then the user is properly authenticated
  ```
- **Method**: N/A (Procedure)
- **Endpoint**: N/A

#### `basicAuthDetails(ctx: Context; realm = "Enter details"): tuple[username, password: string]`

- **Description**: Gets the username and password details sent with Basic authentication. Use this over `basicAuth` if you want to check details against your own user list.
- **Raises**: `UnAuthorisedError`, `KeyError`, `BadRequestError`, `ValueError`.
- **Example**:
  ```nim
  import mike

  "/user/login" -> get:
    let (username, password) = ctx.basicAuthDetails()
    # We can now go into the DB and check if username matches password
  ```
- **Method**: N/A (Procedure)
- **Endpoint**: N/A

#### `bearerToken(ctx: Context): string`

- **Description**: Returns the bearer token sent in the request. Raises `UnAuthorisedError`, `KeyError`, or `BadRequestError` if the token is missing or malformed.
- **Method**: N/A (Procedure)
- **Endpoint**: N/A

#### `fromRequest[T: AuthScheme](ctx: Context; name: string; _: typedesc[T]): T`

- **Description**: Gets an authentication scheme from the request headers. Raises an exception if no header is passed or the scheme is empty.
- **Method**: N/A (Procedure)
- **Endpoint**: N/A

#### `fromRequest[T: Option[AuthScheme]](ctx: Context; name: string; _: typedesc[T]): T`

- **Description**: Gets an optional authentication scheme from the request headers.
- **Method**: N/A (Procedure)
- **Endpoint**: N/A
```

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

### Get URL Encoded Form Data

Source: https://ire4ever1190.github.io/mike/stable

Parses and retrieves URL-encoded form data from the request context.

```APIDOC
## POST /url-form

### Description
Parses the request body as URL-encoded form data and returns it as a structured object.

### Method
POST

### Endpoint
/url-form

### Parameters
#### Request Body
- **ctx** (Context) - Required - The request context.

### Request Example
```json
{
  "ctx": "<context_object>"
}
```

### Response
#### Success Response (200)
- **URLEncodedForm** - An object containing the parsed key-value pairs from the URL-encoded form data.

#### Response Example
```json
{
  "field1": "value1",
  "field2": "value2"
}
```
```

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

### Get HTTP Status Helper

Source: https://ire4ever1190.github.io/mike/stable

Retrieves the current HTTP status code from the context. Available in helpers and response modules.

```nim
proc status(ctx: Context): HttpCode
```

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

### Send File

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers.html

Responds to a context with a file. Supports range requests if enabled.

```APIDOC
## POST /sendFile

### Description
Responds to a context with a file.
* **allowRanges** : Whether to support range requests. Only use this if there is little processing before sending the file.

### Method
POST

### Endpoint
/sendFile

### Parameters
#### Path Parameters
None

#### Query Parameters
- **filename** (string) - Required - The name of the file to send.
- **dir** (string) - Optional - The directory where the file is located (defaults to ".").
- **headers** (HttpHeaders) - Optional - Additional headers to include.
- **downloadName** (string) - Optional - The name to suggest for download.
- **charset** (string) - Optional - The character set for the file (defaults to "utf-8").
- **bufsize** (int) - Optional - The buffer size for reading the file (defaults to 4096).
- **allowRanges** (bool) - Optional - Whether to allow range requests (defaults to false).

### Request Example
```json
{
  "filename": "report.pdf",
  "dir": "/path/to/files",
  "downloadName": "monthly_report.pdf",
  "allowRanges": true
}
```

### Response
#### Success Response (200)
The content of the specified file is sent to the client.

#### Response Example
(File content)
```

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

### Initialize Handler using router

Source: https://ire4ever1190.github.io/mike/stable

Initializes a handler with a specific path, position, and allowed HTTP verbs. This procedure is part of the routing mechanism.

```nim
proc initHandler[T](handler: T; path: string; pos: HandlerPos; verbs: set[HttpMethod]): Handler[ T]
```

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

### Implementing Custom Data Handling in Mike

Source: https://ire4ever1190.github.io/mike/stable/mike.html

Shows how to pass custom data through the request lifecycle (before, main, after handlers) in Mike. It defines a custom object inheriting from `RootObj` and demonstrates adding and retrieving it from the context.

```nim
import mike
type
  # Our custom object just needs to inherit from RootObj
  Session = ref object of RootObj
    name: string
    doNotTrack: bool

"/^path" -> beforeGet(doNotTrack {.name: "DNT".}: Header[string]):
  let session = Session(
    name: "Bob",
    doNotTrack: doNotTrack == "1"
  )
  # We can then add it to the context like so
  ctx &= session

"/some/page" -> get():
  # We can now get the data back since this is running
  # after the before handler
  let session = ctx[Session]
  if session.doNotTrack:
    echo "Turning off mega spyware...."
  else:
    echo "Spying on every pixel the user looks at"
```

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

### Request Body Access

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers/request.html

Provides functions to get the raw request body or an optional version of it.

```APIDOC
## GET /request/body

### Description
Gets the raw request body from the incoming HTTP request. Returns an empty string if no body is present.

### Method
GET

### Endpoint
/request/body

### Parameters
#### Query Parameters
None

#### Request Body
None

### Response
#### Success Response (200)
- **body** (string) - The raw request body content.

#### Response Example
```json
{
  "body": "This is the request body content."
}
```

## GET /request/optBody

### Description
Returns an optional string representing the request body. This is useful for handling cases where the body might be absent without throwing an error.

### Method
GET

### Endpoint
/request/optBody

### Parameters
#### Query Parameters
None

#### Request Body
None

### Response
#### Success Response (200)
- **optBody** (Option[string]) - An Option containing the request body if present, otherwise None.

#### Response Example
```json
{
  "optBody": "Optional request body content"
}
```
```

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

### Get HTTP Method - Nim

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers/request.html

Retrieves the HTTP method of the request. The return type is HttpMethod.

```nim
proc httpMethod(ctx: Context): HttpMethod {....raises: [], tags: [], forbids: []}

```

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

### Send File

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers/context.html

Responds to a client request with a file. Supports range requests if specified.

```APIDOC
## POST /sendFile

### Description
Responds to a context with a file.
* **allowRanges** : Whether to support range requests. Only use this if there is little processing before sending the file.

### Method
POST

### Endpoint
/sendFile

### Parameters
#### Path Parameters
None

#### Query Parameters
- **filename** (string) - Required - The name of the file to send.
- **dir** (string) - Optional - The directory where the file is located. Defaults to ".".
- **headers** (HttpHeaders) - Optional - Additional headers to include.
- **downloadName** (string) - Optional - The name to suggest for download.
- **charset** (string) - Optional - The character set of the file. Defaults to "utf-8".
- **bufsize** (int) - Optional - The buffer size for reading the file. Defaults to 4096.
- **allowRanges** (bool) - Optional - Whether to allow range requests. Defaults to false.

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **Future[void]** - A future representing the file sending operation.

#### Response Example
None
```

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

### Retrieve Request Headers using helpers and request

Source: https://ire4ever1190.github.io/mike/stable

These procedures fetch specific headers from the request context. Overloads allow fetching a single header value or a default value if the header is not present. Both 'helpers' and 'request' modules provide this functionality.

```nim
proc getHeader(ctx: Context; key: string): string
proc getHeader(ctx: Context; key, default: string): string
```

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

### Serve Public Folder

Source: https://ire4ever1190.github.io/mike/stable

Serves static files from a specified folder, with options for renaming files and enabling/disabling static file serving.

```APIDOC
## servePublic /websites/ire4ever1190_github_io_mike_stable

### Description
Serves static files from a specified folder. Allows renaming of files and configuration of static file serving.

### Method
GET

### Endpoint
/websites/ire4ever1190_github_io_mike_stable

### Parameters
#### Query Parameters
- **folder** (string) - Required - The folder containing the static files.
- **path** (string) - Required - The path to the static file.
- **renames** (array of tuples (string, string)) - Optional - A list of file name renamings.
- **staticFiles** (bool) - Optional - Whether to serve static files (defaults to true if mikeStaticFiles is defined).

### Request Example
```
GET /websites/ire4ever1190_github_io_mike_stable?folder=public&path=index.html&renames=[("old.html","new.html")]
```

### Response
#### Success Response (200)
- **file content** (bytes) - The content of the requested static file.

#### Response Example
```
(Binary content of the file)
```
```

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

### Get Handler Path using macroutils

Source: https://ire4ever1190.github.io/mike/stable

Extracts the path associated with a NimNode representing a handler. This is typically used in conjunction with routing or handler introspection.

```nim
proc getPath(handler: NimNode): string
```

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

### Get HTTP Status Code (Nim)

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers/response.html

Retrieves the current HTTP status code of the response. This function is marked as inline for performance.

```Nim
func status(ctx: Context): HttpCode {.inline, ..."raises": [], "tags": [], "forbids": [].}


     Returns the HTTP status code code of the current response
```

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

### Respond to Request (Nim)

Source: https://ire4ever1190.github.io/mike/stable/mike/response.html

The 'respond' procedure handles sending information back to an HTTP client. It takes a Request object, a Context object, and an optional contentLength as input. This procedure may raise a ValueError.

```nim
proc respond(req: Request; ctx: Context; contentLength = none(int)) {".
    ...raises: [ValueError], tags: [], forbids: [].}
```

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

### Set Content Type

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers/context.html

Sets the 'Content-Type' header based on the provided file name. For example, 'index.html' will set the content type to 'text/html'.

```APIDOC
## POST /websites/ire4ever1190_github_io_mike_stable/setContentType

### Description
Sets the content type to be for a given file name. For example, 'index.html' will set the 'Content-Type' header to 'text/html'.

### Method
POST

### Endpoint
/websites/ire4ever1190_github_io_mike_stable/setContentType

### Parameters
#### Path Parameters
- **ctx** (Context) - Required - The context object for the request.
- **fileName** (string) - Required - The name of the file to determine the content type.

### Request Example
```json
{
  "ctx": "<context_object>",
  "fileName": "index.html"
}
```

### Response
#### Success Response (200)
This endpoint does not return a specific response body upon success, but it modifies the response headers.

#### Response Example
(No specific response body example, header modification is the outcome)
```

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

### Define servePublic Macro for Serving Static Files

Source: https://ire4ever1190.github.io/mike/stable/mike/public.html

This macro serves files from a given folder and path. It allows for optional file renaming and can embed static files into the binary if compiled with specific flags or options.

```nim
macro servePublic(folder, path: static[string];
                  renames: openArray[(string, string)] = [];
                  staticFiles: static[bool] = defined(mikeStaticFiles))
```

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

### Get Request Header - Nim

Source: https://ire4ever1190.github.io/mike/stable/mike/helpers/request.html

Retrieves a specific header value by its key. This function may raise a KeyError if the header is not found.

```nim
proc getHeader(ctx: Context; key: string): string {....raises: [KeyError],
    tags: [], forbids: []}

```

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

### Create New Response in Nim

Source: https://ire4ever1190.github.io/mike/stable/mike/context.html

Creates and returns a new, empty Response object. This procedure is used to initialize a response that will be populated later.

```nim
proc newResponse(): Response {....raises: [], tags: [], forbids: [].}
```

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

### servePublic Macro

Source: https://ire4ever1190.github.io/mike/stable/mike/public.html

The servePublic macro allows you to serve all files within a specified folder. It offers options to include these files directly in your compiled binary, eliminating the need for separate deployment.

```APIDOC
## servePublic Macro

### Description
Serves files requested from a given path. If `staticFiles` is true or the file is compiled with `-d:mikeStaticFiles`, all files are included in the binary.

### Method
Macro

### Endpoint
N/A (Macro)

### Parameters
#### Path Parameters
- **folder** (string) - Required - The folder containing the files to serve.
- **path** (string) - Required - The base path under which the files will be accessible.

#### Query Parameters
None

#### Request Body
None

### Request Example
```
import mike
servePublic("public/", "/static")
# Files inside the public folder are now accessible at /static/
# e.g., index.html inside public/ will be at url http://localhost/static/index.html

servePublic("/", "/static", renames = {
  "": "index.html" # / will return /static/index.html (If no other handler handles it)
})
```

### Response
#### Success Response (200)
Files served from the specified folder.

#### Response Example
(Depends on the files being served)
```

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

### Create and Initialize Cookies with Different Expiration Options

Source: https://ire4ever1190.github.io/mike/stable/mike/cookies.html

Demonstrates how to initialize cookies using the `initCookie` procedure. It covers creating session cookies, cookies with a specific expiration date, and cookies with a maximum age (time interval). These functions are essential for managing cookie lifecycles.

```nim
import mike/cookies

# Create a cookie that expires when user closes the browser
discard initCookie("foo", "bar")

import std/times
# Create a cookie that expires after an hour
discard initCookie("foo", "bar", 1.hours)

# Create a cookie that expires at a certain date
discard initCookie("foo", "bar", "2047-11-03".parse("yyyy-MM-dd"))
```
Tokens:
Raw