That workaround is odd, are you using 0.16.0? The following works for me on 
devel.

(by the way, I would advise against using `proc` for proc types, better to be 
explicit.)
    
    
    import asynchttpserver, asyncdispatch
    
    
    type
        Router* = ref object of RootObj
            routes: seq[Route]
        Route* = ref object of RootObj
            path*: string
            get*: proc (req: Request): Future[void]
            post*: proc (req: Request): Future[void]
            put*: proc (req: Request): Future[void]
            delete*: proc(req: Request): Future[void]
        Response* = ref object of RootObj
            request*: Request
            status*: HttpCode
            data*: string
            headers*: HttpHeaders
    
    
    proc newRouter*(): Router =
        result = Router(
            routes: @[]
        )
    
    
    proc notFoundHandler*(req: Request): Future[void] {.async.} =
        await req.respond(Http404, "404 Not Found")
    
    
    proc newRoute*(
        path: string,
        get, post, put, delete: proc (req: Request): Future[void] = 
notFoundHandler
    ): Route =
        result = Route(
            path: path,
            get: get,
            post: post,
            put: put,
            delete: delete
        )
    
    
    
    let DEFAULT_HEADERS = newHttpHeaders([
        ("Content-Type", "text/html"),
        ("Accept", "text/html"),
        ("Accept-Charset", "utf-8"),
        ("Accept-Encoding", "gzip, deflate"),
        ("Connection", "keep-alive")
    ])
    
    
    
    proc newResponse*(
        request: Request,
        status: HttpCode = Http200,
        data: string = "",
        headers: HttpHeaders = DEFAULT_HEADERS
    ): Response =
        result = Response(
            request: request,
            status: status,
            data: data,
            headers: headers
        )
    
    
    proc log*(resp: Response): void =
        echo $resp.status
    
    
    proc send*(resp: Response) {.async.} =
        log(resp)
        await resp.request.respond(
            resp.status,
            resp.data,
            resp.headers
        )
    
    
    proc register*(router: Router, routes: varargs[Route]) =
        for route in items(routes):
            router.routes.add(route)
    
    
    proc route*(router: Router, req: Request) {.async.} =
        for route in router.routes:
            if route.path == req.url.path:
                case req.reqMethod:
                    of HttpGet:
                        await route.get(req)
                    else: continue
        await notFoundHandler(req)
    
    

Reply via email to