inject request and response into controller

yaroo/lib/http/http.dart

@@ -2,10 +2,11 @@
 
 import 'dart:async';
 
-import 'package:meta/meta_meta.dart';
 import 'package:yaroo/src/_reflector/reflector.dart';
 import 'package:yaroo/src/core.dart';
 
+import 'http.dart';
+
 export 'package:pharaoh/pharaoh.dart'
     show
         Request,
@@ -20,23 +21,43 @@
         useShelfMiddleware;
 
 @inject
-abstract class BaseController extends AppInstance {}
+abstract class ApplicationController extends AppInstance {
+  late final Request request;
 
-@inject
-abstract class ServiceProvider extends AppInstance {
-  static List<Type> get defaultProviders => [AppServiceProvider];
+  late final Response response;
 
-  FutureOr<void> boot();
-}
+  Map<String, dynamic> get params => request.params;
+
+  Map<String, dynamic> get query => request.query;
+
+  Map<String, dynamic> get headers => request.headers;
 
-@Target({TargetKind.parameter})
-class Param {
-  const Param(String name);
+  get body => request.body;
+
+  Response badRequest([String? message]) {
+    const status = 422;
+    if (message == null) return response.status(status);
+    return response.json({'message': message}, statusCode: status);
+  }
+
+  Response notFound([String? message]) {
+    const status = 404;
+    if (message == null) return response.status(status);
+    return response.json({'message': message}, statusCode: status);
+  }
+
+  Response jsonResponse(data, {int statusCode = 200}) {
+    return response.json(data, statusCode: statusCode);
+  }
+
+  Response redirectTo(String url, {int statusCode = 302}) {
+    return response.redirect(url, statusCode);
+  }
 }
 
-@Target({TargetKind.parameter})
-class Body {
-  final String? param;
+@inject
+abstract class ServiceProvider extends AppInstance {
+  static List<Type> get defaultProviders => [AppServiceProvider];
 
-  const Body({this.param});
+  FutureOr<void> boot();
 }

yaroo/lib/src/_reflector/reflector.dart

@@ -64,7 +64,7 @@
   final method = defn.$2;
 
   final ctrlMirror = inject.reflectType(type) as r.ClassMirror;
-  if (ctrlMirror.superclass?.reflectedType != BaseController) {
+  if (ctrlMirror.superclass?.reflectedType != ApplicationController) {
     throw ArgumentError('$type must extend BaseController');
   }
 
@@ -74,8 +74,9 @@
     throw ArgumentError('$type does not have method  #${symbolToString(method)}');
   }
 
-  // final parameters = actualMethod.parameters.map((e) => e.reflectedType);
-  // print(parameters);
+  if (actualMethod.parameters.isNotEmpty) {
+    throw ArgumentError.value('$type.${actualMethod.simpleName}', null, 'Controller methods cannot have parameters');
+  }
 
   return ControllerMethod(defn);
 }

yaroo/lib/src/_router/definition.dart

@@ -1,8 +1,8 @@
 import 'package:meta/meta.dart';
 import 'package:pharaoh/pharaoh.dart';
 
-import '../../../http/http.dart';
 import '../_reflector/reflector.dart';
+import '../core.dart';
 import 'utils.dart';
 
 enum RouteDefinitionType { route, group, middleware }
@@ -46,10 +46,27 @@
 typedef ControllerMethodDefinition = (Type controller, Symbol symbol);
 
 class ControllerMethod {
-  final ControllerMethodDefinition classMethod;
-  final List<Type> parameters = [];
+  final ControllerMethodDefinition method;
 
-  ControllerMethod(this.classMethod);
+  String get methodName => symbolToString(method.$2);
+
+  Type get controller => method.$1;
+
+  ControllerMethod(this.method);
+}
+
+class ControllerMethodParam {
+  final String name;
+  final Type type;
+  final bool required;
+  final List<Object> metadata;
+
+  const ControllerMethodParam(
+    this.name,
+    this.type, {
+    this.metadata = const [],
+    this.required = true,
+  });
 }
 
 class ControllerRouteMethodDefinition extends RouteDefinition {
@@ -63,12 +80,9 @@
 
   @override
   void commit(Spanner spanner) {
+    final handler = ApplicationFactory.buildControllerMethod(method);
     for (final routeMethod in route.methods) {
-      spanner.addRoute(
-        routeMethod,
-        route.path,
-        useRequestHandler(_controllerHandler(method)),
-      );
+      spanner.addRoute(routeMethod, route.path, useRequestHandler(handler));
     }
   }
 }
@@ -134,18 +148,3 @@
     spanner.addRoute(method, path, useRequestHandler(handler));
   }
 }
-
-RequestHandler _controllerHandler(ControllerMethod method) {
-  final defn = method.classMethod;
-
-  return (req, res) async {
-    final instance = createNewInstance<BaseController>(defn.$1);
-    final mirror = inject.reflect(instance);
-
-    final result = await Future.sync(
-      () => mirror.invoke(symbolToString(defn.$2), [req, res]),
-    );
-
-    return result;
-  };
-}

yaroo/lib/src/core.dart

@@ -87,17 +87,15 @@
 
   List<Middleware> get globalMiddlewares => [bodyParser];
 
-  Future<void> bootstrap({
-    bool start_server = true,
-  }) async {
+  Future<void> bootstrap({bool listen = true}) async {
     if (dbConfig != null) {
       DB.init(dbConfig!);
       await DB.defaultDriver.connect();
     }
 
     await _bootstrapComponents(appConfig);
 
-    if (start_server) await startServer();
+    if (listen) await startServer();
   }
 
   Future<void> startServer() async {
@@ -128,4 +126,22 @@
     final application = (instanceFromRegistry<Application>() as _YarooAppImpl);
     return request(application._createPharaohInstance());
   }
+
+  static RequestHandler buildControllerMethod(ControllerMethod method) {
+    return (req, res) async {
+      final methodName = method.methodName;
+      final instance = createNewInstance<ApplicationController>(method.controller);
+      final mirror = inject.reflect(instance);
+
+      mirror
+        ..invokeSetter('request', req)
+        ..invokeSetter('response', res);
+
+      methodCall() => mirror.invoke(methodName, []);
+
+      final result = await Future.sync(methodCall);
+
+      return result;
+    };
+  }
 }

yaroo/test/router_test.dart

@@ -4,7 +4,7 @@ import 'package:yaroo/yaroo.dart';
 
 import './router_test.reflectable.dart';
 
-class TestController extends BaseController {
+class TestController extends ApplicationController {
   void create() {}
 
   void index() {}