Index

Modules: mike, mike/bodyParsers/form, mike/bodyParsers/multipart, mike/common, mike/context, mike/cookies, mike/ctxhooks, mike/dsl, mike/errors, mike/helpers, mike/helpers/context, mike/helpers/request, mike/helpers/response, mike/macroutils, mike/public, mike/response, mike/router.

API symbols

`$`:

• cookies: proc `$`(c: SetCookie): string
• helpers: proc `$`(x: AuthScheme): string
• router: proc `$`(nodes: seq[PatternNode]): string

`->`:

• dsl: macro `->`(path: static[string]; info: untyped; body: untyped): untyped
• dsl: macro `->`(error: typedesc[CatchableError]; info, body: untyped)

`==`:

• cookies: proc `==`(a, b: SetCookie): bool
• router: proc `==`(a, b: Handler): bool

`[]`:

• context: proc `[]`[T: RootRef](ctx: Context; _: typedesc[T]): T
• context: proc `[]`[T: Option[ref object]](ctx: Context; _: typedesc[T]): T

add:

• context: proc add[T: RootRef](ctx: Context; data: T)
• cookies: proc add(ctx: Context; c: SetCookie)

addHeader:

• helpers: proc addHeader(ctx: Context; key, value: string)
• response: proc addHeader(ctx: Context; key, value: string)

addMiddleware:

• dsl: macro addMiddleware(path: static[string]; verb: static[HttpMethod]; pos: static[HandlerPos]; handler: AsyncHandler)

allowedCharacters:

• router: const allowedCharacters

allowsBody:

• helpers: proc allowsBody(ctx: Context): bool
• context: proc allowsBody(ctx: Context): bool

AsyncHandler:

• context: type AsyncHandler

AuthScheme:

• helpers: type AuthScheme

authScheme:

• helpers: proc authScheme(ctx: Context): Option[string]

BadRequestError:

• errors: object BadRequestError

basicAuth:

• helpers: proc basicAuth(ctx: Context; username, password: string; realm = "Enter details"): Authorization

basicAuthDetails:

• helpers: proc basicAuthDetails(ctx: Context; realm = "Enter details"): tuple[ username, password: string]

BasicType:

• ctxhooks: type BasicType

bearerToken:

• helpers: proc bearerToken(ctx: Context): string

beenModified:

• helpers: proc beenModified(ctx: Context; modDate: DateTime = now()): bool
• context: proc beenModified(ctx: Context; modDate: DateTime = now()): bool

body:

• helpers: proc body(ctx: Context): string
• request: proc body(ctx: Context): string

checkPathCharacters:

• router: proc checkPathCharacters(path: string): (bool, char)

closed:

• helpers: proc closed(ctx: Context): bool
• context: proc closed(ctx: Context): bool

compare:

• router: proc compare[T](a, b: Handler[T]): int

contains:

• context: proc contains[T: RootRef](ctx: Context; data: typedesc[T]): bool

contentType:

• multipart: proc contentType(mv: MultipartValue): Option[string]

Context:

• context: type Context

Cookie:

• ctxhooks: type Cookie

cookies:

• cookies: proc cookies(ctx: Context): StringTableRef

createAsyncHandler:

• macroutils: proc createAsyncHandler(handler: NimNode; path: string; parameters: seq[ProcParameter]): NimNode

CtxParam:

• ctxhooks: type CtxParam

Data:

• ctxhooks: type Data

ensureCorrectPath:

• router: proc ensureCorrectPath(path: string; checkCharacters: static[bool] = true): string

expectKind:

• macroutils: proc expectKind(n: NimNode; k: NimNodeKind; msg: string)

filename:

• multipart: proc filename(mv: MultipartValue): Option[string]

ForbiddenError:

• errors: object ForbiddenError

Form:

• ctxhooks: type Form

fromForm:

• ctxhooks: proc fromForm(formVal: string; _: typedesc[bool]): bool
• ctxhooks: proc fromForm(formVal: string; _: typedesc[string]): string
• ctxhooks: proc fromForm[T: SomeInteger](formVal: string; _: typedesc[T]): T

fromRequest:

