refactor: more cleanup and moving stuff around

Author: drujensen

lightbug.🔥

@@ -1,4 +1,5 @@
 from lightbug_http import *
+from lightbug_http.middleware.helpers import Success
 
 struct HelloWorld(HTTPHandler):
     fn handle(self, context: Context) -> HTTPResponse:

lightbug_http/middleware.mojo

@@ -0,0 +1,17 @@
+from lightbug_http.middleware.middleware import Context, Middleware, MiddlewareChain
+
+from lightbug_http.middleware.basicauth import BasicAuthMiddleware
+from lightbug_http.middleware.compression import CompressionMiddleware
+from lightbug_http.middleware.cors import CorsMiddleware
+from lightbug_http.middleware.error import ErrorMiddleware
+from lightbug_http.middleware.logger import LoggerMiddleware
+from lightbug_http.middleware.notfound import NotFoundMiddleware
+from lightbug_http.middleware.router import RouterMiddleware, HTTPHandler
+from lightbug_http.middleware.static import StaticMiddleware
+
+# from lightbug_http.middleware.csrf import CsrfMiddleware
+# from lightbug_http.middleware.session import SessionMiddleware
+# from lightbug_http.middleware.websocket import WebSocketMiddleware
+# from lightbug_http.middleware.cache import CacheMiddleware
+# from lightbug_http.middleware.cookies import CookiesMiddleware
+# from lightbug_http.middleware.session import SessionMiddleware

lightbug_http/middleware/__init__.mojo

@@ -0,0 +1,24 @@
+from lightbug_http.middleware.helpers import Unauthorized
+
+## BasicAuth middleware requires basic authentication to access the route.
+@value
+struct BasicAuthMiddleware(Middleware):
+    var next: Middleware
+    var username: String
+    var password: String
+
+    fn set_next(self, next: Middleware):
+        self.next = next
+
+    fn __init__(self, username: String, password: String):
+        self.username = username
+        self.password = password
+
+    fn call(self, context: Context) -> HTTPResponse:
+        var request = context.request
+        var auth = request.headers["Authorization"]
+        if auth == f"Basic {username}:{password}":
+            context.params["username"] = username
+            return next.call(context)
+        else:
+            return Unauthorized("Requires Basic Authentication")

lightbug_http/middleware/basicauth.mojo

@@ -0,0 +1,17 @@
+## Compression middleware compresses the response body.
+@value
+struct CompressionMiddleware(Middleware):
+    var next: Middleware
+
+    fn set_next(self, next: Middleware):
+        self.next = next
+
+    fn call(self, context: Context) -> HTTPResponse:
+        var response = self.next.call(context)
+        response.body = self.compress(response.body)
+        return response
+
+    fn compress(self, body: Bytes) -> Bytes:
+        #TODO: implement compression
+        return body
+

lightbug_http/middleware/compression.mojo

@@ -0,0 +1,26 @@
+from lightbug_http.middleware.helpers import Unauthorized
+
+## CORS middleware adds the necessary headers to allow cross-origin requests.
+@value
+struct CorsMiddleware(Middleware):
+    var next: Middleware
+    var allow_origin: String
+
+    fn set_next(self, next: Middleware):
+        self.next = next
+
+    fn __init__(self, allow_origin: String):
+        self.allow_origin = allow_origin
+
+    fn call(self, context: Context) -> HTTPResponse:
+        if context.request.header.method() == "OPTIONS":
+            var response = next.call(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 self.next.call(context)
+        else:
+            return Unauthorized("CORS not allowed")

lightbug_http/middleware/cors.mojo

@@ -0,0 +1,18 @@
+from lightbug_http.middleware.helpers import InternalServerError
+
+## Error handler will catch any exceptions thrown by the other
+## middleware and return a 500 response.
+## It should be the first middleware in the chain.
+@value
+struct ErrorMiddleware(Middleware):
+    var next: Middleware
+
+    fn set_next(self, next: Middleware):
+        self.next = next
+
+    fn call(inout self, context: Context) -> HTTPResponse:
+        try:
+            return self.next.call(context)
+        except e:
+            return InternalServerError(e)
+