@morojs/moro 1.6.0 → 1.6.1

package/src/core/modules/modules.ts

@@ -1,10 +1,10 @@
 // Module System - Definition and Loading
 import { promises as fs } from 'fs';
 import path from 'path';
-import { Container } from '../utilities/index.js';
-import { ModuleConfig } from '../../types/module.js';
-import { ModuleDefinition, ModuleRoute, ModuleSocket } from '../../types/module.js';
-import { createFrameworkLogger } from '../logger/index.js';
+import { Container } from '../utilities';
+import { ModuleConfig } from '../../types/module';
+import { ModuleDefinition, ModuleRoute, ModuleSocket } from '../../types/module';
+import { logger, createFrameworkLogger } from '../logger';
 
 // Module Definition Function
 export function defineModule(definition: ModuleDefinition): ModuleConfig {
@@ -24,21 +24,6 @@ export function defineModule(definition: ModuleDefinition): ModuleConfig {
       cache: route.cache,
       rateLimit: route.rateLimit,
       middleware: route.middleware,
-      // Copy all additional properties for extensibility
-      ...Object.fromEntries(
-        Object.entries(route).filter(
-          ([key]) =>
-            ![
-              'method',
-              'path',
-              'handler',
-              'validation',
-              'cache',
-              'rateLimit',
-              'middleware',
-            ].includes(key)
-        )
-      ),
     }));
 
     // Store the actual route handler functions
