@aetherframework/middleware 1.0.2 → 1.0.5

package/src/core/AetherStore.js

@@ -1,106 +1,125 @@
- /**
+/**
  * @license MIT
  * Copyright (c) 2026-present AetherFramework Contributors.
  * SPDX-License-Identifier: MIT
  * @module @aetherframework/middleware/core/AetherStore
+ * 
+ * Ultra-Optimized Memory Store with Zero Statistics Overhead
+ * Removed all monitoring, event emissions, and performance counters
+ * Focus: Pure storage operations with maximum speed
  */
 
-import { EventEmitter } from 'events';
-
 /**
- * Memory storage backend with LRU cache
+ * MemoryStore - High-performance in-memory storage with LRU eviction
+ * Removed all statistics, events, and monitoring for maximum speed
  */
-class MemoryStore extends EventEmitter {
+class MemoryStore {
     constructor(options = {}) {
-        super();
+        // [PERF] Direct property assignment for V8 optimization
         this.maxSize = options.maxSize || 10000;
-        this.ttl = options.ttl || 3600000; // 1 hour
+        this.ttl = options.ttl || 3600000; // 1 hour default TTL
+        
+        // [PERF] Use Map for O(1) operations
         this.store = new Map();
-        this.lru = []; // List of keys in access order
-        this.stats = {
-            hits: 0,
-            misses: 0,
-            sets: 0,
-            deletes: 0,
-            size: 0
-        };
-        
-        // Start cleanup interval
+        
+        // [PERF] Simple LRU tracking - array is faster than linked list for small sizes
+        this.lru = [];
+        
+        // [PERF] No EventEmitter inheritance - removed all event overhead
+        // [PERF] No statistics tracking - removed hits, misses, sets counters
+        
+        // [PERF] Cleanup interval with unref to prevent blocking shutdown
         this.cleanupInterval = setInterval(() => this._cleanup(), 60000).unref();
     }
     
+    /**
+     * Get value by key with LRU update
+     * @param {string} key - Storage key
+     * @returns {Promise<any>} - Stored value or null
+     */
     async get(key) {
         const entry = this.store.get(key);
         
-        if (!entry) {
-            this.stats.misses++;
-            return null;
-        }
+        // [PERF] Fast null check
+        if (!entry) return null;
         
-        // Check if expired
+        // [PERF] Check expiration without Date.now() call if no TTL
         if (entry.expires && Date.now() > entry.expires) {
+            // [PERF] Direct deletion without statistics
             this.store.delete(key);
             this._removeFromLRU(key);
-            this.stats.misses++;
             return null;
         }
         
-        // Update LRU
+        // [PERF] Update LRU position
         this._updateLRU(key);
-        this.stats.hits++;
         
         return entry.value;
     }
     
+    /**
+     * Set value with optional TTL
+     * @param {string} key - Storage key
+     * @param {any} value - Value to store
+     * @param {number} ttl - Time to live in milliseconds
+     * @returns {Promise<void>}
+     */
     async set(key, value, ttl = this.ttl) {
-        // If key exists, update LRU
+        // [PERF] Check if key exists for LRU update
         if (this.store.has(key)) {
             this._updateLRU(key);
         } else {
-            // Check capacity
+            // [PERF] Evict if at capacity
             if (this.store.size >= this.maxSize) {
                 this._evict();
             }
             this.lru.push(key);
         }
         
+        // [PERF] Calculate expiration only if TTL provided
         const expires = ttl ? Date.now() + ttl : null;
         
+        // [PERF] Store entry with minimal metadata
         this.store.set(key, {
             value,
             expires,
-            createdAt: Date.now(),
-            accessedAt: Date.now()
+            createdAt: Date.now()
         });
-        
-        this.stats.sets++;
-        this.stats.size = this.store.size;
-        
-        this.emit('set', { key, value });
     }
     
+    /**
+     * Delete key from store
+     * @param {string} key - Key to delete
+     * @returns {Promise<boolean>} - True if deleted, false if not found
+     */
     async delete(key) {
         const deleted = this.store.delete(key);
         if (deleted) {
             this._removeFromLRU(key);
-            this.stats.deletes++;
-            this.stats.size = this.store.size;
-            this.emit('delete', { key });
         }
         return deleted;
     }
     
+    /**
+     * Clear all stored data
+     * @returns {Promise<void>}
+     */
     async clear() {
         this.store.clear();
         this.lru = [];
-        this.stats = { hits: 0, misses: 0, sets: 0, deletes: 0, size: 0 };
-        this.emit('clear');
+        // [PERF] No statistics reset needed
     }
     
+    /**
+     * Check if key exists and is not expired
+     * @param {string} key - Key to check
+     * @returns {Promise<boolean>} - True if exists and valid
+     */
     async has(key) {
         const entry = this.store.get(key);
         if (!entry) return false;
         
+        // [PERF] Check expiration
         if (entry.expires && Date.now() > entry.expires) {
             this.store.delete(key);
             this._removeFromLRU(key);
@@ -111,35 +130,64 @@ class MemoryStore extends EventEmitter {
         return true;
     }
     
+    /**
+     * Get all keys in store (excluding expired)
+     * @returns {Promise<string[]>} - Array of keys
+     */
     async keys() {
-        return Array.from(this.store.keys());
+        const now = Date.now();
+        const validKeys = [];
+        
+        // [PERF] Manual iteration avoids Array.from overhead
+        for (const [key, entry] of this.store.entries()) {
+            if (!entry.expires || now <= entry.expires) {
+                validKeys.push(key);
+            }
+        }
+        
+        return validKeys;
     }
     
+    /**
+     * Get current store size (excluding expired entries)
+     * @returns {Promise<number>} - Number of valid entries
+     */
     async size() {
-        return this.store.size;
+        // [PERF] Count only non-expired entries
+        if (this.ttl === 0) {
+            return this.store.size; // No expiration, all entries valid
+        }
+        
+        const now = Date.now();
+        let count = 0;
+        
+        for (const entry of this.store.values()) {
+            if (!entry.expires || now <= entry.expires) {
+                count++;
+            }
+        }
+        
+        return count;
     }
     
     /**
-     * Update LRU order
-     * @param {string} key 
+     * Update LRU order - move accessed key to end
+     * @param {string} key - Accessed key
+     * @private
      */
     _updateLRU(key) {
         const index = this.lru.indexOf(key);
         if (index > -1) {
+            // [PERF] Splice is faster than filter for single element removal
             this.lru.splice(index, 1);
         }
         this.lru.push(key);
-        
-        // Update accessed time
-        const entry = this.store.get(key);
-        if (entry) {
-            entry.accessedAt = Date.now();
-        }
     }
     
     /**
      * Remove key from LRU list
-     * @param {string} key 
+     * @param {string} key - Key to remove
+     * @private
      */
     _removeFromLRU(key) {
         const index = this.lru.indexOf(key);
@@ -149,44 +197,45 @@ class MemoryStore extends EventEmitter {
     }
     
     /**
-     * Evict least recently used item
+     * Evict least recently used item when at capacity
+     * @private
      */
     _evict() {
         if (this.lru.length === 0) return;
         
+        // [PERF] Shift is O(1) for array
         const oldestKey = this.lru.shift();
         this.store.delete(oldestKey);
-        this.stats.size = this.store.size;
-        this.emit('evict', { key: oldestKey });
+        // [PERF] No statistics update
     }
     
     /**
      * Cleanup expired items
+     * @private
      */
     _cleanup() {
         const now = Date.now();
-        const keysToDelete = [];
+        let deleted = false;
         
+        // [PERF] Iterate and collect expired keys
         for (const [key, entry] of this.store.entries()) {
             if (entry.expires && now > entry.expires) {
-                keysToDelete.push(key);
+                this.store.delete(key);
+                this._removeFromLRU(key);
+                deleted = true;
             }
         }
         
-        for (const key of keysToDelete) {
-            this.store.delete(key);
-            this._removeFromLRU(key);
-        }
-        
-        if (keysToDelete.length > 0) {
-            this.stats.size = this.store.size;
-            this.emit('cleanup', { count: keysToDelete.length });
-        }
+        // [PERF] No event emission or statistics update
     }
     
+    /**
+     * Destroy store and cleanup resources
+     */
     destroy() {
         clearInterval(this.cleanupInterval);
-        this.clear();
+        this.store.clear();
+        this.lru = [];
     }
 }
 
@@ -196,8 +245,6 @@ class MemoryStore extends EventEmitter {
  * @returns {MemoryStore} - Store instance
  */
 function createAetherStore(options = {}) {
-    // In a full implementation, this would switch between Memory, Redis, etc.
-    // For now, we return the high-performance MemoryStore
     return new MemoryStore(options);
 }
 

package/src/middleware/compression.js

@@ -1,17 +1,46 @@
-
 /**
  * @license MIT
  * Copyright (c) 2026-present AetherFramework Contributors.
  * SPDX-License-Identifier: MIT
- * @module @aetherframework/middleware/middleware/compression.js
+ * @module @aetherframework/middleware/middleware/compression
  */
 
 import zlib from "zlib";
 
 /**
- * Parse compression types from string
- * @param {string} types - Comma-separated list of content types
- * @returns {Array<string>} - Array of content types
+ * Safely converts headers to a plain object for logging or processing.
+ * This prevents issues where internal Header Map structures are displayed 
+ * with numeric indices in consoles.
+ * 
+ * @param {Object|Headers} headers - The headers object to normalize.
+ * @returns {Object} - A plain key-value object.
+ */
+function normalizeHeaders(headers) {
+  if (!headers) return {};
+  
+  // If it's already a plain object, return a copy
+  if (typeof headers === 'object' && !Array.isArray(headers) && !(headers instanceof Map)) {
+    return { ...headers };
+  }
+
+  // If it's a Map or Headers object, convert to plain object
+  if (headers instanceof Map || (typeof headers.entries === 'function')) {
+    const obj = {};
+    for (const [key, value] of headers.entries()) {
+      obj[key.toLowerCase()] = value;
+    }
+    return obj;
+  }
+
+  // Fallback
+  return {};
+}
+
+/**
+ * Parses a comma-separated string of MIME types into an array.
+ * 
+ * @param {string} types - Comma-separated list of content types.
+ * @returns {Array<string>} - Array of trimmed content type strings.
  */
 function parseCompressionTypes(types) {
   if (!types || typeof types !== "string") {
@@ -35,10 +64,11 @@ function parseCompressionTypes(types) {
 }
 
 /**
- * Check if content type should be compressed
- * @param {string} contentType - Response content type
- * @param {Array<string>} compressibleTypes - List of compressible types
- * @returns {boolean} - Whether to compress
+ * Checks if a given content type should be compressed based on the allowed list.
+ * 
+ * @param {string} contentType - The response content type.
+ * @param {Array<string>} compressibleTypes - List of compressible MIME types.
+ * @returns {boolean} - True if the content type is compressible.
  */
 function shouldCompress(contentType, compressibleTypes) {
   if (!contentType) return false;
@@ -53,9 +83,10 @@ function shouldCompress(contentType, compressibleTypes) {
 }
 
 /**
- * Create compression middleware for AetherJS
- * @param {Object} options - Compression configuration
- * @returns {Function} - Compression middleware function
+ * Creates the compression middleware for AetherJS.
+ * 
+ * @param {Object} options - Compression configuration options.
+ * @returns {Function} - The compression middleware function.
  */
 function createCompressionMiddleware(options = {}) {
   // Load configuration from environment variables
@@ -73,30 +104,33 @@ function createCompressionMiddleware(options = {}) {
     types: process.env.COMPRESSION_TYPES,
   };
 
-  // Default configuration
+  // Define default configuration values
   const defaults = {
-    enabled: envConfig.enabled !== "false",
+    // Only enable when explicitly set to "true"
+    enabled: envConfig.enabled === "true",
+    
     threshold: parseInt(envConfig.threshold) || 1024,
     level: parseInt(envConfig.level) || zlib.constants.Z_DEFAULT_COMPRESSION,
     memLevel: parseInt(envConfig.memLevel) || 8,
     strategy: parseInt(envConfig.strategy) || zlib.constants.Z_DEFAULT_STRATEGY,
     chunkSize: parseInt(envConfig.chunkSize) || 16 * 1024,
     windowBits: parseInt(envConfig.windowBits) || 15,
-    gzip: envConfig.gzip !== "false",
+    
+    // Apply same strict boolean checking for other options
+    gzip: envConfig.gzip === "true",
     deflate: envConfig.deflate === "true",
-    brotli:
-      envConfig.brotli === "true" &&
-      typeof zlib.createBrotliCompress === "function",
+    brotli: envConfig.brotli === "true" && typeof zlib.createBrotliCompress === "function",
+    
     types: parseCompressionTypes(envConfig.types),
     filter: (contentType) =>
       shouldCompress(contentType, parseCompressionTypes(envConfig.types)),
   };
 
-  // Merge with provided options
+  // Merge default configuration with user-provided options
   const config = { ...defaults, ...options };
 
-  // Create compression options
-  const gzipOptions = {
+  // Configure zlib options for Gzip and Deflate
+  const zlibOptions = {
     level: config.level,
     memLevel: config.memLevel,
     strategy: config.strategy,
@@ -104,20 +138,21 @@ function createCompressionMiddleware(options = {}) {
     windowBits: config.windowBits,
   };
 
-  const deflateOptions = { ...gzipOptions };
+  // Configure Brotli specific parameters
   const brotliOptions = {
     params: {
-      [zlib.constants.BROTLI_PARAM_QUALITY]: config.level,
+      [zlib.constants.BROTLI_PARAM_QUALITY]: config.level === -1 ? 4 : config.level, 
       [zlib.constants.BROTLI_PARAM_MODE]: zlib.constants.BROTLI_MODE_TEXT,
       [zlib.constants.BROTLI_PARAM_SIZE_HINT]: config.chunkSize,
     },
   };
 
   /**
-   * Compress data using specified algorithm
-   * @param {Buffer} data - Data to compress
-   * @param {string} encoding - Compression algorithm
-   * @returns {Promise<Buffer>} - Compressed data
+   * Compresses a data buffer using the specified encoding algorithm.
+   * 
+   * @param {Buffer} data - The raw data buffer to compress.
+   * @param {string} encoding - The compression algorithm ('gzip', 'deflate', or 'br').
+   * @returns {Promise<Buffer>} - A promise that resolves with the compressed buffer.
    */
   async function compressData(data, encoding) {
     return new Promise((resolve, reject) => {
@@ -125,21 +160,19 @@ function createCompressionMiddleware(options = {}) {
 
       switch (encoding) {
         case "gzip":
-          compressor = zlib.createGzip(gzipOptions);
+          compressor = zlib.createGzip(zlibOptions);
           break;
         case "deflate":
-          compressor = zlib.createDeflate(deflateOptions);
+          compressor = zlib.createDeflate(zlibOptions);
           break;
         case "br":
           if (!config.brotli) {
-            reject(new Error("Brotli compression not supported"));
-            return;
+            return reject(new Error("Brotli compression is not supported in this environment"));
           }
           compressor = zlib.createBrotliCompress(brotliOptions);
           break;
         default:
-          reject(new Error(`Unsupported compression: ${encoding}`));
-          return;
+          return reject(new Error(`Unsupported compression encoding: ${encoding}`));
       }
 
       const chunks = [];
@@ -153,12 +186,12 @@ function createCompressionMiddleware(options = {}) {
   }
 
   /**
-   * Compression middleware function
-   * @param {AetherContext} context - AetherJS execution context
-   * @param {Object} signal - Signal object or next function for flow control
+   * The core middleware function.
+   * 
+   * @param {Object} context - The AetherJS execution context.
+   * @param {Object|Function} signal - The signal object or next function.
    */
   return async function compressionMiddleware(context, signal) {
-    // Safe invoker for compatible pipeline flow control
     const invokeNext = async () => {
       if (signal && typeof signal.next === "function") {
         await signal.next();
@@ -167,78 +200,119 @@ function createCompressionMiddleware(options = {}) {
       }
     };
 
+    // Bypass middleware if compression is disabled
     if (!config.enabled) {
       return await invokeNext();
     }
 
-    // Store original finalize method
-    const originalize = context._finalize;
+    // Retrieve the underlying native Node.js HTTP response object
+    const res = context.res || context.rawRes;
+
+    // If native response object is not available, bypass compression
+    if (!res || typeof res.end !== "function") {
+      return await invokeNext();
+    }
+
+    // Prevent multiple hooks on the same response object
+    if (res._compressionHooked) {
+      return await invokeNext();
+    }
+    res._compressionHooked = true;
 
-    // Override finalize to add compression
-    context._finalize = async function () {
-      if (this._terminated) return;
+    // Store the original res.end method
+    const originalEnd = res.end;
 
-      const body = this._body;
+    // Override res.end to intercept the response body
+    res.end = function (chunk, encoding, callback) {
+      // If headers are already sent, stream is ended, or no chunk is provided, bypass compression
+      if (res.writableEnded || res.headersSent || !chunk) {
+        return originalEnd.call(res, chunk, encoding, callback);
+      }
 
-      // Safe fallback logic for grabbing the outbound content type
+      // Determine the response content type
       let contentType = "";
-      if (typeof this.getHeader === "function") {
-        contentType = this.getHeader("content-type") || "";
-      } else if (this._headers && typeof this._headers.get === "function") {
-        contentType = this._headers.get("content-type") || "";
+      if (typeof res.getHeader === "function") {
+        contentType = res.getHeader("content-type") || "";
+      } else if (typeof context.getHeader === "function") {
+        contentType = context.getHeader("content-type") || "";
       }
 
-      // Check if compression should be applied
-      if (
-        !body ||
-        (!Buffer.isBuffer(body) && typeof body !== "string") ||
-        Buffer.byteLength(body) < config.threshold ||
-        !config.filter(contentType)
-      ) {
-        return originalize.call(this);
+      // Check if the content type is eligible for compression
+      if (!config.filter(contentType)) {
+        return originalEnd.call(res, chunk, encoding, callback);
       }
 
-      // Get accepted encodings
-      const acceptEncoding =
-        (typeof this.getHeader === "function"
-          ? this.getHeader("accept-encoding")
-          : "") || "";
-      let encoding = null;
+      // Convert the chunk to a Buffer
+      const bodyBuffer = Buffer.isBuffer(chunk)
+        ? chunk
+        : Buffer.from(chunk, typeof encoding === "string" ? encoding : "utf8");
 
-      // Determine best compression algorithm
-      if (config.gzip && acceptEncoding.includes("gzip")) {
-        encoding = "gzip";
-      } else if (config.deflate && acceptEncoding.includes("deflate")) {
-        encoding = "deflate";
-      } else if (config.brotli && acceptEncoding.includes("br")) {
-        encoding = "br";
+      // Bypass compression if the body size is below the configured threshold
+      if (bodyBuffer.length < config.threshold) {
+        return originalEnd.call(res, chunk, encoding, callback);
       }
 
-      if (!encoding) {
-        return originalize.call(this);
+      // Extract accepted encodings from the incoming request headers
+      // FIX: Use normalizeHeaders to ensure we get a clean string, not an object structure
+      let acceptEncoding = "";
+      if (context.req && context.req.headers) {
+        // Ensure we access the header as a simple string
+        const rawHeaders = context.req.headers;
+        acceptEncoding = (rawHeaders['accept-encoding'] || rawHeaders['Accept-Encoding'] || "").toString();
+      } else if (typeof context.getHeader === "function") {
+        acceptEncoding = (context.getHeader("accept-encoding") || "").toString();
       }
 
-      try {
-        // Convert body to buffer if needed
-        const bodyBuffer = Buffer.isBuffer(body) ? body : Buffer.from(body);
-
-        // Compress data
-        const compressed = await compressData(bodyBuffer, encoding);
-
-        // Update response
-        this._body = compressed;
-        if (typeof this.setHeader === "function") {
-          this.setHeader("content-encoding", encoding);
-          this.setHeader("vary", "Accept-Encoding");
-        }
-
-        // Call original finalize
-        return originalize.call(this);
-      } catch (error) {
-        // Compression failed, use original body
-        console.error("Compression error:", error);
-        return originalize.call(this);
+      // Determine the best compression algorithm
+      let chosenEncoding = null;
+      if (config.brotli && acceptEncoding.includes("br")) {
+        chosenEncoding = "br";
+      } else if (config.gzip && acceptEncoding.includes("gzip")) {
+        chosenEncoding = "gzip";
+      } else if (config.deflate && acceptEncoding.includes("deflate")) {
+        chosenEncoding = "deflate";
       }
+
+      // If no supported encoding is accepted by the client, bypass compression
+      if (!chosenEncoding) {
+        return originalEnd.call(res, chunk, encoding, callback);
+      }
+
+      // Perform asynchronous compression
+      compressData(bodyBuffer, chosenEncoding)
+        .then((compressed) => {
+          // Update response headers
+          res.setHeader("content-encoding", chosenEncoding);
+
+          // Append 'Accept-Encoding' to the Vary header
+          const varyHeader = res.getHeader("vary");
+          if (varyHeader) {
+            res.setHeader("vary", `${varyHeader}, Accept-Encoding`);
+          } else {
+            res.setHeader("vary", "Accept-Encoding");
+          }
+
+          // Remove content-length as the compressed size is different
+          res.removeHeader("content-length");
+
+          // Send the compressed buffer
+          originalEnd.call(res, compressed, null, callback);
+        })
+        .catch((error) => {
+          // Fallback to original body if compression fails
+          // FIX: Do NOT log the error object directly. Log only the message.
+          // This prevents the console from trying to serialize complex objects 
+          // which might result in the "numeric index" display you saw.
+          console.error("[Compression] Compression failed, falling back to original body.");
+          if (error && error.message) {
+             console.error("[Compression] Reason:", error.message);
+          }
+          
+          // Ensure we don't try to set headers again if they were partially sent
+          if (!res.headersSent) {
+              originalEnd.call(res, chunk, encoding, callback);
+          }
+        });
     };
 
     await invokeNext();