qhttpx 1.9.4 → 2.0.0

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

@@ -0,0 +1,11 @@
+export declare class RequestTimer {
+    private cachedTime;
+    private readonly perfStart;
+    private readonly updateInterval;
+    private lastUpdate;
+    private intervalId;
+    constructor();
+    now(): number;
+    preciseNow(): number;
+}
+export declare const globalTimer: RequestTimer;

package/dist/src/core/timer.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalTimer = exports.RequestTimer = void 0;
+class RequestTimer {
+    constructor() {
+        this.cachedTime = Date.now();
+        this.perfStart = performance.now();
+        this.updateInterval = 10; // Update every 10ms
+        this.lastUpdate = this.perfStart;
+        // Auto-update timer
+        this.intervalId = setInterval(() => {
+            this.cachedTime = Date.now();
+            this.lastUpdate = performance.now();
+        }, this.updateInterval);
+        // Ensure the timer doesn't keep the process alive
+        this.intervalId.unref();
+    }
+    now() {
+        // Use cached time for most calls
+        return this.cachedTime;
+    }
+    preciseNow() {
+        // For metrics that need precision, calculate offset
+        const elapsed = performance.now() - this.lastUpdate;
+        return this.cachedTime + Math.floor(elapsed);
+    }
+}
+exports.RequestTimer = RequestTimer;
+exports.globalTimer = new RequestTimer();

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

@@ -5,14 +5,24 @@ import type { DatabaseManager } from '../database/manager';
 import type { RouteSchema, Validator } from '../validation/types';
 import type { ViewEngine } from '../views/types';
 import type { RequestFusionOptions } from './fusion';
+export type { RequestFusionOptions };
 export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
