[WIP] New router

opium/src/app.ml

@@ -2,6 +2,7 @@ open Import
 module Server = Httpaf_lwt_unix.Server
 module Reqd = Httpaf.Reqd
 open Lwt.Syntax
+module Route = Router.Route
 
 let err_invalid_host host =
   Lwt.fail_invalid_arg ("Could not get host info for `" ^ host ^ "`")

opium/src/middlewares/middleware_router.ml

@@ -10,54 +10,48 @@ module Method_map = Map.Make (struct
   ;;
 end)
 
-type 'a t = (Route.t * 'a) list Method_map.t
+type t = Rock.Handler.t Method_map.t Router.t
 
-let empty = Method_map.empty
+let empty = Router.empty
 
-let get t meth =
-  match Method_map.find_opt meth t with
-  | None -> []
-  | Some xs -> List.rev xs
-;;
-
-let add t ~route ~meth ~action =
-  Method_map.update
-    meth
-    (function
-      | None -> Some [ route, action ]
-      | Some xs -> Some ((route, action) :: xs))
-    t
+let add (t : t) ~route ~meth ~action =
+  Router.update t route ~f:(function
+      | None -> Method_map.singleton meth action
+      | Some m -> Method_map.add meth action m)
 ;;
 
 (** finds matching endpoint and returns it with the parsed list of parameters *)
-let matching_endpoint endpoints meth uri =
-  let endpoints = get endpoints meth in
-  List.find_map endpoints ~f:(fun ep ->
-      uri |> Route.match_url (fst ep) |> Option.map (fun p -> ep, p))
+let matching_endpoint (endpoints : t) meth uri =
+  match Router.match_url endpoints uri with
+  | None -> None
+  | Some (a, params) ->
+    (match Method_map.find_opt meth a with
+    | None -> None
+    | Some h -> Some (h, params))
 ;;
 
 module Env = struct
-  let key : Route.matches Context.key =
-    Context.Key.create ("path_params", Route.sexp_of_matches)
+  let key : Router.Params.t Context.key =
+    Context.Key.create ("path_params", Router.Params.sexp_of_t)
   ;;
 end
 
-let splat req = Context.find_exn Env.key req.Request.env |> fun route -> route.Route.splat
+let splat req = Context.find_exn Env.key req.Request.env |> Router.Params.unnamed
 
 (* not param_exn since if the endpoint was selected it's likely that the parameter is
    already there *)
 let param req param =
-  let { Route.params; _ } = Context.find_exn Env.key req.Request.env in
-  List.assoc param params
+  let params = Context.find_exn Env.key req.Request.env in
+  Router.Params.named params param
 ;;
 
 let m endpoints =
   let filter default req =
     match matching_endpoint endpoints req.Request.meth req.Request.target with
     | None -> default req
-    | Some (endpoint, params) ->
+    | Some (handler, params) ->
       let env_with_params = Context.add Env.key params req.Request.env in
-      (snd endpoint) { req with Request.env = env_with_params }
+      handler { req with Request.env = env_with_params }
   in
   Rock.Middleware.create ~name:"Router" ~filter
 ;;

opium/src/middlewares/middleware_router.mli

@@ -1,7 +1,7 @@
-type 'a t
+type t
 
-val m : Rock.Handler.t t -> Rock.Middleware.t
-val empty : 'action t
-val add : 'a t -> route:Route.t -> meth:Method.t -> action:'a -> 'a t
+val m : t -> Rock.Middleware.t
+val empty : t
+val add : t -> route:Router.Route.t -> meth:Method.t -> action:Rock.Handler.t -> t
 val param : Request.t -> string -> string
 val splat : Request.t -> string list

opium/src/opium.ml

@@ -1,3 +1,7 @@
+module Private = struct
+  module Router = Router
+end
+
 module Context = Context
 module Headers = Headers
 module Cookie = Cookie
@@ -8,8 +12,8 @@ module Body = Body
 module Request = Request
 module Response = Response
 module App = App
-module Route = Route
 module Auth = Auth
+module Route = Router.Route
 module Router = Middleware_router
 
 module Handler = struct

opium/src/opium.mli

@@ -1,3 +1,9 @@
+module Private : sig
+  module Router : module type of struct
+    include Router
+  end
+end
+
 module Context = Context
 module Headers = Headers
 module Cookie = Cookie
@@ -8,14 +14,14 @@ module Body = Body
 module Request = Request
 module Response = Response
 module App = App
-module Route = Route
 module Auth = Auth
+module Route = Router.Route
 
 module Router : sig
-  type 'action t
+  type t
 
-  val empty : 'action t
-  val add : 'a t -> route:Route.t -> meth:Method.t -> action:'a -> 'a t
+  val empty : t
+  val add : t -> route:Route.t -> meth:Method.t -> action:Rock.Handler.t -> t
   val param : Request.t -> string -> string
   val splat : Request.t -> string list
 end
@@ -88,7 +94,7 @@ module Middleware : sig
 
       will redirect any URI containing two segments with the last segment containing
       "hello" to the handler defined in [Handler.hello_world]. *)
-  val router : Rock.Handler.t Router.t -> Rock.Middleware.t
+  val router : Router.t -> Rock.Middleware.t
 
   (** {3 [debugger]} *)