stratal 0.0.13 → 0.0.15

package/dist/router/services/route-registration.service.js

@@ -1,700 +0,0 @@
-import { getMethodInjections } from '../../di';
-import { getControllerGuards, getMethodGuards, GuardExecutionService, } from '../../guards';
-import { createRoute } from '../../i18n/validation';
-import { getWsOnCloseMethod, getWsOnErrorMethod, getWsOnMessageMethod, isGateway } from '../../websocket/decorators';
-import { GatewayContext } from '../../websocket/gateway-context';
-import { DEFAULT_CONTENT_TYPE, HTTP_METHODS, METHOD_STATUS_CODES, SECURITY_SCHEMES, VERSION_NEUTRAL } from '../constants';
-import { getControllerOptions, getControllerRoute, getDecoratedMethods, getHttpDecoratedMethods, getHttpRouteMetadata, getRouteConfig, } from '../decorators';
-import { ControllerMethodNotFoundError, ControllerRegistrationError, OpenAPIRouteRegistrationError, } from '../errors';
-import { RouterContext } from '../router-context';
-import { commonErrorSchemas } from '../schemas/common.schemas';
-const invokeHandler = (instance, method, ...args) => {
-    try {
-        return Promise.resolve(instance[method](...args));
-    }
-    catch (err) {
-        return Promise.reject(err);
-    }
-};
-/**
- * Route registration service
- * Manages controller and route registration with OpenAPI support
- *
- * Responsibilities:
- * - Register RESTful controllers with OpenAPI metadata
- * - Auto-derive HTTP methods/paths from controller method names
- * - Build OpenAPI route configurations with guard execution
- * - Validate all controllers have access decorators (strict mode)
- * - Create controller handlers with DI resolution
- */
-export class RouteRegistrationService {
-    logger;
-    versioningOptions;
-    controllerClasses = new Map();
-    constructor(logger, versioningOptions = null) {
-        this.logger = logger;
-        this.versioningOptions = versioningOptions;
-    }
-    /**
-     * Configure router with controllers
-     *
-     * @param app - OpenAPIHono application instance
-     * @param controllers - Array of controller classes from modules
-     */
-    async configure(app, controllers) {
-        this.logger.info('Registering controllers', {
-            controllerCount: controllers.length,
-        });
-        // Sort controllers: specific routes first, wildcard handlers last
-        // This ensures more specific routes are matched before catch-all wildcards
-        // (e.g., /api/v1/auth/magic-link matches before /api/v1/auth/:path{.+})
-        const sortedControllers = [...controllers].sort((a, b) => {
-            const aHasHandle = 'handle' in a.prototype;
-            const bHasHandle = 'handle' in b.prototype;
-            if (aHasHandle && !bHasHandle)
-                return 1; // a goes after b
-            if (!aHasHandle && bHasHandle)
-                return -1; // a goes before b
-            return 0; // maintain relative order
-        });
-        // Single-pass partition: gateways vs regular controllers
-        const gateways = [];
-        const regulars = [];
-        for (const c of sortedControllers) {
-            if (isGateway(c)) {
-                gateways.push(c);
-            }
-            else {
-                regulars.push(c);
-            }
-        }
-        // Register WebSocket gateways
-        for (const GatewayClass of gateways) {
-            await this.registerGateway(app, GatewayClass);
-        }
-        // Register controllers
-        for (const ControllerClass of regulars) {
-            this.registerController(app, ControllerClass);
-        }
-        this.logger.info('Controller registration complete');
-    }
-    /**
-     * Register a WebSocket gateway
-     * Applies versioning and guards, then registers an upgradeWebSocket handler
-     */
-    async registerGateway(app, GatewayClass) {
-        const route = getControllerRoute(GatewayClass);
-        if (!route) {
-            throw new ControllerRegistrationError(GatewayClass.name, 'Missing @Gateway decorator or route metadata');
-        }
-        const controllerOpts = getControllerOptions(GatewayClass);
-        const paths = this.versioningOptions
-            ? this.resolveVersionedPaths(route, controllerOpts)
-            : [route];
-        for (const fullPath of paths) {
-            await this.registerGatewayRoute(app, GatewayClass, fullPath);
-        }
-    }
-    /**
-     * Register a single WebSocket gateway route
-     */
-    async registerGatewayRoute(app, GatewayClass, fullPath) {
-        // Collect class-level guards
-        const controllerGuards = getControllerGuards(GatewayClass)?.guards ?? [];
-        // Dynamic import: only load hono/cloudflare-workers when gateways exist
-        const { upgradeWebSocket } = await import('hono/cloudflare-workers');
-        // Cache WS metadata once at registration time (not per-connection)
-        const onMsgMethod = getWsOnMessageMethod(GatewayClass);
-        const onCloseMethod = getWsOnCloseMethod(GatewayClass);
-        const onErrMethod = getWsOnErrorMethod(GatewayClass);
-        const wsHandler = upgradeWebSocket((c) => {
-            const routerCtx = new RouterContext(c);
-            const container = routerCtx.getContainer();
-            const gateway = container.resolve(GatewayClass);
-            // Cloudflare Workers doesn't support the `onOpen` WebSocket event;
-            // the upgrade callback itself serves as the open context.
-            const events = {};
-            const bindWsHandler = (method, onCatch) => {
-                return (evt, ws) => {
-                    const ctx = new GatewayContext(c, ws);
-                    c.executionCtx.waitUntil(invokeHandler(gateway, method, evt, ctx).catch((err) => {
-                        this.logger.error(`WebSocket ${method} handler error`, { gateway: GatewayClass.name, error: err instanceof Error ? err.message : String(err) });
-                        onCatch?.(err, ws);
-                    }));
-                };
-            };
-            if (onMsgMethod) {
-                events.onMessage = bindWsHandler(onMsgMethod, (_err, ws) => ws.close(1011, 'Internal Error'));
-            }
-            if (onCloseMethod) {
-                events.onClose = bindWsHandler(onCloseMethod);
-            }
-            if (onErrMethod) {
-                events.onError = bindWsHandler(onErrMethod);
-            }
-            return events;
-        });
-        this.logger.info('Registering WebSocket gateway', {
-            gateway: GatewayClass.name,
-            path: fullPath,
-        });
-        const handlers = [];
-        if (controllerGuards.length > 0) {
-            this.logger.info('Gateway guards', {
-                gateway: GatewayClass.name,
-                path: fullPath,
-                guardCount: controllerGuards.length,
-            });
-            handlers.push(this.createGuardMiddleware(controllerGuards));
-        }
-        handlers.push(wsHandler);
-        // Type assertion needed because Hono's overloaded .get() signatures
-        // don't accept a spread of MiddlewareHandler[] alongside upgradeWebSocket's output type
-        app.get(fullPath, ...handlers);
-    }
-    /**
-     * Register a single controller with all its routes
-     * Validates that controller has access decorator (strict mode)
-     */
-    registerController(app, ControllerClass) {
-        const route = getControllerRoute(ControllerClass);
-        if (!route) {
-            throw new ControllerRegistrationError(ControllerClass.name, 'Missing @Controller decorator or route metadata');
-        }
-        const className = ControllerClass.name;
-        this.controllerClasses.set(className, ControllerClass);
-        const prototype = ControllerClass.prototype;
-        const controllerOpts = getControllerOptions(ControllerClass);
-        // Handle wildcard routes (non-RESTful controllers) — check once, not per version
-        if (prototype.handle) {
-            if (!this.versioningOptions) {
-                this.registerWildcardRoute(app, ControllerClass, route);
-            }
-            else {
-                for (const versionedRoute of this.resolveVersionedPaths(route, controllerOpts)) {
-                    this.registerWildcardRoute(app, ControllerClass, versionedRoute);
-                }
-            }
-            return;
-        }
-        // Compute decorated methods once (loop-invariant)
-        const decoratedMethods = getDecoratedMethods(ControllerClass);
-        const httpDecoratedMethods = getHttpDecoratedMethods(ControllerClass);
-        // Enforce mutual exclusivity once
-        if (decoratedMethods.length > 0 && httpDecoratedMethods.length > 0) {
-            throw new ControllerRegistrationError(ControllerClass.name, 'Cannot mix @Route() with HTTP method decorators (@Get, @Post, etc.) in the same controller. Use one pattern or the other.');
-        }
-        // Fast path: no versioning — inline dispatch, no array allocation, no loop
-        if (!this.versioningOptions) {
-            this.dispatchRoutes(app, ControllerClass, route, decoratedMethods, httpDecoratedMethods, controllerOpts, prototype);
-            return;
-        }
-        // Versioning path: resolve versioned paths and register each
-        for (const versionedRoute of this.resolveVersionedPaths(route, controllerOpts)) {
-            this.dispatchRoutes(app, ControllerClass, versionedRoute, decoratedMethods, httpDecoratedMethods, controllerOpts, prototype);
-        }
-    }
-    /**
-     * Dispatch route registration based on decorator type
-     */
-    dispatchRoutes(app, ControllerClass, path, decoratedMethods, httpDecoratedMethods, controllerOpts, prototype) {
-        if (httpDecoratedMethods.length > 0) {
-            this.registerHttpRoutes(app, ControllerClass, path, httpDecoratedMethods, controllerOpts);
-        }
-        else if (decoratedMethods.length > 0) {
-            this.registerOpenAPIRoutes(app, ControllerClass, path, decoratedMethods, controllerOpts);
-        }
-        else {
-            this.registerRESTfulRoutes(app, ControllerClass, path, prototype);
-        }
-    }
-    /**
-     * Resolve versioned paths for a controller based on versioning configuration.
-     *
-     * @param basePath - The base path from @Controller decorator
-     * @param controllerOpts - Controller options (may contain version)
-     * @returns Array of resolved paths (with version prefix if applicable)
-     */
-    resolveVersionedPaths(basePath, controllerOpts) {
-        // Versioning disabled — always return base path
-        if (!this.versioningOptions) {
-            return [basePath];
-        }
-        const version = controllerOpts?.version;
-        // VERSION_NEUTRAL — explicitly opt out of versioning
-        if (version === VERSION_NEUTRAL) {
-            return [basePath];
-        }
-        const prefix = this.versioningOptions.prefix ?? 'v';
-        // Explicit version(s) on the controller
-        if (version !== undefined) {
-            const versions = Array.isArray(version) ? version : [version];
-            return versions.map(v => `/${prefix}${v}${basePath}`);
-        }
-        // No explicit version — apply defaultVersion if set
-        if (this.versioningOptions.defaultVersion !== undefined) {
-            const defaults = Array.isArray(this.versioningOptions.defaultVersion)
-                ? this.versioningOptions.defaultVersion
-                : [this.versioningOptions.defaultVersion];
-            return defaults.map(v => `/${prefix}${v}${basePath}`);
-        }
-        // Versioning enabled but no version and no default — no prefix
-        return [basePath];
-    }
-    /**
-     * Create a guard execution middleware
-     *
-     * This middleware executes all guards for a route before the handler.
-     * Guards are executed in order; all must pass for the request to proceed.
-     *
-     * @param guards - Array of guards to execute
-     * @returns Hono middleware function
-     */
-    createGuardMiddleware(guards) {
-        const guardService = new GuardExecutionService(this.logger);
-        return async (c, next) => {
-            const ctx = new RouterContext(c);
-            const container = ctx.getContainer();
-            // Execute all guards - throws on failure
-            await guardService.executeGuards(guards, ctx, container);
-            // All guards passed, continue to handler
-            await next();
-        };
-    }
-    /**
-     * Register wildcard route for non-RESTful controllers
-     */
-    registerWildcardRoute(app, ControllerClass, route) {
-        this.logger.info(`Registering wildcard route`, {
-            controller: ControllerClass.name,
-            route: `${route}/:path{.+}`,
-            method: 'ALL',
-        });
-        const handler = this.createControllerHandler(ControllerClass, 'handle');
-        // Match base route exactly
-        app.all(route, handler);
-        // Match all sub-paths using named regex wildcard
-        app.all(`${route}/:path{.+}`, handler);
-    }
-    /**
-     * Register OpenAPI routes with metadata
-     */
-    registerOpenAPIRoutes(app, ControllerClass, route, decoratedMethods, controllerOpts) {
-        const className = ControllerClass.name;
-        const prototype = ControllerClass.prototype;
-        // Check if entire controller is hidden from docs
-        const controllerHidden = controllerOpts?.hideFromDocs ?? false;
-        // Collect controller-level guards
-        const controllerGuards = getControllerGuards(ControllerClass)?.guards ?? [];
-        for (const methodName of decoratedMethods) {
-            const routeConfig = getRouteConfig(prototype, methodName);
-            if (!routeConfig)
-                continue;
-            const derived = this.deriveHttpMethodAndPath(methodName, route);
-            if (!derived) {
-                this.logger.warn(`Cannot derive HTTP method/path for ${className}.${methodName}`);
-                continue;
-            }
-            // Check if route is hidden (route-level overrides controller-level)
-            const hideFromDocs = routeConfig.hideFromDocs ?? controllerHidden;
-            if (hideFromDocs) {
-                // Register route handler without OpenAPI metadata
-                this.logger.info(`Registering hidden route (no OpenAPI)`, {
-                    controller: className,
-                    method: derived.method.toUpperCase(),
-                    path: derived.path,
-                    methodName,
-                });
-                this.registerRouteWithoutOpenAPI(app, ControllerClass, methodName, derived);
-                continue;
-            }
-            // Collect method-level guards
-            const methodGuards = getMethodGuards(prototype, methodName)?.guards ?? [];
-            // Combine controller and method guards
-            // Controller guards run first, then method guards
-            const allGuards = [...controllerGuards, ...methodGuards];
-            if (allGuards.length > 0) {
-                this.logger.info(`Route guards`, {
-                    controller: className,
-                    method: derived.method.toUpperCase(),
-                    path: derived.path,
-                    methodName,
-                    guardCount: allGuards.length,
-                });
-            }
-            // Build and register OpenAPI route
-            const metadata = this.mergeMetadata(controllerOpts, routeConfig, ControllerClass, methodName);
-            const openApiRoute = this.buildOpenAPIRoute(derived.method, derived.path, routeConfig, metadata, allGuards, methodName);
-            this.logger.info(`Registering OpenAPI route`, {
-                controller: className,
-                method: derived.method.toUpperCase(),
-                path: derived.path,
-                methodName,
-                tags: metadata.tags,
-            });
-            // Register OpenAPI route with handler
-            app.openapi(openApiRoute, async (c) => {
-                const ctx = new RouterContext(c);
-                const requestContainer = ctx.getContainer();
-                const controller = requestContainer.resolve(ControllerClass);
-                const method = controller[methodName];
-                if (typeof method === 'function') {
-                    const injectedArgs = this.resolveMethodInjections(prototype, methodName, requestContainer);
-                    return await method.call(controller, ctx, ...injectedArgs);
-                }
-                throw new ControllerMethodNotFoundError(methodName, className);
-            });
-        }
-    }
-    /**
-     * Register routes using HTTP method decorators (@Get, @Post, etc.)
-     * These use explicit method + path instead of convention-based derivation
-     */
-    registerHttpRoutes(app, ControllerClass, basePath, httpDecoratedMethods, controllerOpts) {
-        const className = ControllerClass.name;
-        const prototype = ControllerClass.prototype;
-        const controllerHidden = controllerOpts?.hideFromDocs ?? false;
-        const controllerGuards = getControllerGuards(ControllerClass)?.guards ?? [];
-        for (const methodName of httpDecoratedMethods) {
-            const httpMeta = getHttpRouteMetadata(prototype, methodName);
-            if (!httpMeta)
-                continue;
-            const fullPath = this.joinPaths(basePath, httpMeta.path);
-            const routeConfig = httpMeta.config;
-            const hideFromDocs = routeConfig.hideFromDocs ?? controllerHidden;
-            // @All routes or hidden routes are registered without OpenAPI
-            if (httpMeta.method === 'all' || hideFromDocs) {
-                this.logger.info(`Registering route (no OpenAPI)`, {
-                    controller: className,
-                    method: httpMeta.method.toUpperCase(),
-                    path: fullPath,
-                    methodName,
-                });
-                this.registerRouteWithoutOpenAPI(app, ControllerClass, methodName, {
-                    method: httpMeta.method,
-                    path: fullPath,
-                });
-                continue;
-            }
-            // Collect method-level guards
-            const methodGuards = getMethodGuards(prototype, methodName)?.guards ?? [];
-            const allGuards = [...controllerGuards, ...methodGuards];
-            if (allGuards.length > 0) {
-                this.logger.info(`Route guards`, {
-                    controller: className,
-                    method: httpMeta.method.toUpperCase(),
-                    path: fullPath,
-                    methodName,
-                    guardCount: allGuards.length,
-                });
-            }
-            // Build and register OpenAPI route
-            const metadata = this.mergeMetadata(controllerOpts, routeConfig, ControllerClass, methodName);
-            const statusCode = routeConfig.statusCode ?? 200;
-            const openApiRoute = this.buildOpenAPIRoute(httpMeta.method, fullPath, routeConfig, metadata, allGuards, undefined, statusCode);
-            this.logger.info(`Registering OpenAPI route`, {
-                controller: className,
-                method: httpMeta.method.toUpperCase(),
-                path: fullPath,
-                methodName,
-                tags: metadata.tags,
-            });
-            app.openapi(openApiRoute, async (c) => {
-                const ctx = new RouterContext(c);
-                const requestContainer = ctx.getContainer();
-                const controller = requestContainer.resolve(ControllerClass);
-                const method = controller[methodName];
-                if (typeof method === 'function') {
-                    const injectedArgs = this.resolveMethodInjections(prototype, methodName, requestContainer);
-                    return await method.call(controller, ctx, ...injectedArgs);
-                }
-                throw new ControllerMethodNotFoundError(methodName, className);
-            });
-        }
-    }
-    /**
-     * Join a base path and a route path, normalizing slashes
-     */
-    joinPaths(basePath, routePath) {
-        if (routePath === '/')
-            return basePath;
-        return basePath + routePath;
-    }
-    /**
-     * Register route without OpenAPI metadata (for hidden routes)
-     * Route is functional but won't appear in documentation
-     */
-    registerRouteWithoutOpenAPI(app, ControllerClass, methodName, derived) {
-        // Create handler function
-        const prototype = ControllerClass.prototype;
-        const handler = async (c) => {
-            const ctx = new RouterContext(c);
-            const requestContainer = ctx.getContainer();
-            const controller = requestContainer.resolve(ControllerClass);
-            const method = controller[methodName];
-            if (typeof method === 'function') {
-                const injectedArgs = this.resolveMethodInjections(prototype, methodName, requestContainer);
-                return await method.call(controller, ctx, ...injectedArgs);
-            }
-            throw new ControllerMethodNotFoundError(methodName, ControllerClass.name);
-        };
-        // Register route handler without OpenAPI metadata using type-safe method dispatch
-        // Note: Only common HTTP methods (get, post, put, patch, delete) are supported
-        // For other methods, we fall back to all() which accepts any HTTP method
-        switch (derived.method) {
-            case 'get':
-                app.get(derived.path, handler);
-                break;
-            case 'post':
-                app.post(derived.path, handler);
-                break;
-            case 'put':
-                app.put(derived.path, handler);
-                break;
-            case 'patch':
-                app.patch(derived.path, handler);
-                break;
-            case 'delete':
-                app.delete(derived.path, handler);
-                break;
-            case 'all':
-                app.all(derived.path, handler);
-                break;
-            default:
-                // For head, options, trace, or any other method, use all()
-                app.all(derived.path, handler);
-                break;
-        }
-    }
-    /**
-     * Register traditional RESTful routes without OpenAPI
-     */
-    registerRESTfulRoutes(app, ControllerClass, route, prototype) {
-        if (prototype.index) {
-            app.get(route, this.createControllerHandler(ControllerClass, 'index'));
-        }
-        if (prototype.show) {
-            app.get(`${route}/:id`, this.createControllerHandler(ControllerClass, 'show'));
-        }
-        if (prototype.create) {
-            app.post(route, this.createControllerHandler(ControllerClass, 'create'));
-        }
-        if (prototype.update) {
-            app.put(`${route}/:id`, this.createControllerHandler(ControllerClass, 'update'));
-        }
-        if (prototype.patch) {
-            app.patch(`${route}/:id`, this.createControllerHandler(ControllerClass, 'patch'));
-        }
-        if (prototype.destroy) {
-            app.delete(`${route}/:id`, this.createControllerHandler(ControllerClass, 'destroy'));
-        }
-    }
-    /**
-     * Auto-derive HTTP method and path from controller method name
-     * Uses HTTP_METHODS constant for RESTful convention mapping
-     */
-    deriveHttpMethodAndPath(methodName, basePath) {
-        if (!(methodName in HTTP_METHODS))
-            return null;
-        const mapping = HTTP_METHODS[methodName];
-        return {
-            method: mapping.method,
-            path: basePath + mapping.path,
-        };
-    }
-    /**
-     * Merge controller-level and route-level metadata
-     * Tags are merged (appended), security is merged (union)
-     * Guards automatically add sessionCookie security if present
-     */
-    mergeMetadata(controllerOpts, routeConfig, ControllerClass, methodName) {
-        const tags = [...(controllerOpts?.tags ?? []), ...(routeConfig.tags ?? [])];
-        // Check if guards are present (indicates authentication is required)
-        const prototype = ControllerClass.prototype;
-        const hasMethodGuards = (getMethodGuards(prototype, methodName)?.guards.length ?? 0) > 0;
-        const hasControllerGuards = (getControllerGuards(ControllerClass)?.guards.length ?? 0) > 0;
-        const requiresAuth = hasMethodGuards || hasControllerGuards;
-        // Merge security: if route explicitly sets security (even empty array), use it
-        // Otherwise inherit from controller
-        let security = [];
-        if (routeConfig.security !== undefined) {
-            // Route has explicit security (could be empty for public routes)
-            security = [...(controllerOpts?.security ?? []), ...routeConfig.security];
-        }
-        else if (controllerOpts?.security) {
-            // Inherit controller security
-            security = controllerOpts.security;
-        }
-        // Auto-add sessionCookie security if guards are present
-        if (requiresAuth && !security.includes(SECURITY_SCHEMES.SESSION_COOKIE)) {
-            security.push(SECURITY_SCHEMES.SESSION_COOKIE);
-        }
-        // Convert security array to OpenAPI security format
-        const securityArray = security.length > 0
-            ? (security.map((scheme) => ({ [scheme]: [] })))
-            : [];
-        return { tags, security: securityArray };
-    }
-    /**
-     * Build OpenAPI route configuration from metadata
-     * Creates a route definition compatible with @hono/zod-openapi
-     * Includes guard execution for proper access control
-     *
-     * Execution order: Global middlewares → Guards → Handler
-     */
-    buildOpenAPIRoute(method, path, routeConfig, metadata, guards, methodName, statusCodeOverride) {
-        try {
-            const route = {
-                method,
-                path,
-                request: {},
-                responses: {},
-            };
-            // Add guard execution middleware using Hono's built-in middleware property
-            if (guards.length > 0) {
-                route.middleware = [this.createGuardMiddleware(guards)];
-            }
-            // Add request body if defined
-            if (routeConfig.body) {
-                const bodySchema = this.isRouteBodyObject(routeConfig.body) ? routeConfig.body.schema : routeConfig.body;
-                const bodyContentType = this.isRouteBodyObject(routeConfig.body) ? routeConfig.body.contentType ?? DEFAULT_CONTENT_TYPE : DEFAULT_CONTENT_TYPE;
-                route.request = {
-                    ...route.request,
-                    body: {
-                        content: {
-                            [bodyContentType]: {
-                                schema: bodySchema,
-                            },
-                        },
-                    },
-                };
-            }
-            // Add query parameters if defined
-            if (routeConfig.query) {
-                route.request = {
-                    ...route.request,
-                    query: routeConfig.query,
-                };
-            }
-            // Add URL parameters if defined
-            if (routeConfig.params) {
-                route.request = {
-                    ...route.request,
-                    params: routeConfig.params,
-                };
-            }
-            // Derive success status code from method name or use override
-            const successStatus = statusCodeOverride
-                ?? (methodName && METHOD_STATUS_CODES[methodName])
-                ?? 200;
-            // Build responses object with auto-derived status
-            const responses = {};
-            // Add success response with derived status code
-            const responseDef = routeConfig.response;
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- response may be undefined at runtime
-            if (responseDef) {
-                if (typeof responseDef === 'object' && 'schema' in responseDef) {
-                    const responseContentType = responseDef.contentType ?? DEFAULT_CONTENT_TYPE;
-                    responses[successStatus] = {
-                        content: {
-                            [responseContentType]: { schema: responseDef.schema },
-                        },
-                        description: responseDef.description ?? `Response ${successStatus}`,
-                    };
-                }
-                else {
-                    responses[successStatus] = {
-                        content: {
-                            [DEFAULT_CONTENT_TYPE]: { schema: responseDef },
-                        },
-                        description: `Response ${successStatus}`,
-                    };
-                }
-            }
-            // Auto-merge common error schemas (400, 401, 403, 404, 409, 500)
-            // Controllers only need to define success response; error responses are added automatically
-            for (const [statusStr, schema] of Object.entries(commonErrorSchemas)) {
-                const status = parseInt(statusStr);
-                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- defensive: avoid overwriting success response status
-                responses[status] ??= schema;
-            }
-            route.responses = responses;
-            // Add tags if provided
-            if (metadata.tags.length > 0) {
-                route.tags = metadata.tags;
-            }
-            // Add security if provided
-            if (metadata.security.length > 0) {
-                route.security = metadata.security;
-            }
-            // Add description and summary
-            if (routeConfig.description) {
-                route.description = routeConfig.description;
-            }
-            if (routeConfig.summary) {
-                route.summary = routeConfig.summary;
-            }
-            return createRoute(route);
-        }
-        catch (error) {
-            throw new OpenAPIRouteRegistrationError(path, error instanceof Error ? error.message : String(error));
-        }
-    }
-    /**
-     * Check if a body definition is a RouteBodyObject (has schema key) vs bare ZodType
-     */
-    isRouteBodyObject(body) {
-        return typeof body === 'object' && 'schema' in body;
-    }
-    /**
-     * Resolve method parameter injections from the container
-     *
-     * @param prototype - Controller prototype
-     * @param methodName - Method name to get injections for
-     * @param container - Request-scoped container
-     * @returns Array of resolved dependencies in parameter order
-     */
-    resolveMethodInjections(prototype, methodName, container) {
-        const injections = getMethodInjections(prototype, methodName);
-        if (!injections.length)
-            return [];
-        return injections.map((inj) => container.resolve(inj.token));
-    }
-    /**
-     * Create controller handler that resolves controller from request-scoped container
-     * This ensures each request gets a fresh controller with request-scoped context
-     */
-    createControllerHandler(ControllerClass, methodName) {
-        return async (c) => {
-            this.logger.info('Handler invoked', {
-                path: c.req.path,
-                method: c.req.method,
-                controller: ControllerClass.name,
-                methodName: methodName,
-            });
-            try {
-                const ctx = new RouterContext(c);
-                const requestContainer = ctx.getContainer();
-                // Resolve controller from request-scoped container
-                // Controller will get request-scoped TenancyContext via DI
-                const controller = requestContainer.resolve(ControllerClass);
-                const method = controller[methodName];
-                if (typeof method === 'function') {
-                    const injectedArgs = this.resolveMethodInjections(ControllerClass.prototype, methodName, requestContainer);
-                    return await method.apply(controller, [ctx, ...injectedArgs]);
-                }
-                throw new ControllerMethodNotFoundError(methodName, ControllerClass.name);
-            }
-            catch (error) {
-                this.logger.error('Error in controller handler', {
-                    controller: ControllerClass.name,
-                    methodName: methodName,
-                    error: error instanceof Error ? error.message : String(error),
-                    stack: error instanceof Error ? error.stack : undefined,
-                });
-                throw error;
-            }
-        };
-    }
-}
-//# sourceMappingURL=route-registration.service.js.map