@velajs/vela 1.4.0 → 1.5.0

package/dist/fetch/fetch.module.js

@@ -4,13 +4,14 @@ function _ts_decorate(decorators, target, key, desc) {
     else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-import { createModuleRef } from "../module/decorators.js";
 import { Module } from "../module/decorators.js";
+import { stableHash } from "../module/stable-hash.js";
 import { HttpService, HTTP_MODULE_OPTIONS } from "./fetch.service.js";
 export class HttpModule {
     static forRoot(options = {}) {
         return {
-            module: createModuleRef('HttpModule'),
+            module: HttpModule,
+            key: stableHash(options),
             providers: [
                 {
                     provide: HTTP_MODULE_OPTIONS,
@@ -26,7 +27,11 @@ export class HttpModule {
     }
     static forRootAsync(options) {
         return {
-            module: createModuleRef('HttpModule'),
+            module: HttpModule,
+            key: options.key ?? stableHash({
+                inject: options.inject,
+                useFactory: options.useFactory
+            }),
             imports: options.imports ?? [],
             providers: [
                 {

package/dist/http/argument-resolver.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from 'hono';
+import type { Container } from '../container/container';
+import type { PipeTransform } from '../pipeline/types';
+import type { ParamMetadata } from './types';
+export declare class ArgumentResolver {
+    private readonly ipExtractor;
+    constructor(ipExtractor: (c: Context) => string | null);
+    extract(c: Context, paramMetadata: ParamMetadata[], pipes: PipeTransform[], requestContainer: Container, paramTypes?: unknown[]): Promise<unknown[]>;
+    private extractParam;
+}

package/dist/http/argument-resolver.js

@@ -0,0 +1,89 @@
+import { getCookie } from "hono/cookie";
+import { ParamType } from "../constants.js";
+import { instantiate } from "./instantiate.js";
+const PARAM_EXTRACTORS = new Map([
+    [
+        ParamType.PARAM,
+        (c, p)=>p.name ? c.req.param(p.name) : c.req.param()
+    ],
+    [
+        ParamType.QUERY,
+        (c, p)=>p.name ? c.req.query(p.name) : c.req.query()
+    ],
+    [
+        ParamType.BODY,
+        async (c, p)=>{
+            let body;
+            try {
+                body = await c.req.json();
+            } catch  {
+                return undefined;
+            }
+            return p.name && body !== null && typeof body === 'object' ? body[p.name] : body;
+        }
+    ],
+    [
+        ParamType.HEADERS,
+        (c, p)=>p.name ? c.req.header(p.name) : c.req.header()
+    ],
+    [
+        ParamType.REQUEST,
+        (c)=>c
+    ],
+    [
+        ParamType.RESPONSE,
+        (c)=>c
+    ],
+    [
+        ParamType.COOKIE,
+        (c, p)=>p.name ? getCookie(c, p.name) : getCookie(c)
+    ],
+    [
+        ParamType.RAW_BODY,
+        async (c)=>new Uint8Array(await c.req.arrayBuffer())
+    ]
+]);
+// Pulls handler arguments from the request, applies shared pipes (global +
+// controller + method) and then per-param pipes. Empty paramMetadata returns
+// `[c]` to match the old direct-Hono-handler shape — a back-compat behavior
+// the framework's tests rely on.
+export class ArgumentResolver {
+    ipExtractor;
+    constructor(ipExtractor){
+        this.ipExtractor = ipExtractor;
+    }
+    async extract(c, paramMetadata, pipes, requestContainer, paramTypes) {
+        if (paramMetadata.length === 0) {
+            return [
+                c
+            ];
+        }
+        const maxIndex = paramMetadata.at(-1).index;
+        const args = new Array(maxIndex + 1).fill(undefined);
+        for (const param of paramMetadata){
+            let value = await this.extractParam(c, param);
+            const metadata = {
+                type: param.type,
+                data: param.name,
+                metatype: paramTypes?.[param.index]
+            };
+            for (const pipe of pipes){
+                value = await pipe.transform(value, metadata);
+            }
+            if (param.pipes && param.pipes.length > 0) {
+                for (const paramPipe of param.pipes){
+                    const pipeInstance = instantiate(paramPipe, requestContainer);
+                    value = await pipeInstance.transform(value, metadata);
+                }
+            }
+            args[param.index] = value;
+        }
+        return args;
+    }
+    extractParam(c, param) {
+        if (param.type === ParamType.IP) return this.ipExtractor(c);
+        const extractor = PARAM_EXTRACTORS.get(param.type);
+        if (extractor) return extractor(c, param);
+        return param.factory ? param.factory(param.name, c) : undefined;
+    }
+}

package/dist/http/handler-executor.d.ts

@@ -0,0 +1,20 @@
+import type { Context } from 'hono';
+import type { Container } from '../container/container';
+import type { Token, Type } from '../container/types';
+import type { CanActivate, ExceptionFilter, NestInterceptor, PipeTransform } from '../pipeline/types';
+import type { FilterType, GuardType, InterceptorType, ParameterMetadata, PipeType } from '../registry/types';
+import type { ArgumentResolver } from './argument-resolver';
+import type { RouteMetadata } from './types';
+export interface HandlerGlobals {
+    guards: Array<GuardType | Token<CanActivate>>;
+    pipes: Array<PipeType | Token<PipeTransform>>;
+    interceptors: Array<InterceptorType | Token<NestInterceptor>>;
+    filters: Array<FilterType | Token<ExceptionFilter>>;
+}
+export declare class HandlerExecutor {
+    private readonly argumentResolver;
+    private readonly getGlobals;
+    private readonly getRequestContainer;
+    constructor(argumentResolver: ArgumentResolver, getGlobals: () => HandlerGlobals, getRequestContainer: (c: Context) => Container);
+    create(route: RouteMetadata, controller: Type, allParamMetadata: Map<string | symbol, ParameterMetadata[]>): (c: Context) => Promise<Response>;
+}

package/dist/http/handler-executor.js

@@ -0,0 +1,108 @@
+import { ForbiddenException, HttpException } from "../errors/http-exception.js";
+import { ComponentManager } from "../pipeline/component.manager.js";
+import { shouldFilterCatch } from "../pipeline/decorators.js";
+import { getHttpCode, getRedirect, getResponseHeaders } from "./decorators.js";
+import { buildExecutionContext } from "./execution-context.js";
+import { instantiateMany } from "./instantiate.js";
+import { applyResponseHeaders, mapRedirect, mapResponse } from "./response-mapper.js";
+// Builds the per-request closure that runs guards, pipes, interceptors, the
+// handler itself, and exception filters. Pure orchestration — Hono route
+// registration stays in RouteManager. Globals are read via a callback so
+// post-create additions (`useGlobalGuards`, etc.) propagate to subsequent
+// requests without rebuilding routes.
+export class HandlerExecutor {
+    argumentResolver;
+    getGlobals;
+    getRequestContainer;
+    constructor(argumentResolver, getGlobals, getRequestContainer){
+        this.argumentResolver = argumentResolver;
+        this.getGlobals = getGlobals;
+        this.getRequestContainer = getRequestContainer;
+    }
+    create(route, controller, allParamMetadata) {
+        const paramMetadata = (allParamMetadata.get(route.handlerName) || []).sort((a, b)=>a.index - b.index);
+        // Read param types once at build time for metatype population.
+        // Routed via Reflect so the polyfill funnels both src-level and dist-level
+        // consumers to the same registry (matters in tests that import from dist).
+        const paramTypes = Reflect.getMetadata('design:paramtypes', controller.prototype, route.handlerName);
+        const methodGuards = ComponentManager.getComponents('guard', controller, route.handlerName);
+        const methodPipes = ComponentManager.getComponents('pipe', controller, route.handlerName);
+        const methodInterceptors = ComponentManager.getComponents('interceptor', controller, route.handlerName);
+        // Filters: reverse order (handler → controller → global) — closest to handler runs first
+        const methodFilters = [
+            ...ComponentManager.getComponents('filter', controller, route.handlerName)
+        ].reverse();
+        const httpCode = getHttpCode(controller, route.handlerName);
+        const responseHeaders = getResponseHeaders(controller, route.handlerName);
+        const redirect = getRedirect(controller, route.handlerName);
+        return async (c)=>{
+            // Combine global + method at request time so post-create registrations propagate.
+            const requestContainer = this.getRequestContainer(c);
+            const globals = this.getGlobals();
+            const guards = [
+                ...instantiateMany(globals.guards, requestContainer),
+                ...instantiateMany(methodGuards, requestContainer)
+            ];
+            const pipes = [
+                ...instantiateMany(globals.pipes, requestContainer),
+                ...instantiateMany(methodPipes, requestContainer)
+            ];
+            const interceptors = [
+                ...instantiateMany(globals.interceptors, requestContainer),
+                ...instantiateMany(methodInterceptors, requestContainer)
+            ];
+            const filters = [
+                ...instantiateMany(methodFilters, requestContainer),
+                ...instantiateMany(globals.filters, requestContainer)
+            ];
+            const executionContext = buildExecutionContext(c, controller, route.handlerName);
+            try {
+                const instance = requestContainer.resolve(controller);
+                // 1. Extract args + run pipes (vela order: args before guards).
+                const args = await this.argumentResolver.extract(c, paramMetadata, pipes, requestContainer, paramTypes);
+                // 2. Guards (fail-fast).
+                for (const guard of guards){
+                    const canActivate = await guard.canActivate(executionContext);
+                    if (!canActivate) {
+                        throw new ForbiddenException();
+                    }
+                }
+                // 3. Get handler method.
+                const method = Reflect.get(instance, route.handlerName);
+                if (typeof method !== 'function') {
+                    throw new Error(`Method ${String(route.handlerName)} not found on controller`);
+                }
+                // 4. Build core handler.
+                const coreHandler = async ()=>Reflect.apply(method, instance, args);
+                // 5. Run interceptor chain.
+                const result = await ComponentManager.runInterceptorChain(interceptors, executionContext, coreHandler);
+                if (redirect) {
+                    return mapRedirect(c, result, redirect);
+                }
+                const response = mapResponse(c, result, httpCode);
+                applyResponseHeaders(response, responseHeaders);
+                return response;
+            } catch (error) {
+                for (const filter of filters){
+                    if (shouldFilterCatch(filter, error)) {
+                        try {
+                            const filtered = await filter.catch(error, executionContext);
+                            return mapResponse(c, filtered);
+                        } catch  {
+                            break;
+                        }
+                    }
+                }
+                if (error instanceof HttpException) {
+                    const response = error.getResponse();
+                    const status = error.getStatus();
+                    return c.json(response, status);
+                }
+                return c.json({
+                    statusCode: 500,
+                    message: 'Internal Server Error'
+                }, 500);
+            }
+        };
+    }
+}

package/dist/http/instantiate.d.ts

@@ -0,0 +1,4 @@
+import type { Container } from '../container/container';
+import type { Token, Type } from '../container/types';
+export declare function instantiate<T>(classOrInstance: Type<T> | Token<T> | T, container: Container): T;
+export declare function instantiateMany<T>(items: Array<Type<T> | Token<T> | T>, container: Container): T[];

package/dist/http/instantiate.js

@@ -0,0 +1,18 @@
+// Resolve a class/token through the container if registered, otherwise treat
+// the input as a plain instance. Used by RouteManager and HandlerExecutor to
+// materialize middleware, guards, pipes, interceptors, and filters per request.
+export function instantiate(classOrInstance, container) {
+    if (typeof classOrInstance === 'function') {
+        if (container.has(classOrInstance)) {
+            return container.resolve(classOrInstance);
+        }
+        return new classOrInstance();
+    }
+    if (container.has(classOrInstance)) {
+        return container.resolve(classOrInstance);
+    }
+    return classOrInstance;
+}
+export function instantiateMany(items, container) {
+    return items.map((item)=>instantiate(item, container));
+}

package/dist/http/response-mapper.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from 'hono';
+export interface ResponseRedirect {
+    url: string;
+    statusCode: number;
+}
+export declare function mapResponse(c: Context, result: unknown, statusCode?: number): Response;
+export declare function mapRedirect(c: Context, result: unknown, redirect: ResponseRedirect): Response;
+export declare function applyResponseHeaders(response: Response, headers: Iterable<readonly [string, string]>): void;

package/dist/http/response-mapper.js

@@ -0,0 +1,42 @@
+// A handler returning `{ url, statusCode? }` may override the @Redirect-decorator
+// destination — kept identical to the previous inline behavior.
+function parseRedirectResult(result) {
+    if (typeof result !== 'object' || result === null) return undefined;
+    if (!('url' in result)) return undefined;
+    const obj = result;
+    if (typeof obj.url !== 'string') return undefined;
+    return {
+        url: obj.url,
+        ...typeof obj.statusCode === 'number' ? {
+            statusCode: obj.statusCode
+        } : {}
+    };
+}
+// Maps a controller return value to a Hono Response. `null`/`undefined` → 204
+// (empty body); strings → text; anything else → JSON. A pre-built Response
+// passes through unchanged.
+export function mapResponse(c, result, statusCode) {
+    if (result instanceof Response) {
+        return result;
+    }
+    if (result === null || result === undefined) {
+        return c.body(null, statusCode ?? 204);
+    }
+    if (typeof result === 'string') {
+        return c.text(result, statusCode ?? 200);
+    }
+    return c.json(result, statusCode ?? 200);
+}
+// Honors @Redirect on the handler. If the handler returned `{ url, statusCode? }`,
+// those override the decorator's defaults; otherwise the decorator wins.
+export function mapRedirect(c, result, redirect) {
+    const overrides = parseRedirectResult(result);
+    const finalUrl = overrides?.url ?? redirect.url;
+    const finalStatus = overrides?.statusCode ?? redirect.statusCode;
+    return c.redirect(finalUrl, finalStatus);
+}
+export function applyResponseHeaders(response, headers) {
+    for (const [name, value] of headers){
+        response.headers.set(name, value);
+    }
+}

package/dist/http/route.manager.d.ts

@@ -13,7 +13,6 @@ export interface RouteManagerOptions {
 export declare class RouteManager {
     private container;
     private static readonly METHOD_REGISTRAR;
-    private static readonly PARAM_EXTRACTORS;
     private controllers;
     private globalMiddleware;
     private globalPipes;
@@ -22,7 +21,7 @@ export declare class RouteManager {
     private globalFilters;
     private globalPrefix;
     private consumerMiddlewareDefinitions;
-    private readonly ipExtractor;
+    private readonly handlerExecutor;
     constructor(container: Container, options?: RouteManagerOptions);
     registerConsumerMiddleware(definitions: MiddlewareRouteDefinition[]): this;
     setGlobalPrefix(prefix: string): this;
@@ -36,17 +35,10 @@ export declare class RouteManager {
     useGlobalInterceptorTokens(...interceptorTokens: Array<Token<NestInterceptor>>): this;
     useGlobalFilters(...filters: FilterType[]): this;
     useGlobalFilterTokens(...filterTokens: Array<Token<ExceptionFilter>>): this;
-    private instantiate;
-    private instantiateMany;
     private getMiddlewarePriority;
     private getRequestContainer;
     registerController(controller: Type): this;
     build(): Promise<Hono>;
-    private createExecutionContext;
-    private createHandler;
-    private extractArguments;
-    private extractParam;
-    private createResponse;
     private registerRoute;
     private buildVersionedPaths;
     private compilePathMatcher;