@carno.js/core 1.0.2 → 1.0.4

package/src/testing/TestHarness.ts

@@ -1,177 +1,177 @@
-import type { Server } from 'bun';
-import { Carno, type CarnoConfig } from '../Carno';
-import { Container, type Token } from '../container/Container';
-
-/**
- * Test configuration options.
- */
-export interface TestOptions {
-    config?: CarnoConfig;
-    listen?: boolean | number;
-    port?: number;
-    controllers?: (new (...args: any[]) => any)[];
-    services?: (Token | any)[];
-}
-
-/**
- * Test harness - provides utilities for testing Carno applications.
- */
-export interface TestHarness {
-    /** The Carno app instance */
-    app: Carno;
-
-    /** The internal DI container */
-    container: Container;
-
-    /** The HTTP server (if listening) */
-    server?: Server<any>;
-
-    /** The port the server is running on */
-    port?: number;
-
-    /** Resolve a service from the container */
-    resolve<T>(token: Token<T>): T;
-
-    /** Make an HTTP request to the app */
-    request(path: string, init?: RequestInit): Promise<Response>;
-
-    /** Make a GET request */
-    get(path: string, init?: Omit<RequestInit, 'method'>): Promise<Response>;
-
-    /** Make a POST request */
-    post(path: string, body?: any, init?: Omit<RequestInit, 'method' | 'body'>): Promise<Response>;
-
-    /** Make a PUT request */
-    put(path: string, body?: any, init?: Omit<RequestInit, 'method' | 'body'>): Promise<Response>;
-
-    /** Make a DELETE request */
-    delete(path: string, init?: Omit<RequestInit, 'method'>): Promise<Response>;
-
-    /** Close the test harness and cleanup */
-    close(): Promise<void>;
-}
-
-/**
- * Create a test harness for Turbo applications.
- * 
- * @example
- * ```typescript
- * const harness = await createTestHarness({
- *   controllers: [UserController],
- *   services: [UserService],
- *   listen: true
- * });
- * 
- * const response = await harness.get('/users');
- * expect(response.status).toBe(200);
- * 
- * await harness.close();
- * ```
- */
-export async function createTestHarness(options: TestOptions = {}): Promise<TestHarness> {
-    const config: CarnoConfig = {
-        ...options.config,
-        disableStartupLog: true
-    };
-
-    const app = new Carno(config);
-
-    // Register controllers
-    if (options.controllers) {
-        app.controllers(options.controllers);
-    }
-
-    // Register services
-    if (options.services) {
-        app.services(options.services);
-    }
-
-    const port = resolvePort(options);
-    let server: Server<any> | undefined;
-
-    if (shouldListen(options.listen)) {
-        app.listen(port);
-        server = (app as any).server;
-    }
-
-    const actualPort = server?.port ?? port;
-    const container = (app as any).container as Container;
-
-    // Pre-bind methods for performance
-    const baseUrl = `http://127.0.0.1:${actualPort}`;
-
-    const request = async (path: string, init?: RequestInit): Promise<Response> => {
-        if (!server) {
-            throw new Error('Server not running. Set listen: true in options.');
-        }
-        const url = path.startsWith('http') ? path : `${baseUrl}${path.startsWith('/') ? path : '/' + path}`;
-        return fetch(url, init);
-    };
-
-    return {
-        app,
-        container,
-        server,
-        port: actualPort,
-
-        resolve: <T>(token: Token<T>): T => container.get(token),
-
-        request,
-
-        get: (path, init) => request(path, { ...init, method: 'GET' }),
-
-        post: (path, body, init) => request(path, {
-            ...init,
-            method: 'POST',
-            body: body ? JSON.stringify(body) : undefined,
-            headers: { 'Content-Type': 'application/json', ...init?.headers }
-        }),
-
-        put: (path, body, init) => request(path, {
-            ...init,
-            method: 'PUT',
-            body: body ? JSON.stringify(body) : undefined,
-            headers: { 'Content-Type': 'application/json', ...init?.headers }
-        }),
-
-        delete: (path, init) => request(path, { ...init, method: 'DELETE' }),
-
-        close: async () => {
-            app.stop();
-        }
-    };
-}
-
-/**
- * Run a test routine with automatic harness cleanup.
- * 
- * @example
- * ```typescript
- * await withTestApp(async (harness) => {
- *   const response = await harness.get('/health');
- *   expect(response.status).toBe(200);
- * }, { controllers: [HealthController], listen: true });
- * ```
- */
-export async function withTestApp(
-    routine: (harness: TestHarness) => Promise<void>,
-    options: TestOptions = {}
-): Promise<void> {
-    const harness = await createTestHarness(options);
-
-    try {
-        await routine(harness);
-    } finally {
-        await harness.close();
-    }
-}
-
-function shouldListen(value: TestOptions['listen']): boolean {
-    return typeof value === 'number' || Boolean(value);
-}
-
-function resolvePort(options: TestOptions): number {
-    if (typeof options.listen === 'number') return options.listen;
-    if (typeof options.port === 'number') return options.port;
-    return 0; // Random port
-}
+import type { Server } from 'bun';
+import { Carno, type CarnoConfig } from '../Carno';
+import { Container, type Token } from '../container/Container';
+
+/**
+ * Test configuration options.
+ */
+export interface TestOptions {
+    config?: CarnoConfig;
+    listen?: boolean | number;
+    port?: number;
+    controllers?: (new (...args: any[]) => any)[];
+    services?: (Token | any)[];
+}
+
+/**
+ * Test harness - provides utilities for testing Carno applications.
+ */
+export interface TestHarness {
+    /** The Carno app instance */
+    app: Carno;
+
+    /** The internal DI container */
+    container: Container;
+
+    /** The HTTP server (if listening) */
+    server?: Server<any>;
+
+    /** The port the server is running on */
+    port?: number;
+
+    /** Resolve a service from the container */
+    resolve<T>(token: Token<T>): T;
+
+    /** Make an HTTP request to the app */
+    request(path: string, init?: RequestInit): Promise<Response>;
+
+    /** Make a GET request */
+    get(path: string, init?: Omit<RequestInit, 'method'>): Promise<Response>;
+
+    /** Make a POST request */
+    post(path: string, body?: any, init?: Omit<RequestInit, 'method' | 'body'>): Promise<Response>;
+
+    /** Make a PUT request */
+    put(path: string, body?: any, init?: Omit<RequestInit, 'method' | 'body'>): Promise<Response>;
+
+    /** Make a DELETE request */
+    delete(path: string, init?: Omit<RequestInit, 'method'>): Promise<Response>;
+
+    /** Close the test harness and cleanup */
+    close(): Promise<void>;
+}
+
+/**
+ * Create a test harness for Turbo applications.
+ * 
+ * @example
+ * ```typescript
+ * const harness = await createTestHarness({
+ *   controllers: [UserController],
+ *   services: [UserService],
+ *   listen: true
+ * });
+ * 
+ * const response = await harness.get('/users');
+ * expect(response.status).toBe(200);
+ * 
+ * await harness.close();
+ * ```
+ */
+export async function createTestHarness(options: TestOptions = {}): Promise<TestHarness> {
+    const config: CarnoConfig = {
+        ...options.config,
+        disableStartupLog: true
+    };
+
+    const app = new Carno(config);
+
+    // Register controllers
+    if (options.controllers) {
+        app.controllers(options.controllers);
+    }
+
+    // Register services
+    if (options.services) {
+        app.services(options.services);
+    }
+
+    const port = resolvePort(options);
+    let server: Server<any> | undefined;
+
+    if (shouldListen(options.listen)) {
+        app.listen(port);
+        server = (app as any).server;
+    }
+
+    const actualPort = server?.port ?? port;
+    const container = (app as any).container as Container;
+
+    // Pre-bind methods for performance
+    const baseUrl = `http://127.0.0.1:${actualPort}`;
+
+    const request = async (path: string, init?: RequestInit): Promise<Response> => {
+        if (!server) {
+            throw new Error('Server not running. Set listen: true in options.');
+        }
+        const url = path.startsWith('http') ? path : `${baseUrl}${path.startsWith('/') ? path : '/' + path}`;
+        return fetch(url, init);
+    };
+
+    return {
+        app,
+        container,
+        server,
+        port: actualPort,
+
+        resolve: <T>(token: Token<T>): T => container.get(token),
+
+        request,
+
+        get: (path, init) => request(path, { ...init, method: 'GET' }),
+
+        post: (path, body, init) => request(path, {
+            ...init,
+            method: 'POST',
+            body: body ? JSON.stringify(body) : undefined,
+            headers: { 'Content-Type': 'application/json', ...init?.headers }
+        }),
+
+        put: (path, body, init) => request(path, {
+            ...init,
+            method: 'PUT',
+            body: body ? JSON.stringify(body) : undefined,
+            headers: { 'Content-Type': 'application/json', ...init?.headers }
+        }),
+
+        delete: (path, init) => request(path, { ...init, method: 'DELETE' }),
+
+        close: async () => {
+            app.stop();
+        }
+    };
+}
+
+/**
+ * Run a test routine with automatic harness cleanup.
+ * 
+ * @example
+ * ```typescript
+ * await withTestApp(async (harness) => {
+ *   const response = await harness.get('/health');
+ *   expect(response.status).toBe(200);
+ * }, { controllers: [HealthController], listen: true });
+ * ```
+ */
+export async function withTestApp(
+    routine: (harness: TestHarness) => Promise<void>,
+    options: TestOptions = {}
+): Promise<void> {
+    const harness = await createTestHarness(options);
+
+    try {
+        await routine(harness);
+    } finally {
+        await harness.close();
+    }
+}
+
+function shouldListen(value: TestOptions['listen']): boolean {
+    return typeof value === 'number' || Boolean(value);
+}
+
+function resolvePort(options: TestOptions): number {
+    if (typeof options.listen === 'number') return options.listen;
+    if (typeof options.port === 'number') return options.port;
+    return 0; // Random port
+}

