feat(dart_frog_cli): add dart_frog_new_brick (middleware implementation) (#624)

* feat(dart_frog_cli): add dart_frog_new_brick

* Update bricks/dart_frog_new/__brick__/{{~ middleware.dart }}

Author: renancaraujo

bricks/dart_frog_new/__brick__/{{filename}}

@@ -1,3 +1,7 @@
 import 'package:dart_frog/dart_frog.dart';
 
-{{> route.dart}}
+{{#is_route}}
+{{> route.dart}}
+{{/is_route}}{{#is_middleware}}
+{{> middleware.dart}}
+{{/is_middleware}}

bricks/dart_frog_new/__brick__/{{~ middleware.dart }}

@@ -0,0 +1,4 @@
+Handler middleware(Handler handler) {
+  // TODO: implement middleware
+  return handler;
+}

bricks/dart_frog_new/__brick__/{{~ route.dart }}

@@ -1,7 +1,8 @@
 {{^params}}Response onRequest(RequestContext context) {
 {{/params}}{{#params.0}}Response onRequest(
   RequestContext context,{{#params}}
-  String {{.}},{{/params}}
+  String {{#camelCase}}{{.}}{{/camelCase}},{{/params}}
 ) {
-{{/params.0}}  return Response(body: 'Welcome to Dart Frog!');
+{{/params.0}}  // TODO: implement route handler
+  return Response(body: 'This is a new route!');
 }

bricks/dart_frog_new/hooks/lib/post_gen.dart

@@ -11,6 +11,11 @@ Future<void> postGen(
   io.Directory? directory,
   void Function(int exitCode) exit = _defaultExit,
 }) async {
+  final succeeded = context.vars.containsKey('dir_path');
+  if (!succeeded) {
+    return exit(1);
+  }
+
   final dirPath = context.vars['dir_path'] as String;
   final currentDirectory = directory ?? io.Directory.current;
 

bricks/dart_frog_new/hooks/lib/pre_gen.dart

@@ -46,16 +46,31 @@ void preGen(
     return exit(1);
   }
 
-  // The path in which the route will be created
+  // The path in which the route or middleware will be created
   final routePath = normalizeRoutePath(context.vars['route_path'] as String);
 
-  return _preGenRoute(
-    context,
-    routePath: routePath,
-    routeConfiguration: routeConfiguration,
-    projectDirectory: projectDirectory,
-    exit: exit,
-  );
+  if (type == 'route') {
+    return _preGenRoute(
+      context,
+      routePath: routePath,
+      routeConfiguration: routeConfiguration,
+      projectDirectory: projectDirectory,
+      exit: exit,
+    );
+  }
+
+  if (type == 'middleware') {
+    return _preGenMiddleware(
+      context,
+      routePath: routePath,
+      routeConfiguration: routeConfiguration,
+      projectDirectory: projectDirectory,
+      exit: exit,
+    );
+  }
+
+  context.logger.err('Unrecognized type: $type');
+  return exit(1);
 }
 
 void _preGenRoute(
@@ -125,7 +140,86 @@ void _preGenRoute(
     return exit(1);
   }
 
+  context.vars['is_route'] = true;
   context.vars['dir_path'] = path.dirname(routeFileName);
   context.vars['filename'] = path.basename(routeFileName);
   context.vars['params'] = parameterNames;
 }
+
+void _preGenMiddleware(
+  HookContext context, {
+  required String routePath,
+  required RouteConfiguration routeConfiguration,
+  required io.Directory projectDirectory,
+  required void Function(int exitCode) exit,
+}) {
+  final routesDirectoryPath = path.relative(
+    io.Directory(path.join(projectDirectory.path, 'routes')).path,
+  );
+
+  const middlewareFilename = '_middleware.dart';
+
+  // Get the path to directory containing the middleware file
+  final String middlewareContainingDir;
+  if (routePath == '/') {
+    middlewareContainingDir = routesDirectoryPath;
+  } else {
+    middlewareContainingDir = path.withoutExtension(
+      routeToPath(
+        routePath.toBracketParameterSyntax,
+        preamble: routesDirectoryPath,
+      ),
+    );
+  }
+
+  // Verify if the middleware file already exists
+  final middlewareFilePath =
+      path.join(middlewareContainingDir, middlewareFilename);
+  final middlewareExists = io.File(middlewareFilePath).existsSync();
+  if (middlewareExists) {
+    context.logger.err('There is already a middleware at $middlewareFilePath');
+    return exit(1);
+  }
+
+  // Verify if the given route already exists as directory
+  final routeExistsAsDirectory = io.Directory(
+    middlewareContainingDir.toBracketParameterSyntax,
+  ).existsSync();
+
+  // If the route does not exist as directory, we must check if any of its
+  // ancestor routes exists as file routes to avoid rogue routes.
+  if (!routeExistsAsDirectory) {
+    final fileRoute = routeConfiguration.containingFileRoute(
+      routePath,
+      includeSelf: true,
+    );
+
+    if (fileRoute != null) {
+      final filePath = path.normalize(
+        path.join(routesDirectoryPath, fileRoute.path),
+      );
+
+      io.Directory(path.withoutExtension(filePath)).createSync();
+
+      final newFilepath = filePath.replaceFirst('.dart', '/index.dart');
+      io.File(filePath).renameSync(newFilepath);
+      context.logger
+          .detail('Renamed $filePath to $newFilepath to avoid rogue routes');
+    }
+  }
+
+  try {
+    middlewareContainingDir.toBracketParameterSyntax.getParameterNames();
+  } on FormatException catch (exception) {
+    context.logger.err('Failed to create middleware: ${exception.message}');
+    return exit(1);
+  }
+
+  context.logger.detail(
+    'Creating middleware file: ${middlewareFilePath.toBracketParameterSyntax}',
+  );
+
+  context.vars['is_middleware'] = true;
+  context.vars['dir_path'] = middlewareContainingDir.toBracketParameterSyntax;
+  context.vars['filename'] = middlewareFilename;
+}

bricks/dart_frog_new/hooks/test/post_gen_test.dart

@@ -48,6 +48,12 @@ void main() {
       );
     });
 
+    test('exit(1) if dir_path is not defined', () {
+      final exitCalls = <int>[];
+      postGen(context, exit: exitCalls.add);
+      expect(exitCalls, equals([1]));
+    });
+
     test('moves file to supposed directory', () {
       final directory = io.Directory.systemTemp.createTempSync(
         'dart_frog_new_hooks_test',