@carno.js/core 1.1.1 → 1.1.2

package/src/cors/CorsHandler.ts

@@ -1,145 +1,145 @@
-/**
- * CORS Configuration types.
- */
-export type CorsOrigin =
-    | string
-    | string[]
-    | RegExp
-    | ((origin: string) => boolean);
-
-export interface CorsConfig {
-    origins: CorsOrigin;
-    methods?: string[];
-    allowedHeaders?: string[];
-    exposedHeaders?: string[];
-    credentials?: boolean;
-    maxAge?: number;
-}
-
-export const DEFAULT_CORS_METHODS = ['GET', 'HEAD', 'PUT', 'PATCH', 'POST', 'DELETE'];
-export const DEFAULT_CORS_HEADERS = ['Content-Type', 'Authorization', 'X-Requested-With', 'Accept', 'Origin'];
-
-type OriginMatcher = (origin: string) => boolean;
-
-/**
- * CORS Handler - Pre-computes headers at startup for maximum performance.
- */
-export class CorsHandler {
-    private readonly cache = new Map<string, Record<string, string>>();
-    private readonly methodsStr: string;
-    private readonly headersStr: string;
-    private readonly exposedStr: string | null;
-    private readonly maxAgeStr: string | null;
-    private readonly hasCredentials: boolean;
-    private readonly isWildcard: boolean;
-    private readonly matcher: OriginMatcher;
-
-    // Pre-created preflight response for wildcard CORS
-    private readonly preflightResponse: Response | null = null;
-
-    constructor(config: CorsConfig) {
-        this.methodsStr = (config.methods || DEFAULT_CORS_METHODS).join(', ');
-        this.headersStr = (config.allowedHeaders || DEFAULT_CORS_HEADERS).join(', ');
-        this.exposedStr = config.exposedHeaders?.join(', ') || null;
-        this.maxAgeStr = config.maxAge?.toString() || null;
-        this.hasCredentials = !!config.credentials;
-        this.isWildcard = config.origins === '*';
-        this.matcher = this.buildMatcher(config.origins);
-
-        // Pre-create preflight response for wildcard
-        if (this.isWildcard) {
-            this.preflightResponse = new Response(null, {
-                status: 204,
-                headers: this.buildHeaders('*')
-            });
-        }
-    }
-
-    /**
-     * Handle preflight (OPTIONS) request.
-     */
-    preflight(origin: string): Response {
-        if (this.isWildcard && this.preflightResponse) {
-            return this.preflightResponse.clone();
-        }
-
-        if (!this.isAllowed(origin)) {
-            return new Response(null, { status: 403 });
-        }
-
-        return new Response(null, {
-            status: 204,
-            headers: this.getHeaders(origin)
-        });
-    }
-
-    /**
-     * Apply CORS headers to a response.
-     */
-    apply(response: Response, origin: string): Response {
-        if (!this.isAllowed(origin)) {
-            return response;
-        }
-
-        const headers = this.getHeaders(origin);
-        for (const [key, value] of Object.entries(headers)) {
-            response.headers.set(key, value);
-        }
-
-        return response;
-    }
-
-    /**
-     * Check if origin is allowed.
-     */
-    isAllowed(origin: string): boolean {
-        return this.matcher(origin);
-    }
-
-    /**
-     * Get cached CORS headers for origin.
-     */
-    private getHeaders(origin: string): Record<string, string> {
-        const key = this.isWildcard ? '*' : origin;
-        let headers = this.cache.get(key);
-
-        if (!headers) {
-            headers = this.buildHeaders(origin);
-            this.cache.set(key, headers);
-        }
-
-        return headers;
-    }
-
-    private buildHeaders(origin: string): Record<string, string> {
-        const headers: Record<string, string> = {
-            'Access-Control-Allow-Origin': this.isWildcard ? '*' : origin,
-            'Access-Control-Allow-Methods': this.methodsStr,
-            'Access-Control-Allow-Headers': this.headersStr
-        };
-
-        if (this.hasCredentials) {
-            headers['Access-Control-Allow-Credentials'] = 'true';
-        }
-        if (this.exposedStr) {
-            headers['Access-Control-Expose-Headers'] = this.exposedStr;
-        }
-        if (this.maxAgeStr) {
-            headers['Access-Control-Max-Age'] = this.maxAgeStr;
-        }
-
-        return headers;
-    }
-
-    private buildMatcher(origins: CorsOrigin): OriginMatcher {
-        if (origins === '*') return () => true;
-        if (typeof origins === 'string') return (o) => o === origins;
-        if (Array.isArray(origins)) {
-            const set = new Set(origins);
-            return (o) => set.has(o);
-        }
-        if (origins instanceof RegExp) return (o) => origins.test(o);
-        if (typeof origins === 'function') return origins;
-        return () => false;
-    }
-}
+/**
+ * CORS Configuration types.
+ */
+export type CorsOrigin =
+    | string
+    | string[]
+    | RegExp
+    | ((origin: string) => boolean);
+
+export interface CorsConfig {
+    origins: CorsOrigin;
+    methods?: string[];
+    allowedHeaders?: string[];
+    exposedHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+}
+
+export const DEFAULT_CORS_METHODS = ['GET', 'HEAD', 'PUT', 'PATCH', 'POST', 'DELETE'];
+export const DEFAULT_CORS_HEADERS = ['Content-Type', 'Authorization', 'X-Requested-With', 'Accept', 'Origin'];
+
+type OriginMatcher = (origin: string) => boolean;
+
+/**
+ * CORS Handler - Pre-computes headers at startup for maximum performance.
+ */
+export class CorsHandler {
+    private readonly cache = new Map<string, Record<string, string>>();
+    private readonly methodsStr: string;
+    private readonly headersStr: string;
+    private readonly exposedStr: string | null;
+    private readonly maxAgeStr: string | null;
+    private readonly hasCredentials: boolean;
+    private readonly isWildcard: boolean;
+    private readonly matcher: OriginMatcher;
+
+    // Pre-created preflight response for wildcard CORS
+    private readonly preflightResponse: Response | null = null;
+
+    constructor(config: CorsConfig) {
+        this.methodsStr = (config.methods || DEFAULT_CORS_METHODS).join(', ');
+        this.headersStr = (config.allowedHeaders || DEFAULT_CORS_HEADERS).join(', ');
+        this.exposedStr = config.exposedHeaders?.join(', ') || null;
+        this.maxAgeStr = config.maxAge?.toString() || null;
+        this.hasCredentials = !!config.credentials;
+        this.isWildcard = config.origins === '*';
+        this.matcher = this.buildMatcher(config.origins);
+
+        // Pre-create preflight response for wildcard
+        if (this.isWildcard) {
+            this.preflightResponse = new Response(null, {
+                status: 204,
+                headers: this.buildHeaders('*')
+            });
+        }
+    }
+
+    /**
+     * Handle preflight (OPTIONS) request.
+     */
+    preflight(origin: string): Response {
+        if (this.isWildcard && this.preflightResponse) {
+            return this.preflightResponse.clone();
+        }
+
+        if (!this.isAllowed(origin)) {
+            return new Response(null, { status: 403 });
+        }
+
+        return new Response(null, {
+            status: 204,
+            headers: this.getHeaders(origin)
+        });
+    }
+
+    /**
+     * Apply CORS headers to a response.
+     */
+    apply(response: Response, origin: string): Response {
+        if (!this.isAllowed(origin)) {
+            return response;
+        }
+
+        const headers = this.getHeaders(origin);
+        for (const [key, value] of Object.entries(headers)) {
+            response.headers.set(key, value);
+        }
+
+        return response;
+    }
+
+    /**
+     * Check if origin is allowed.
+     */
+    isAllowed(origin: string): boolean {
+        return this.matcher(origin);
+    }
+
+    /**
+     * Get cached CORS headers for origin.
+     */
+    private getHeaders(origin: string): Record<string, string> {
+        const key = this.isWildcard ? '*' : origin;
+        let headers = this.cache.get(key);
+
+        if (!headers) {
+            headers = this.buildHeaders(origin);
+            this.cache.set(key, headers);
+        }
+
+        return headers;
+    }
+
+    private buildHeaders(origin: string): Record<string, string> {
+        const headers: Record<string, string> = {
+            'Access-Control-Allow-Origin': this.isWildcard ? '*' : origin,
+            'Access-Control-Allow-Methods': this.methodsStr,
+            'Access-Control-Allow-Headers': this.headersStr
+        };
+
+        if (this.hasCredentials) {
+            headers['Access-Control-Allow-Credentials'] = 'true';
+        }
+        if (this.exposedStr) {
+            headers['Access-Control-Expose-Headers'] = this.exposedStr;
+        }
+        if (this.maxAgeStr) {
+            headers['Access-Control-Max-Age'] = this.maxAgeStr;
+        }
+
+        return headers;
+    }
+
+    private buildMatcher(origins: CorsOrigin): OriginMatcher {
+        if (origins === '*') return () => true;
+        if (typeof origins === 'string') return (o) => o === origins;
+        if (Array.isArray(origins)) {
+            const set = new Set(origins);
+            return (o) => set.has(o);
+        }
+        if (origins instanceof RegExp) return (o) => origins.test(o);
+        if (typeof origins === 'function') return origins;
+        return () => false;
+    }
+}

