Router

Initialize a Router instance.

Usage Example:

 let router = Router()

Using mergeParameters:

When initialising a Router, mergeParameters allows you to control whether the router will be able to access parameters matched in its parent router. For instance, in the example below if mergeParameters is set to true, GET /Hello/Alex will return “Hello Alex”, but if set to false the greeting parameter will not be accessible and it will return just “ Alex”.

let router = Router()
let userRouter = Router(mergeParameters: true)

router.get("/:greeting") { request, response, _ in
  let greeting = request.parameters["greeting"] ?? ""
  try response.send("\(greeting)").end()
}

userRouter.get("/:user") { request, response, _ in
  let user = request.parameters["user"] ?? ""
  let greeting = request.parameters["greeting"] ?? ""
  try response.send("\(greeting) \(user)").end()
}

router.all("/:greeting", middleware: userRouter)

Returns the current in-memory representation of Codable routes as a Swagger document in JSON format, or nil if the document cannot be generated.

A dictionary of MediaType to BodyEncoder generators. By default this includes an entry mapping the “application/json” media type to a JSONEncoder generator. When a Codable object is sent as a response, an encoder will be generated based on the “Accepts” header or using the defaultResponseMediaType if no matching encoder is found.

Usage Example:

The example below replaces the default JSON encoder with a new encoder that has a different date encoding strategy.

let router = Router()
let newJSONEncoder: () -> BodyEncoder = {
    let encoder = JSONEncoder()
    encoder.dateEncodingStrategy = .secondsSince1970
    return encoder
}
router.encoders[.json] = newJSONEncoder

Considerations for use with OpenAPI generation

In order for your OpenAPI (swagger) document to correctly represent an alternate Date encoding that you have chosen, you must configure your encoders before registering routes.

if the request’s Accept header does not match an encoder, this media type will be used by the RouterResponse to select a BodyEncoder. By default, this is set to “application/json”.

Usage Example:

The example below sets the defaultResponseMediaType as “application/x-yaml”.

let router = Router()
router.defaultResponseMediaType = MediaType(type: .application, subtype: "x-yaml")

A dictionary of MediaType to BodyDecoder generators. By default this includes an entry mapping the “application/json” media type to a JSONDecoder generator and an entry mapping “application/x-www-form-urlencoded” media type to QueryDecoder When a Codable object is read from the body of a request, a decoder will be generated based on the “Content-Type” header.

Usage Example:

The example below replaces the default JSON decoder with a new decoder that has a different date encoding strategy.

let router = Router()
let newJSONDecoder: () -> BodyDecoder = {
    let decoder = JSONDecoder()
    decoder.dateDecodingStrategy = .secondsSince1970
    return decoder
}
router.decoders[.json] = newJSONDecoder

The root directory where template files should be placed in order to be automatically handed over to an appropriate templating engine for content generation. The directory should sit at the same level as the project’s “Sources” directory. Defaults to “./Views/”.

Usage Example:

The example below changes the directory where template files should be placed to be “./myViews/”

let router = Router()
router.viewsPath = "./myViews/"

Register a template engine to a given router instance. A template engine allows rendering of documents using static templates.

By default the templating engine will handle files in the ./Views directory that match the file extension it supports. You can change this default location using the viewsPath property.

Usage Example:

let router = Router()
router.add(templateEngine: MyTemplateEngine())
router.add(templateEngine: MyOtherTemplateEngine(), forFileExtensions: ["html"], useDefaultFileExtension: false)

If multiple different template engines are registered for the same extension, the template engine that is registered last will be the one that attempts to render all template files with the chosen extension.

Sets the default templating engine to be used when the extension of a file in the viewsPath doesn’t match the extension of one of the registered templating engines.

Usage Example:

let router = Router()
router.setDefault(templateEngine: MyTemplateEngine())

If the template engine doesn’t provide a default extension you can provide one using add(templateEngine:forFileExtensions:useDefaultFileExtension:). If a router instance doesn’t have a template engine registered that can render the given template file a “No template engine defined for extension” TemplatingError is thrown.