package/src/utils/Metadata.ts

@@ -1,43 +1,43 @@
-/**
- * Utility class for handling metadata operations.
- * Wraps Reflect.getMetadata and Reflect.defineMetadata.
- */
-export class Metadata {
-  static get<T = any>(key: string | symbol, target: any): T | undefined {
-    return Reflect.getMetadata(key, target);
-  }
-
-  static set(key: string | symbol, value: any, target: any): void {
-    Reflect.defineMetadata(key, value, target);
-  }
-
-  static has(key: string | symbol, target: any): boolean {
-    return Reflect.hasMetadata(key, target);
-  }
-
-  static delete(key: string | symbol, target: any): boolean {
-    return Reflect.deleteMetadata(key, target);
-  }
-
-  static keys(target: any): (string | symbol)[] {
-    return Reflect.getMetadataKeys(target);
-  }
-
-  static getType(target: any, propertyKey: string | symbol): any {
-    return Reflect.getMetadata('design:type', target, propertyKey);
-  }
-}
-
-/**
- * Type guard for checking if value is an object.
- */
-export function isObject(value: unknown): value is Record<string, any> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-/**
- * Type guard for checking if value is a string.
- */
-export function isString(value: unknown): value is string {
-  return typeof value === 'string';
-}
+/**
+ * Utility class for handling metadata operations.
+ * Wraps Reflect.getMetadata and Reflect.defineMetadata.
+ */
+export class Metadata {
+  static get<T = any>(key: string | symbol, target: any): T | undefined {
+    return Reflect.getMetadata(key, target);
+  }
+
+  static set(key: string | symbol, value: any, target: any): void {
+    Reflect.defineMetadata(key, value, target);
+  }
+
+  static has(key: string | symbol, target: any): boolean {
+    return Reflect.hasMetadata(key, target);
+  }
+
+  static delete(key: string | symbol, target: any): boolean {
+    return Reflect.deleteMetadata(key, target);
+  }
+
+  static keys(target: any): (string | symbol)[] {
+    return Reflect.getMetadataKeys(target);
+  }
+
+  static getType(target: any, propertyKey: string | symbol): any {
+    return Reflect.getMetadata('design:type', target, propertyKey);
+  }
+}
+
+/**
+ * Type guard for checking if value is an object.
+ */
+export function isObject(value: unknown): value is Record<string, any> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Type guard for checking if value is a string.
+ */
+export function isString(value: unknown): value is string {
+  return typeof value === 'string';
+}