@@ -109,14 +94,18 @@ export class ModuleLoader {
               }
             }
           } catch (error) {
-            this.moduleLogger.warn(`Could not load module from ${modulePath}`, 'MODULE_LOADER', {
-              error: error instanceof Error ? error.message : String(error),
-            });
+            this.moduleLogger.warn(
+              `⚠️  Could not load module from ${modulePath}:`,
+              'ModuleLoader',
+              {
+                error: error instanceof Error ? error.message : String(error),
+              }
+            );
           }
         }
       }
     } catch (error) {
-      this.moduleLogger.error('Failed to discover modules', 'MODULE_LOADER', {
+      this.moduleLogger.error('Failed to discover modules:', 'ModuleLoader', {
         error: error instanceof Error ? error.message : String(error),
       });
     }

package/src/core/networking/adapters/index.ts

@@ -1,9 +1,8 @@
 // WebSocket Adapters for Moro Framework
 // Export all available adapters from this centralized location
 
-export { SocketIOAdapter } from './socketio-adapter.js';
-export { WSAdapter } from './ws-adapter.js';
-export { UWebSocketsAdapter } from './uws-adapter.js';
+export { SocketIOAdapter } from './socketio-adapter';
+export { WSAdapter } from './ws-adapter';
 
 // Re-export the adapter interface for convenience
 export type {
@@ -14,4 +13,4 @@ export type {
   WebSocketEmitter,
   WebSocketMiddleware,
   WebSocketEventHandler,
-} from '../websocket-adapter.js';
+} from '../websocket-adapter';

package/src/core/networking/adapters/socketio-adapter.ts

@@ -1,7 +1,6 @@
 // Socket.IO WebSocket Adapter for Moro Framework
 // Implements the WebSocket adapter interface using Socket.IO
 
-import { resolveUserPackage } from '../../utilities/package-utils.js';
 import {
   WebSocketAdapter,
   WebSocketAdapterOptions,
@@ -9,7 +8,7 @@ import {
   WebSocketConnection,
   WebSocketEmitter,
   WebSocketMiddleware,
-} from '../websocket-adapter.js';
+} from '../websocket-adapter';
 
 /**
  * Socket.IO adapter implementation
@@ -20,9 +19,8 @@ export class SocketIOAdapter implements WebSocketAdapter {
 
   async initialize(httpServer: any, options: WebSocketAdapterOptions = {}): Promise<void> {
     try {
-      // Dynamic import from user's context to find their installed socket.io
-      const socketIOPath = resolveUserPackage('socket.io');
-      const { Server } = await import(socketIOPath);
+      // Dynamic import to avoid requiring socket.io as a hard dependency
+      const { Server } = await import('socket.io');
 
       this.io = new Server(httpServer, {
         cors: options.cors || { origin: '*' },

package/src/core/networking/adapters/ws-adapter.ts

@@ -1,7 +1,6 @@
 // Native WebSocket Adapter for Moro Framework
 // Implements the WebSocket adapter interface using the 'ws' library
 
-import { resolveUserPackage } from '../../utilities/package-utils.js';
 import {
   WebSocketAdapter,
   WebSocketAdapterOptions,
@@ -9,8 +8,8 @@ import {
   WebSocketConnection,
   WebSocketEmitter,
   WebSocketMiddleware,
-} from '../websocket-adapter.js';
-import { createFrameworkLogger } from '../../logger/index.js';
+} from '../websocket-adapter';
+import { createFrameworkLogger } from '../../logger';
 
 /**
  * Native WebSocket adapter using the 'ws' library
@@ -20,15 +19,14 @@ export class WSAdapter implements WebSocketAdapter {
   private wss: any; // WebSocket server instance
   private namespaces = new Map<string, WSNamespaceWrapper>();
   private connections = new Map<string, WSConnectionWrapper>();
-  private wsLogger = createFrameworkLogger('WEBSOCKET_ADAPTER');
   private customIdGenerator?: () => string;
   private connectionCounter = 0;
+  private wsLogger = createFrameworkLogger('WEBSOCKET_ADAPTER');
 
   async initialize(httpServer: any, options: WebSocketAdapterOptions = {}): Promise<void> {
     try {
-      // Dynamic import from user's context to find their installed ws library
-      const wsPath = resolveUserPackage('ws');
-      const { WebSocketServer } = await import(wsPath);
+      // Dynamic import to avoid requiring ws as a hard dependency
+      const { WebSocketServer } = await import('ws');
 
       this.wss = new WebSocketServer({
         server: httpServer,
@@ -102,7 +100,10 @@ export class WSAdapter implements WebSocketAdapter {
     // ws library handles compression at the browser level
     // This is a no-op but kept for interface compatibility
     if (enabled) {
-      this.wsLogger.warn('Compression is handled automatically by the ws library and browsers');
+      this.wsLogger.warn(
+        'Compression is handled automatically by the ws library and browsers',
+        'WSAdapter'
+      );
     }
   }
 

package/src/core/networking/index.ts

@@ -1,4 +1,3 @@
 // Networking System - Centralized Exports
-export { WebSocketManager } from './websocket-manager.js';
-export { ServiceRegistry } from './service-discovery.js';
-export type { ServiceInfo, ServiceDiscoveryOptions } from './service-discovery.js';
+export { WebSocketManager } from './websocket-manager';
+export { ServiceRegistry, ServiceInfo, ServiceDiscoveryOptions } from './service-discovery';

package/src/core/networking/service-discovery.ts

@@ -1,6 +1,7 @@
 // Service Discovery Client for Microservices
 // Supports Consul, Kubernetes, and in-memory registry
-import { createFrameworkLogger } from '../logger/index.js';
+
+import { logger, createFrameworkLogger } from '../logger';
 
 export interface ServiceInfo {
   name: string;
@@ -123,7 +124,7 @@ export class ServiceRegistry {
         throw new Error(`Consul registration failed: ${response.statusText}`);
       }
     } catch (error) {
-      this.serviceLogger.error('Failed to register with Consul', 'SERVICE_DISCOVERY', {
+      this.serviceLogger.error('Failed to register with Consul:', 'ServiceRegistry', {
         error: error instanceof Error ? error.message : String(error),
       });
       // Fallback to in-memory
@@ -154,7 +155,7 @@ export class ServiceRegistry {
         metadata: entry.Service.Meta,
       }));
     } catch (error) {
-      this.serviceLogger.error('Failed to discover from Consul', 'SERVICE_DISCOVERY', {
+      this.serviceLogger.error('Failed to discover from Consul:', 'ServiceRegistry', {
         error: error instanceof Error ? error.message : String(error),
       });
       return this.discoverFromMemory(serviceName);
@@ -169,7 +170,7 @@ export class ServiceRegistry {
         method: 'PUT',
       });
     } catch (error) {
-      this.serviceLogger.error('Failed to deregister from Consul', 'SERVICE_DISCOVERY', {
+      this.serviceLogger.error('Failed to deregister from Consul:', 'ServiceRegistry', {
         error: error instanceof Error ? error.message : String(error),
       });
     }
@@ -204,7 +205,7 @@ export class ServiceRegistry {
         },
       ];
     } catch (error) {
-      this.serviceLogger.error('Failed to discover from Kubernetes', 'SERVICE_DISCOVERY', {
+      this.serviceLogger.error('Failed to discover from Kubernetes:', 'ServiceRegistry', {
         error: error instanceof Error ? error.message : String(error),
       });
       return this.discoverFromMemory(serviceName);
@@ -241,7 +242,7 @@ export class ServiceRegistry {
               this.removeUnhealthyService(serviceName, service);
             }
           } catch (error) {
-            this.serviceLogger.warn(`Health check failed for ${serviceName}`, 'SERVICE_DISCOVERY', {
+            this.serviceLogger.warn(`Health check failed for ${serviceName}:`, 'ServiceRegistry', {
               error: error instanceof Error ? error.message : String(error),
             });
             this.removeUnhealthyService(serviceName, service);

package/src/core/networking/websocket-manager.ts

@@ -1,12 +1,10 @@
 // WebSocket Manager for Moro Framework
 // Manages WebSocket connections using pluggable adapters
-import * as zlib from 'zlib';
-import { Container } from '../utilities/index.js';
-import { CircuitBreaker } from '../utilities/index.js';
-import { ModuleConfig, WebSocketDefinition } from '../../types/module.js';
-import { WebSocketAdapter, WebSocketNamespace, WebSocketConnection } from './websocket-adapter.js';
-import { createFrameworkLogger } from '../logger/index.js';
-import { normalizeValidationError } from '../validation/schema-interface.js';
+import { Container } from '../utilities';
+import { CircuitBreaker } from '../utilities';
+import { ModuleConfig, WebSocketDefinition } from '../../types/module';
+import { WebSocketAdapter, WebSocketNamespace, WebSocketConnection } from './websocket-adapter';
+import { createFrameworkLogger } from '../logger';
 
 export class WebSocketManager {
   private circuitBreakers = new Map<string, CircuitBreaker>();
@@ -136,6 +134,7 @@ export class WebSocketManager {
             data = await wsConfig.validation.parseAsync(data);
           } catch (validationError: any) {
             // Handle universal validation errors
+            const { normalizeValidationError } = require('../validation/schema-interface');
             const normalizedError = normalizeValidationError(validationError);
             const error = {
               success: false,
@@ -265,6 +264,7 @@ export class WebSocketManager {
     if (buffer[0] === 0x1f && buffer[1] === 0x8b) {
       // This is gzipped data
       try {
+        const zlib = require('zlib');
         return zlib.gunzipSync(buffer);
       } catch {
         return buffer;

package/src/core/routing/app-integration.ts

@@ -8,9 +8,9 @@ import {
   createRoute,
   defineRoute,
   HttpMethod,
-} from './index.js';
-import { HttpRequest, HttpResponse } from '../http/index.js';
-import { createFrameworkLogger } from '../logger/index.js';
+} from './index';
+import { HttpRequest, HttpResponse } from '../http';
+import { createFrameworkLogger } from '../logger';
 
 const logger = createFrameworkLogger('AppIntegration');
 

package/src/core/routing/index.ts

@@ -1,9 +1,9 @@
 // Intelligent Routing System for Moro Framework
 // Schema-first with automatic middleware ordering and chainable API
 
-import { ValidationSchema } from '../validation/schema-interface.js';
-import { HttpRequest, HttpResponse } from '../http/index.js';
-import { createFrameworkLogger } from '../logger/index.js';
+import { ValidationSchema } from '../validation/schema-interface';
+import { HttpRequest, HttpResponse } from '../http';
+import { createFrameworkLogger } from '../logger';
 
 const logger = createFrameworkLogger('IntelligentRouting');
 
@@ -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/aws-lambda-adapter.ts

@@ -1,7 +1,7 @@
 // AWS Lambda runtime adapter
-import { BaseRuntimeAdapter } from './base-adapter.js';
-import { HttpRequest, HttpResponse } from '../../types/http.js';
-import { RuntimeHttpResponse } from '../../types/runtime.js';
+import { BaseRuntimeAdapter } from './base-adapter';
+import { HttpRequest, HttpResponse } from '../../types/http';
+import { RuntimeHttpResponse } from '../../types/runtime';
 
 export interface LambdaEvent {
   httpMethod: string;

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

@@ -1,6 +1,6 @@
 // Base runtime adapter with common functionality
-import { RuntimeAdapter, RuntimeType, RuntimeHttpResponse } from '../../types/runtime.js';
-import { HttpRequest, HttpResponse } from '../../types/http.js';
+import { RuntimeAdapter, RuntimeType, RuntimeHttpResponse } from '../../types/runtime';
+import { HttpRequest, HttpResponse } from '../../types/http';
 import { randomBytes } from 'crypto';
 
 export abstract class BaseRuntimeAdapter implements RuntimeAdapter {

package/src/core/runtime/cloudflare-workers-adapter.ts

@@ -1,7 +1,7 @@
 // Cloudflare Workers runtime adapter
-import { BaseRuntimeAdapter } from './base-adapter.js';
-import { HttpRequest, HttpResponse } from '../../types/http.js';
-import { RuntimeHttpResponse } from '../../types/runtime.js';
+import { BaseRuntimeAdapter } from './base-adapter';
+import { HttpRequest, HttpResponse } from '../../types/http';
+import { RuntimeHttpResponse } from '../../types/runtime';
 
 export interface WorkersEnv {
   [key: string]: any;

package/src/core/runtime/index.ts

@@ -1,9 +1,9 @@
 // Runtime adapters export
-export { BaseRuntimeAdapter } from './base-adapter.js';
-export { NodeRuntimeAdapter } from './node-adapter.js';
-export { VercelEdgeAdapter } from './vercel-edge-adapter.js';
-export { AWSLambdaAdapter } from './aws-lambda-adapter.js';
-export { CloudflareWorkersAdapter } from './cloudflare-workers-adapter.js';
+export { BaseRuntimeAdapter } from './base-adapter';
+export { NodeRuntimeAdapter } from './node-adapter';
+export { VercelEdgeAdapter } from './vercel-edge-adapter';
+export { AWSLambdaAdapter } from './aws-lambda-adapter';
+export { CloudflareWorkersAdapter } from './cloudflare-workers-adapter';
 
 // Re-export types
 export type {
@@ -12,18 +12,18 @@ export type {
   RuntimeConfig,
   RuntimeMoroOptions,
   RuntimeHttpResponse,
-} from '../../types/runtime.js';
+} from '../../types/runtime';
 
 // Re-export specific runtime types
-export type { LambdaEvent, LambdaContext, LambdaResponse } from './aws-lambda-adapter.js';
-export type { WorkersEnv, WorkersContext } from './cloudflare-workers-adapter.js';
+export type { LambdaEvent, LambdaContext, LambdaResponse } from './aws-lambda-adapter';
+export type { WorkersEnv, WorkersContext } from './cloudflare-workers-adapter';
 
 // Runtime factory functions
-import { NodeRuntimeAdapter } from './node-adapter.js';
-import { VercelEdgeAdapter } from './vercel-edge-adapter.js';
-import { AWSLambdaAdapter } from './aws-lambda-adapter.js';
-import { CloudflareWorkersAdapter } from './cloudflare-workers-adapter.js';
-import { RuntimeType, RuntimeAdapter } from '../../types/runtime.js';
+import { NodeRuntimeAdapter } from './node-adapter';
+import { VercelEdgeAdapter } from './vercel-edge-adapter';
+import { AWSLambdaAdapter } from './aws-lambda-adapter';
+import { CloudflareWorkersAdapter } from './cloudflare-workers-adapter';
+import { RuntimeType, RuntimeAdapter } from '../../types/runtime';
 
 export function createRuntimeAdapter(type: RuntimeType): RuntimeAdapter {
   switch (type) {

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

@@ -1,9 +1,9 @@
 // Node.js runtime adapter
 import { IncomingMessage, ServerResponse } from 'http';
-import { BaseRuntimeAdapter } from './base-adapter.js';
-import { HttpRequest, HttpResponse } from '../../types/http.js';
-import { RuntimeHttpResponse } from '../../types/runtime.js';
-import { MoroHttpServer } from '../http/http-server.js';
+import { BaseRuntimeAdapter } from './base-adapter';
+import { HttpRequest, HttpResponse } from '../../types/http';
+import { RuntimeHttpResponse } from '../../types/runtime';
+import { MoroHttpServer } from '../http/http-server';
 
 export class NodeRuntimeAdapter extends BaseRuntimeAdapter {
   readonly type = 'node' as const;
@@ -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();
       };
     }