-export declare enum RoutePriority {
-    CRITICAL = "critical",
-    STANDARD = "standard",
-    BEST_EFFORT = "best-effort"
-}
+export type RoutePriority = 'critical' | 'standard' | 'best-effort';
+export declare const RoutePriority: {
+    CRITICAL: RoutePriority;
+    STANDARD: RoutePriority;
+    BEST_EFFORT: RoutePriority;
+};
+export type RouteMetadata = {
+    needsQuery?: boolean;
+    needsCookies?: boolean;
+    needsBody?: boolean;
+    pipeline?: QHTTPXHandler;
+};
 export type RouteOptions = {
     priority?: RoutePriority;
+    metadata?: RouteMetadata;
+    staticResponse?: any;
 };
 export declare class HttpError extends Error {
     status: number;
@@ -39,7 +49,7 @@ export type QHTTPXFile = {
     data: Buffer;
     size: number;
 };
-export type QHTTPXContext = {
+export interface QHTTPXContext {
     readonly req: IncomingMessage;
     readonly res: ServerResponse;
     readonly headers: IncomingHttpHeaders;
@@ -58,6 +68,7 @@ export type QHTTPXContext = {
     serializer?: (value: unknown) => string;
     readonly json: (body: unknown, status?: number) => void;
     readonly send: (body: string | Buffer, status?: number) => void;
+    readonly httpError: (status: number, message?: string, details?: unknown) => HttpError;
     readonly html: (html: string, status?: number) => void;
     readonly redirect: (url: string, status?: number) => void;
     readonly setCookie: (name: string, value: string, options?: CookieOptions) => void;
@@ -68,15 +79,26 @@ export type QHTTPXContext = {
     disableAutoEnd?: boolean;
     readonly path: string;
     readonly next?: () => Promise<void>;
-};
+}
 export type QHTTPXOpHandler = (params: any, ctx: QHTTPXContext) => any | Promise<any>;
-export type QHTTPXHandler = (ctx: QHTTPXContext) => void | Promise<void>;
+export type QHTTPXHandler<Result = any> = (ctx: QHTTPXContext) => Result | Promise<Result>;
 export type QHTTPXRouteOptions = {
     schema?: RouteSchema | Record<string, any>;
-    handler: QHTTPXHandler;
+    body?: any;
+    params?: any;
+    query?: any;
+    headers?: any;
+    response?: any;
+    handler?: QHTTPXHandler;
     priority?: RoutePriority;
+    staticResponse?: any;
 };
 export type QHTTPXRouteConfig = Omit<QHTTPXRouteOptions, 'handler'>;
+export interface QHTTPXRouteMethod {
+    (path: string, handler: QHTTPXHandler | QHTTPXRouteOptions): void;
+    (path: string, handler: QHTTPXHandler, config: QHTTPXRouteConfig): void;
+    (path: string, config: QHTTPXRouteConfig, handler: QHTTPXHandler): void;
+}
 export type QHTTPXMiddleware = (ctx: QHTTPXContext, next: () => Promise<void>) => void | Promise<void>;
 export type QHTTPXErrorContext = QHTTPXContext & {
     error: unknown;
@@ -103,7 +125,7 @@ export type QHTTPXTaskOptions = {
     maxRetries?: number;
     backoffMs?: number;
 };
-export type PerformanceMode = 'balanced' | 'ultra';
+export type PerformanceMode = 'default';
 export interface RateLimitStore {
     increment(key: string, windowMs: number): Promise<{
         total: number;
@@ -123,6 +145,11 @@ export interface RateLimitOptions {
     store?: RateLimitStore;
     trustProxy?: boolean;
 }
+export interface RateLimitConfig {
+    windowMs: number;
+    max: number;
+}
+export type RateLimitPreset = 'strict' | 'relaxed' | 'standard';
 export type QHTTPXOptions = {
     name?: string;
     workers?: 'auto' | number;
@@ -173,8 +200,9 @@ export type SecurityHeadersOptions = {
     strictTransportSecurity?: string | null;
 };
 export type SecureDefaultsOptions = {
-    cors?: CorsOptions;
+    cors?: CorsOptions | boolean;
     securityHeaders?: SecurityHeadersOptions;
+    rateLimit?: RateLimitOptions;
 };
 export type CorsOrigin = string | string[] | ((origin: string | undefined) => string | null | undefined);
 export type CorsOptions = {
@@ -189,8 +217,8 @@ export type CompressionOptions = {
     threshold?: number;
     level?: number;
 };
-export type QHTTPXPlugin<Options = any> = (app: any, // We use 'any' here to avoid circular dependency with QHTTPX class, or we could use an interface
-options: Options) => void | Promise<void>;
+import type { QHTTPXScope } from './scope';
+export type QHTTPXPlugin<Options = any> = (app: QHTTPXScope, options: Options) => void | Promise<void>;
 export type QHTTPXPluginOptions = {
     prefix?: string;
     [key: string]: any;

package/dist/src/core/types.js

@@ -1,12 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpError = exports.RoutePriority = void 0;
-var RoutePriority;
-(function (RoutePriority) {
-    RoutePriority["CRITICAL"] = "critical";
-    RoutePriority["STANDARD"] = "standard";
-    RoutePriority["BEST_EFFORT"] = "best-effort";
-})(RoutePriority || (exports.RoutePriority = RoutePriority = {}));
+exports.RoutePriority = {
+    CRITICAL: 'critical',
+    STANDARD: 'standard',
+    BEST_EFFORT: 'best-effort',
+};
 class HttpError extends Error {
     constructor(status, message, options = {}) {
         super(message ?? 'HTTP Error');
@@ -17,3 +16,4 @@ class HttpError extends Error {
     }
 }
 exports.HttpError = HttpError;
+;

package/dist/src/index.d.ts

@@ -1,7 +1,7 @@
 import { QHTTPX } from './core/server';
-import type { QHTTPXOptions } from './core/types';
-import { NativeAdapter } from './core/native-adapter';
+import type { QHTTPXOptions, QHTTPXPlugin } from './core/types';
 export { QHTTPX } from './core/server';
+export { QHTTPXScope } from './core/scope';
 export * from './core/types';
 export * from './core/errors';
 export * from './middleware/cors';
@@ -31,9 +31,11 @@ export * from './validation/types';
 export * from './validation/simple';
 export * from './openapi/generator';
 export * from './client';
-export { NativeAdapter } from './core/native-adapter';
 export declare function createHttpApp(options?: QHTTPXOptions): QHTTPX;
-export declare function createNativeApp(options?: QHTTPXOptions): NativeAdapter;
+/**
+ * Type helper for defining plugins
+ */
+export declare function plugin(fn: QHTTPXPlugin): QHTTPXPlugin;
 /**
  * Singleton instance for quick start
  * @example

package/dist/src/index.js

@@ -14,14 +14,15 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.app = exports.NativeAdapter = exports.getStringifier = exports.fastJsonStringify = exports.BufferPool = exports.createSecureDefaults = exports.createSecurityHeadersMiddleware = exports.QHTTPX = void 0;
+exports.app = exports.getStringifier = exports.fastJsonStringify = exports.BufferPool = exports.createSecureDefaults = exports.createSecurityHeadersMiddleware = exports.QHTTPXScope = exports.QHTTPX = void 0;
 exports.createHttpApp = createHttpApp;
-exports.createNativeApp = createNativeApp;
+exports.plugin = plugin;
 const server_1 = require("./core/server");
 const presets_1 = require("./middleware/presets");
-const native_adapter_1 = require("./core/native-adapter");
 var server_2 = require("./core/server");
 Object.defineProperty(exports, "QHTTPX", { enumerable: true, get: function () { return server_2.QHTTPX; } });
+var scope_1 = require("./core/scope");
+Object.defineProperty(exports, "QHTTPXScope", { enumerable: true, get: function () { return scope_1.QHTTPXScope; } });
 __exportStar(require("./core/types"), exports);
 __exportStar(require("./core/errors"), exports);
 __exportStar(require("./middleware/cors"), exports);
@@ -56,26 +57,24 @@ __exportStar(require("./validation/types"), exports);
 __exportStar(require("./validation/simple"), exports);
 __exportStar(require("./openapi/generator"), exports);
 __exportStar(require("./client"), exports);
-var native_adapter_2 = require("./core/native-adapter");
-Object.defineProperty(exports, "NativeAdapter", { enumerable: true, get: function () { return native_adapter_2.NativeAdapter; } });
 function createHttpApp(options = {}) {
     const app = new server_1.QHTTPX(options);
-    // Skip middleware in ultra mode for maximum performance
-    if (options.performanceMode !== 'ultra') {
-        const middlewares = (0, presets_1.createApiPreset)({
-            rateLimit: options.rateLimit,
-            cors: options.cors,
-            compression: options.compression,
-            logging: options.logging,
-            security: options.security,
-        });
-        middlewares.forEach((mw) => app.use(mw));
-    }
+    // Apply default middleware presets
+    const middlewares = (0, presets_1.createApiPreset)({
+        rateLimit: options.rateLimit,
+        cors: options.cors,
+        compression: options.compression,
+        logging: options.logging,
+        security: options.security,
+    });
+    middlewares.forEach((mw) => app.use(mw));
     return app;
 }
-function createNativeApp(options = {}) {
-    const app = createHttpApp(options);
-    return new native_adapter_1.NativeAdapter(app);
+/**
+ * Type helper for defining plugins
+ */
+function plugin(fn) {
+    return fn;
 }
 /**
  * Singleton instance for quick start
@@ -83,7 +82,7 @@ function createNativeApp(options = {}) {
  * import { app } from 'qhttpx';
  * app.get('/', ({ json }) => json({ hello: 'world' }));
  */
-exports.app = createHttpApp();
+exports.app = new server_1.QHTTPX();
 /**
  * Default export for simplified usage
  * @example

package/dist/src/middleware/security.js

@@ -30,7 +30,12 @@ function createSecurityHeadersMiddleware(options = {}) {
 }
 function createSecureDefaults(options = {}) {
     const middlewares = [];
-    middlewares.push((0, cors_1.createCorsMiddleware)(options.cors));
+    const corsOpts = options.cors;
+    if (corsOpts !== false) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const opts = (corsOpts === true || corsOpts === undefined) ? {} : corsOpts;
+        middlewares.push((0, cors_1.createCorsMiddleware)(opts));
+    }
     middlewares.push(createSecurityHeadersMiddleware(options.securityHeaders));
     return middlewares;
 }

package/dist/src/router/radix-tree.d.ts

@@ -1,18 +1,21 @@
-import { QHTTPXHandler, RoutePriority } from '../core/types';
+import { QHTTPXHandler, RoutePriority, RouteMetadata } from '../core/types';
 export type RouteData = {
     handler: QHTTPXHandler;
     priority: RoutePriority;
+    metadata: RouteMetadata;
 };
 export type MatchResult = {
     handler: QHTTPXHandler;
     priority: RoutePriority;
     params: Record<string, string>;
+    metadata: RouteMetadata;
 };
 export declare class RadixTree {
     private root;
-    insert(segments: string[], handler: QHTTPXHandler, priority: RoutePriority): void;
+    insert(segments: string[], handler: QHTTPXHandler, priority: RoutePriority, metadata: RouteMetadata): void;
     lookup(segments: string[]): MatchResult | null;
     lookupPath(path: string): MatchResult | null;
+    private toMatchResult;
     private findPath;
     private find;
 }

package/dist/src/router/radix-tree.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RadixTree = void 0;
+const EMPTY_PARAMS = Object.freeze({});
 class Node {
     constructor() {
         // Map segment -> Node
@@ -18,7 +19,7 @@ class RadixTree {
     constructor() {
         this.root = new Node();
     }
-    insert(segments, handler, priority) {
+    insert(segments, handler, priority, metadata) {
         let node = this.root;
         for (const segment of segments) {
             if (segment.startsWith(':')) {
@@ -39,11 +40,14 @@ class RadixTree {
                 node = node.children.get(segment);
             }
         }
-        node.data = { handler, priority };
-        node.staticMatch = { handler, priority, params: {} };
+        node.data = { handler, priority, metadata };
+        node.staticMatch = { handler, priority, params: EMPTY_PARAMS, metadata };
     }
     lookup(segments) {
-        return this.find(this.root, segments, 0);
+        const result = this.find(this.root, segments, 0);
+        if (!result)
+            return null;
+        return this.toMatchResult(result);
     }
     lookupPath(path) {
         if (path === '/' || path === '') {
@@ -53,13 +57,43 @@ class RadixTree {
             return null;
         }
         const start = path.charCodeAt(0) === 47 ? 1 : 0;
-        return this.findPath(this.root, path, start);
+        const result = this.findPath(this.root, path, start);
+        if (!result)
+            return null;
+        if (!result.params) {
+            return {
+                handler: result.handler,
+                priority: result.priority,
+                params: EMPTY_PARAMS,
+                metadata: result.metadata
+            };
+        }
+        return this.toMatchResult(result);
+    }
+    toMatchResult(result) {
+        const params = {};
+        let node = result.params;
+        while (node) {
+            params[node.key] = node.value;
+            node = node.next;
+        }
+        return {
+            handler: result.handler,
+            priority: result.priority,
+            params,
+            metadata: result.metadata
+        };
     }
     findPath(node, path, start) {
         // Handle trailing slash or end of path
         if (start >= path.length) {
             if (node.staticMatch) {
-                return node.staticMatch;
+                return {
+                    handler: node.staticMatch.handler,
+                    priority: node.staticMatch.priority,
+                    params: null,
+                    metadata: node.staticMatch.metadata
+                };
             }
             return null;
         }
@@ -84,13 +118,15 @@ class RadixTree {
         if (node.paramChild) {
             const result = this.findPath(node.paramChild, path, nextStart);
             if (result) {
-                // Clone params to avoid modifying shared staticMatch
-                const newParams = { ...result.params };
-                newParams[node.paramChild.paramName] = segment;
                 return {
                     handler: result.handler,
                     priority: result.priority,
-                    params: newParams
+                    metadata: result.metadata,
+                    params: {
+                        key: node.paramChild.paramName,
+                        value: segment,
+                        next: result.params
+                    }
                 };
             }
         }
@@ -102,7 +138,8 @@ class RadixTree {
                 return {
                     handler: node.data.handler,
                     priority: node.data.priority,
-                    params: {},
+                    metadata: node.data.metadata,
+                    params: null,
                 };
             }
             return null;
@@ -120,9 +157,16 @@ class RadixTree {
         if (node.paramChild) {
             const result = this.find(node.paramChild, segments, index + 1);
             if (result) {
-                // If match found down this path, add current param to it
-                result.params[node.paramChild.paramName] = segment;
-                return result;
+                return {
+                    handler: result.handler,
+                    priority: result.priority,
+                    metadata: result.metadata,
+                    params: {
+                        key: node.paramChild.paramName,
+                        value: segment,
+                        next: result.params
+                    }
+                };
             }
         }
         return null;

package/dist/src/router/router.d.ts

@@ -1,22 +1,25 @@
-import { HTTPMethod, QHTTPXHandler, RouteOptions, RoutePriority } from '../core/types';
+import { HTTPMethod, QHTTPXHandler, RouteOptions, RoutePriority, RouteMetadata } from '../core/types';
 import { RouteSchema } from '../validation/types';
 type RouteDefinition = {
     path: string;
     segments: string[];
     handler: QHTTPXHandler;
     priority: RoutePriority;
+    metadata: RouteMetadata;
     schema?: RouteSchema | Record<string, unknown>;
 };
 export type RouteMatch = {
     handler: QHTTPXHandler;
     params: Record<string, string>;
     priority: RoutePriority;
+    metadata: RouteMetadata;
 };
 export declare class Router {
     private readonly methodBuckets;
-    private readonly radixTrees;
     private readonly staticRoutes;
+    private readonly dynamicRoutes;
     private isFrozen;
+    private detectMetadata;
     register(method: HTTPMethod, path: string, handler: QHTTPXHandler, options?: RouteOptions & {
         schema?: RouteSchema | Record<string, unknown>;
     }): void;