@morojs/moro 1.5.17 → 1.6.1

package/src/core/routing/index.ts

@@ -256,91 +256,20 @@ export class IntelligentRouteBuilder implements RouteBuilder {
 
 // Executable route with intelligent middleware ordering
 export class ExecutableRoute implements CompiledRoute {
-  // PERFORMANCE OPTIMIZATION: Pre-analyze route requirements
-  private readonly requiresAuth: boolean;
-  private readonly requiresValidation: boolean;
-  private readonly requiresRateLimit: boolean;
-  private readonly requiresCache: boolean;
-  private readonly hasBeforeMiddleware: boolean;
-  private readonly hasAfterMiddleware: boolean;
-  private readonly hasTransformMiddleware: boolean;
-  private readonly isFastPath: boolean;
-
-  constructor(public readonly schema: RouteSchema) {
-    // Pre-calculate what this route actually needs
-    this.requiresAuth = !!this.schema.auth;
-    this.requiresValidation = !!this.schema.validation;
-    this.requiresRateLimit = !!this.schema.rateLimit;
-    this.requiresCache = !!this.schema.cache;
-    this.hasBeforeMiddleware = !!this.schema.middleware?.before?.length;
-    this.hasAfterMiddleware = !!this.schema.middleware?.after?.length;
-    this.hasTransformMiddleware = !!this.schema.middleware?.transform?.length;
-
-    // Fast path: no middleware, no auth, no validation, no rate limiting
-    this.isFastPath =
-      !this.requiresAuth &&
-      !this.requiresValidation &&
-      !this.requiresRateLimit &&
-      !this.requiresCache &&
-      !this.hasBeforeMiddleware &&
-      !this.hasAfterMiddleware &&
-      !this.hasTransformMiddleware;
-
-    // Log fast path routes for monitoring
-    if (this.isFastPath) {
-      logger.debug(`Fast path route: ${this.schema.method} ${this.schema.path}`, 'FastPath');
-    }
-  }
+  constructor(public readonly schema: RouteSchema) {}
 
   async execute(req: HttpRequest, res: HttpResponse): Promise<void> {
     const validatedReq = req as ValidatedRequest;
 
     try {
-      // PERFORMANCE OPTIMIZATION: Fast path for simple routes
-      if (this.isFastPath) {
-        // Skip all middleware - execute handler directly
-        const result = await this.schema.handler(validatedReq, res);
-        if (result !== undefined && !res.headersSent) {
-          res.json(result);
-        }
-        return;
-      }
-
-      // Optimized middleware execution - only run what's needed
-      if (this.hasBeforeMiddleware) {
-        await this.executePhase('before', validatedReq, res);
-        if (res.headersSent) return;
-      }
-
-      if (this.requiresRateLimit) {
-        await this.executePhase('rateLimit', validatedReq, res);
-        if (res.headersSent) return;
-      }
-
-      if (this.requiresAuth) {
-        await this.executePhase('auth', validatedReq, res);
-        if (res.headersSent) return;
-      }
-
-      if (this.requiresValidation) {
-        await this.executePhase('validation', validatedReq, res);
-        if (res.headersSent) return;
-      }
-
-      if (this.hasTransformMiddleware) {
-        await this.executePhase('transform', validatedReq, res);
-        if (res.headersSent) return;
-      }
-
-      if (this.requiresCache) {
-        await this.executePhase('cache', validatedReq, res);
-        if (res.headersSent) return;
-      }
-
-      if (this.hasAfterMiddleware) {
-        await this.executePhase('after', validatedReq, res);
-        if (res.headersSent) return;
-      }
+      // Execute middleware in intelligent order
+      await this.executePhase('before', validatedReq, res);
+      await this.executePhase('rateLimit', validatedReq, res);
+      await this.executePhase('auth', validatedReq, res);
+      await this.executePhase('validation', validatedReq, res);
+      await this.executePhase('transform', validatedReq, res);
+      await this.executePhase('cache', validatedReq, res);
+      await this.executePhase('after', validatedReq, res);
 
       // Execute handler last
       if (!res.headersSent) {
@@ -432,32 +361,15 @@ export class ExecutableRoute implements CompiledRoute {
     req: HttpRequest,
     res: HttpResponse
   ): Promise<void> {
-    // PERFORMANCE OPTIMIZATION: Reduce Promise overhead
     return new Promise((resolve, reject) => {
-      let resolved = false;
-
-      const next = () => {
-        if (!resolved) {
-          resolved = true;
-          resolve();
-        }
-      };
-
       try {
+        const next = () => resolve();
         const result = middleware(req, res, next);
         if (result instanceof Promise) {
-          result.then(() => !resolved && next()).catch(reject);
-        } else {
-          // Synchronous middleware - call next immediately if not called
-          if (!resolved) {
-            next();
-          }
+          result.then(() => resolve()).catch(reject);
         }
       } catch (error) {
-        if (!resolved) {
-          resolved = true;
-          reject(error);
-        }
+        reject(error);
       }
     });
   }
@@ -471,90 +383,10 @@ export class ExecutableRoute implements CompiledRoute {
   }
 
   private async executeAuth(req: ValidatedRequest, res: HttpResponse): Promise<void> {
-    const authConfig = this.schema.auth;
-    const auth = req.auth;
-
-    // This should never happen since executeAuth is only called when auth config exists
-    if (!authConfig) {
-      logger.error('executeAuth called without auth config', 'Auth');
-      return;
-    }
-
+    // Authentication implementation will be added
     logger.debug('Auth check', 'Auth', {
-      config: authConfig,
-      isAuthenticated: auth?.isAuthenticated,
-      userRoles: auth?.user?.roles,
+      config: this.schema.auth,
     });
-
-    // Check if auth middleware ran
-    if (!auth) {
-      res.status(500);
-      res.json({
-        success: false,
-        error: 'Authentication middleware not configured',
-        message: 'Auth middleware must be installed before using route-level auth',
-      });
-      return;
-    }
-
-    // Check authentication requirement (default is required unless optional: true)
-    if (!authConfig.optional && !auth.isAuthenticated) {
-      res.status(401);
-      res.json({
-        success: false,
-        error: 'Authentication required',
-        message: 'You must be logged in to access this resource',
-      });
-      return;
-    }
-
-    // Skip further checks if not authenticated but optional
-    if (!auth.isAuthenticated && authConfig.optional) {
-      return; // Continue to handler
-    }
-
-    // Only check roles/permissions if user is authenticated
-    if (auth.isAuthenticated) {
-      const user = auth.user;
-
-      // Check roles if specified
-      if (authConfig.roles && authConfig.roles.length > 0) {
-        const userRoles = user?.roles || [];
-        const hasRole = authConfig.roles.some((role: string) => userRoles.includes(role));
-
-        if (!hasRole) {
-          res.status(403);
-          res.json({
-            success: false,
-            error: 'Insufficient permissions',
-            message: `Required roles: ${authConfig.roles.join(', ')}`,
-            userRoles,
-          });
-          return;
-        }
-      }
-
-      // Check permissions if specified
-      if (authConfig.permissions && authConfig.permissions.length > 0) {
-        const userPermissions = user?.permissions || [];
-        const hasPermission = authConfig.permissions.every((permission: string) =>
-          userPermissions.includes(permission)
-        );
-
-        if (!hasPermission) {
-          res.status(403);
-          res.json({
-            success: false,
-            error: 'Insufficient permissions',
-            message: `Required permissions: ${authConfig.permissions.join(', ')}`,
-            userPermissions,
-          });
-          return;
-        }
-      }
-    }
-
-    // All auth checks passed
   }
 
   private async executeValidation(req: ValidatedRequest, res: HttpResponse): Promise<void> {
@@ -643,22 +475,6 @@ export class ExecutableRoute implements CompiledRoute {
       config: this.schema.cache,
     });
   }
-
-  // Performance monitoring
-  getPerformanceInfo() {
-    return {
-      path: this.schema.path,
-      method: this.schema.method,
-      isFastPath: this.isFastPath,
-      requiresAuth: this.requiresAuth,
-      requiresValidation: this.requiresValidation,
-      requiresRateLimit: this.requiresRateLimit,
-      requiresCache: this.requiresCache,
-      hasBeforeMiddleware: this.hasBeforeMiddleware,
-      hasAfterMiddleware: this.hasAfterMiddleware,
-      hasTransformMiddleware: this.hasTransformMiddleware,
-    };
-  }
 }
 
 // Factory functions for creating routes

package/src/core/runtime/node-adapter.ts

@@ -138,30 +138,24 @@ export class NodeRuntimeAdapter extends BaseRuntimeAdapter {
 
     if (!enhanced.cookie) {
       enhanced.cookie = function (name: string, value: string, options?: any) {
-        if (!this.headersSent) {
-          const cookieString = `${name}=${value}`;
-          this.setHeader('Set-Cookie', cookieString);
-        }
+        const cookieString = `${name}=${value}`;
+        this.setHeader('Set-Cookie', cookieString);
         return this;
       };
     }
 
     if (!enhanced.clearCookie) {
       enhanced.clearCookie = function (name: string, options?: any) {
-        if (!this.headersSent) {
-          this.setHeader('Set-Cookie', `${name}=; expires=Thu, 01 Jan 1970 00:00:00 GMT`);
-        }
+        this.setHeader('Set-Cookie', `${name}=; expires=Thu, 01 Jan 1970 00:00:00 GMT`);
         return this;
       };
     }
 
     if (!enhanced.redirect) {
       enhanced.redirect = function (url: string, status?: number) {
-        if (!this.headersSent) {
-          this.statusCode = status || 302;
-          this.setHeader('Location', url);
-          this.end();
-        }
+        this.statusCode = status || 302;
+        this.setHeader('Location', url);
+        this.end();
       };
     }