@carno.js/core 1.1.1 → 1.2.0

package/src/utils/parseQuery.ts

@@ -1,161 +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;
-    }
-}
+/**
+ * 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;
+    }
+}

package/src/validation/ValibotAdapter.ts

@@ -1,95 +1,95 @@
-import type { ValidatorAdapter, ValidationResult, ValidationError } from './ValidatorAdapter';
-import { VALIDATION_SCHEMA, getSchema } from './ValidatorAdapter';
-import { ValidationException } from './ZodAdapter';
-
-/**
- * Valibot Adapter for Turbo validation.
- * 
- * Usage:
- * ```typescript
- * import * as v from 'valibot';
- * 
- * @Schema(v.object({
- *   name: v.pipe(v.string(), v.minLength(1)),
- *   email: v.pipe(v.string(), v.email())
- * }))
- * class CreateUserDto {
- *   name: string;
- *   email: string;
- * }
- * ```
- */
-export class ValibotAdapter implements ValidatorAdapter {
-    readonly name = 'ValibotAdapter';
-
-    private schemaCache = new Map<any, any>();
-    private valibot: any = null;
-
-    constructor() {
-        // Lazy load valibot
-        try {
-            this.valibot = require('valibot');
-        } catch {
-            // Will be loaded on first use
-        }
-    }
-
-    private ensureValibot(): any {
-        if (!this.valibot) {
-            this.valibot = require('valibot');
-        }
-        return this.valibot;
-    }
-
-    hasValidation(target: any): boolean {
-        return getSchema(target) !== undefined;
-    }
-
-    validate<T>(target: any, value: unknown): ValidationResult<T> {
-        const schema = this.getOrCacheSchema(target);
-
-        if (!schema) {
-            return { success: true, data: value as T };
-        }
-
-        const v = this.ensureValibot();
-        const result = v.safeParse(schema, value);
-
-        if (result.success) {
-            return { success: true, data: result.output };
-        }
-
-        return {
-            success: false,
-            errors: this.formatErrors(result.issues)
-        };
-    }
-
-    validateOrThrow<T>(target: any, value: unknown): T {
-        const result = this.validate<T>(target, value);
-
-        if (result.success) {
-            return result.data!;
-        }
-
-        throw new ValidationException(result.errors!);
-    }
-
-    private getOrCacheSchema(target: any): any {
-        let schema = this.schemaCache.get(target);
-
-        if (schema === undefined) {
-            schema = getSchema(target) ?? null;
-            this.schemaCache.set(target, schema);
-        }
-
-        return schema;
-    }
-
-    private formatErrors(issues: any[]): ValidationError[] {
-        return issues.map((issue: any) => ({
-            path: issue.path?.map((p: any) => p.key).join('.') || '',
-            message: issue.message
-        }));
-    }
-}
+import type { ValidatorAdapter, ValidationResult, ValidationError } from './ValidatorAdapter';
+import { VALIDATION_SCHEMA, getSchema } from './ValidatorAdapter';
+import { ValidationException } from './ZodAdapter';
+
+/**
+ * Valibot Adapter for Turbo validation.
+ * 
+ * Usage:
+ * ```typescript
+ * import * as v from 'valibot';
+ * 
+ * @Schema(v.object({
+ *   name: v.pipe(v.string(), v.minLength(1)),
+ *   email: v.pipe(v.string(), v.email())
+ * }))
+ * class CreateUserDto {
+ *   name: string;
+ *   email: string;
+ * }
+ * ```
+ */
+export class ValibotAdapter implements ValidatorAdapter {
+    readonly name = 'ValibotAdapter';
+
+    private schemaCache = new Map<any, any>();
+    private valibot: any = null;
+
+    constructor() {
+        // Lazy load valibot
+        try {
+            this.valibot = require('valibot');
+        } catch {
+            // Will be loaded on first use
+        }
+    }
+
+    private ensureValibot(): any {
+        if (!this.valibot) {
+            this.valibot = require('valibot');
+        }
+        return this.valibot;
+    }
+
+    hasValidation(target: any): boolean {
+        return getSchema(target) !== undefined;
+    }
+
+    validate<T>(target: any, value: unknown): ValidationResult<T> {
+        const schema = this.getOrCacheSchema(target);
+
+        if (!schema) {
+            return { success: true, data: value as T };
+        }
+
+        const v = this.ensureValibot();
+        const result = v.safeParse(schema, value);
+
+        if (result.success) {
+            return { success: true, data: result.output };
+        }
+
+        return {
+            success: false,
+            errors: this.formatErrors(result.issues)
+        };
+    }
+
+    validateOrThrow<T>(target: any, value: unknown): T {
+        const result = this.validate<T>(target, value);
+
+        if (result.success) {
+            return result.data!;
+        }
+
+        throw new ValidationException(result.errors!);
+    }
+
+    private getOrCacheSchema(target: any): any {
+        let schema = this.schemaCache.get(target);
+
+        if (schema === undefined) {
+            schema = getSchema(target) ?? null;
+            this.schemaCache.set(target, schema);
+        }
+
+        return schema;
+    }
+
+    private formatErrors(issues: any[]): ValidationError[] {
+        return issues.map((issue: any) => ({
+            path: issue.path?.map((p: any) => p.key).join('.') || '',
+            message: issue.message
+        }));
+    }
+}

