feat(#18): initial implementation

packages/serinus/bin/bearer_hook.dart

@@ -0,0 +1,19 @@
+import 'package:serinus/serinus.dart';
+import 'package:serinus/src/services/hook.dart';
+
+class BearerHook extends Hook {
+
+  const BearerHook();
+
+  @override
+  Future<void> beforeRequest(Request request, InternalResponse response) async {
+    String? authValue = request.headers['authorization'];
+    authValue = authValue?.toLowerCase();
+    if(authValue == null || !authValue.contains('bearer')) {
+      throw UnauthorizedException();
+    }
+    final String token = authValue.split('bearer ')[1];
+    request.addData('token', token);
+  }
+
+}

packages/serinus/bin/cors_hook.dart

@@ -0,0 +1,106 @@
+import 'package:serinus/serinus.dart';
+import 'package:serinus/src/services/hook.dart';
+
+class CorsHook extends Hook<Response> {
+
+  final List<String> allowedOrigins;
+
+  CorsHook({this.allowedOrigins = const ['*']}){
+    _defaultHeaders = {
+      'Access-Control-Expose-Headers': '',
+      'Access-Control-Allow-Credentials': 'true',
+      'Access-Control-Allow-Headers': _defaultHeadersList.join(','),
+      'Access-Control-Allow-Methods': _defaultMethodsList.join(','),
+      'Access-Control-Max-Age': '86400',
+    };
+    _defaultHeadersAll =
+        _defaultHeaders.map((key, value) => MapEntry(key, [value]));
+  }
+
+  Map<String, List<String>> _defaultHeadersAll = {};
+
+  final _defaultHeadersList = [
+    'accept',
+    'accept-encoding',
+    'authorization',
+    'content-type',
+    'dnt',
+    'origin',
+    'user-agent',
+    'access-control-allow-origin'
+  ];
+
+  final _defaultMethodsList = [
+    'DELETE',
+    'GET',
+    'OPTIONS',
+    'PATCH',
+    'POST',
+    'PUT'
+  ];
+
+  Map<String, String> _defaultHeaders = {};
+
+  /// The response headers.
+  Map<String, String> responseHeaders = {};
+
+  @override
+  Future<Response?> beforeRequest(Request request, InternalResponse response) async {
+    if(request.method == 'OPTIONS') {
+      response.headers({
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+        'Access-Control-Max-Age': '86400',
+      });
+      response.status(200);
+      await response.send();
+      return null;
+    }
+    return null;
+  }
+
+  @override
+  Future<Response?> onRequest(Request request, RequestContext? context, ReqResHandler? handler, InternalResponse response) async {
+    /// Get the origin from the request headers.
+    final origin = request.headers['origin'];
+
+    /// Check if the origin is allowed.
+    if (
+        context != null && handler != null && (
+          origin == null ||
+          (!allowedOrigins.contains('*') && !allowedOrigins.contains(origin))
+        )
+    ) {
+      return handler(context);
+    }
+
+    /// Set the response headers.
+    final headers = <String, List<String>>{
+      ..._defaultHeadersAll,
+    };
+
+    /// Add the origin to the response headers.
+    headers['Access-Control-Allow-Origin'] = [origin];
+
+    /// Stringify the headers.
+    final stringHeaders =
+        headers.map((key, value) => MapEntry(key, value.join(',')));
+    responseHeaders = {
+      ...stringHeaders,
+    };
+
+    /// Call the handler.
+    final response = await handler!(context!);
+
+    /// Add the headers to the response.
+    response.addHeaders({
+      ...stringHeaders,
+    });
+
+    /// Return the response.
+    return response;
+
+  }
+
+}

packages/serinus/bin/serinus.dart

@@ -2,6 +2,7 @@ import 'dart:io';
 
 import 'package:serinus/serinus.dart';
 
+
 class TestMiddleware extends Middleware {
   int counter = 0;
 
@@ -239,6 +240,8 @@ void main(List<String> arguments) async {
   //   type: VersioningType.uri,
   //   version: 1
   // );
+  //application.use(CorsHook());
+  //application.use(BearerHook());
   application.changeBodySizeLimit(
       BodySizeLimit.change(text: 10, size: BodySizeValue.b));
   await application.serve();

packages/serinus/lib/src/contexts/request_context.dart

@@ -10,7 +10,7 @@ sealed class RequestContext {
   final Request request;
 
   /// The [body] property contains the body of the context.
-  late final Body body;
+  Body get body => request.body ?? Body.empty();
 
   /// The [path] property contains the path of the request.
   String get path => request.path;
@@ -32,7 +32,6 @@ sealed class RequestContext {
   RequestContext(
     this.providers,
     this.request,
-    this.body,
   );
 
   /// This method is used to retrieve a provider from the context.
@@ -45,7 +44,7 @@ sealed class RequestContext {
 }
 
 class _RequestContextImpl extends RequestContext {
-  _RequestContextImpl(super.providers, super.request, super.body);
+  _RequestContextImpl(super.providers, super.request);
 
   @override
   T use<T>() {
@@ -69,8 +68,8 @@ final class RequestContextBuilder {
   });
 
   /// The [build] method is used to build the request context.
-  RequestContext build(Request request, Body body) {
-    _context = _RequestContextImpl(providers, request, body);
+  RequestContext build(Request request) {
+    _context = _RequestContextImpl(providers, request);
     return _context!;
   }
 }

packages/serinus/lib/src/core/application.dart

@@ -17,6 +17,7 @@ import '../http/http.dart';
 import '../http/internal_request.dart';
 import '../injector/explorer.dart';
 import '../mixins/mixins.dart';
+import '../services/hook.dart';
 import '../services/logger_service.dart';
 import '../versioning.dart';
 import 'core.dart';
@@ -194,4 +195,11 @@ class SerinusApplication extends Application {
   Future<void> register() async {
     await modulesContainer.registerModules(entrypoint, entrypoint.runtimeType);
   }
+
+  /// The [use] method is used to add a hook to the application.
+  void use(Hook hook) {
+    config.addHook(hook);
+    _logger.info('Hook ${hook.runtimeType} added to application');
+  }
+
 }

packages/serinus/lib/src/core/application_config.dart

@@ -8,6 +8,7 @@ import '../body_size_limit.dart';
 import '../engines/view_engine.dart';
 import '../global_prefix.dart';
 import '../http/cors.dart';
+import '../services/hook.dart';
 import '../versioning.dart';
 
 /// The configuration for the application
@@ -120,6 +121,14 @@ final class ApplicationConfig {
   /// The ws adapter for the application
   WsAdapter? wsAdapter;
 
+  /// The hooks for the application
+  final Set<Hook> hooks = {};
+
+  /// Add a hook to the application
+  void addHook(Hook hook) {
+    hooks.add(hook);
+  }
+
   /// The application config constructor
   ApplicationConfig({
     required this.host,

packages/serinus/lib/src/handlers/handler.dart

@@ -26,10 +26,6 @@ abstract class Handler {
   /// This method is responsible for handling the request.
   Future<void> handle(
       InternalRequest request, InternalResponse response) async {
-    if (request.method == 'OPTIONS') {
-      await config.cors?.call(request, Request(request), null, null);
-      return;
-    }
     try {
       await handleRequest(request, response);
     } on SerinusException catch (e) {
@@ -46,10 +42,10 @@ abstract class Handler {
 
   /// Build the request context from the request and body
   RequestContext buildRequestContext(
-      Iterable<Provider> providers, Request request, Body body) {
+      Iterable<Provider> providers, Request request) {
     RequestContextBuilder builder = RequestContextBuilder(providers: {
       for (final provider in providers) provider.runtimeType: provider
     });
-    return builder.build(request, body);
+    return builder.build(request);
   }
 }

packages/serinus/lib/src/handlers/request_handler.dart

@@ -34,13 +34,29 @@ class RequestHandler extends Handler {
   @override
   Future<void> handleRequest(
       InternalRequest request, InternalResponse response) async {
+    final Request wrappedRequest = Request(request);
+    await wrappedRequest.parseBody();
+    final body = wrappedRequest.body!;
+    final bodySizeLimit = config.bodySizeLimit;
+    if (bodySizeLimit.isExceeded(body)) {
+      throw PayloadTooLargeException(
+          message: 'Request body size is too large',
+          uri: Uri.parse(request.path));
+    }
+    for(final hook in config.hooks) {
+      if(response.isClosed){
+        return;
+      }
+      await hook.beforeRequest(wrappedRequest, response);
+    }
     Response? result;
     final routeLookup = router.getRouteByPathAndMethod(
         request.path.endsWith('/')
             ? request.path.substring(0, request.path.length - 1)
             : request.path,
         request.method.toHttpMethod());
     final routeData = routeLookup.route;
+    wrappedRequest.setParams(params: routeLookup.params);
     if (routeData == null) {
       throw NotFoundException(
           message:
@@ -63,19 +79,7 @@ class RequestHandler extends Handler {
     }
     final scopedProviders = (injectables.providers
         .addAllIfAbsent(modulesContainer.globalProviders));
-    final wrappedRequest = Request(
-      request,
-      params: routeLookup.params,
-    );
-    await wrappedRequest.parseBody();
-    final body = wrappedRequest.body!;
-    final bodySizeLimit = config.bodySizeLimit;
-    if (bodySizeLimit.isExceeded(body)) {
-      throw PayloadTooLargeException(
-          message: 'Request body size is too large',
-          uri: Uri.parse(request.path));
-    }
-    final context = buildRequestContext(scopedProviders, wrappedRequest, body);
+    final context = buildRequestContext(scopedProviders, wrappedRequest);
     final middlewares = injectables.filterMiddlewaresByRoute(
         routeData.path, wrappedRequest.params);
     ExecutionContext? executionContext;
@@ -97,14 +101,21 @@ class RequestHandler extends Handler {
       executionContext = await handlePipes(route.pipes, controller.pipes,
           injectables.pipes, context, executionContext);
     }
-    if (config.cors != null) {
-      result =
-          await config.cors?.call(request, wrappedRequest, context, handler);
+    if (config.hooks.isNotEmpty) {
+      for (final hook in config.hooks) {
+        if (response.isClosed) {
+          return;
+        }
+        result = await hook.onRequest(wrappedRequest, context, handler, response);
+      }
     } else {
       result = await handler.call(context);
     }
     await response.finalize(result ?? Response.text(''),
         viewEngine: config.viewEngine);
+    for(final hook in config.hooks) {
+      await hook.afterRequest(request, response);
+    }
   }
 
   /// Handles the middlewares

packages/serinus/lib/src/http/internal_response.dart

@@ -21,6 +21,11 @@ class InternalResponse {
   /// The base url of the server
   final String? baseUrl;
 
+  bool _isClosed = false;
+
+  /// This method is used to check if the response is closed.
+  bool get isClosed => _isClosed;
+
   /// The [InternalResponse] constructor is used to create a new instance of the [InternalResponse] class.
   InternalResponse(this._original, {this.baseUrl}) {
     _original.headers.chunkedTransferEncoding = false;
@@ -37,12 +42,13 @@ class InternalResponse {
   /// This method is used to send data to the response.
   ///
   /// After sending the data, the response will be closed.
-  Future<void> send(List<int> data) async {
+  Future<void> send([List<int> data = const []]) async {
     _original.add(data);
     _events.add(ResponseEvent.data);
     _original.close();
     _events.add(ResponseEvent.afterSend);
     _events.add(ResponseEvent.close);
+    _isClosed = true;
   }
 
   /// This method is used to send a stream of data to the response.
@@ -54,6 +60,7 @@ class InternalResponse {
     _original.close();
     _events.add(ResponseEvent.afterSend);
     _events.add(ResponseEvent.close);
+    _isClosed = true;
   }
 
   /// This method is used to set the status code of the response.

packages/serinus/lib/src/http/request.dart

@@ -40,6 +40,13 @@ class Request {
     }
   }
 
+  /// This method is used to set the parameters of the request.
+  void setParams({
+    Map<String, dynamic> params = const {},
+  }) {
+    params.addAll(params);
+  }
+
   final Map<String, dynamic> _queryParamters = {};
 
   /// The path of the request.