create-phoenixjs 0.1.1 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "create-phoenixjs",
-	"version": "0.1.1",
+	"version": "0.1.2",
 	"description": "Create a new PhoenixJS project - A TypeScript framework inspired by Laravel, powered by Bun",
 	"type": "module",
 	"bin": {

package/template/framework/cli/commands/MakeMiddlewareCommand.ts

@@ -25,11 +25,12 @@ export class MakeMiddlewareCommand extends Command {
 
 		fs.mkdirSync(directory, { recursive: true });
 
-		const template = `import { Middleware, MiddlewareHandler, NextFunction, Request, Response } from '@framework/middleware/Middleware';
+		const template = `import type { Middleware, NextFunction, Request } from '@framework/middleware/Middleware';
 
 export class ${className} implements Middleware {
-    async handle(request: Request, next: NextFunction): Promise<Response | any> {
-        // middleware logic
+    async handle(request: Request, next: NextFunction): Promise<Response> {
+        // Add your middleware logic here
+        
         return next(request);
     }
 }

package/template/framework/core/Kernel.ts

@@ -11,7 +11,7 @@ import { FrameworkRequest } from '@framework/http/Request';
 import { FrameworkResponse } from '@framework/http/Response';
 import { Router } from '@framework/routing/Router';
 import { Pipeline } from '@framework/middleware/Pipeline';
-import type { MiddlewareHandler, MiddlewareResolvable } from '@framework/middleware/Middleware';
+import type { Middleware, MiddlewareHandler, MiddlewareResolvable } from '@framework/middleware/Middleware';
 import type { RouteMatch } from '@framework/routing/RouteRegistry';
 import type { ControllerConstructor } from '@framework/controller/Controller';
 
@@ -229,15 +229,25 @@ export class Kernel {
 				// Check for middleware alias
 				const aliased = Router.resolveMiddleware(m);
 				if (aliased && typeof aliased !== 'string') {
-					resolved.push(aliased);
+					// Handle the aliased middleware (could be class or instance)
+					if (typeof aliased === 'function' && aliased.prototype && typeof aliased.prototype.handle === 'function') {
+						const MiddlewareClass = aliased as new () => Middleware;
+						resolved.push(new MiddlewareClass());
+					} else {
+						resolved.push(aliased as MiddlewareHandler);
+					}
 				}
 				// Check for middleware group
 				else if (this.middlewareGroups.has(m)) {
 					resolved.push(...(this.middlewareGroups.get(m) || []));
 				}
 				// String middleware not resolved - skip for now (will be resolved via controller in Phase 2)
+			} else if (typeof m === 'function' && m.prototype && typeof m.prototype.handle === 'function') {
+				// Handle middleware class constructors (instantiate them)
+				const MiddlewareClass = m as new () => Middleware;
+				resolved.push(new MiddlewareClass());
 			} else {
-				resolved.push(m);
+				resolved.push(m as MiddlewareHandler);
 			}
 		}
 

package/template/framework/middleware/Middleware.ts

@@ -7,6 +7,9 @@
 
 import { FrameworkRequest } from '@framework/http/Request';
 
+// Re-export for convenience in middleware files
+export { FrameworkRequest as Request } from '@framework/http/Request';
+
 /**
  * The function signature for the next middleware in the chain
  */
@@ -45,6 +48,13 @@ export type MiddlewareHandler =
 	| ((request: FrameworkRequest, next: NextFunction) => Promise<Response>);
 
 /**
- * Type for middleware that can be resolved from string name
+ * Middleware class constructor type
+ * For passing middleware classes directly (will be instantiated automatically)
  */
-export type MiddlewareResolvable = string | MiddlewareHandler;
+export type MiddlewareClass = new (...args: unknown[]) => Middleware;
+
+/**
+ * Type for middleware that can be resolved from string name, class, or instance
+ */
+export type MiddlewareResolvable = string | MiddlewareHandler | MiddlewareClass;
+