@engjts/nexus 0.1.7 → 0.1.8

package/dist/core/context.js

@@ -6,8 +6,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContextImpl = void 0;
 exports.parseBody = parseBody;
-const url_1 = require("url");
-const querystring_1 = require("querystring");
+const fast_querystring_1 = require("fast-querystring");
 const store_1 = require("./store");
 /**
  * Cookie manager implementation
@@ -65,57 +64,94 @@ class CookieManager {
         });
     }
 }
+/**
+ * Pre-cached headers for common content types
+ * This avoids object creation on every response
+ */
+const CACHED_HEADERS = {
+    JSON: { 'Content-Type': 'application/json' },
+    HTML: { 'Content-Type': 'text/html; charset=utf-8' },
+    TEXT: { 'Content-Type': 'text/plain; charset=utf-8' },
+};
 /**
  * Response builder implementation
+ * Supports fast-json-stringify for optimized JSON serialization
  */
 class ResponseBuilderImpl {
     _status = 200;
     _headers = {};
+    _hasCustomHeaders = false;
+    _serializers = null;
     status(code) {
         this._status = code;
         return this;
     }
     header(name, value) {
         this._headers[name] = value;
+        this._hasCustomHeaders = true;
         return this;
     }
+    /**
+     * Set serializers for this response builder (called by router)
+     * @internal
+     */
+    setSerializers(serializers) {
+        this._serializers = serializers;
+    }
+    /**
+     * Get the appropriate serializer for current status code
+     */
+    getSerializer() {
+        if (!this._serializers)
+            return null;
+        // Try exact match first
+        const exactMatch = this._serializers.get(this._status);
+        if (exactMatch)
+            return exactMatch;
+        // Try status code ranges (2xx, 4xx, 5xx)
+        const range = `${Math.floor(this._status / 100)}xx`;
+        const rangeMatch = this._serializers.get(range);
+        if (rangeMatch)
+            return rangeMatch;
+        // Try default
+        return this._serializers.get('default') || null;
+    }
     json(data) {
+        // Try to use fast serializer first
+        const serializer = this.getSerializer();
+        const body = serializer ? serializer(data) : JSON.stringify(data);
         return {
             statusCode: this._status,
-            headers: {
-                ...this._headers,
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify(data)
+            headers: this._hasCustomHeaders
+                ? { ...this._headers, 'Content-Type': 'application/json' }
+                : CACHED_HEADERS.JSON,
+            body
         };
     }
     html(content) {
         return {
             statusCode: this._status,
-            headers: {
-                ...this._headers,
-                'Content-Type': 'text/html; charset=utf-8'
-            },
+            headers: this._hasCustomHeaders
+                ? { ...this._headers, 'Content-Type': 'text/html; charset=utf-8' }
+                : CACHED_HEADERS.HTML,
             body: content
         };
     }
     text(content) {
         return {
             statusCode: this._status,
-            headers: {
-                ...this._headers,
-                'Content-Type': 'text/plain; charset=utf-8'
-            },
+            headers: this._hasCustomHeaders
+                ? { ...this._headers, 'Content-Type': 'text/plain; charset=utf-8' }
+                : CACHED_HEADERS.TEXT,
             body: content
         };
     }
     redirect(url, status = 302) {
         return {
             statusCode: status,
-            headers: {
-                ...this._headers,
-                'Location': url
-            },
+            headers: this._hasCustomHeaders
+                ? { ...this._headers, 'Location': url }
+                : { 'Location': url },
             body: ''
         };
     }
@@ -127,6 +163,33 @@ class ResponseBuilderImpl {
             stream: readable
         };
     }
+    /**
+     * Reset for reuse (object pooling)
+     */
+    reset() {
+        this._status = 200;
+        this._headers = {};
+        this._hasCustomHeaders = false;
+        this._serializers = null;
+    }
+}
+/**
+ * Reusable response builder pool
+ */
+const responseBuilderPool = [];
+const RESPONSE_BUILDER_POOL_SIZE = 100;
+function acquireResponseBuilder() {
+    if (responseBuilderPool.length > 0) {
+        const builder = responseBuilderPool.pop();
+        builder.reset();
+        return builder;
+    }
+    return new ResponseBuilderImpl();
+}
+function releaseResponseBuilder(builder) {
+    if (responseBuilderPool.length < RESPONSE_BUILDER_POOL_SIZE) {
+        responseBuilderPool.push(builder);
+    }
 }
 /**
  * Context implementation
@@ -134,39 +197,328 @@ class ResponseBuilderImpl {
 class ContextImpl {
     method;
     path;
-    url;
+    _url = null; // Lazy URL creation
+    _host = 'localhost';
     params = {};
-    query = {};
-    body = null;
+    _query = null; // Lazy query parsing
+    _queryString = ''; // Raw query string for lazy parsing
     headers;
-    cookies;
+    _cookieHeader;
+    _cookies = null; // Lazy cookie parsing
     raw;
     response;
+    // Lazy body parsing - key optimization!
+    _parsedBody = undefined;
+    _bodyPromise = null;
+    _bodyParsed = false;
     // Store registry reference (set by Application)
     _storeRegistry;
-    // Request-scoped store registry (created per request)
-    _requestStoreRegistry;
-    // Request-scoped simple key-value storage
-    _data = new Map();
+    // Request-scoped store registry - now lazy!
+    _requestStoreRegistry = null;
+    // Request-scoped simple key-value storage - now lazy!
+    _data = null;
     // Debug mode
     _debug = false;
     constructor(req, res) {
         this.raw = { req, res };
-        // Parse method
-        this.method = (req.method?.toUpperCase() || 'GET');
-        // Parse URL and query
-        const parsedUrl = (0, url_1.parse)(req.url || '/', true);
-        this.path = parsedUrl.pathname || '/';
-        this.url = new URL(this.path, `http://${req.headers.host || 'localhost'}`);
-        this.query = parsedUrl.query;
-        // Parse headers
+        // Parse method - use direct access, avoid optional chaining overhead
+        this.method = (req.method ? req.method.toUpperCase() : 'GET');
+        // Fast URL parsing - just extract path, delay query parsing
+        const url = req.url || '/';
+        const queryIndex = url.indexOf('?');
+        if (queryIndex === -1) {
+            this.path = url;
+            this._queryString = '';
+            this._query = null; // Will be {} when accessed
+        }
+        else {
+            this.path = url.substring(0, queryIndex);
+            // Store query string for lazy parsing
+            this._queryString = url.substring(queryIndex + 1);
+            this._query = null; // Parse lazily
+        }
+        // Store host for lazy URL creation
+        this._host = req.headers.host || 'localhost';
+        // URL is now lazy - don't create here!
+        this._url = null;
+        // Parse headers (direct reference, no copy)
         this.headers = req.headers;
-        // Parse cookies
-        this.cookies = new CookieManager(req.headers.cookie);
-        // Create response builder
-        this.response = new ResponseBuilderImpl();
-        // Create request-scoped store registry
-        this._requestStoreRegistry = new store_1.RequestStoreRegistry(this._debug);
+        // Store cookie header for lazy parsing
+        this._cookieHeader = req.headers.cookie;
+        this._cookies = null;
+        // Get response builder from pool
+        this.response = acquireResponseBuilder();
+    }
+    /**
+     * Lazy URL getter - only create URL object when accessed
+     * Most handlers don't need the full URL object
+     */
+    get url() {
+        if (!this._url) {
+            this._url = new URL(this.path, `http://${this._host}`);
+        }
+        return this._url;
+    }
+    set url(value) {
+        this._url = value;
+    }
+    /**
+     * Lazy query getter - only parse query string when accessed
+     * Most simple endpoints like /json don't need query parsing
+     * Inline fast-querystring for minimal overhead
+     */
+    get query() {
+        if (this._query === null) {
+            // Inline fast-querystring call directly - no method call overhead
+            this._query = this._queryString
+                ? (0, fast_querystring_1.parse)(this._queryString)
+                : {};
+        }
+        return this._query;
+    }
+    set query(value) {
+        this._query = value;
+    }
+    /**
+     * Lazy cookies getter - only parse cookies when accessed
+     */
+    get cookies() {
+        if (!this._cookies) {
+            this._cookies = new CookieManager(this._cookieHeader);
+        }
+        return this._cookies;
+    }
+    set cookies(value) {
+        this._cookies = value;
+    }
+    /**
+     * Reinitialize context for pooling (avoids new object creation)
+     */
+    reinitialize(req, res) {
+        this.raw = { req, res };
+        this.method = (req.method ? req.method.toUpperCase() : 'GET');
+        // Fast URL parsing - delay query parsing
+        const url = req.url || '/';
+        const queryIndex = url.indexOf('?');
+        if (queryIndex === -1) {
+            this.path = url;
+            this._queryString = '';
+            this._query = null;
+        }
+        else {
+            this.path = url.substring(0, queryIndex);
+            this._queryString = url.substring(queryIndex + 1);
+            this._query = null; // Parse lazily
+        }
+        // Lazy URL - don't create here
+        this._host = req.headers.host || 'localhost';
+        this._url = null;
+        this.headers = req.headers;
+        // Lazy cookies
+        this._cookieHeader = req.headers.cookie;
+        this._cookies = null;
+        // Reuse or get new response builder from pool
+        if (this.response && typeof this.response.reset === 'function') {
+            this.response.reset();
+        }
+        else {
+            this.response = acquireResponseBuilder();
+        }
+        // Reset body state
+        this._parsedBody = undefined;
+        this._bodyPromise = null;
+        this._bodyParsed = false;
+        // Reset params
+        this.params = {};
+        // Lazy data and store - just null them, create on access
+        if (this._data) {
+            this._data.clear();
+        }
+        this._requestStoreRegistry = null;
+    }
+    /**
+     * Lazy body getter - parses body on first access
+     * This is the KEY optimization that fixes POST performance!
+     */
+    get body() {
+        // If already parsed synchronously, return it
+        if (this._bodyParsed) {
+            return this._parsedBody;
+        }
+        // Return undefined if not parsed yet
+        // Use getBody() for async access
+        return this._parsedBody;
+    }
+    /**
+     * Set body directly (for backwards compatibility)
+     */
+    set body(value) {
+        this._parsedBody = value;
+        this._bodyParsed = true;
+    }
+    /**
+     * Check if body is ready for sync access (no await needed)
+     */
+    get isBodyReady() {
+        return this._bodyParsed;
+    }
+    /**
+     * Wait for body to be parsed
+     * Use this if you need to ensure body is available for sync access
+     * @example
+     * ```typescript
+     * app.post('/data', async (ctx) => {
+     *   await ctx.waitForBody();
+     *   console.log(ctx.body); // Now safe to access synchronously
+     * });
+     * ```
+     */
+    async waitForBody() {
+        return this.getBody();
+    }
+    /**
+     * Async body getter - use this in handlers for POST/PUT/PATCH
+     * @example
+     * ```typescript
+     * app.post('/data', async (ctx) => {
+     *   const body = await ctx.getBody();
+     *   return { received: body };
+     * });
+     * ```
+     */
+    async getBody() {
+        // Already parsed
+        if (this._bodyParsed) {
+            return this._parsedBody;
+        }
+        // Already parsing (dedup concurrent calls)
+        if (this._bodyPromise) {
+            return this._bodyPromise;
+        }
+        // Start parsing with optimized parser
+        this._bodyPromise = this.parseBodyOptimized();
+        this._parsedBody = await this._bodyPromise;
+        this._bodyParsed = true;
+        this._bodyPromise = null;
+        return this._parsedBody;
+    }
+    /**
+     * Ultra-optimized body parser inspired by Fastify's approach
+     * Key optimizations:
+     * 1. Pre-check content-type before reading data
+     * 2. Use direct string concatenation with setEncoding
+     * 3. Minimal closure allocation
+     * 4. Fast-path for JSON (most common case)
+     */
+    parseBodyOptimized() {
+        const req = this.raw.req;
+        const contentType = req.headers['content-type'];
+        // Fast path: determine parser type once, before data collection
+        const isJSON = contentType ? contentType.charCodeAt(0) === 97 && contentType.startsWith('application/json') : false;
+        const isForm = !isJSON && contentType ? contentType.includes('x-www-form-urlencoded') : false;
+        return new Promise((resolve, reject) => {
+            // Set encoding for string mode - avoids Buffer.toString() overhead
+            req.setEncoding('utf8');
+            let body = '';
+            const onData = (chunk) => {
+                body += chunk;
+            };
+            const onEnd = () => {
+                // Cleanup listeners immediately
+                req.removeListener('data', onData);
+                req.removeListener('end', onEnd);
+                req.removeListener('error', onError);
+                if (!body) {
+                    resolve({});
+                    return;
+                }
+                try {
+                    if (isJSON) {
+                        resolve(JSON.parse(body));
+                    }
+                    else if (isForm) {
+                        resolve((0, fast_querystring_1.parse)(body));
+                    }
+                    else {
+                        resolve(body);
+                    }
+                }
+                catch (e) {
+                    reject(e);
+                }
+            };
+            const onError = (err) => {
+                req.removeListener('data', onData);
+                req.removeListener('end', onEnd);
+                req.removeListener('error', onError);
+                reject(err);
+            };
+            req.on('data', onData);
+            req.on('end', onEnd);
+            req.on('error', onError);
+        });
+    }
+    /**
+     * Internal body parser - optimized for performance
+     * Uses string accumulation instead of Buffer.concat for better perf
+     * @deprecated Use parseBodyOptimized instead
+     */
+    parseBodyInternal() {
+        return new Promise((resolve, reject) => {
+            const req = this.raw.req;
+            const contentType = req.headers['content-type'] || '';
+            // Use setEncoding to get strings directly - faster than Buffer.toString()
+            req.setEncoding('utf8');
+            let body = '';
+            req.on('data', (chunk) => {
+                body += chunk;
+            });
+            req.on('end', () => {
+                if (!body) {
+                    resolve({});
+                    return;
+                }
+                try {
+                    // Inline content type check for hot path (JSON)
+                    if (contentType.includes('application/json')) {
+                        resolve(JSON.parse(body));
+                    }
+                    else if (contentType.includes('application/x-www-form-urlencoded')) {
+                        resolve((0, fast_querystring_1.parse)(body));
+                    }
+                    else {
+                        resolve(body);
+                    }
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+            req.on('error', reject);
+        });
+    }
+    /**
+     * Parse body based on content type
+     */
+    parseContentType(body, contentType) {
+        if (contentType.includes('application/json')) {
+            return body ? JSON.parse(body) : {};
+        }
+        else if (contentType.includes('application/x-www-form-urlencoded')) {
+            return (0, fast_querystring_1.parse)(body);
+        }
+        else if (contentType.includes('text/')) {
+            return body;
+        }
+        return body;
+    }
+    /**
+     * Clear body state (for pooling)
+     */
+    clearBody() {
+        this._parsedBody = undefined;
+        this._bodyPromise = null;
+        this._bodyParsed = false;
     }
     // Convenience methods
     json(data, status) {
@@ -215,6 +567,24 @@ class ContextImpl {
         }
         return this._storeRegistry.get(StoreClass);
     }
+    /**
+     * Lazy getter for request store registry
+     */
+    getOrCreateRequestStoreRegistry() {
+        if (!this._requestStoreRegistry) {
+            this._requestStoreRegistry = new store_1.RequestStoreRegistry(this._debug);
+        }
+        return this._requestStoreRegistry;
+    }
+    /**
+     * Lazy getter for request data map
+     */
+    getOrCreateData() {
+        if (!this._data) {
+            this._data = new Map();
+        }
+        return this._data;
+    }
     /**
      * Access a request-scoped store by its class
      * Store only exists for this request, disposed after response
@@ -244,7 +614,7 @@ class ContextImpl {
      * ```
      */
     requestStore(StoreClass) {
-        return this._requestStoreRegistry.get(StoreClass);
+        return this.getOrCreateRequestStoreRegistry().get(StoreClass);
     }
     /**
      * Set a value in request-scoped storage
@@ -264,7 +634,7 @@ class ContextImpl {
      * ```
      */
     set(key, value) {
-        this._data.set(key, value);
+        this.getOrCreateData().set(key, value);
     }
     /**
      * Get a value from request-scoped storage
@@ -279,7 +649,7 @@ class ContextImpl {
      * ```
      */
     get(key) {
-        return this._data.get(key);
+        return this._data?.get(key);
     }
     /**
      * Set store registry (called by Application)
@@ -294,23 +664,32 @@ class ContextImpl {
      */
     setDebugMode(debug) {
         this._debug = debug;
-        // Re-create request store registry with debug mode
-        this._requestStoreRegistry = new store_1.RequestStoreRegistry(debug);
+        // Reset request store registry - will be created lazily with new debug mode
+        this._requestStoreRegistry = null;
     }
     /**
      * Dispose request-scoped stores and data (called after response)
      * @internal
      */
     disposeRequestStores() {
-        this._requestStoreRegistry.dispose();
-        this._data.clear();
+        if (this._requestStoreRegistry) {
+            this._requestStoreRegistry.dispose();
+            this._requestStoreRegistry = null;
+        }
+        if (this._data) {
+            this._data.clear();
+        }
+        // Release response builder back to pool
+        if (this.response && typeof this.response.reset === 'function') {
+            releaseResponseBuilder(this.response);
+        }
     }
     /**
      * Get request store registry for advanced usage
      * @internal
      */
     getRequestStoreRegistry() {
-        return this._requestStoreRegistry;
+        return this.getOrCreateRequestStoreRegistry();
     }
     /**
      * Set route parameters (called by router)
@@ -319,21 +698,38 @@ class ContextImpl {
         this.params = params;
     }
     /**
-     * Set request body (called after parsing)
+     * Set response serializers for fast JSON serialization
+     * Called by router when route has response schema
+     * @internal
+     */
+    setSerializers(serializers) {
+        if (this.response && typeof this.response.setSerializers === 'function') {
+            this.response.setSerializers(serializers);
+        }
+    }
+    /**
+     * Set request body (called after parsing or by middleware)
+     * @deprecated Use ctx.getBody() for async body access
      */
     setBody(body) {
-        this.body = body;
+        this._parsedBody = body;
+        this._bodyParsed = true;
     }
     /**
      * Get all Set-Cookie headers
      */
     getSetCookieHeaders() {
-        return this.cookies.getSetCookieHeaders();
+        // Use _cookies directly to avoid creating CookieManager if not needed
+        if (!this._cookies) {
+            return [];
+        }
+        return this._cookies.getSetCookieHeaders();
     }
 }
 exports.ContextImpl = ContextImpl;
 /**
  * Parse request body based on Content-Type
+ * @deprecated Use ctx.getBody() instead for lazy parsing
  */
 async function parseBody(req) {
     return new Promise((resolve, reject) => {
@@ -348,7 +744,7 @@ async function parseBody(req) {
                     resolve(body ? JSON.parse(body) : {});
                 }
                 else if (contentType.includes('application/x-www-form-urlencoded')) {
-                    resolve((0, querystring_1.parse)(body));
+                    resolve((0, fast_querystring_1.parse)(body));
                 }
                 else if (contentType.includes('text/')) {
                     resolve(body);