package/src/decorators/Controller.ts

@@ -1,63 +1,63 @@
-import { CONTROLLER_META, ROUTES_META } from '../metadata';
-import type { ControllerOptions, ControllerMeta } from '../metadata';
-
-/**
- * Normalizes path or options to ControllerOptions.
- */
-function normalizeOptions(pathOrOptions?: string | ControllerOptions): ControllerOptions {
-    if (!pathOrOptions) {
-        return {};
-    }
-
-    if (typeof pathOrOptions === 'string') {
-        return { path: pathOrOptions };
-    }
-
-    return pathOrOptions;
-}
-
-/**
- * Normalizes a path to start with / and not end with /.
- */
-function normalizePath(path: string): string {
-    if (!path) return '';
-
-    let normalized = path.startsWith('/') ? path : '/' + path;
-
-    if (normalized !== '/' && normalized.endsWith('/')) {
-        normalized = normalized.slice(0, -1);
-    }
-
-    return normalized;
-}
-
-/**
- * Marks a class as a controller with a base path.
- *
- * @example
- * // Simple path
- * @Controller('/users')
- *
- * @example
- * // With options
- * @Controller({ path: '/users', children: [ProfileController] })
- */
-export function Controller(pathOrOptions?: string | ControllerOptions): ClassDecorator {
-    return (target) => {
-        const options = normalizeOptions(pathOrOptions);
-        const path = normalizePath(options.path || '');
-
-        const meta: ControllerMeta = {
-            path,
-            scope: options.scope,
-            children: options.children
-        };
-
-        Reflect.defineMetadata(CONTROLLER_META, meta, target);
-
-        // Ensure routes array exists
-        if (!Reflect.hasMetadata(ROUTES_META, target)) {
-            Reflect.defineMetadata(ROUTES_META, [], target);
-        }
-    };
-}
+import { CONTROLLER_META, ROUTES_META } from '../metadata';
+import type { ControllerOptions, ControllerMeta } from '../metadata';
+
+/**
+ * Normalizes path or options to ControllerOptions.
+ */
+function normalizeOptions(pathOrOptions?: string | ControllerOptions): ControllerOptions {
+    if (!pathOrOptions) {
+        return {};
+    }
+
+    if (typeof pathOrOptions === 'string') {
+        return { path: pathOrOptions };
+    }
+
+    return pathOrOptions;
+}
+
+/**
+ * Normalizes a path to start with / and not end with /.
+ */
+function normalizePath(path: string): string {
+    if (!path) return '';
+
+    let normalized = path.startsWith('/') ? path : '/' + path;
+
+    if (normalized !== '/' && normalized.endsWith('/')) {
+        normalized = normalized.slice(0, -1);
+    }
+
+    return normalized;
+}
+
+/**
+ * Marks a class as a controller with a base path.
+ *
+ * @example
+ * // Simple path
+ * @Controller('/users')
+ *
+ * @example
+ * // With options
+ * @Controller({ path: '/users', children: [ProfileController] })
+ */
+export function Controller(pathOrOptions?: string | ControllerOptions): ClassDecorator {
+    return (target) => {
+        const options = normalizeOptions(pathOrOptions);
+        const path = normalizePath(options.path || '');
+
+        const meta: ControllerMeta = {
+            path,
+            scope: options.scope,
+            children: options.children
+        };
+
+        Reflect.defineMetadata(CONTROLLER_META, meta, target);
+
+        // Ensure routes array exists
+        if (!Reflect.hasMetadata(ROUTES_META, target)) {
+            Reflect.defineMetadata(ROUTES_META, [], target);
+        }
+    };
+}