Set up a “sub router” to handle requests. Chaining a route handler onto another router can make it easier to build a server that serves a large set of paths. Each sub router handles all of the path mappings below its parent’s route path.

Usage Example:

The example below shows how the route `/parent/child’ can be defined using a sub router.

let router = Router()
let parent = router.route("/parent")
parent.get("/child") { request, response, next in
    // If allowPartialMatch was set to false, this would not be called.
}

Set up handlers for a named request parameter. This can make it easier to handle multiple routes requiring the same parameter which needs to be handled in a certain way.

Usage Example:

let router = Router()
router.parameter("id") { request, response, param, next in
    if let _ = Int(param) {
        // Id is an integer, continue
        next()
    }
    else {
        // Id is not an integer, error
        try response.status(.badRequest).send("ID is not an integer").end()
    }
}

router.get("/item/:id") { request, response, _ in
    // This will only be reached if the id parameter is an integer
}
router.get("/user/:id") { request, response, _ in
    // This will only be reached if the id parameter is an integer
}

Set up handlers for a number of named request parameters. This can make it easier to handle multiple routes requiring similar parameters which need to be handled in a certain way.

Usage Example:

let router = Router()
router.parameter(["id", "num"]) { request, response, param, next in
    if let _ = Int(param) {
        // Parameter is an integer, continue
        next()
    }
    else {
        // Parameter is not an integer, error
        try response.status(.badRequest).send("\(param) is not an integer").end()
    }
}

router.get("/item/:id/:num") { request, response, _ in
    // This will only be reached if the id and num parameters are integers.
}

Set up handlers for a number of named request parameters. This can make it easier to handle multiple routes requiring similar parameters which need to be handled in a certain way.

Usage Example:

let router = Router()
func handleInt(request: RouterRequest, response: RouterResponse, param: String, next: @escaping () -> Void) throws -> Void {
    if let _ = Int(param) {
        // Parameter is an integer, continue
    }
    else {
        // Parameter is not an integer, error
        try response.status(.badRequest).send("\(param) is not an integer").end()
    }
    next()
}

func handleItem(request: RouterRequest, response: RouterResponse, param: String, next: @escaping () -> Void) throws -> Void {
    let itemId = Int(param) //This will only be reached if id is an integer
    ...
}

router.parameter(["id"], handlers: [handleInt, handleItem])

router.get("/item/:id/") { request, response, _ in
    ...
}

Sets up a closure that will be invoked when a GET request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware and a handler which responds with a single Codable object or a RequestError. The handler contains the developer’s logic, which determines the server’s response.

Usage Example:

In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an optional User, where User conforms to Codable.

router.get("/user") { (session: MySession, respondWith: (User?, RequestError?) -> Void) in
    guard let user: User = session.user else {
       return respondWith(nil, .notFound)
    }
    respondWith(user, nil)
}

Multiple Middleware:

The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:

router.get("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3,
                       respondWith: (User?, RequestError?) -> Void) in

Sets up a closure that will be invoked when a GET request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware and a handler which responds with an array of Codable objects or a RequestError. The handler contains the developer’s logic, which determines the server’s response.

Usage Example:

In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an optional User array, where User conforms to Codable.

router.get("/user") { (session: MySession, respondWith: ([User]?, RequestError?) -> Void) in
   guard let user: [User] = session.user else {
       return respondWith(nil, .notFound)
   }
   respondWith([user], nil)
}

Multiple Middleware:

The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:

router.get("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3,
                       respondWith: ([User]?, RequestError?) -> Void) in

Sets up a closure that will be invoked when a GET request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware, an Identifier and a handler which responds with a single Codable object or a RequestError. The handler contains the developer’s logic, which determines the server’s response.

Usage Example:

In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an [Int: User] dictionary, where User conforms to Codable.

router.get("/user") { (session: MySession, id: Int, respondWith: (User?, RequestError?) -> Void) in
   guard let user: User = session.user[id] else {
       return respondWith(nil, .notFound)
   }
   respondWith(user, nil)
}

Multiple Middleware:

The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:

router.get("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3, id: Int,
                       respondWith: (User?, RequestError?) -> Void) in

Sets up a closure that will be invoked when a GET request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware and a handler which responds with an array of (Identifier, Codable) tuples or a RequestError. The handler contains the developer’s logic, which determines the server’s response.

Usage Example:

In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an [(Int, User)] dictionary, where User conforms to Codable.

router.get("/user") { (session: MySession, respondWith: ([(Int, User)]?, RequestError?) -> Void) in
   guard let users: [(Int, User)] = session.users else {
       return respondWith(nil, .notFound)
   }
   respondWith(users, nil)
}

Multiple Middleware:

The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:

router.get("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3, id: Int,
                       respondWith: ([(Int, User)]?, RequestError?) -> Void) in

Sets up a closure that will be invoked when a GET request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware, the parsed query parameters, and a handler which responds with a single Codable object or a RequestError. The handler contains the developer’s logic, which determines the server’s response.

Usage Example:

In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an [Int: User] dictionary, where User conforms to Codable.

struct Query: QueryParams {
   let id: Int
}
router.get("/user") { (session: MySession, query: Query, respondWith: (User?, RequestError?) -> Void) in
   guard let user: User = session.user[query.id] else {
       return respondWith(nil, .notFound)
   }
   respondWith(user, nil)
}

Multiple Middleware:

The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:

router.get("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3, query: Query,
respondWith: (User?, RequestError?) -> Void) in

Sets up a closure that will be invoked when a GET request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware, the parsed query parameters, and a handler which responds with an array of Codable objects or a RequestError. The handler contains the developer’s logic, which determines the server’s response.

Usage Example:

In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an [Int: [User]] dictionary, where User conforms to Codable.

struct Query: QueryParams {
   let id: Int
}
router.get("/user") { (session: MySession, query: Query, respondWith: ([User]?, RequestError?) -> Void) in
   guard let user: [User] = session.user[query.id] else {
       return respondWith(nil, .notFound)
   }
   respondWith(user, nil)
}

Multiple Middleware:

The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:

router.get("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3, query: Query,
                       respondWith: ([User]?, RequestError?) -> Void) in

Sets up a closure that will be invoked when a GET request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware, the parsed query parameters, and a handler which responds with an array of Codable objects or a RequestError. The handler contains the developer’s logic, which determines the server’s response.

Usage Example:

In this example, MyHTTPAuth is a struct that conforms to the TypeSafeHTTPBasic protocol from Kitura-CredentialsHTTP to provide basic HTTP authentication.

struct Query: QueryParams {
    let id: Int
}
router.get("/user") { (auth: MyHTTPAuth, query: Query?, respondWith: ([User]?, RequestError?) -> Void) in
    if let query = query {
        let matchedUsers = userArray.filter { $0.id <=  query.id }
        return respondWith(matchedUsers, nil)
    } else {
        respondWith(userArray, nil)
    }
}

Multiple Middleware:

The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:

router.get("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3, query: Query,
respondWith: ([User]?, RequestError?) -> Void) in

Sets up a closure that will be invoked when a DELETE request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware and a handler which responds with nil on success, or a RequestError. The handler contains the developer’s logic, which determines the server’s response.

Usage Example:

In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an optional User, where User conforms to Codable.

router.delete("/user") { (session: MySession, respondWith: (RequestError?) -> Void) in
   session.user: User? = nil
   respondWith(nil)
}

Multiple Middleware:

The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:

router.delete("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3,
                          respondWith: (RequestError?) -> Void) in

Sets up a closure that will be invoked when a DELETE request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware, an Identifier and a handler which responds with nil on success, or a RequestError. The handler contains the developer’s logic, which determines the server’s response.

Usage Example:

In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an [Int: User] dictionary, where User conforms to Codable.

router.delete("/user") { (session: MySession, id: Int, respondWith: (RequestError?) -> Void) in
    session.user[id] = nil
    respondWith(nil)
}

Multiple Middleware:

The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:

router.delete("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3, id: Int,
                          respondWith: (RequestError?) -> Void) in

Sets up a closure that will be invoked when a DELETE request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware, the parsed query parameters, and a handler which responds with nil on success, or a RequestError. The handler contains the developer’s logic, which determines the server’s response.

Usage Example:

In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an [Int: User] dictionary, where User conforms to Codable.

struct Query: QueryParams {
   let id: Int
}
router.delete("/user") { (session: MySession, query: Query, respondWith: (RequestError?) -> Void) in
   session.user[query.id] = nil
   respondWith(nil)
}

Multiple Middleware:

The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:

router.delete("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3, query: Query,
                          respondWith: (RequestError?) -> Void) in

Sets up a closure that will be invoked when a DELETE request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware, the parsed query parameters, and a handler which responds with nil on success, or a RequestError. The handler contains the developer’s logic, which determines the server’s response.

Usage Example:

In this example, MyHTTPAuth is a struct that conforms to the TypeSafeHTTPBasic protocol from Kitura-CredentialsHTTP to provide basic HTTP authentication.

struct Query: QueryParams {
    let id: Int
}
router.delete("/user") { (auth: MyHTTPAuth, query: Query?, respondWith: (RequestError?) -> Void) in
    if let query = query {
        userArray = userArray.filter { $0.id != query.id }
        return respondWith(nil)
    } else {
        userArray = []
        return respondWith(nil)
    }
}

Multiple Middleware:

The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:

router.delete("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3, query: Query?,
respondWith: (RequestError?) -> Void) in

Sets up a closure that will be invoked when a POST request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware, a Codable object and a handler which responds with a single Codable object or a RequestError. The handler contains the developer’s logic, which determines the server’s response.

Usage Example:

In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an optional User, where User conforms to Codable.

router.post("/user") { (session: MySession, user: User, respondWith: (User?, RequestError?) -> Void) in
   if session.user == nil {
       return respondWith(nil, .badRequest)
   } else {
       session.user = user
       respondWith(user, nil)
   }
}

Multiple Middleware:

The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:

router.post("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3, user: User,
                        respondWith: (User?, RequestError?) -> Void) in

Sets up a closure that will be invoked when a POST request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware, a Codable object and a handler which responds with an Identifier and a Codable object, or a RequestError. The handler contains the developer’s logic, which determines the server’s response.

Usage Example:

In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an [Int: User] dictionary, where User conforms to Codable.

router.post("/user") { (session: MySession, user: User, respondWith: (Int?, User?, RequestError?) -> Void) in
   let newId = session.users.count + 1
   session.user[newId] = user
   respondWith(newId, user, nil)
   }
}

Multiple Middleware:

The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:

router.post("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3, user: User, respondWith: (Int?, User?, RequestError?) -> Void) in

Sets up a closure that will be invoked when a PUT request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware, an Identifier, a Codable object and a handler which responds with a single Codable object or a RequestError. The handler contains the developer’s logic, which determines the server’s response.

Usage Example:

In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an [Int: User] dictionary, where User conforms to Codable.

router.post("/user") { (session: MySession,  id: Int, user: User, respondWith: (User?, RequestError?) -> Void) in
    session.user[id] = user
    respondWith(user, nil)
}

Multiple Middleware:

The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:

router.put("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3,
id: Int, user: User, respondWith: (User?, RequestError?) -> Void) in

Sets up a closure that will be invoked when a PATCH request to the provided route is received by the server. The closure accepts a successfully executed instance of TypeSafeMiddleware, an Identifier, a Codable object and a handler which responds with a single Codable object or a RequestError. The handler contains the developer’s logic, which determines the server’s response.

Usage Example:

In this example, MySession is a struct that conforms to the TypeSafeMiddleware protocol and specifies an [Int: User] dictionary, where User conforms to Codable.

router.patch("/user") { (session: MySession, id: Int, inputUser: User, respondWith: (User?, RequestError?) -> Void) in
guard let user: User = session.user[id] else {
       return respondWith(nil, .notFound)
   }
   user.id = inputUser.id ?? user.id
   user.name = inputUser.name ?? user.name
   respondWith(user, nil)
   }
}

Multiple Middleware:

The closure can process up to three TypeSafeMiddleware objects by defining them in the handler:

router.patch("/user") { (middle1: Middle1, middle2: Middle2, middle3: Middle3,
id: Int, user: User, respondWith: (User?, RequestError?) -> Void) in

Setup a CodableArrayClosure on the provided route which will be invoked when a request comes to the server.

Usage Example:

//User is a struct object that conforms to Codable
router.get("/users") { (respondWith: ([User]?, RequestError?) -> Void) in

   ...

   respondWith(users, nil)
}

Setup a SimpleCodableClosure on the provided route which will be invoked when a request comes to the server.

Usage Example:

//Status is a struct object that conforms to Codable
router.get("/status") { (respondWith: (Status?, RequestError?) -> Void) in

   ...

   respondWith(status, nil)
}

Setup a IdentifierSimpleCodableClosure on the provided route which will be invoked when a request comes to the server.

Usage Example:

//User is a struct object that conforms to Codable
router.get("/users") { (id: Int, respondWith: (User?, RequestError?) -> Void) in

   ...

   respondWith(user, nil)
}

Setup a IdentifierCodableArrayClosure on the provided route which will be invoked when a request comes to the server.

Usage Example:

//User is a struct object that conforms to Codable
router.get("/users") { (respondWith: ([(Int, User)]?, RequestError?) -> Void) in

   ...

   respondWith([(Int, User)], nil)
}

Setup a (QueryParams, CodableArrayResultClosure) -> Void on the provided route which will be invoked when a request comes to the server.

Usage Example:

// MyQuery is a codable struct defining the supported query parameters
// User is a struct object that conforms to Codable
router.get("/query") { (query: MyQuery, respondWith: ([User]?, RequestError?) -> Void) in

   ...

   respondWith(users, nil)
}

Setup a (QueryParams, CodableResultClosure) -> Void on the provided route which will be invoked when a request comes to the server.

Usage Example:

// MyQuery is a codable struct defining the supported query parameters
// User is a struct object that conforms to Codable
router.get("/query") { (query: MyQuery, respondWith: (User?, RequestError?) -> Void) in

...

respondWith(user, nil)
}

Setup a (QueryParams?, CodableArrayResultClosure) -> Void on the provided route which will be invoked when a request comes to the server.

Usage Example:

// MyQuery is a codable struct defining the supported query parameters
// User is a struct object that conforms to Codable
router.get("/query") { (query: MyQuery?, respondWith: ([User]?, RequestError?) -> Void) in

   ...

   respondWith(users, nil)
}

Setup a (QueryParams?, CodableResultClosure) -> Void on the provided route which will be invoked when a request comes to the server.

Usage Example:

// MyQuery is a codable struct defining the supported query parameters
// User is a struct object that conforms to Codable
router.get("/query") { (query: MyQuery?, respondWith: (User?, RequestError?) -> Void) in

...

respondWith(user, nil)
}

Setup a NonCodableClosure on the provided route which will be invoked when a request comes to the server.

Usage Example:

router.delete("/users") { (respondWith: (RequestError?) -> Void) in

   ...

   respondWith(nil)
}

Setup a IdentifierNonCodableClosure on the provided route which will be invoked when a request comes to the server.

Usage Example:

router.delete("/users") { (id: Int, respondWith: (RequestError?) -> Void) in

   ...

   respondWith(nil)
}

Setup a (QueryParams, ResultClosure) -> Void on the provided route which will be invoked when a request comes to the server.

Usage Example:

// MyQuery is a codable struct defining the supported query parameters
router.delete("/query") { (query: MyQuery, respondWith: (RequestError?) -> Void) in

...

respondWith(nil)
}

Setup a (QueryParams?, ResultClosure) -> Void on the provided route which will be invoked when a request comes to the server.

Usage Example:

// MyQuery is a codable struct defining the supported query parameters
router.delete("/query") { (query: MyQuery?, respondWith: (RequestError?) -> Void) in

...

respondWith(nil)
}

Setup a CodableClosure on the provided route which will be invoked when a POST request comes to the server. In this scenario, the ID (i.e. unique identifier) is a field in the Codable instance.

Usage Example:

//User is a struct object that conforms to Codable
router.post("/users") { (user: User, respondWith: (User?, RequestError?) -> Void) in

   ...

   respondWith(user, nil)
}

Setup a CodableIdentifierClosure on the provided route which will be invoked when a POST request comes to the server. In this scenario, the ID (i.e. unique identifier) for the Codable instance is a separate field (which is sent back to the client in the location HTTP header).

Usage Example:

//User is a struct object that conforms to Codable
router.post("/users") { (user: User, respondWith: (Int?, User?, RequestError?) -> Void) in

   ...

   respondWith(id, user, nil)
}

Setup a IdentifierCodableClosure on the provided route which will be invoked when a request comes to the server.

Usage Example:

//User is a struct object that conforms to Codable
router.put("/users") { (id: Int, user: User, respondWith: (User?, RequestError?) -> Void) in

   ...

   respondWith(user, nil)
}

Setup a IdentifierCodableClosure on the provided route which will be invoked when a request comes to the server.

Usage Example:

//User is a struct object that conforms to Codable
//OptionalUser is a struct object that conforms to Codable where all properties are optional
router.patch("/users") { (id: Int, patchUser: OptionalUser, respondWith: (User?, RequestError?) -> Void) -> Void in

   ...

   respondWith(user, nil)
}

Handle an HTTP request as a middleware. Used internally in Router to allow for sub routing.

Handle new incoming requests to the server.

Setup error handling that will cause a set of one or more closures of the type RouterHandler to be invoked when an error occurs.

Setup error handling that will cause an array of one or more closures of the type RouterHandler to be invoked when an error occurs.

Setup error handling that will cause a set of one or more RouterMiddleware to be invoked when an error occurs.

Setup error handling that will cause an array of one or more RouterMiddleware to be invoked when an error occurs.

Setup a set of one or more closures of the type RouterHandler that will be invoked when any request comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.

Setup an array of one or more closures of the type RouterHandler that will be invoked when any request comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.

Setup a set of one or more RouterMiddleware that will be invoked when any request comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.

Setup an array of one or more RouterMiddleware that will be invoked when any request comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.

Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP GET requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.

Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP GET requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.

Setup a set of one or more RouterMiddleware that will be invoked when HTTP GET requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.

Setup an array of one or more RouterMiddleware that will be invoked when HTTP GET requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.

Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP HEAD requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.

Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP HEAD requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.

Setup a set of one or more RouterMiddleware that will be invoked when HTTP HEAD requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.

Setup an array of one or more RouterMiddleware that will be invoked when HTTP HEAD requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.

Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP POST requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.

Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP POST requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.

Setup a set of one or more RouterMiddleware that will be invoked when HTTP POST requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.

Setup an array of one or more RouterMiddleware that will be invoked when HTTP POST requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.

Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP PUT requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.

Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP PUT requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.

Setup a set of one or more RouterMiddleware that will be invoked when HTTP PUT requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.

Setup an array of one or more RouterMiddleware that will be invoked when HTTP PUT requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.

Setup a set of one or more closures of the type RouterHandler that will be invoked when HTTP DELETE requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.

Setup an array of one or more closures of the type RouterHandler that will be invoked when HTTP DELETE requests comes to the server. If a path pattern is specified, the handlers will only be invoked if the pattern is matched.

Setup a set of one or more RouterMiddleware that will be invoked when HTTP DELETE requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.

Setup an array of one or more RouterMiddleware that will be invoked when HTTP DELETE requests comes to the server. If a path pattern is specified, the RouterMiddleware will only be invoked if the pattern is matched.