@hazeljs/core 0.2.0-alpha.1

package/dist/router.js

@@ -0,0 +1,506 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Router = void 0;
+const middleware_1 = require("./middleware");
+const pipe_1 = require("./pipes/pipe");
+const http_error_1 = require("./errors/http.error");
+require("reflect-metadata");
+const logger_1 = __importDefault(require("./logger"));
+const request_parser_1 = require("./request-parser");
+const hazel_response_1 = require("./hazel-response");
+const validation_pipe_1 = require("./pipes/validation.pipe");
+const ROUTE_METADATA_KEY = 'hazel:routes';
+const CONTROLLER_METADATA_KEY = 'hazel:controller';
+const HTTP_CODE_METADATA_KEY = 'hazel:http-code';
+const HEADER_METADATA_KEY = 'hazel:headers';
+const REDIRECT_METADATA_KEY = 'hazel:redirect';
+const TIMEOUT_METADATA_KEY = 'hazel:timeout';
+const OPTIONAL_INDICES_METADATA_KEY = 'hazel:optional-indices';
+class Router {
+    constructor(container) {
+        this.container = container;
+        this.routes = new Map();
+        this.routesByMethod = new Map();
+        this.middlewareHandler = new middleware_1.MiddlewareHandler(container);
+        // Initialize route cache for common HTTP methods
+        this.routesByMethod.set('GET', new Map());
+        this.routesByMethod.set('POST', new Map());
+        this.routesByMethod.set('PUT', new Map());
+        this.routesByMethod.set('DELETE', new Map());
+        this.routesByMethod.set('PATCH', new Map());
+    }
+    registerController(controller) {
+        logger_1.default.debug(`Registering controller: ${controller.name}`);
+        const controllerMetadata = Reflect.getMetadata(CONTROLLER_METADATA_KEY, controller) || {};
+        const routes = Reflect.getMetadata(ROUTE_METADATA_KEY, controller) || [];
+        logger_1.default.debug('Controller metadata:', controllerMetadata);
+        logger_1.default.debug('Found routes:', routes);
+        routes.forEach((route) => {
+            const { method, path, propertyKey } = route;
+            const basePath = controllerMetadata.path || '';
+            const routePath = path || '';
+            const fullPath = this.normalizePath(`${basePath}${routePath}`);
+            logger_1.default.debug(`Registering route: ${method} ${fullPath} (handler: ${String(propertyKey)})`);
+            // Get parameter types from TypeScript metadata
+            const paramTypes = Reflect.getMetadata('design:paramtypes', controller.prototype, propertyKey) || [];
+            logger_1.default.debug('Parameter types:', paramTypes.map((t) => t?.name || 'undefined'));
+            // Get parameter injections
+            const injections = Reflect.getMetadata('hazel:inject', controller, propertyKey) || [];
+            logger_1.default.debug('Parameter injections:', injections);
+            // Create a route handler for this specific route
+            // Pass the controller class, not instance, so it can be resolved per-request
+            const handler = this.createRouteHandler(controller, propertyKey);
+            const methodUpper = method.toUpperCase();
+            const routeKey = `${methodUpper} ${fullPath}`;
+            // Store in both maps for compatibility
+            this.routes.set(routeKey, [handler]);
+            // Store in method-specific cache for faster lookup
+            let methodRoutes = this.routesByMethod.get(methodUpper);
+            if (!methodRoutes) {
+                methodRoutes = new Map();
+                this.routesByMethod.set(methodUpper, methodRoutes);
+            }
+            methodRoutes.set(fullPath, [handler]);
+            // Log the route pattern for debugging
+            const pattern = this.createRoutePattern(fullPath);
+            logger_1.default.debug('Route pattern:', {
+                path: fullPath,
+                pattern: pattern.toString(),
+                pipes: route.pipes?.map((p) => p.type.name) || [],
+                paramTypes: paramTypes.map((t) => t?.name || 'undefined'),
+            });
+        });
+        logger_1.default.debug('All registered routes:');
+        this.routes.forEach((handlers, route) => {
+            logger_1.default.debug(`${route}`);
+        });
+    }
+    async applyPipes(value, pipes, context) {
+        let result = value;
+        // Get route-specific pipes
+        const allPipes = pipes.map((p) => this.container.resolve(p.type));
+        for (const pipe of allPipes) {
+            try {
+                result = await pipe.transform(result, context);
+            }
+            catch (error) {
+                logger_1.default.error('Validation error:', error);
+                // Re-throw the error to be caught by the route handler
+                throw error;
+            }
+        }
+        return result;
+    }
+    async applyInterceptors(interceptors, context, next) {
+        if (interceptors.length === 0) {
+            return next();
+        }
+        const [current, ...remaining] = interceptors;
+        const interceptor = this.container.resolve(current.type);
+        return interceptor.intercept(context, () => this.applyInterceptors(remaining, context, next));
+    }
+    createRouteHandler(controllerClass, methodName) {
+        return async (req, res, matchedContext) => {
+            // Generate a unique request ID for request-scoped providers
+            const requestId = `req-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+            try {
+                logger_1.default.debug('=== Request Handler Start ===');
+                logger_1.default.debug(`Method: ${req.method}, URL: ${req.url}`);
+                logger_1.default.debug('Matched context:', matchedContext);
+                // Optimize: Only serialize for debug logging
+                if (logger_1.default.isDebugEnabled && logger_1.default.isDebugEnabled()) {
+                    const safeBody = JSON.parse(JSON.stringify(req.body || {}));
+                    logger_1.default.debug(`Request body: ${JSON.stringify(safeBody, null, 2)}`);
+                }
+                // Resolve controller instance per-request with requestId
+                const controller = this.container.resolve(controllerClass, requestId);
+                const routes = Reflect.getMetadata(ROUTE_METADATA_KEY, controllerClass) || [];
+                const route = routes.find((r) => r.propertyKey === methodName);
+                if (!route) {
+                    throw new Error(`Route not found for method ${String(methodName)}`);
+                }
+                // Get parameter injections
+                const injections = Reflect.getMetadata('hazel:inject', controllerClass, methodName) || [];
+                // Use the matched context if available, otherwise create a new one
+                const context = matchedContext || {
+                    params: req.params || {},
+                    query: req.query || {},
+                    body: req.body || {},
+                    headers: Object.fromEntries(Object.entries(req.headers || {})
+                        .filter(([key]) => !key.toLowerCase().includes('authorization'))
+                        .map(([key, value]) => [key, String(value)])),
+                    method: req.method || 'GET',
+                    url: req.url || '/',
+                };
+                context.retryOptions = Reflect.getMetadata('hazel:retry', controllerClass.prototype, methodName);
+                // Execute guards (class-level + method-level)
+                const classGuards = Reflect.getMetadata('hazel:guards', controllerClass) || [];
+                const methodGuards = Reflect.getMetadata('hazel:guards', controllerClass.prototype, methodName) || [];
+                const allGuards = [...classGuards, ...methodGuards];
+                if (allGuards.length > 0) {
+                    const executionContext = {
+                        switchToHttp: () => ({
+                            getRequest: () => req,
+                            getResponse: () => res,
+                            getContext: () => context,
+                        }),
+                    };
+                    for (const guardType of allGuards) {
+                        const guard = this.container.resolve(guardType);
+                        const result = await guard.canActivate(executionContext);
+                        if (!result) {
+                            throw new http_error_1.UnauthorizedError('Unauthorized');
+                        }
+                    }
+                    // Propagate user set by guard to context
+                    if (req.user) {
+                        context.user = req.user;
+                    }
+                }
+                // Set DTO type from the first parameter that has a DTO type
+                for (const injection of injections) {
+                    if (injection?.dtoType) {
+                        context.dtoType = injection.dtoType;
+                        break;
+                    }
+                }
+                // Get pipes for this route
+                const routePipes = route.pipes || [];
+                // Prepare arguments for the controller method
+                const args = [];
+                for (let i = 0; i < injections.length; i++) {
+                    const injection = injections[i];
+                    if (typeof injection === 'string') {
+                        // Handle @Body, @Param, @Query decorators
+                        if (injection === 'body') {
+                            args[i] = context.body;
+                        }
+                        else if (injection === 'param') {
+                            args[i] = context.params;
+                        }
+                        else if (injection === 'query') {
+                            args[i] = context.query;
+                        }
+                        else if (injection === 'headers') {
+                            args[i] = context.headers;
+                        }
+                    }
+                    else if (typeof injection === 'object' && injection !== null) {
+                        if (injection.type === 'headers') {
+                            // Handle @Headers decorator
+                            const headerName = injection.name;
+                            if (headerName) {
+                                args[i] = context.headers[headerName.toLowerCase()];
+                            }
+                            else {
+                                args[i] = context.headers;
+                            }
+                        }
+                        else if (injection.type === 'request') {
+                            // Handle @Req() / @Request() decorator - raw request for multipart, etc.
+                            args[i] = req;
+                        }
+                        else if (injection.type === 'response') {
+                            // Handle @Res decorator
+                            args[i] = new hazel_response_1.HazelExpressResponse(res);
+                        }
+                        else if (injection.type === 'body') {
+                            // Handle @Body decorator with DTO type
+                            if (injection.dtoType) {
+                                context.dtoType = injection.dtoType;
+                                logger_1.default.debug('Setting DTO type in context:', injection.dtoType.name);
+                            }
+                            args[i] = context.body;
+                        }
+                        else if (injection.type === 'param') {
+                            // Handle @Param decorator with pipe
+                            const paramName = injection.name;
+                            const paramValue = matchedContext?.params[paramName] || context.params[paramName];
+                            if (injection.pipe) {
+                                const pipe = this.container.resolve(injection.pipe);
+                                args[i] = await pipe.transform(paramValue, context);
+                            }
+                            else {
+                                args[i] = paramValue;
+                            }
+                        }
+                        else if (injection.type === 'query') {
+                            // Handle @Query decorator with pipe
+                            const paramName = injection.name;
+                            const queryValue = paramName ? context.query[paramName] : context.query;
+                            if (injection.pipe) {
+                                const pipe = this.container.resolve(injection.pipe);
+                                args[i] = await pipe.transform(queryValue, context);
+                            }
+                            else {
+                                args[i] = queryValue;
+                            }
+                        }
+                        else if (injection.type === 'user') {
+                            // Handle @CurrentUser() decorator — reads from context.user (set by a guard)
+                            const user = context.user ?? req.user;
+                            args[i] = injection.field ? user?.[injection.field] : user;
+                        }
+                        else if (injection.type === 'ip') {
+                            const r = req;
+                            const forwarded = r.headers?.['x-forwarded-for'];
+                            const ip = typeof forwarded === 'string'
+                                ? forwarded.split(',')[0].trim()
+                                : Array.isArray(forwarded)
+                                    ? forwarded[0]?.trim()
+                                    : r.socket?.remoteAddress;
+                            args[i] = ip ?? undefined;
+                        }
+                        else if (injection.type === 'host') {
+                            const host = req.headers?.['host'];
+                            args[i] = typeof host === 'string' ? host : Array.isArray(host) ? host[0] : undefined;
+                        }
+                        else if (injection.type === 'session') {
+                            args[i] = req.session;
+                        }
+                        else if (injection.type === 'custom' && typeof injection.resolve === 'function') {
+                            // Handle custom parameter decorators (e.g. @Ability() from @hazeljs/casl).
+                            // The decorator stores a resolver function; call it with request, context, container.
+                            args[i] = await injection.resolve(req, context, this.container);
+                        }
+                    }
+                }
+                const optionalIndices = Reflect.getMetadata(OPTIONAL_INDICES_METADATA_KEY, controllerClass, methodName) || [];
+                for (const i of optionalIndices) {
+                    if (i < args.length && (args[i] === undefined || args[i] === null)) {
+                        args[i] = undefined;
+                    }
+                }
+                // Auto-inject RequestContext for undecorated parameters
+                const paramTypes = Reflect.getMetadata('design:paramtypes', controllerClass.prototype, methodName) || [];
+                for (let i = 0; i < paramTypes.length; i++) {
+                    if (args[i] === undefined && !injections[i]) {
+                        args[i] = context;
+                    }
+                }
+                // Apply ValidationPipe to the body if a DTO type is present
+                if (context.body && context.dtoType) {
+                    logger_1.default.debug('Applying ValidationPipe with DTO type:', context.dtoType.name);
+                    const validationPipe = this.container.resolve(validation_pipe_1.ValidationPipe);
+                    context.body = await validationPipe.transform(context.body, context);
+                    args[injections.findIndex((i) => typeof i === 'object' && i !== null && i.type === 'body')] = context.body;
+                }
+                // Apply other pipes to the body if it exists
+                if (context.body) {
+                    context.body = await this.applyPipes(context.body, routePipes, context);
+                }
+                // Get the controller method
+                const method = controller[methodName];
+                const timeoutMs = Reflect.getMetadata(TIMEOUT_METADATA_KEY, controllerClass.prototype, methodName);
+                let handlerPromise = this.applyInterceptors(Reflect.getMetadata('hazel:interceptors', controllerClass, methodName) || [], context, async () => {
+                    return method.apply(controller, args);
+                });
+                if (timeoutMs != null && timeoutMs > 0) {
+                    handlerPromise = Promise.race([
+                        handlerPromise,
+                        new Promise((_, reject) => {
+                            setTimeout(() => reject(new http_error_1.RequestTimeoutError(`Request timed out after ${timeoutMs}ms`)), timeoutMs);
+                        }),
+                    ]);
+                }
+                const result = await handlerPromise;
+                // Apply @Redirect metadata
+                const redirectMeta = Reflect.getMetadata(REDIRECT_METADATA_KEY, controllerClass.prototype, methodName);
+                if (redirectMeta) {
+                    res.status(redirectMeta.statusCode).setHeader('Location', redirectMeta.url);
+                    res.end();
+                    return;
+                }
+                // Apply @Header metadata (response headers)
+                const headersMeta = Reflect.getMetadata(HEADER_METADATA_KEY, controllerClass.prototype, methodName);
+                if (headersMeta) {
+                    for (const h of headersMeta) {
+                        res.setHeader(h.name, h.value);
+                    }
+                }
+                // Apply @HttpCode metadata
+                const httpCode = Reflect.getMetadata(HTTP_CODE_METADATA_KEY, controllerClass.prototype, methodName);
+                // Handle the response
+                if (result !== undefined) {
+                    if (httpCode) {
+                        res.status(httpCode);
+                    }
+                    if (typeof result === 'string' && result.trim().startsWith('<!DOCTYPE html>')) {
+                        // Handle HTML response
+                        res.setHeader('Content-Type', 'text/html');
+                        res.send(result);
+                    }
+                    else {
+                        // Handle JSON response
+                        res.json(result);
+                    }
+                }
+                else if (httpCode) {
+                    res.status(httpCode).end();
+                }
+            }
+            catch (error) {
+                logger_1.default.error('Request handler error:', error);
+                if (error instanceof pipe_1.ValidationError) {
+                    const errorResponse = error.toJSON();
+                    logger_1.default.error('Validation error response:', errorResponse);
+                    res.status(400).json({
+                        statusCode: 400,
+                        message: errorResponse.message,
+                        errors: errorResponse.errors,
+                    });
+                }
+                else if (error instanceof http_error_1.HttpError) {
+                    res.status(error.statusCode).json({
+                        statusCode: error.statusCode,
+                        message: error.message,
+                    });
+                }
+                else {
+                    // Log unhandled errors with full context
+                    logger_1.default.error('Unhandled error:', {
+                        error: error instanceof Error ? error.message : String(error),
+                        stack: error instanceof Error ? error.stack : undefined,
+                        requestId,
+                        method: req.method,
+                        url: req.url,
+                    });
+                    res.status(500).json({
+                        statusCode: 500,
+                        message: process.env.NODE_ENV === 'production'
+                            ? 'Internal server error'
+                            : error instanceof Error ? error.message : 'Unknown error',
+                    });
+                }
+            }
+            finally {
+                // CRITICAL: Clean up request-scoped providers to prevent memory leaks
+                this.container.clearRequestScope(requestId);
+            }
+        };
+    }
+    extractParams(path, routePath) {
+        const params = {};
+        const pathParts = path.split('/');
+        const routeParts = routePath.split('/');
+        for (let i = 0; i < routeParts.length; i++) {
+            if (routeParts[i].startsWith(':')) {
+                const paramName = routeParts[i].slice(1);
+                params[paramName] = pathParts[i];
+                logger_1.default.debug(`Extracted param ${paramName}:`, pathParts[i]);
+            }
+        }
+        logger_1.default.debug('Extracted params:', params);
+        return params;
+    }
+    matchPath(path, routePath) {
+        const pathParts = path.split('/');
+        const routeParts = routePath.split('/');
+        if (pathParts.length !== routeParts.length) {
+            return false;
+        }
+        for (let i = 0; i < routeParts.length; i++) {
+            if (!routeParts[i].startsWith(':') && routeParts[i] !== pathParts[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    createRoutePattern(path) {
+        if (path === '/') {
+            return /^\/?$/;
+        }
+        // Escape forward slashes and convert :param to ([^/]+)
+        const pattern = path
+            .replace(/[.*+?^${}()|[\]\\]/g, '\\$&') // Escape special regex characters
+            .replace(/:[^/]+/g, '([^/]+)');
+        return new RegExp(`^${pattern}/?$`);
+    }
+    normalizePath(path) {
+        if (path.length > 1 && path.endsWith('/')) {
+            path = path.slice(0, -1);
+        }
+        return path.startsWith('/') ? path : `/${path}`;
+    }
+    async match(method, url, context) {
+        const path = this.normalizePath(url.split('?')[0] || '/');
+        logger_1.default.debug(`Matching route: ${method} ${path}`);
+        // Use method-specific cache for O(1) method lookup instead of O(n)
+        const methodRoutes = this.routesByMethod.get(method);
+        if (!methodRoutes) {
+            logger_1.default.debug(`No routes registered for method: ${method}`);
+            return null;
+        }
+        // Now only iterate through routes for this specific HTTP method
+        for (const [routePath, handlers] of methodRoutes.entries()) {
+            if (this.matchPath(path, routePath)) {
+                const params = this.extractParams(path, routePath);
+                logger_1.default.debug('Matched route:', { method, url, params });
+                // Create a new context with the matched parameters
+                const matchedContext = {
+                    ...context,
+                    params: params, // Don't merge, just use the extracted params
+                };
+                logger_1.default.debug('Created matched context:', matchedContext);
+                // Create a new handler that ensures the context is passed
+                const handler = handlers[0];
+                const wrappedHandler = async (req, res, ctx) => {
+                    logger_1.default.debug('Wrapped handler called with context:', ctx);
+                    await handler(req, res, matchedContext);
+                };
+                return { handler: wrappedHandler, context: matchedContext };
+            }
+        }
+        return null;
+    }
+    get(path, handlers) {
+        this.addRoute('GET', path, handlers);
+    }
+    post(path, handlers) {
+        this.addRoute('POST', path, handlers);
+    }
+    put(path, handlers) {
+        this.addRoute('PUT', path, handlers);
+    }
+    delete(path, handlers) {
+        this.addRoute('DELETE', path, handlers);
+    }
+    addRoute(method, path, handlers) {
+        const normalizedPath = this.normalizePath(path);
+        this.routes.set(`${method.toUpperCase()} ${normalizedPath}`, handlers);
+    }
+    async handleRequest(req, res) {
+        try {
+            logger_1.default.debug('=== Request Handler Start ===');
+            logger_1.default.debug(`Method: ${req.method}, URL: ${req.url}`);
+            // Parse the request to get the initial context
+            const context = await request_parser_1.RequestParser.parseRequest(req);
+            logger_1.default.debug('Initial context:', context);
+            // Match the request method and URL
+            const match = await this.match(req.method || 'GET', req.url || '/', context);
+            if (!match) {
+                logger_1.default.debug(`No route found for ${req.method} ${req.url}`);
+                res.status(404).json({ error: 'Not Found' });
+                return;
+            }
+            // Log the matched context before passing it
+            logger_1.default.debug('Matched context before handler:', match.context);
+            // Update request params with matched parameters
+            req.params = match.context.params;
+            logger_1.default.debug('Updated request params:', req.params);
+            // Call the matched handler with the matched context
+            const handler = match.handler;
+            await handler(req, res, match.context);
+        }
+        catch (error) {
+            logger_1.default.error('Error handling request:', error);
+            res
+                .status(500)
+                .json({ error: error instanceof Error ? error.message : 'Internal Server Error' });
+        }
+    }
+}
+exports.Router = Router;

package/dist/routing/route-matcher.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Route pattern matcher with support for:
+ * - Named parameters (:id)
+ * - Optional parameters (:id?)
+ * - Wildcard routes (*)
+ * - Regex patterns
+ */
+export declare class RouteMatcher {
+    private readonly path;
+    private pattern;
+    private paramNames;
+    private isWildcard;
+    constructor(path: string);
+    /**
+     * Compile the route path into a regex pattern
+     */
+    private compile;
+    /**
+     * Match a URL path against this route
+     */
+    match(path: string): RouteMatch | null;
+    /**
+     * Get the route path
+     */
+    getPath(): string;
+    /**
+     * Check if route has parameters
+     */
+    hasParams(): boolean;
+    /**
+     * Get parameter names
+     */
+    getParamNames(): string[];
+}
+export interface RouteMatch {
+    params: Record<string, string>;
+    path: string;
+}
+//# sourceMappingURL=route-matcher.d.ts.map

package/dist/routing/route-matcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-matcher.d.ts","sourceRoot":"","sources":["../../src/routing/route-matcher.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,qBAAa,YAAY;IAKX,OAAO,CAAC,QAAQ,CAAC,IAAI;IAJjC,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,UAAU,CAAgB;IAClC,OAAO,CAAC,UAAU,CAAS;gBAEE,IAAI,EAAE,MAAM;IAIzC;;OAEG;IACH,OAAO,CAAC,OAAO;IAgCf;;OAEG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IA4BtC;;OAEG;IACH,OAAO,IAAI,MAAM;IAIjB;;OAEG;IACH,SAAS,IAAI,OAAO;IAIpB;;OAEG;IACH,aAAa,IAAI,MAAM,EAAE;CAG1B;AAED,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,IAAI,EAAE,MAAM,CAAC;CACd"}

package/dist/routing/route-matcher.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteMatcher = void 0;
+const logger_1 = __importDefault(require("../logger"));
+/**
+ * Route pattern matcher with support for:
+ * - Named parameters (:id)
+ * - Optional parameters (:id?)
+ * - Wildcard routes (*)
+ * - Regex patterns
+ */
+class RouteMatcher {
+    constructor(path) {
+        this.path = path;
+        this.paramNames = [];
+        this.isWildcard = false;
+        this.compile();
+    }
+    /**
+     * Compile the route path into a regex pattern
+     */
+    compile() {
+        // Check for wildcard
+        if (this.path.includes('*')) {
+            this.isWildcard = true;
+        }
+        let pattern = this.path;
+        // Escape special regex characters except : and *
+        pattern = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+        // Handle optional parameters (:id?)
+        pattern = pattern.replace(/:(\w+)\?/g, (_, paramName) => {
+            this.paramNames.push(paramName);
+            return '(?:/([^/]+))?';
+        });
+        // Handle required parameters (:id)
+        pattern = pattern.replace(/:(\w+)/g, (_, paramName) => {
+            this.paramNames.push(paramName);
+            return '([^/]+)';
+        });
+        // Handle wildcards (*)
+        pattern = pattern.replace(/\*/g, '(.*)');
+        // Ensure exact match with optional trailing slash
+        this.pattern = new RegExp(`^${pattern}/?$`);
+        logger_1.default.debug(`Compiled route pattern: ${this.path} -> ${this.pattern}`);
+    }
+    /**
+     * Match a URL path against this route
+     */
+    match(path) {
+        const match = this.pattern.exec(path);
+        if (!match) {
+            return null;
+        }
+        const params = {};
+        // Extract parameters
+        for (let i = 0; i < this.paramNames.length; i++) {
+            const value = match[i + 1];
+            if (value !== undefined) {
+                params[this.paramNames[i]] = decodeURIComponent(value);
+            }
+        }
+        // Handle wildcard
+        if (this.isWildcard && match[match.length - 1]) {
+            params['*'] = match[match.length - 1];
+        }
+        return {
+            params,
+            path: this.path,
+        };
+    }
+    /**
+     * Get the route path
+     */
+    getPath() {
+        return this.path;
+    }
+    /**
+     * Check if route has parameters
+     */
+    hasParams() {
+        return this.paramNames.length > 0;
+    }
+    /**
+     * Get parameter names
+     */
+    getParamNames() {
+        return [...this.paramNames];
+    }
+}
+exports.RouteMatcher = RouteMatcher;

package/dist/routing/version.decorator.d.ts

@@ -0,0 +1,36 @@
+import 'reflect-metadata';
+/**
+ * Version types
+ */
+export declare enum VersioningType {
+    URI = "uri",
+    HEADER = "header",
+    MEDIA_TYPE = "media-type",
+    CUSTOM = "custom"
+}
+/**
+ * Versioning options
+ */
+export interface VersioningOptions {
+    type: VersioningType;
+    header?: string;
+    key?: string;
+    extractor?: (request: unknown) => string | undefined;
+}
+/**
+ * Version decorator for controllers and routes
+ */
+export declare function Version(version: string | string[]): MethodDecorator & ClassDecorator;
+/**
+ * Get version metadata from a class or method
+ */
+export declare function getVersionMetadata(target: object | (new (...args: unknown[]) => object), propertyKey?: string | symbol): string[] | undefined;
+/**
+ * Check if a version matches the requested version
+ */
+export declare function matchVersion(routeVersions: string[] | undefined, requestedVersion: string | undefined, _options?: VersioningOptions): boolean;
+/**
+ * Extract version from request based on versioning type
+ */
+export declare function extractVersion(request: unknown, options: VersioningOptions): string | undefined;
+//# sourceMappingURL=version.decorator.d.ts.map