package/src/decorators/Inject.ts

@@ -1,16 +1,16 @@
-import { INJECT_META } from '../metadata';
-import type { Token } from '../container/Container';
-
-/**
- * Explicitly specifies which token to inject.
- * Useful for interfaces or when automatic detection fails.
- */
-export function Inject(token: Token): ParameterDecorator {
-    return (target, propertyKey, parameterIndex) => {
-        const existing: Map<number, Token> = Reflect.getMetadata(INJECT_META, target) || new Map();
-
-        existing.set(parameterIndex, token);
-
-        Reflect.defineMetadata(INJECT_META, existing, target);
-    };
-}
+import { INJECT_META } from '../metadata';
+import type { Token } from '../container/Container';
+
+/**
+ * Explicitly specifies which token to inject.
+ * Useful for interfaces or when automatic detection fails.
+ */
+export function Inject(token: Token): ParameterDecorator {
+    return (target, propertyKey, parameterIndex) => {
+        const existing: Map<number, Token> = Reflect.getMetadata(INJECT_META, target) || new Map();
+
+        existing.set(parameterIndex, token);
+
+        Reflect.defineMetadata(INJECT_META, existing, target);
+    };
+}

package/src/decorators/Middleware.ts

@@ -1,22 +1,22 @@
-import { MIDDLEWARE_META, type MiddlewareInfo } from '../metadata';
-
-/**
- * Middleware decorator.
- * Can be applied to controllers or individual methods.
- */
-export function Use(...middlewares: Function[]): ClassDecorator & MethodDecorator {
-    return function (target: any, propertyKey?: string) {
-        const isMethod = propertyKey !== undefined;
-        const metaTarget = isMethod ? target.constructor : target;
-        const existing: MiddlewareInfo[] = Reflect.getMetadata(MIDDLEWARE_META, metaTarget) || [];
-
-        for (const handler of middlewares) {
-            existing.push({
-                handler,
-                target: isMethod ? propertyKey : undefined
-            });
-        }
-
-        Reflect.defineMetadata(MIDDLEWARE_META, existing, metaTarget);
-    } as ClassDecorator & MethodDecorator;
-}
+import { MIDDLEWARE_META, type MiddlewareInfo } from '../metadata';
+
+/**
+ * Middleware decorator.
+ * Can be applied to controllers or individual methods.
+ */
+export function Use(...middlewares: Function[]): ClassDecorator & MethodDecorator {
+    return function (target: any, propertyKey?: string) {
+        const isMethod = propertyKey !== undefined;
+        const metaTarget = isMethod ? target.constructor : target;
+        const existing: MiddlewareInfo[] = Reflect.getMetadata(MIDDLEWARE_META, metaTarget) || [];
+
+        for (const handler of middlewares) {
+            existing.push({
+                handler,
+                target: isMethod ? propertyKey : undefined
+            });
+        }
+
+        Reflect.defineMetadata(MIDDLEWARE_META, existing, metaTarget);
+    } as ClassDecorator & MethodDecorator;
+}

