qhttpx 1.8.5 → 1.8.11

package/dist/src/cli/index.js

@@ -142,26 +142,29 @@ function runNew(projectName) {
     const pkgJson = {
         name: projectName,
         version: '0.0.1',
+        type: 'module',
         scripts: {
             dev: 'qhttpx dev src/index.ts',
             start: 'qhttpx start dist/index.js',
             build: 'tsc'
         },
         dependencies: {
-            'qhttpx': '^1.0.0'
+            'qhttpx': '^1.8.6',
+            'dotenv': '^16.4.1'
         },
         devDependencies: {
-            'typescript': '^5.0.0',
-            '@types/node': '^20.0.0',
-            'tsx': '^4.0.0'
+            'typescript': '^5.3.3',
+            '@types/node': '^20.11.16',
+            'tsx': '^4.7.0'
         }
     };
     fs_1.default.writeFileSync(path_1.default.join(projectDir, 'package.json'), JSON.stringify(pkgJson, null, 2));
     // tsconfig.json
     const tsConfig = {
         compilerOptions: {
-            target: 'ES2020',
-            module: 'commonjs',
+            target: 'ES2022',
+            module: 'Node16',
+            moduleResolution: 'Node16',
             rootDir: 'src',
             outDir: 'dist',
             strict: true,
@@ -174,15 +177,34 @@ function runNew(projectName) {
     fs_1.default.writeFileSync(path_1.default.join(projectDir, 'tsconfig.json'), JSON.stringify(tsConfig, null, 2));
     // src/index.ts
     const indexTs = `import { createHttpApp } from 'qhttpx';
+import 'dotenv/config';
 
-const app = createHttpApp();
+const app = createHttpApp({
+  // ⚡ Performance: Auto-coalesce duplicate requests
+  enableRequestFusion: true,
 
-app.get('/', (ctx) => {
-  ctx.json({ message: 'Hello from QHTTPX!' });
+  // 🛡️ Security: Built-in CORS & Rate Limiting
+  cors: true,
+  rateLimit: {
+    windowMs: 15 * 60 * 1000, // 15 min
+    max: 100, // 100 reqs per IP
+    trustProxy: true
+  },
+
+  // 🗜️ Optimization: Gzip/Brotli compression
+  compression: true
+});
+
+app.get('/', ({ json }) => {
+  json({ 
+    message: 'Welcome to QHTTPX 🚀', 
+    status: 'online',
+    timestamp: Date.now() 
+  });
 });
 
-app.listen(3000).then(({ port }) => {
-  console.log(\`Server running on port \${port}\`);
+app.listen(Number(process.env.PORT) || 3000, () => {
+  console.log(\`Server running on http://localhost:\${process.env.PORT || 3000}\`);
 });
 `;
     fs_1.default.writeFileSync(path_1.default.join(projectDir, 'src', 'index.ts'), indexTs);

package/dist/src/core/errors.d.ts

@@ -0,0 +1,34 @@
+import { HttpError } from './types';
+export declare class BadRequestException extends HttpError {
+    constructor(message?: string, details?: unknown);
+}
+export declare class UnauthorizedException extends HttpError {
+    constructor(message?: string, details?: unknown);
+}
+export declare class ForbiddenException extends HttpError {
+    constructor(message?: string, details?: unknown);
+}
+export declare class NotFoundException extends HttpError {
+    constructor(message?: string, details?: unknown);
+}
+export declare class MethodNotAllowedException extends HttpError {
+    constructor(message?: string, details?: unknown);
+}
+export declare class ConflictException extends HttpError {
+    constructor(message?: string, details?: unknown);
+}
+export declare class PayloadTooLargeException extends HttpError {
+    constructor(message?: string, details?: unknown);
+}
+export declare class UnsupportedMediaTypeException extends HttpError {
+    constructor(message?: string, details?: unknown);
+}
+export declare class TooManyRequestsException extends HttpError {
+    constructor(message?: string, details?: unknown);
+}
+export declare class InternalServerErrorException extends HttpError {
+    constructor(message?: string, details?: unknown);
+}
+export declare class ServiceUnavailableException extends HttpError {
+    constructor(message?: string, details?: unknown);
+}

package/dist/src/core/errors.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceUnavailableException = exports.InternalServerErrorException = exports.TooManyRequestsException = exports.UnsupportedMediaTypeException = exports.PayloadTooLargeException = exports.ConflictException = exports.MethodNotAllowedException = exports.NotFoundException = exports.ForbiddenException = exports.UnauthorizedException = exports.BadRequestException = void 0;
+const types_1 = require("./types");
+class BadRequestException extends types_1.HttpError {
+    constructor(message = 'Bad Request', details) {
+        super(400, message, { code: 'BAD_REQUEST', details });
+    }
+}
+exports.BadRequestException = BadRequestException;
+class UnauthorizedException extends types_1.HttpError {
+    constructor(message = 'Unauthorized', details) {
+        super(401, message, { code: 'UNAUTHORIZED', details });
+    }
+}
+exports.UnauthorizedException = UnauthorizedException;
+class ForbiddenException extends types_1.HttpError {
+    constructor(message = 'Forbidden', details) {
+        super(403, message, { code: 'FORBIDDEN', details });
+    }
+}
+exports.ForbiddenException = ForbiddenException;
+class NotFoundException extends types_1.HttpError {
+    constructor(message = 'Not Found', details) {
+        super(404, message, { code: 'NOT_FOUND', details });
+    }
+}
+exports.NotFoundException = NotFoundException;
+class MethodNotAllowedException extends types_1.HttpError {
+    constructor(message = 'Method Not Allowed', details) {
+        super(405, message, { code: 'METHOD_NOT_ALLOWED', details });
+    }
+}
+exports.MethodNotAllowedException = MethodNotAllowedException;
+class ConflictException extends types_1.HttpError {
+    constructor(message = 'Conflict', details) {
+        super(409, message, { code: 'CONFLICT', details });
+    }
+}
+exports.ConflictException = ConflictException;
+class PayloadTooLargeException extends types_1.HttpError {
+    constructor(message = 'Payload Too Large', details) {
+        super(413, message, { code: 'PAYLOAD_TOO_LARGE', details });
+    }
+}
+exports.PayloadTooLargeException = PayloadTooLargeException;
+class UnsupportedMediaTypeException extends types_1.HttpError {
+    constructor(message = 'Unsupported Media Type', details) {
+        super(415, message, { code: 'UNSUPPORTED_MEDIA_TYPE', details });
+    }
+}
+exports.UnsupportedMediaTypeException = UnsupportedMediaTypeException;
+class TooManyRequestsException extends types_1.HttpError {
+    constructor(message = 'Too Many Requests', details) {
+        super(429, message, { code: 'TOO_MANY_REQUESTS', details });
+    }
+}
+exports.TooManyRequestsException = TooManyRequestsException;
+class InternalServerErrorException extends types_1.HttpError {
+    constructor(message = 'Internal Server Error', details) {
+        super(500, message, { code: 'INTERNAL_SERVER_ERROR', details });
+    }
+}
+exports.InternalServerErrorException = InternalServerErrorException;
+class ServiceUnavailableException extends types_1.HttpError {
+    constructor(message = 'Service Unavailable', details) {
+        super(503, message, { code: 'SERVICE_UNAVAILABLE', details });
+    }
+}
+exports.ServiceUnavailableException = ServiceUnavailableException;

package/dist/src/core/native-adapter.d.ts

@@ -0,0 +1,11 @@
+import net from 'net';
+import { QHTTPX } from './server';
+export declare class NativeAdapter {
+    private app;
+    private nativeServer;
+    private responsePool;
+    constructor(app: QHTTPX);
+    listen(port: number, cb?: () => void): net.Server | Promise<{
+        port: number;
+    }>;
+}

package/dist/src/core/native-adapter.js

@@ -0,0 +1,211 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeAdapter = void 0;
+const net_1 = __importDefault(require("net"));
+const stream_1 = require("stream");
+const native_1 = require("../native");
+class MockIncomingMessage extends stream_1.Readable {
+    constructor(socket, method, url, headers) {
+        super();
+        this.httpVersion = '1.1';
+        this.socket = socket;
+        this.method = method;
+        this.url = url;
+        this.headers = headers;
+    }
+    _read() {
+        // No-op, data is pushed manually
+    }
+}
+class MockServerResponse extends stream_1.Writable {
+    constructor(socket, nativeServer) {
+        super();
+        this.statusCode = 200;
+        this.headersSent = false;
+        this.headers = {};
+        this.socket = socket;
+        this.nativeServer = nativeServer;
+    }
+    setHeader(name, value) {
+        this.headers[name.toLowerCase()] = value;
+        return this;
+    }
+    getHeader(name) {
+        return this.headers[name.toLowerCase()];
+    }
+    getHeaders() {
+        return { ...this.headers };
+    }
+    hasHeader(name) {
+        return Object.prototype.hasOwnProperty.call(this.headers, name.toLowerCase());
+    }
+    removeHeader(name) {
+        delete this.headers[name.toLowerCase()];
+    }
+    writeHead(statusCode, headers) {
+        this.statusCode = statusCode;
+        if (headers) {
+            for (const key in headers) {
+                this.setHeader(key, headers[key]);
+            }
+        }
+        return this;
+    }
+    reset(socket) {
+        this.socket = socket;
+        this.statusCode = 200;
+        this.headersSent = false;
+        this.headers = {};
+        this.removeAllListeners();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _write(chunk, encoding, callback) {
+        if (!this.headersSent) {
+            this.sendHeaders();
+        }
+        this.socket.write(chunk, encoding, callback);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    end(arg1, arg2, arg3) {
+        if (arg1 && typeof arg1 !== 'function') {
+            if (!this.headersSent) {
+                // Optimization: Use native createResponse / createJSONResponse if possible
+                try {
+                    let respBuffer;
+                    // Check for JSON object (not buffer/string)
+                    if (typeof arg1 === 'object' && !Buffer.isBuffer(arg1)) {
+                        respBuffer = this.nativeServer.createJSONResponse(arg1);
+                    }
+                    else {
+                        const body = arg1;
+                        const headers = {};
+                        for (const k in this.headers) {
+                            const v = this.headers[k];
+                            headers[k] = Array.isArray(v) ? v.join(', ') : String(v);
+                        }
+                        respBuffer = this.nativeServer.createResponse(this.statusCode, headers, body);
+                    }
+                    // Try direct writeResponse if FD is available
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const fd = this.socket._handle?.fd;
+                    if (typeof fd === 'number' && fd >= 0) {
+                        this.nativeServer.writeResponse(fd, [respBuffer]);
+                    }
+                    else {
+                        this.socket.write(respBuffer);
+                    }
+                    this.headersSent = true;
+                    if (arg2 && typeof arg2 === 'function')
+                        arg2();
+                    else if (arg3 && typeof arg3 === 'function')
+                        arg3();
+                    return this;
+                }
+                catch {
+                    // Fallback
+                }
+            }
+            this.write(arg1, arg2);
+        }
+        if (!this.headersSent) {
+            this.sendHeaders();
+        }
+        super.end();
+        if (arg1 && typeof arg1 === 'function')
+            arg1();
+        else if (arg2 && typeof arg2 === 'function')
+            arg2();
+        else if (arg3 && typeof arg3 === 'function')
+            arg3();
+        return this;
+    }
+    sendHeaders() {
+        let head = `HTTP/1.1 ${this.statusCode} OK\r\n`; // Status msg todo
+        for (const key in this.headers) {
+            const val = this.headers[key];
+            if (Array.isArray(val)) {
+                for (const v of val) {
+                    head += `${key}: ${v}\r\n`;
+                }
+            }
+            else {
+                head += `${key}: ${val}\r\n`;
+            }
+        }
+        head += '\r\n';
+        this.socket.write(head);
+        this.headersSent = true;
+    }
+}
+class MockResponsePool {
+    constructor(nativeServer) {
+        this.pool = [];
+        this.nativeServer = nativeServer;
+    }
+    acquire(socket) {
+        const res = this.pool.pop();
+        if (res) {
+            res.reset(socket);
+            return res;
+        }
+        return new MockServerResponse(socket, this.nativeServer);
+    }
+    release(res) {
+        // Simple cap to prevent memory leak if something goes wrong
+        if (this.pool.length < 2000) {
+            this.pool.push(res);
+        }
+    }
+}
+class NativeAdapter {
+    constructor(app) {
+        this.app = app;
+        this.nativeServer = new native_1.NativeServer();
+        this.responsePool = new MockResponsePool(this.nativeServer);
+    }
+    listen(port, cb) {
+        if (!this.nativeServer.isAvailable) {
+            console.warn('Native server not available, falling back to Node.js HTTP');
+            return this.app.listen(port, cb);
+        }
+        const server = net_1.default.createServer((socket) => {
+            let buffer = Buffer.alloc(0);
+            socket.on('data', (chunk) => {
+                buffer = buffer.length === 0 ? chunk : Buffer.concat([buffer, chunk]);
+                // Try parsing
+                const res = this.nativeServer.parse(buffer);
+                if (res) {
+                    // Parsed successfully
+                    const req = new MockIncomingMessage(socket, res.method, res.path, res.headers);
+                    const response = this.responsePool.acquire(socket);
+                    response.on('finish', () => {
+                        this.responsePool.release(response);
+                    });
+                    // Push body if any
+                    if (res.bodyOffset < buffer.length) {
+                        req.push(buffer.slice(res.bodyOffset));
+                    }
+                    req.push(null); // End of body (assuming single packet for now or content-length handling needed for real impl)
+                    // Reset buffer for pipelining support (not implemented here, assuming connection: close or one req per packet for simplicity)
+                    buffer = Buffer.alloc(0);
+                    // Dispatch to QHTTPX
+                    this.app.handleRequest(req, response);
+                }
+                else if (res === null) {
+                    // Error
+                    socket.destroy();
+                }
+                // else undefined -> partial, wait for more data
+            });
+            socket.on('error', () => {
+                // console.error(err);
+            });
+        });
+        server.listen(port, cb);
+        return server;
+    }
+}
+exports.NativeAdapter = NativeAdapter;

package/dist/src/core/server.d.ts

@@ -1,9 +1,53 @@
-import http from 'http';
+import http, { IncomingMessage, ServerResponse, IncomingHttpHeaders } from 'http';
+import { URL } from 'url';
 import { WebSocketManager } from './websocket';
+import { Validator } from '../validation/types';
 import { OpenAPIOptions } from '../openapi/generator';
-import { HTTPMethod, QHTTPXErrorHandler, QHTTPXHandler, QHTTPXMethodNotAllowedHandler, QHTTPXMiddleware, QHTTPXNotFoundHandler, QHTTPXOptions, QHTTPXRouteOptions, QHTTPXPlugin, QHTTPXPluginOptions } from './types';
+import { HTTPMethod, QHTTPXContext, QHTTPXErrorHandler, QHTTPXHandler, QHTTPXMethodNotAllowedHandler, QHTTPXMiddleware, QHTTPXNotFoundHandler, QHTTPXOptions, QHTTPXRouteOptions, QHTTPXPlugin, QHTTPXPluginOptions, CookieOptions, QHTTPXFile } from './types';
 import { Logger } from './logger';
+export declare class QHTTPXContextImpl implements QHTTPXContext {
+    req: IncomingMessage;
+    res: ServerResponse;
+    headers: IncomingHttpHeaders;
+    method: HTTPMethod;
+    params: Record<string, string>;
+    query: Record<string, string | string[]>;
+    body: unknown;
+    files?: Record<string, QHTTPXFile | QHTTPXFile[]>;
+    cookies: Record<string, string>;
+    private _state;
+    requestId: string | undefined;
+    requestStart: number | undefined;
+    serializer?: (value: unknown) => string;
+    disableAutoEnd?: boolean;
+    path: string;
+    error?: Error;
+    next?: () => Promise<void>;
+    private _url;
+    private _ip;
+    private _app;
+    private _appJsonSerializer;
+    constructor(app: QHTTPX);
+    get bufferPool(): any;
+    get db(): any;
+    get state(): Record<string, unknown>;
+    set state(v: Record<string, unknown>);
+    get ip(): string;
+    set ip(v: string);
+    get url(): URL;
+    set url(v: URL);
+    json(payload: unknown, status?: number): void;
+    send(payload: string | Buffer, status?: number): void;
+    html(payload: string, status?: number): void;
+    redirect(url: string, status?: number): void;
+    setCookie(name: string, value: string, options: CookieOptions | undefined): void;
+    render(view: string, locals?: Record<string, unknown>): Promise<void>;
+    validate<T>(schema: unknown, data?: unknown): Promise<T>;
+    reset(): void;
+}
 export declare class QHTTPX {
+    private static readonly EMPTY_PARAMS;
+    private static readonly EMPTY_MATCH;
     private readonly options;
     private readonly server;
     readonly logger: Logger;
@@ -24,11 +68,13 @@ export declare class QHTTPX {
     private readonly onBeforeShutdownHooks;
     private readonly onShutdownHooks;
     private nextRequestId;
+    private requestCounter;
     private readonly wsManager;
     private readonly ultraMode;
     private readonly batchExecutor?;
     private readonly fusion?;
-    private readonly validator;
+    readonly validator: Validator;
+    private readonly poolLimit;
     constructor(options?: QHTTPXOptions);
     get serverInstance(): http.Server;
     get websocket(): WebSocketManager;
@@ -82,7 +128,9 @@ export declare class QHTTPX {
     private createContext;
     private acquireContext;
     private releaseContext;
-    private handleRequest;
+    private handleNoMatch;
+    handleRequest(req: IncomingMessage, res: ServerResponse): void;
+    private dispatch;
     private handleUpgrade;
     private runLifecycleHooks;
     private handleError;