package/src/validation/ValidatorAdapter.ts

@@ -1,69 +1,69 @@
-/**
- * Validation result type.
- */
-export interface ValidationResult<T = any> {
-    success: boolean;
-    data?: T;
-    errors?: ValidationError[];
-}
-
-export interface ValidationError {
-    path: string;
-    message: string;
-}
-
-/**
- * Base interface for validation adapters.
- * Adapters provide validation capabilities for different libraries.
- */
-export interface ValidatorAdapter {
-    /**
-     * Validator name for debugging.
-     */
-    readonly name: string;
-
-    /**
-     * Check if a target has validation schema.
-     */
-    hasValidation(target: any): boolean;
-
-    /**
-     * Validate and transform a value.
-     * Returns result object instead of throwing for better performance.
-     */
-    validate<T>(target: any, value: unknown): ValidationResult<T>;
-
-    /**
-     * Validate and transform, throwing on error.
-     * Used when you want to short-circuit on failure.
-     */
-    validateOrThrow<T>(target: any, value: unknown): T;
-}
-
-/**
- * Validation configuration for Turbo.
- */
-export interface ValidationConfig {
-    adapter: ValidatorAdapter;
-}
-
-/**
- * Symbol for storing validation schema on DTOs.
- */
-export const VALIDATION_SCHEMA = Symbol('turbo:validation');
-
-/**
- * Decorator to attach a validation schema to a DTO class.
- */
-export function Schema(schema: any): ClassDecorator {
-    return (target) => {
-        Reflect.defineMetadata(VALIDATION_SCHEMA, schema, target);
-    };
-}
-
-/**
- * Get the validation schema from a DTO class.
- */
-export function getSchema(target: any): any | undefined {
-    return Reflect.getMetadata(VALIDATION_SCHEMA, target);
-}
+/**
+ * Validation result type.
+ */
+export interface ValidationResult<T = any> {
+    success: boolean;
+    data?: T;
+    errors?: ValidationError[];
+}
+
+export interface ValidationError {
+    path: string;
+    message: string;
+}
+
+/**
+ * Base interface for validation adapters.
+ * Adapters provide validation capabilities for different libraries.
+ */
+export interface ValidatorAdapter {
+    /**
+     * Validator name for debugging.
+     */
+    readonly name: string;
+
+    /**
+     * Check if a target has validation schema.
+     */
+    hasValidation(target: any): boolean;
+
+    /**
+     * Validate and transform a value.
+     * Returns result object instead of throwing for better performance.
+     */
+    validate<T>(target: any, value: unknown): ValidationResult<T>;
+
+    /**
+     * Validate and transform, throwing on error.
+     * Used when you want to short-circuit on failure.
+     */
+    validateOrThrow<T>(target: any, value: unknown): T;
+}
+
+/**
+ * Validation configuration for Turbo.
+ */
+export interface ValidationConfig {
+    adapter: ValidatorAdapter;
+}
+
+/**
+ * Symbol for storing validation schema on DTOs.
+ */
+export const VALIDATION_SCHEMA = Symbol('turbo:validation');
+
+/**
+ * Decorator to attach a validation schema to a DTO class.
+ */
+export function Schema(schema: any): ClassDecorator {
+    return (target) => {
+        Reflect.defineMetadata(VALIDATION_SCHEMA, schema, target);
+    };
+}
+
+/**
+ * Get the validation schema from a DTO class.
+ */
+export function getSchema(target: any): any | undefined {
+    return Reflect.getMetadata(VALIDATION_SCHEMA, target);
+}