feat: support middleware

Author: drujensen

lightbug.🔥

@@ -2,5 +2,17 @@ from lightbug_http import *
 
 fn main() raises:
     var server = SysServer()
-    var handler = Welcome()
-    server.listen_and_serve("0.0.0.0:8080", handler)
+    var middleware = MiddlewareChain()
+    middleware.add(CompressionMiddleware())
+    middleware.add(ErrorMiddleware())
+    middleware.add(LoggerMiddleware())
+    middleware.add(CorsMiddleware(allows_origin = "*"))
+    middleware.add(BasicAuthMiddleware("admin", "password"))
+
+    var router = RouterMiddleware()
+    router.add("GET", "/static", StaticMiddleware("static"))
+
+    middleware.add(router)
+    
+    server.listen_and_serve("0.0.0.0:8080", middleware)
+

lightbug_http/__init__.mojo

@@ -2,6 +2,7 @@ from lightbug_http.http import HTTPRequest, HTTPResponse, OK
 from lightbug_http.service import HTTPService, Welcome
 from lightbug_http.sys.server import SysServer
 from lightbug_http.tests.run import run_tests
+from lightbug_http.middleware import *
 
 trait DefaultConstructible:
     fn __init__(inout self) raises:

lightbug_http/middleware.mojo

@@ -1,120 +1,139 @@
+from lightbug_http.http import HTTPRequest, HTTPResponse
+
 struct Context:
     var request: Request
     var params: Dict[String, AnyType]
 
-    func __init__(request: Request):
+    fn __init__(self, request: Request):
         self.request = request
         self.params = Dict[String, AnyType]()
 
 trait Middleware:
     var next: Middleware
 
-    func call(context: Context) -> Response:
+    fn call(self, context: Context) -> Response:
         ...
 
 struct ErrorMiddleware(Middleware):
-    func call(context: Context) -> Response:
-        do:
+    fn call(self, context: Context) -> Response:
+        try:
             return next.call(context: context)
         catch e: Exception:
             return InternalServerError()
 
 struct LoggerMiddleware(Middleware):
-    func call(context: Context) -> Response:
+    fn call(self, context: Context) -> Response:
         print("Request: \(context.request)")
         return next.call(context: context)
 
-struct RouterMiddleware(Middleware):
-    var routes: Dict[String, Middleware]
-
-    func __init__():
-        self.routes = Dict[String, Middleware]()
-
-    func add(route: String, middleware: Middleware):
-        routes[route] = middleware
-
-    func call(context: Context) -> Response:
-        # TODO: create a more advanced router
-
-        var route = context.request.path
-        if middleware = routes[route]:
-            return middleware.call(context: context)
-        else:
-            return NotFound()
-
 struct StaticMiddleware(Middleware):
     var path: String
 
-    funct __init__(path: String):
+    fnt __init__(self, path: String):
         self.path = path
 
-    func call(context: Context) -> Response:
-        var file = File(path: path + context.request.path)
+    fn call(self, context: Context) -> Response:
+        if context.request.path == "/":
+            var file = File(path: path + "index.html")
+        else:
+            var file = File(path: path + context.request.path)
+
         if file.exists:
-            return FileResponse(file: file)
+          var html: String
+          with open(file, "r") as f:
+              html = f.read()
+          return OK(html.as_bytes(), "text/html")
         else:
             return next.call(context: context)
 
 struct CorsMiddleware(Middleware):
-    func call(context: Context) -> Response:
-        var response = next.call(context: context)
-        response.headers["Access-Control-Allow-Origin"] = "*"
-        return response
+    var allow_origin: String
+
+    fn __init__(self, allow_origin: String):
+        self.allow_origin = allow_origin
+
+    fn call(self, context: Context) -> Response:
+        if context.request.method == "OPTIONS":
+            var response = next.call(context: context)
+            response.headers["Access-Control-Allow-Origin"] = allow_origin
+            response.headers["Access-Control-Allow-Methods"] = "GET, POST, PUT, DELETE, OPTIONS"
+            response.headers["Access-Control-Allow-Headers"] = "Content-Type, Authorization"
+            return response
+
+        if context.request.origin == allow_origin:
+            return next.call(context: context)
+        else:
+            return Unauthorized()
 
 struct CompressionMiddleware(Middleware):
-    func call(context: Context) -> Response:
+    fn call(self, context: Context) -> Response:
         var response = next.call(context: context)
         response.body = compress(response.body)
         return response
 
-struct SessionMiddleware(Middleware):
-    var session: Session
+    fn compress(self, body: Bytes) -> Bytes:
+        #TODO: implement compression
+        return body
 
-    func call(context: Context) -> Response:
-        var request = context.request
-        var response = context.response
-        var session = session.load(request)
-        context.params["session"] = session
-        response = next.call(context: context)
-        session.save(response)
-        return response
+
+struct RouterMiddleware(Middleware):
+    var routes: Dict[String, Middleware]
+
+    fn __init__(self):
+        self.routes = Dict[String, Middleware]()
+
+    fn add(self, method: String, route: String, middleware: Middleware):
+      routes[method + ":" + route] = middleware
+
+    fn call(self, context: Context) -> Response:
+        # TODO: create a more advanced router
+        var method = context.request.method
+        var route = context.request.path
+        if middleware = routes[method + ":" + route]:
+            return middleware.call(context: context)
+        else:
+            return next.call(context: context)
 
 struct BasicAuthMiddleware(Middleware):
     var username: String
     var password: String
 
-    func __init__(username: String, password: String):
+    fn __init__(self, username: String, password: String):
         self.username = username
         self.password = password
 
-    func call(context: Context) -> Response:
+    fn call(self, context: Context) -> Response:
         var request = context.request
         var auth = request.headers["Authorization"]
         if auth == "Basic \(username):\(password)":
+            context.params["username"] = username
             return next.call(context: context)
         else:
             return Unauthorized()
 
-struct MiddlewareChain:
+# always add at the end of the middleware chain
+struct NotFoundMiddleware(Middleware):
+    fn call(self, context: Context) -> Response:
+        return NotFound()
+
+struct MiddlewareChain(HttpService):
     var middlewares: Array[Middleware]
 
-    func __init__():
+    fn __init__(self):
         self.middlewares = Array[Middleware]()
 
-    func add(middleware: Middleware):
+    fn add(self, middleware: Middleware):
         if middlewares.count == 0:
             middlewares.append(middleware)
         else:
             var last = middlewares[middlewares.count - 1]
             last.next = middleware
             middlewares.append(middleware)
 
-    func execute(request: Request) -> Response:
+    fn func(self, request: Request) -> Response:
+        self.add(NotFoundMiddleware())
         var context = Context(request: request, response: response)
-        if middlewares.count > 0:
-            return middlewares[0].call(context: context)
-        else:
-            return NotFound()
+        return middlewares[0].call(context: context)
 
 fn OK(body: Bytes) -> HTTPResponse:
     return OK(body, String("text/plain"))

lightbug_http/service.mojo

@@ -19,6 +19,9 @@ struct Printer(HTTPService):
 struct Welcome(HTTPService):
     fn func(self, req: HTTPRequest) raises -> HTTPResponse:
         var uri = req.uri()
+        var html: String
+        with open("static/index.html", "r") as f:
+            html = f.read()
 
         if uri.path() == "/":
             var html: Bytes