package/src/utils/parseQuery.ts

@@ -0,0 +1,161 @@
+/**
+ * High-performance query string parser.
+ * 
+ * Based on Elysia's approach - uses manual string parsing with charCodeAt()
+ * instead of new URL() for significant performance gains.
+ * 
+ * Benchmark: ~10x faster than new URL().searchParams
+ */
+
+// Bit flags for tracking decode requirements
+const KEY_HAS_PLUS = 1;
+const KEY_NEEDS_DECODE = 2;
+const VALUE_HAS_PLUS = 4;
+const VALUE_NEEDS_DECODE = 8;
+
+/**
+ * Parse query string from a full URL.
+ * Extracts the query portion and parses key-value pairs.
+ * 
+ * @param url Full URL string (e.g., "http://localhost/path?foo=bar&baz=123")
+ * @returns Record<string, string> - parsed query parameters
+ */
+export function parseQueryFromURL(url: string): Record<string, string> {
+    // Find the start of query string
+    const queryStart = url.indexOf('?');
+
+    if (queryStart === -1) {
+        return Object.create(null);
+    }
+
+    // Find the end of query string (before hash if present)
+    let queryEnd = url.indexOf('#', queryStart);
+
+    if (queryEnd === -1) {
+        queryEnd = url.length;
+    }
+
+    return parseQuery(url, queryStart + 1, queryEnd);
+}
+
+/**
+ * Parse query string directly.
+ * 
+ * @param input Query string without leading '?' (e.g., "foo=bar&baz=123")
+ * @returns Record<string, string> - parsed query parameters
+ */
+export function parseQueryString(input: string): Record<string, string> {
+    return parseQuery(input, 0, input.length);
+}
+
+/**
+ * Internal parser - parses query string from startIndex to endIndex.
+ */
+function parseQuery(
+    input: string,
+    startIndex: number,
+    endIndex: number
+): Record<string, string> {
+    const result: Record<string, string> = Object.create(null);
+
+    let flags = 0;
+    let startingIndex = startIndex - 1;
+    let equalityIndex = startingIndex;
+
+    for (let i = startIndex; i < endIndex; i++) {
+        switch (input.charCodeAt(i)) {
+            // '&' - separator between key-value pairs
+            case 38:
+                processKeyValuePair(i);
+                startingIndex = i;
+                equalityIndex = i;
+                flags = 0;
+                break;
+
+            // '=' - separator between key and value
+            case 61:
+                if (equalityIndex <= startingIndex) {
+                    equalityIndex = i;
+                } else {
+                    // Multiple '=' means value needs decode
+                    flags |= VALUE_NEEDS_DECODE;
+                }
+                break;
+
+            // '+' - space encoding
+            case 43:
+                if (equalityIndex > startingIndex) {
+                    flags |= VALUE_HAS_PLUS;
+                } else {
+                    flags |= KEY_HAS_PLUS;
+                }
+                break;
+
+            // '%' - URL encoding
+            case 37:
+                if (equalityIndex > startingIndex) {
+                    flags |= VALUE_NEEDS_DECODE;
+                } else {
+                    flags |= KEY_NEEDS_DECODE;
+                }
+                break;
+        }
+    }
+
+    // Process the last pair
+    if (startingIndex < endIndex) {
+        processKeyValuePair(endIndex);
+    }
+
+    return result;
+
+    function processKeyValuePair(pairEndIndex: number) {
+        const hasBothKeyValuePair = equalityIndex > startingIndex;
+        const effectiveEqualityIndex = hasBothKeyValuePair
+            ? equalityIndex
+            : pairEndIndex;
+
+        const keySlice = input.slice(startingIndex + 1, effectiveEqualityIndex);
+
+        // Skip empty keys
+        if (!hasBothKeyValuePair && keySlice.length === 0) {
+            return;
+        }
+
+        let finalKey = keySlice;
+
+        if (flags & KEY_HAS_PLUS) {
+            finalKey = finalKey.replace(/\+/g, ' ');
+        }
+
+        if (flags & KEY_NEEDS_DECODE) {
+            try {
+                finalKey = decodeURIComponent(finalKey);
+            } catch {
+                // Keep original if decode fails
+            }
+        }
+
+        let finalValue = '';
+
+        if (hasBothKeyValuePair) {
+            let valueSlice = input.slice(equalityIndex + 1, pairEndIndex);
+
+            if (flags & VALUE_HAS_PLUS) {
+                valueSlice = valueSlice.replace(/\+/g, ' ');
+            }
+
+            if (flags & VALUE_NEEDS_DECODE) {
+                try {
+                    finalValue = decodeURIComponent(valueSlice);
+                } catch {
+                    finalValue = valueSlice;
+                }
+            } else {
+                finalValue = valueSlice;
+            }
+        }
+
+        result[finalKey] = finalValue;
+    }
+}