@velajs/vela 0.4.3 → 0.5.0

package/dist/http/route.manager.js

@@ -1,6 +1,7 @@
 import { Hono } from "hono";
 import { HttpMethod, ParamType } from "../constants.js";
 import { getMetadata } from "../metadata.js";
+import { RequestMethod } from "./middleware-consumer.js";
 import { ForbiddenException, HttpException } from "../errors/http-exception.js";
 import { ComponentManager } from "../pipeline/component.manager.js";
 import { shouldFilterCatch } from "../pipeline/decorators.js";
@@ -27,9 +28,14 @@ export class RouteManager {
     globalInterceptors = [];
     globalFilters = [];
     globalPrefix = '';
+    consumerMiddlewareDefinitions = [];
     constructor(container){
         this.container = container;
     }
+    registerConsumerMiddleware(definitions) {
+        this.consumerMiddlewareDefinitions.push(...definitions);
+        return this;
+    }
     setGlobalPrefix(prefix) {
         this.globalPrefix = prefix && !prefix.startsWith('/') ? `/${prefix}` : prefix;
         return this;
@@ -125,6 +131,37 @@ export class RouteManager {
                 return resolved.use(c, next);
             });
         }
+        // Register MiddlewareConsumer-configured middleware
+        for (const def of this.consumerMiddlewareDefinitions){
+            app.use('*', (c, next)=>{
+                const reqPath = c.req.path;
+                const reqMethod = c.req.method;
+                const matches = def.routes.some((route)=>{
+                    if (!this.matchesConsumerPath(reqPath, route.path)) return false;
+                    if (route.method && route.method !== RequestMethod.ALL) {
+                        if (reqMethod !== route.method) return false;
+                    }
+                    return true;
+                });
+                if (!matches) return next();
+                const excluded = def.excludes.some((exclude)=>{
+                    if (!this.matchesConsumerPath(reqPath, exclude.path)) return false;
+                    if (exclude.method && exclude.method !== RequestMethod.ALL) {
+                        if (reqMethod !== exclude.method) return false;
+                    }
+                    return true;
+                });
+                if (excluded) return next();
+                const requestContainer = this.getRequestContainer(c);
+                const runChain = (index)=>{
+                    if (index >= def.middleware.length) return next();
+                    const instance = this.instantiate(def.middleware[index], requestContainer);
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    return instance.use(c, ()=>runChain(index + 1)).then(()=>{});
+                };
+                return runChain(0);
+            });
+        }
         // First pass: register all custom routes (must come before CRUD /:id routes)
         for (const { controller, metadata, routes } of this.controllers){
             if (routes.length > 0) {
@@ -171,10 +208,15 @@ export class RouteManager {
     }
     createExecutionContext(c, controller, route) {
         return {
+            getType: ()=>'http',
             getClass: ()=>controller,
             getHandler: ()=>route.handlerName,
             getContext: ()=>c,
-            getRequest: ()=>c.req.raw
+            getRequest: ()=>c.req.raw,
+            switchToHttp: ()=>({
+                    getRequest: ()=>c.req.raw,
+                    getResponse: ()=>c
+                })
         };
     }
     createHandler(route, controller, allParamMetadata) {
@@ -326,6 +368,28 @@ export class RouteManager {
                 return headers;
             case ParamType.REQUEST:
                 return c;
+            case ParamType.RESPONSE:
+                return c;
+            case ParamType.IP:
+                return c.req.raw.headers.get('x-forwarded-for')?.split(',')[0]?.trim() ?? c.req.raw.headers.get('x-real-ip') ?? null;
+            case ParamType.COOKIE:
+                {
+                    const cookieHeader = c.req.raw.headers.get('cookie') ?? '';
+                    const cookies = {};
+                    for (const pair of cookieHeader.split(';')){
+                        const eqIdx = pair.indexOf('=');
+                        if (eqIdx === -1) continue;
+                        const name = pair.slice(0, eqIdx).trim();
+                        const value = pair.slice(eqIdx + 1).trim();
+                        if (name) cookies[name] = decodeURIComponent(value);
+                    }
+                    return param.name ? cookies[param.name] ?? undefined : cookies;
+                }
+            case ParamType.RAW_BODY:
+                {
+                    const buffer = await c.req.arrayBuffer();
+                    return new Uint8Array(buffer);
+                }
             default:
                 // Custom param decorator — use factory if available
                 if (param.factory) {
@@ -393,6 +457,16 @@ export class RouteManager {
         const cleanPath = path && !path.startsWith('/') ? `/${path}` : path;
         return `${cleanPrefix}${cleanPath}` || '/';
     }
+    matchesConsumerPath(reqPath, routePath) {
+        if (routePath === '*') return true;
+        const normalized = routePath.startsWith('/') ? routePath : `/${routePath}`;
+        if (reqPath === normalized) return true;
+        if (reqPath.startsWith(`${normalized}/`)) return true;
+        if (normalized.endsWith('*')) {
+            return reqPath.startsWith(normalized.slice(0, -1));
+        }
+        return false;
+    }
     getControllers() {
         return [
             ...this.controllers

package/dist/index.d.ts

@@ -2,14 +2,16 @@ import './metadata';
 export { defineMetadata, getMetadata } from './metadata';
 export { VelaFactory } from './factory';
 export { VelaApplication } from './application';
-export { Container, Injectable, Inject, InjectionToken } from './container/index';
+export { Container, Injectable, Inject, Optional, InjectionToken, ForwardRef, forwardRef, ModuleRef, mixin } from './container/index';
 export type { Type, Token, InjectableOptions, ProviderOptions, } from './container/index';
 export { METADATA_KEYS, HttpMethod, ParamType, Scope } from './constants';
-export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Sse, Param, Query, Body, Headers, Req, HttpCode, Header, Redirect, createParamDecorator, } from './http/index';
+export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Sse, Param, Query, Body, Headers, Req, Res, Ip, Cookie, Cookies, RawBody, HttpCode, Header, Redirect, createParamDecorator, applyDecorators, } from './http/index';
 export { Logger, LogLevel } from './services/index';
 export type { LoggerService } from './services/index';
 export { ConfigModule, ConfigService, CONFIG_OPTIONS } from './config/index';
 export type { ConfigModuleOptions } from './config/index';
+export { HttpModule, HttpService, HTTP_MODULE_OPTIONS, HttpRequestException } from './fetch/index';
+export type { HttpModuleOptions, HttpResponse, HttpRequestConfig } from './fetch/index';
 export { CorsModule, CORS_OPTIONS } from './cors/index';
 export type { CorsOptions } from './cors/index';
 export { CacheModule, CacheService, CacheInterceptor, MemoryCacheStore, CacheKey, CacheTTL, CACHE_MANAGER, CACHE_MODULE_OPTIONS, CACHE_KEY_METADATA, CACHE_TTL_METADATA, } from './cache/index';
@@ -22,12 +24,15 @@ export { HealthModule, HealthCheckService, HealthIndicatorService, HttpHealthInd
 export type { HealthCheckResult, HealthCheckStatus, HealthIndicatorResult, HealthIndicatorFunction, ResponseCheckCallback, HttpPingOptions, } from './health/index';
 export { ThrottlerModule, ThrottlerGuard, ThrottlerStorage, Throttle, SkipThrottle, THROTTLER_OPTIONS, THROTTLER_STORAGE, THROTTLE_METADATA, SKIP_THROTTLE_METADATA, } from './throttler/index';
 export type { ThrottlerModuleOptions, ThrottleConfig, ThrottlerStore, ThrottlerStorageRecord, RateLimitInfo, } from './throttler/index';
-export { Module } from './module/index';
-export type { ModuleOptions, DynamicModule } from './module/index';
+export { Global, Module } from './module/index';
+export type { ModuleOptions, DynamicModule, AsyncModuleOptions, ModuleImport } from './module/index';
+export { RequestMethod } from './http/index';
+export type { MiddlewareConsumer, NestModule, RouteInfo } from './http/index';
 export { UseMiddleware, UseGuards, UsePipes, UseInterceptors, UseFilters, Catch, SetMetadata, Reflector, APP_GUARD, APP_PIPE, APP_INTERCEPTOR, APP_FILTER, APP_MIDDLEWARE, } from './pipeline/index';
-export type { ExecutionContext, CanActivate, CallHandler, NestInterceptor, NestMiddleware, PipeTransform, ExceptionFilter, ArgumentMetadata, ReflectableDecorator, CreateDecoratorOptions, } from './pipeline/index';
+export type { HttpArgumentsHost, ExecutionContext, CanActivate, CallHandler, NestInterceptor, NestMiddleware, PipeTransform, ExceptionFilter, ArgumentMetadata, ReflectableDecorator, CreateDecoratorOptions, } from './pipeline/index';
 export type { Constructor, MiddlewareType, GuardType, PipeType, InterceptorType, FilterType, } from './registry/index';
-export { ParseIntPipe, ParseFloatPipe, ParseBoolPipe, DefaultValuePipe, RequiredPipe, ZodValidationPipe, } from './pipeline/index';
+export { ParseIntPipe, ParseFloatPipe, ParseBoolPipe, ParseUUIDPipe, ParseEnumPipe, ParseArrayPipe, DefaultValuePipe, RequiredPipe, ZodValidationPipe, } from './pipeline/index';
+export type { ParseUUIDPipeOptions, ParseArrayPipeOptions } from './pipeline/index';
 export { HttpException, BadRequestException, UnauthorizedException, ForbiddenException, NotFoundException, MethodNotAllowedException, NotAcceptableException, RequestTimeoutException, ConflictException, GoneException, PayloadTooLargeException, UnsupportedMediaTypeException, UnprocessableEntityException, TooManyRequestsException, InternalServerErrorException, NotImplementedException, BadGatewayException, ServiceUnavailableException, GatewayTimeoutException, } from './errors/index';
 export type { OnModuleInit, OnApplicationBootstrap, OnModuleDestroy, OnApplicationShutdown, BeforeApplicationShutdown, } from './lifecycle/index';
 export { MetadataRegistry } from './registry/index';

package/dist/index.js

@@ -4,15 +4,17 @@ export { defineMetadata, getMetadata } from "./metadata.js";
 export { VelaFactory } from "./factory.js";
 export { VelaApplication } from "./application.js";
 // DI Container
-export { Container, Injectable, Inject, InjectionToken } from "./container/index.js";
+export { Container, Injectable, Inject, Optional, InjectionToken, ForwardRef, forwardRef, ModuleRef, mixin } from "./container/index.js";
 // Constants
 export { METADATA_KEYS, HttpMethod, ParamType, Scope } from "./constants.js";
 // HTTP Decorators
-export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Sse, Param, Query, Body, Headers, Req, HttpCode, Header, Redirect, createParamDecorator } from "./http/index.js";
+export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Sse, Param, Query, Body, Headers, Req, Res, Ip, Cookie, Cookies, RawBody, HttpCode, Header, Redirect, createParamDecorator, applyDecorators } from "./http/index.js";
 // Services
 export { Logger, LogLevel } from "./services/index.js";
 // Config
 export { ConfigModule, ConfigService, CONFIG_OPTIONS } from "./config/index.js";
+// HTTP Client
+export { HttpModule, HttpService, HTTP_MODULE_OPTIONS, HttpRequestException } from "./fetch/index.js";
 // CORS
 export { CorsModule, CORS_OPTIONS } from "./cors/index.js";
 // Cache
@@ -26,11 +28,12 @@ export { HealthModule, HealthCheckService, HealthIndicatorService, HttpHealthInd
 // Throttler
 export { ThrottlerModule, ThrottlerGuard, ThrottlerStorage, Throttle, SkipThrottle, THROTTLER_OPTIONS, THROTTLER_STORAGE, THROTTLE_METADATA, SKIP_THROTTLE_METADATA } from "./throttler/index.js";
 // Module
-export { Module } from "./module/index.js";
+export { Global, Module } from "./module/index.js";
+export { RequestMethod } from "./http/index.js";
 // Pipeline Decorators
 export { UseMiddleware, UseGuards, UsePipes, UseInterceptors, UseFilters, Catch, SetMetadata, Reflector, APP_GUARD, APP_PIPE, APP_INTERCEPTOR, APP_FILTER, APP_MIDDLEWARE } from "./pipeline/index.js";
 // Built-in Pipes
-export { ParseIntPipe, ParseFloatPipe, ParseBoolPipe, DefaultValuePipe, RequiredPipe, ZodValidationPipe } from "./pipeline/index.js";
+export { ParseIntPipe, ParseFloatPipe, ParseBoolPipe, ParseUUIDPipe, ParseEnumPipe, ParseArrayPipe, DefaultValuePipe, RequiredPipe, ZodValidationPipe } from "./pipeline/index.js";
 // Errors
 export { HttpException, BadRequestException, UnauthorizedException, ForbiddenException, NotFoundException, MethodNotAllowedException, NotAcceptableException, RequestTimeoutException, ConflictException, GoneException, PayloadTooLargeException, UnsupportedMediaTypeException, UnprocessableEntityException, TooManyRequestsException, InternalServerErrorException, NotImplementedException, BadGatewayException, ServiceUnavailableException, GatewayTimeoutException } from "./errors/index.js";
 // Registry (for advanced usage)

package/dist/metadata.d.ts

@@ -7,4 +7,4 @@ declare global {
     }
 }
 export declare function defineMetadata(key: string, value: unknown, target: object, propertyKey?: string | symbol): void;
-export declare function getMetadata(key: string, target: object, propertyKey?: string | symbol): unknown;
+export declare function getMetadata<T = unknown>(key: string, target: object, propertyKey?: string | symbol): T | undefined;

package/dist/module/decorators.d.ts

@@ -1,5 +1,6 @@
 import type { Constructor } from '../registry/types';
 import type { ModuleMetadata, ModuleOptions } from './types';
+export declare function Global(): ClassDecorator;
 export declare function Module(options?: ModuleOptions): ClassDecorator;
 export declare function isModule(target: Constructor): boolean;
 export declare function getModuleMetadata(target: Constructor): ModuleMetadata | undefined;

package/dist/module/decorators.js

@@ -1,32 +1,48 @@
 import { METADATA_KEYS } from "../constants.js";
-import { getMetadata } from "../metadata.js";
+import { defineMetadata, getMetadata } from "../metadata.js";
 import { MetadataRegistry } from "../registry/metadata.registry.js";
-export function Module(options = {}) {
+export function Global() {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
     return (target)=>{
+        const existing = MetadataRegistry.getModuleOptions(target);
         MetadataRegistry.setModuleOptions(target, {
+            ...existing,
+            isGlobal: true
+        });
+    };
+}
+export function Module(options = {}) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+    return (target)=>{
+        const normalized = {
             imports: options.imports,
             providers: options.providers,
             controllers: options.controllers,
-            exports: options.exports
-        });
+            exports: options.exports,
+            isGlobal: options.isGlobal
+        };
+        // WeakMap store survives MetadataRegistry.clear() — needed for framework modules
+        // decorated at import time (e.g. HttpModule, CorsModule).
+        defineMetadata(METADATA_KEYS.MODULE_OPTIONS, normalized, target);
+        MetadataRegistry.setModuleOptions(target, normalized);
     };
 }
 export function isModule(target) {
-    return MetadataRegistry.getModuleOptions(target) !== undefined || getMetadata(METADATA_KEYS.MODULE, target) === true;
+    return MetadataRegistry.getModuleOptions(target) !== undefined || getMetadata(METADATA_KEYS.MODULE, target) === true || getMetadata(METADATA_KEYS.MODULE_OPTIONS, target) !== undefined;
 }
 export function getModuleMetadata(target) {
     if (!isModule(target)) {
         return undefined;
     }
-    const options = MetadataRegistry.getModuleOptions(target);
-    if (!options) {
+    const options = MetadataRegistry.getModuleOptions(target) ?? getMetadata(METADATA_KEYS.MODULE_OPTIONS, target);
+    if (!options || typeof options !== 'object') {
         return undefined;
     }
     return {
         providers: options.providers ?? [],
         controllers: options.controllers ?? [],
         imports: options.imports ?? [],
-        exports: options.exports ?? []
+        exports: options.exports ?? [],
+        isGlobal: options.isGlobal === true
     };
 }

package/dist/module/index.d.ts

@@ -1,3 +1,3 @@
-export { Module, isModule, getModuleMetadata } from './decorators';
+export { Global, Module, isModule, getModuleMetadata } from './decorators';
 export { ModuleLoader } from './module-loader';
-export type { ModuleOptions, ModuleMetadata, DynamicModule } from './types';
+export type { ModuleOptions, ModuleMetadata, DynamicModule, AsyncModuleOptions, ModuleImport } from './types';

package/dist/module/index.js

@@ -1,2 +1,2 @@
-export { Module, isModule, getModuleMetadata } from "./decorators.js";
+export { Global, Module, isModule, getModuleMetadata } from "./decorators.js";
 export { ModuleLoader } from "./module-loader.js";

package/dist/module/module-loader.d.ts

@@ -1,5 +1,6 @@
 import type { Container } from '../container/container';
 import type { Token, Type } from '../container/types';
+import type { MiddlewareRouteDefinition } from '../http/middleware-consumer';
 import type { RouteManager } from '../http/route.manager';
 export declare class ModuleLoader {
     private container;
@@ -9,6 +10,8 @@ export declare class ModuleLoader {
     private collectedControllers;
     private registeredProviders;
     private moduleExportsCache;
+    private globalExports;
+    private consumerMiddlewareDefinitions;
     private appProviderCounter;
     private appProviderTokens;
     constructor(container: Container, router: RouteManager);
@@ -20,5 +23,6 @@ export declare class ModuleLoader {
     getControllers(): Type[];
     getRegisteredProviders(): Token[];
     getAppProviderTokens(token: Token): Token[];
-    resolveAllInstances(): unknown[];
+    getConsumerMiddlewareDefinitions(): MiddlewareRouteDefinition[];
+    resolveAllInstances(): Promise<unknown[]>;
 }

package/dist/module/module-loader.js

@@ -1,6 +1,8 @@
 import { Scope } from "../constants.js";
-import { InjectionToken } from "../container/types.js";
+import { ForwardRef, InjectionToken } from "../container/types.js";
+import { MiddlewareBuilder } from "../http/middleware-consumer.js";
 import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_MIDDLEWARE, APP_PIPE } from "../pipeline/tokens.js";
+import { MetadataRegistry } from "../registry/metadata.registry.js";
 import { getModuleMetadata, isModule } from "./decorators.js";
 function isDynamicModule(value) {
     return typeof value === 'object' && value !== null && 'module' in value && typeof value.module === 'function';
@@ -13,6 +15,8 @@ export class ModuleLoader {
     collectedControllers = [];
     registeredProviders = [];
     moduleExportsCache = new Map();
+    globalExports = new Set();
+    consumerMiddlewareDefinitions = [];
     appProviderCounter = 0;
     appProviderTokens = new Map([
         [
@@ -47,12 +51,14 @@ export class ModuleLoader {
         }
     }
     processModule(moduleClassOrDynamic) {
-        // Handle dynamic modules ({ module, controllers, providers })
+        // Handle dynamic modules ({ module, imports, controllers, providers })
         let moduleClass;
+        let extraImports = [];
         let extraControllers = [];
         let extraProviders = [];
         if (isDynamicModule(moduleClassOrDynamic)) {
             moduleClass = moduleClassOrDynamic.module;
+            extraImports = moduleClassOrDynamic.imports ?? [];
             extraControllers = moduleClassOrDynamic.controllers ?? [];
             extraProviders = moduleClassOrDynamic.providers ?? [];
         } else {
@@ -83,8 +89,20 @@ export class ModuleLoader {
         }
         this.processingStack.add(moduleClass);
         try {
-            const importedProviders = new Set();
-            for (const importedModule of metadata.imports){
+            const importedProviders = new Set(this.globalExports);
+            for (const entry of [
+                ...metadata.imports,
+                ...extraImports
+            ]){
+                // Unwrap forwardRef(() => Module) — resolves lazy circular references
+                const isForwardRef = entry instanceof ForwardRef;
+                const importedModule = isForwardRef ? entry.factory() : entry;
+                const importedModuleClass = isDynamicModule(importedModule) ? importedModule.module : importedModule;
+                // If this forwardRef-wrapped import is currently being processed, skip it to
+                // break the circular chain. Non-forwardRef circular imports still throw.
+                if (isForwardRef && this.processingStack.has(importedModuleClass)) {
+                    continue;
+                }
                 const exportedTokens = this.processModule(importedModule);
                 for (const token of exportedTokens){
                     importedProviders.add(token);
@@ -108,9 +126,30 @@ export class ModuleLoader {
                     this.collectedControllers.push(controller);
                 }
             }
+            // Propagate module-level Use* decorators (@UseGuards, @UseInterceptors, etc.) to each controller
+            for (const controller of allControllers){
+                MetadataRegistry.propagateControllerComponents(moduleClass, controller);
+            }
             this.processedModules.add(moduleClass);
             const exports = this.buildExportSet(metadata.exports, allProviders, importedProviders);
             this.moduleExportsCache.set(moduleClass, exports);
+            const isGlobal = metadata.isGlobal || isDynamicModule(moduleClassOrDynamic) && moduleClassOrDynamic.global === true;
+            if (isGlobal) {
+                for (const token of exports){
+                    this.globalExports.add(token);
+                }
+            }
+            // Call configure() if the module implements NestModule
+            if (typeof moduleClass.prototype?.configure === 'function') {
+                try {
+                    const instance = new moduleClass();
+                    const builder = new MiddlewareBuilder();
+                    instance.configure(builder);
+                    this.consumerMiddlewareDefinitions.push(...builder.getDefinitions());
+                } catch  {
+                // Module has constructor dependencies — configure() skipped
+                }
+            }
             return exports;
         } finally{
             this.processingStack.delete(moduleClass);
@@ -123,7 +162,7 @@ export class ModuleLoader {
                 this.registeredProviders.push(provider);
             }
         } else {
-            const token = provider.token;
+            const token = provider.provide;
             if (!token) {
                 this.container.register(provider);
                 return;
@@ -132,7 +171,7 @@ export class ModuleLoader {
                 const syntheticToken = new InjectionToken(`${token.toString()}:${this.appProviderCounter++}`);
                 this.container.register({
                     ...provider,
-                    token: syntheticToken
+                    provide: syntheticToken
                 });
                 this.registeredProviders.push(syntheticToken);
                 this.appProviderTokens.get(token).push(syntheticToken);
@@ -154,7 +193,7 @@ export class ModuleLoader {
                 if (typeof p === 'function') {
                     return p === exported;
                 }
-                return p.token === exported;
+                return p.provide === exported;
             });
             const isImportedProvider = importedProviders.has(exported);
             if (!isLocalProvider && !isImportedProvider) {
@@ -180,14 +219,19 @@ export class ModuleLoader {
             ...this.appProviderTokens.get(token) ?? []
         ];
     }
-    resolveAllInstances() {
+    getConsumerMiddlewareDefinitions() {
+        return [
+            ...this.consumerMiddlewareDefinitions
+        ];
+    }
+    async resolveAllInstances() {
         const instances = [];
         for (const token of this.registeredProviders){
             try {
                 if (this.container.getProviderScope(token) === Scope.REQUEST) {
                     continue;
                 }
-                const instance = this.container.resolve(token);
+                const instance = await this.container.resolveAsync(token);
                 instances.push(instance);
             } catch  {
             // Skip unresolvable tokens
@@ -198,7 +242,7 @@ export class ModuleLoader {
                 if (this.container.getProviderScope(controller) === Scope.REQUEST) {
                     continue;
                 }
-                const instance = this.container.resolve(controller);
+                const instance = await this.container.resolveAsync(controller);
                 if (!instances.includes(instance)) {
                     instances.push(instance);
                 }

package/dist/module/types.d.ts

@@ -1,19 +1,29 @@
-import type { InjectionToken, ProviderOptions, Type } from '../container/types';
+import type { ForwardRef, InjectionToken, ProviderOptions, Token, Type } from '../container/types';
+export type ModuleImport = Type | DynamicModule | ForwardRef;
+export interface AsyncModuleOptions<T = unknown> {
+    imports?: ModuleImport[];
+    useFactory: (...args: any[]) => T | Promise<T>;
+    inject?: Token[];
+}
 export interface DynamicModule {
     module: Type;
+    imports?: ModuleImport[];
     providers?: Array<Type | ProviderOptions>;
     controllers?: Type[];
     exports?: Array<Type | InjectionToken>;
+    global?: boolean;
 }
 export interface ModuleOptions {
     providers?: Array<Type | ProviderOptions>;
     controllers?: Type[];
-    imports?: Array<Type | DynamicModule>;
+    imports?: ModuleImport[];
     exports?: Array<Type | InjectionToken>;
+    isGlobal?: boolean;
 }
 export interface ModuleMetadata {
     providers: Array<Type | ProviderOptions>;
     controllers: Type[];
-    imports: Array<Type | DynamicModule>;
+    imports: ModuleImport[];
     exports: Array<Type | InjectionToken>;
+    isGlobal: boolean;
 }

package/dist/pipeline/index.d.ts

@@ -3,5 +3,6 @@ export { UseMiddleware, UseGuards, UsePipes, UseInterceptors, UseFilters, Catch,
 export { SetMetadata, Reflector } from './reflector';
 export type { ReflectableDecorator, CreateDecoratorOptions } from './reflector';
 export { APP_GUARD, APP_PIPE, APP_INTERCEPTOR, APP_FILTER, APP_MIDDLEWARE } from './tokens';
-export { ParseIntPipe, ParseFloatPipe, ParseBoolPipe, DefaultValuePipe, RequiredPipe, ZodValidationPipe, } from './pipes';
-export type { ExecutionContext, CanActivate, CallHandler, NestInterceptor, NestMiddleware, PipeTransform, ExceptionFilter, ArgumentMetadata, } from './types';
+export { ParseIntPipe, ParseFloatPipe, ParseBoolPipe, ParseUUIDPipe, ParseEnumPipe, ParseArrayPipe, DefaultValuePipe, RequiredPipe, ZodValidationPipe, } from './pipes';
+export type { ParseUUIDPipeOptions, ParseArrayPipeOptions } from './pipes';
+export type { HttpArgumentsHost, ExecutionContext, CanActivate, CallHandler, NestInterceptor, NestMiddleware, PipeTransform, ExceptionFilter, ArgumentMetadata, } from './types';

package/dist/pipeline/index.js

@@ -2,4 +2,4 @@ export { ComponentManager } from "./component.manager.js";
 export { UseMiddleware, UseGuards, UsePipes, UseInterceptors, UseFilters, Catch, getCatchTypes, shouldFilterCatch } from "./decorators.js";
 export { SetMetadata, Reflector } from "./reflector.js";
 export { APP_GUARD, APP_PIPE, APP_INTERCEPTOR, APP_FILTER, APP_MIDDLEWARE } from "./tokens.js";
-export { ParseIntPipe, ParseFloatPipe, ParseBoolPipe, DefaultValuePipe, RequiredPipe, ZodValidationPipe } from "./pipes.js";
+export { ParseIntPipe, ParseFloatPipe, ParseBoolPipe, ParseUUIDPipe, ParseEnumPipe, ParseArrayPipe, DefaultValuePipe, RequiredPipe, ZodValidationPipe } from "./pipes.js";

package/dist/pipeline/pipes.d.ts

@@ -23,3 +23,25 @@ export declare class ZodValidationPipe implements PipeTransform {
     });
     transform(value: unknown, _metadata: ArgumentMetadata): unknown;
 }
+export interface ParseUUIDPipeOptions {
+    version?: '3' | '4' | '5';
+}
+export declare class ParseUUIDPipe implements PipeTransform<string, string> {
+    private readonly options?;
+    constructor(options?: ParseUUIDPipeOptions | undefined);
+    transform(value: string, metadata: ArgumentMetadata): string;
+}
+export declare class ParseEnumPipe<T extends Record<string, string | number>> implements PipeTransform<string, T[keyof T]> {
+    private readonly enumType;
+    constructor(enumType: T);
+    transform(value: string, metadata: ArgumentMetadata): T[keyof T];
+}
+export interface ParseArrayPipeOptions {
+    separator?: string;
+    optional?: boolean;
+}
+export declare class ParseArrayPipe implements PipeTransform {
+    private readonly options?;
+    constructor(options?: ParseArrayPipeOptions | undefined);
+    transform(value: unknown, metadata: ArgumentMetadata): unknown[];
+}

package/dist/pipeline/pipes.js

@@ -50,3 +50,53 @@ export class ZodValidationPipe {
         return this.schema.parse(value);
     }
 }
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const UUID_VERSION_REGEX = {
+    '3': /^[0-9a-f]{8}-[0-9a-f]{4}-3[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    '4': /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    '5': /^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+};
+export class ParseUUIDPipe {
+    options;
+    constructor(options){
+        this.options = options;
+    }
+    transform(value, metadata) {
+        const regex = this.options?.version ? UUID_VERSION_REGEX[this.options.version] : UUID_REGEX;
+        if (!regex.test(value)) {
+            throw new BadRequestException(`Validation failed (uuid${this.options?.version ? ` v${this.options.version}` : ''} expected)${metadata.data ? ` for parameter '${metadata.data}'` : ''}`);
+        }
+        return value;
+    }
+}
+export class ParseEnumPipe {
+    enumType;
+    constructor(enumType){
+        this.enumType = enumType;
+    }
+    transform(value, metadata) {
+        const enumValues = Object.values(this.enumType);
+        if (!enumValues.includes(value)) {
+            throw new BadRequestException(`Validation failed (${enumValues.join(', ')} expected)${metadata.data ? ` for parameter '${metadata.data}'` : ''}`);
+        }
+        return value;
+    }
+}
+export class ParseArrayPipe {
+    options;
+    constructor(options){
+        this.options = options;
+    }
+    transform(value, metadata) {
+        if (value === undefined || value === null || value === '') {
+            if (this.options?.optional) return [];
+            throw new BadRequestException(`Validation failed (array expected)${metadata.data ? ` for parameter '${metadata.data}'` : ''}`);
+        }
+        if (Array.isArray(value)) return value;
+        if (typeof value === 'string') {
+            const sep = this.options?.separator ?? ',';
+            return value.split(sep).map((v)=>v.trim()).filter((v)=>v.length > 0);
+        }
+        throw new BadRequestException(`Validation failed (array expected)${metadata.data ? ` for parameter '${metadata.data}'` : ''}`);
+    }
+}

package/dist/pipeline/tokens.d.ts

@@ -8,7 +8,7 @@ import type { CanActivate, ExceptionFilter, NestInterceptor, NestMiddleware, Pip
  * @Module({
  *   providers: [
  *     AuthGuard,
- *     { token: APP_GUARD, useClass: AuthGuard },
+ *     { provide: APP_GUARD, useClass: AuthGuard },
  *   ],
  * })
  * class AppModule {}

package/dist/pipeline/tokens.js

@@ -7,7 +7,7 @@ import { InjectionToken } from "../container/types.js";
  * @Module({
  *   providers: [
  *     AuthGuard,
- *     { token: APP_GUARD, useClass: AuthGuard },
+ *     { provide: APP_GUARD, useClass: AuthGuard },
  *   ],
  * })
  * class AppModule {}

package/dist/pipeline/types.d.ts

@@ -1,10 +1,26 @@
 import type { Context } from 'hono';
 import type { Type } from '../container/types';
+/**
+ * HTTP-specific arguments host returned by `ExecutionContext.switchToHttp()`.
+ * In Vela/Hono, the `Context` object holds both request and response state.
+ *
+ * - `getRequest()` — the Web `Request` object
+ * - `getResponse()` — the Hono `Context` (use `c.header()`, `c.setCookie()`, etc.)
+ */
+export interface HttpArgumentsHost {
+    getRequest<T = Request>(): T;
+    getResponse<T = Context>(): T;
+}
 export interface ExecutionContext {
+    getType<T extends string = 'http'>(): T;
     getClass(): Type;
     getHandler(): string | symbol;
+    /** Returns the Hono `Context` directly. */
     getContext<T = Context>(): T;
+    /** Shorthand for `switchToHttp().getRequest()` — returns the Web `Request`. */
     getRequest(): Request;
+    /** Switch to the HTTP arguments host for NestJS-style `getRequest()` / `getResponse()` access. */
+    switchToHttp(): HttpArgumentsHost;
 }
 export interface CanActivate {
     canActivate(context: ExecutionContext): boolean | Promise<boolean>;