• ctxhooks: proc fromRequest[T: BasicType](ctx: Context; name: string; _: typedesc[Cookie[T]]): T
• ctxhooks: proc fromRequest[T: Option[BasicType]](ctx: Context; name: string; _: typedesc[Cookie[T]]): T
• ctxhooks: proc fromRequest[name: static[string]; T](ctx: Context; n: string; _: typedesc[CtxParam[name, T]]): auto
• ctxhooks: proc fromRequest[T: Option[ref object]](ctx: Context; name: string; _: typedesc[Data[T]]): T
• ctxhooks: proc fromRequest[T: RootRef](ctx: Context; name: string; _: typedesc[Data[T]]): T
• ctxhooks: proc fromRequest[T](ctx: Context; name: string; _: typedesc[Form[Option[T]]]): Option[ T]
• ctxhooks: proc fromRequest[T: object | ref object](ctx: Context; name: string; _: typedesc[Form[T]]): T
• ctxhooks: proc fromRequest[T: BasicType](ctx: Context; name: string; _: typedesc[Header[T]]): T
• ctxhooks: proc fromRequest[T: Option[HeaderTypes]](ctx: Context; name: string; _: typedesc[Header[T]]): T
• ctxhooks: proc fromRequest[T: seq[BasicType]](ctx: Context; name: string; _: typedesc[Header[T]]): T
• ctxhooks: proc fromRequest[T](ctx: Context; name: string; _: typedesc[Json[Option[T]]]): Option[ T]
• ctxhooks: proc fromRequest[T](ctx: Context; name: string; _: typedesc[Json[T]]): T
• ctxhooks: proc fromRequest(ctx: Context; name: string; _: typedesc[Path[string]]): string
• ctxhooks: proc fromRequest[T: SomeNumber](ctx: Context; name: string; _: typedesc[Path[T]]): T
• ctxhooks: proc fromRequest(ctx: Context; name: string; _: typedesc[Query[bool]]): bool
• ctxhooks: proc fromRequest[T](ctx: Context; name: string; _: typedesc[Query[Option[T]]]): Option[ T]
• ctxhooks: proc fromRequest(ctx: Context; name: string; _: typedesc[Query[string]]): string
• ctxhooks: proc fromRequest[T: SomeNumber](ctx: Context; name: string; _: typedesc[Query[T]]): T
• ctxhooks: template fromRequest(ctx: Context; name: string; _: typedesc[Context]): Context
• helpers: proc fromRequest[T: Option[AuthScheme]](ctx: Context; name: string; _: typedesc[T]): T
• helpers: proc fromRequest[T: AuthScheme](ctx: Context; name: string; _: typedesc[T]): T

getHandlerInfo:

• macroutils: proc getHandlerInfo(path: string; info, body: NimNode): HandlerInfo

getHeader:

• helpers: proc getHeader(ctx: Context; key: string): string
• helpers: proc getHeader(ctx: Context; key, default: string): string
• request: proc getHeader(ctx: Context; key: string): string
• request: proc getHeader(ctx: Context; key, default: string): string

getHeaders:

• helpers: proc getHeaders(ctx: Context; key: string): seq[string]
• request: proc getHeaders(ctx: Context; key: string): seq[string]

getPath:

• macroutils: proc getPath(handler: NimNode): string

Greedy:

• router: PatternType.Greedy

greedyMatch:

• router: const greedyMatch

Handler:

• router: object Handler

handleRequestError:

• dsl: method handleRequestError(error: ref Exception; ctx: Context): owned(Future[void])

HandlerInfo:

• macroutils: object HandlerInfo

HandlerPos:

• common: enum HandlerPos

hasBody:

• helpers: proc hasBody(ctx: Context): bool
• request: proc hasBody(ctx: Context): bool

hasHeader:

• helpers: proc hasHeader(ctx: Context; key: string): bool
• request: proc hasHeader(ctx: Context; key: string): bool

Header:

• ctxhooks: type Header

headers:

• helpers: proc headers(ctx: Context): HttpHeaders
• request: proc headers(ctx: Context): HttpHeaders

HeaderTypes:

• ctxhooks: type HeaderTypes

httpDateFormat:

• common: const httpDateFormat

HttpError:

• errors: object HttpError

httpMethod:

• helpers: proc httpMethod(ctx: Context): HttpMethod
• request: proc httpMethod(ctx: Context): HttpMethod

initCookie:

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

initHandler:

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

InternalServerError:

• errors: object InternalServerError

InvalidContentError:

• multipart: object InvalidContentError