package/src/decorators/Service.ts

@@ -1,18 +1,18 @@
-import { SERVICE_META } from '../metadata';
-import { Scope } from '../container/Container';
-
-export interface ServiceOptions {
-    scope?: Scope;
-}
-
-/**
- * Marks a class as an injectable service.
- * Services are singleton by default.
- */
-export function Service(options: ServiceOptions = {}): ClassDecorator {
-    return (target) => {
-        Reflect.defineMetadata(SERVICE_META, {
-            scope: options.scope ?? Scope.SINGLETON
-        }, target);
-    };
-}
+import { SERVICE_META } from '../metadata';
+import { Scope } from '../container/Container';
+
+export interface ServiceOptions {
+    scope?: Scope;
+}
+
+/**
+ * Marks a class as an injectable service.
+ * Services are singleton by default.
+ */
+export function Service(options: ServiceOptions = {}): ClassDecorator {
+    return (target) => {
+        Reflect.defineMetadata(SERVICE_META, {
+            scope: options.scope ?? Scope.SINGLETON
+        }, target);
+    };
+}

package/src/decorators/methods.ts

@@ -1,58 +1,58 @@
-import { ROUTES_META, type RouteInfo } from '../metadata';
-
-type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head' | 'options';
-
-/**
- * Creates a method decorator for HTTP methods.
- * Supports both legacy decorators (experimentalDecorators) and TS5 stage 3 decorators.
- */
-function createMethodDecorator(method: HttpMethod) {
-    return function (path: string = ''): any {
-        return function (
-            targetOrMethod: any,
-            contextOrPropertyKey?: string | symbol | ClassMethodDecoratorContext,
-            descriptor?: PropertyDescriptor
-        ): any {
-            // TS5 Stage 3 decorators: context is ClassMethodDecoratorContext
-            if (contextOrPropertyKey && typeof contextOrPropertyKey === 'object' && 'kind' in contextOrPropertyKey) {
-                const context = contextOrPropertyKey as ClassMethodDecoratorContext;
-
-                context.addInitializer(function (this: any) {
-                    const constructor = this.constructor;
-                    const routes: RouteInfo[] = Reflect.getMetadata(ROUTES_META, constructor) || [];
-
-                    routes.push({
-                        method,
-                        path: path.startsWith('/') ? path : '/' + path,
-                        handlerName: String(context.name)
-                    });
-
-                    Reflect.defineMetadata(ROUTES_META, routes, constructor);
-                });
-
-                return targetOrMethod;
-            }
-
-            // Legacy decorators (experimentalDecorators: true)
-            const constructor = targetOrMethod.constructor;
-            const propertyKey = contextOrPropertyKey as string | symbol;
-            const routes: RouteInfo[] = Reflect.getMetadata(ROUTES_META, constructor) || [];
-
-            routes.push({
-                method,
-                path: path.startsWith('/') ? path : '/' + path,
-                handlerName: String(propertyKey)
-            });
-
-            Reflect.defineMetadata(ROUTES_META, routes, constructor);
-        };
-    };
-}
-
-export const Get = createMethodDecorator('get');
-export const Post = createMethodDecorator('post');
-export const Put = createMethodDecorator('put');
-export const Delete = createMethodDecorator('delete');
-export const Patch = createMethodDecorator('patch');
-export const Head = createMethodDecorator('head');
-export const Options = createMethodDecorator('options');
+import { ROUTES_META, type RouteInfo } from '../metadata';
+
+type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head' | 'options';
+
+/**
+ * Creates a method decorator for HTTP methods.
+ * Supports both legacy decorators (experimentalDecorators) and TS5 stage 3 decorators.
+ */
+function createMethodDecorator(method: HttpMethod) {
+    return function (path: string = ''): any {
+        return function (
+            targetOrMethod: any,
+            contextOrPropertyKey?: string | symbol | ClassMethodDecoratorContext,
+            descriptor?: PropertyDescriptor
+        ): any {
+            // TS5 Stage 3 decorators: context is ClassMethodDecoratorContext
+            if (contextOrPropertyKey && typeof contextOrPropertyKey === 'object' && 'kind' in contextOrPropertyKey) {
+                const context = contextOrPropertyKey as ClassMethodDecoratorContext;
+
+                context.addInitializer(function (this: any) {
+                    const constructor = this.constructor;
+                    const routes: RouteInfo[] = Reflect.getMetadata(ROUTES_META, constructor) || [];
+
+                    routes.push({
+                        method,
+                        path: path.startsWith('/') ? path : '/' + path,
+                        handlerName: String(context.name)
+                    });
+
+                    Reflect.defineMetadata(ROUTES_META, routes, constructor);
+                });
+
+                return targetOrMethod;
+            }
+
+            // Legacy decorators (experimentalDecorators: true)
+            const constructor = targetOrMethod.constructor;
+            const propertyKey = contextOrPropertyKey as string | symbol;
+            const routes: RouteInfo[] = Reflect.getMetadata(ROUTES_META, constructor) || [];
+
+            routes.push({
+                method,
+                path: path.startsWith('/') ? path : '/' + path,
+                handlerName: String(propertyKey)
+            });
+
+            Reflect.defineMetadata(ROUTES_META, routes, constructor);
+        };
+    };
+}
+
+export const Get = createMethodDecorator('get');
+export const Post = createMethodDecorator('post');
+export const Put = createMethodDecorator('put');
+export const Delete = createMethodDecorator('delete');
+export const Patch = createMethodDecorator('patch');
+export const Head = createMethodDecorator('head');
+export const Options = createMethodDecorator('options');