Json:

• ctxhooks: type Json

json:

• helpers: proc json(ctx: Context): JsonNode
• helpers: proc json[T](ctx: Context; to: typedesc[T]): T
• request: proc json(ctx: Context): JsonNode
• request: proc json[T](ctx: Context; to: typedesc[T]): T

json=:

• helpers: proc json=[T](ctx: Context; json: T)
• response: proc json=[T](ctx: Context; json: T)

Lax:

• cookies: SameSite.Lax

makeErrorConstructor:

• errors: macro makeErrorConstructor(name: untyped; code: HttpCode): untyped

map:

• router: proc map[T](router: var Router[T]; verbs: set[HttpMethod]; path: string; handler: T; pos = Middle)

MappingError:

• router: object MappingError

match:

• router: proc match[T](handler: Handler[T]; path: string): RoutingResult[T]

maxReadAllBytes:

• helpers: const maxReadAllBytes
• context: const maxReadAllBytes

Middle:

• common: HandlerPos.Middle

multipartForm:

• multipart: proc multipartForm(ctx: Context): Table[string, MultipartValue]

MultipartValue:

• multipart: object MultipartValue

newBadRequestError:

• errors: proc newBadRequestError(msg`gensym5: string): ref BadRequestError

newContext:

• context: proc newContext(req: Request): Context

newForbiddenError:

• errors: proc newForbiddenError(msg`gensym7: string): ref ForbiddenError

newInternalServerError:

• errors: proc newInternalServerError(msg`gensym10: string): ref InternalServerError

newInvalidContentError:

• multipart: proc newInvalidContentError(msg`gensym2: string): ref InvalidContentError

newNotFoundError:

• errors: proc newNotFoundError(msg`gensym8: string): ref NotFoundError

newRangeNotSatisfiableError:

• errors: proc newRangeNotSatisfiableError(msg`gensym9: string): ref RangeNotSatisfiableError

newResponse:

• context: proc newResponse(): Response

newUnAuthorisedError:

• errors: proc newUnAuthorisedError(msg`gensym6: string): ref UnAuthorisedError

None:

• cookies: SameSite.None

NotFoundError:

• errors: object NotFoundError

optBody:

• helpers: proc optBody(ctx: Context): Option[string]
• request: proc optBody(ctx: Context): Option[string]

Param:

• router: PatternType.Param

paramStart:

• router: const paramStart

partMatch:

• router: const partMatch

Path:

• ctxhooks: type Path

pathSeparator:

• router: const pathSeparator

PatternNode:

• router: object PatternNode

PatternType:

• router: enum PatternType

Post:

• common: HandlerPos.Post

Pre:

• common: HandlerPos.Pre

ProblemResponse:

• errors: object ProblemResponse

ProcParameter:

• macroutils: object ProcParameter

Query:

• ctxhooks: type Query

RangeNotSatisfiableError:

• errors: object RangeNotSatisfiableError

rearrange:

• router: proc rearrange[T](router: var Router[T])

redirect:

• helpers: proc redirect(ctx: Context; url: string; code = Http307)
• response: proc redirect(ctx: Context; url: string; code = Http307)

replace:

• context: proc replace[T: RootRef](ctx: Context; data: T)

requestRange:

• helpers: proc requestRange(ctx: Context): tuple[start, finish: Option[int]]
• context: proc requestRange(ctx: Context): tuple[start, finish: Option[int]]

respond:

• response: proc respond(req: Request; ctx: Context; contentLength = none(int))

Response:

• context: type Response

route:

• router: iterator route[T](router: Router[T]; verb: HttpMethod; url: sink string; foundMain: var bool): RoutingResult[T]

Router:

• router: object Router

RoutingResult:

• router: object RoutingResult

run:

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

SameSite:

• cookies: enum SameSite

send:

• helpers: proc send(ctx: Context; code: HttpCode; extraHeaders: HttpHeaders = nil)
• helpers: proc send(ctx: Context; prob: ProblemResponse; extraHeaders: HttpHeaders = nil)
• helpers: proc send(ctx: Context; json: sink JsonNode; code = Http200; extraHeaders: HttpHeaders = nil)
• helpers: proc send(ctx: Context; body: sink string; code: HttpCode; extraHeaders: HttpHeaders = nil)
• helpers: proc send(ctx: Context; body: sink string; extraHeaders: HttpHeaders = nil)
• helpers: proc send[T: object | ref object | array | seq | set](ctx: Context; obj: sink T; code = Http200; extraHeaders: HttpHeaders = nil)
• context: proc send(ctx: Context; code: HttpCode; extraHeaders: HttpHeaders = nil)
• context: proc send(ctx: Context; prob: ProblemResponse; extraHeaders: HttpHeaders = nil)
• context: proc send(ctx: Context; json: sink JsonNode; code = Http200; extraHeaders: HttpHeaders = nil)
• context: proc send(ctx: Context; body: sink string; code: HttpCode; extraHeaders: HttpHeaders = nil)
• context: proc send(ctx: Context; body: sink string; extraHeaders: HttpHeaders = nil)
• context: proc send[T: object | ref object | array | seq | set](ctx: Context; obj: sink T; code = Http200; extraHeaders: HttpHeaders = nil)

sendChunk:

• helpers: proc sendChunk(ctx: Context; data: sink string)
• context: proc sendChunk(ctx: Context; data: sink string)

sendCompressed:

• helpers: proc sendCompressed(ctx: Context; body: sink string; compression: CompressedDataFormat; code = Http200; extraHeaders: HttpHeaders = nil)
• helpers: proc sendCompressed(ctx: Context; body: sink string; code = Http200; extraHeaders: HttpHeaders = nil)
• context: proc sendCompressed(ctx: Context; body: sink string; compression: CompressedDataFormat; code = Http200; extraHeaders: HttpHeaders = nil)
• context: proc sendCompressed(ctx: Context; body: sink string; code = Http200; extraHeaders: HttpHeaders = nil)

sendEvent:

• helpers: proc sendEvent(ctx: Context; event, data: string)
• context: proc sendEvent(ctx: Context; event, data: string)

sendFile:

• helpers: proc sendFile(ctx: Context; filename: string; dir = "."; headers: HttpHeaders = nil; downloadName = ""; charset = "utf-8"; bufsize = 4096; allowRanges = false): owned(Future[void])
• context: proc sendFile(ctx: Context; filename: string; dir = "."; headers: HttpHeaders = nil; downloadName = ""; charset = "utf-8"; bufsize = 4096; allowRanges = false): owned(Future[void])

sendPartial:

• helpers: proc sendPartial(ctx: Context; data: sink string)
• context: proc sendPartial(ctx: Context; data: sink string)

servePublic:

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

setContentType:

• helpers: proc setContentType(ctx: Context; fileName: string)
• context: proc setContentType(ctx: Context; fileName: string)

SetCookie:

• cookies: object SetCookie

setCookies:

• cookies: proc setCookies(ctx: Context): StringTableRef

setHeader:

• helpers: proc setHeader(ctx: Context; key, value: string)
• response: proc setHeader(ctx: Context; key, value: string)

specialCharacters:

• router: const specialCharacters

startChunking:

• helpers: proc startChunking(ctx: Context)
• context: proc startChunking(ctx: Context)

startSSE:

• helpers: proc startSSE(ctx: Context; retry = 3000)
• context: proc startSSE(ctx: Context; retry = 3000)

startStreaming:

• helpers: proc startStreaming(ctx: Context; contentLength = none(int))
• context: proc startStreaming(ctx: Context; contentLength = none(int))

status:

• helpers: proc status(ctx: Context): HttpCode
• response: proc status(ctx: Context): HttpCode

status=:

• helpers: proc status=(ctx: Context; code: int | HttpCode)
• response: proc status=(ctx: Context; code: int | HttpCode)

stopSSE:

• helpers: proc stopSSE(ctx: Context)
• context: proc stopSSE(ctx: Context)

Strict:

• cookies: SameSite.Strict

supportedCompression:

• helpers: proc supportedCompression(ctx: Context): Option[CompressedDataFormat]
• context: proc supportedCompression(ctx: Context): Option[CompressedDataFormat]

Text:

• router: PatternType.Text

toNodes:

• router: proc toNodes(path: string): seq[PatternNode]

toString:

• response: proc toString(headers: sink HttpHeaders): string

UnAuthorisedError:

• errors: object UnAuthorisedError

URLEncodedForm:

• form: type URLEncodedForm

urlForm:

• form: proc urlForm(ctx: Context): URLEncodedForm