@velajs/vela 0.4.2 → 0.5.0

package/dist/http/middleware-consumer.js

@@ -0,0 +1,71 @@
+import { MetadataRegistry } from "../registry/metadata.registry.js";
+export var RequestMethod = /*#__PURE__*/ function(RequestMethod) {
+    RequestMethod["GET"] = "GET";
+    RequestMethod["POST"] = "POST";
+    RequestMethod["PUT"] = "PUT";
+    RequestMethod["DELETE"] = "DELETE";
+    RequestMethod["PATCH"] = "PATCH";
+    RequestMethod["OPTIONS"] = "OPTIONS";
+    RequestMethod["HEAD"] = "HEAD";
+    RequestMethod["ALL"] = "ALL";
+    return RequestMethod;
+}({});
+export class MiddlewareBuilder {
+    definitions = [];
+    apply(...middleware) {
+        const currentMiddleware = [
+            ...middleware
+        ];
+        let currentExcludes = [];
+        const proxy = {
+            exclude: (...routes)=>{
+                currentExcludes = routes.map(normalizeRouteArg);
+                return proxy;
+            },
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+            forRoutes: (...routes)=>{
+                this.definitions.push({
+                    middleware: currentMiddleware,
+                    routes: routes.flatMap(resolveRouteArg),
+                    excludes: [
+                        ...currentExcludes
+                    ]
+                });
+                currentExcludes = [];
+                return this;
+            }
+        };
+        return proxy;
+    }
+    getDefinitions() {
+        return [
+            ...this.definitions
+        ];
+    }
+}
+function normalizeRouteArg(route) {
+    return typeof route === 'string' ? {
+        path: route
+    } : route;
+}
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+function resolveRouteArg(route) {
+    if (typeof route === 'string') {
+        return [
+            {
+                path: route
+            }
+        ];
+    }
+    if (typeof route === 'function') {
+        const prefix = MetadataRegistry.getControllerPath(route);
+        return [
+            {
+                path: prefix || '/'
+            }
+        ];
+    }
+    return [
+        route
+    ];
+}

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

@@ -1,6 +1,8 @@
 import { Hono } from 'hono';
 import type { Container } from '../container/container';
-import type { Type } from '../container/types';
+import type { Token, Type } from '../container/types';
+import type { MiddlewareRouteDefinition } from './middleware-consumer';
+import type { CanActivate, ExceptionFilter, NestInterceptor, NestMiddleware, PipeTransform } from '../pipeline/types';
 import type { FilterType, GuardType, InterceptorType, MiddlewareType, PipeType } from '../registry/types';
 import type { ControllerRegistration } from './types';
 export declare class RouteManager {
@@ -12,14 +14,23 @@ export declare class RouteManager {
     private globalInterceptors;
     private globalFilters;
     private globalPrefix;
+    private consumerMiddlewareDefinitions;
     constructor(container: Container);
+    registerConsumerMiddleware(definitions: MiddlewareRouteDefinition[]): this;
     setGlobalPrefix(prefix: string): this;
     useGlobalMiddleware(...middleware: MiddlewareType[]): this;
+    useGlobalMiddlewareTokens(...middlewareTokens: Array<Token<NestMiddleware>>): this;
     useGlobalPipes(...pipes: PipeType[]): this;
+    useGlobalPipeTokens(...pipeTokens: Array<Token<PipeTransform>>): this;
     useGlobalGuards(...guards: GuardType[]): this;
+    useGlobalGuardTokens(...guardTokens: Array<Token<CanActivate>>): this;
     useGlobalInterceptors(...interceptors: InterceptorType[]): this;
+    useGlobalInterceptorTokens(...interceptorTokens: Array<Token<NestInterceptor>>): this;
     useGlobalFilters(...filters: FilterType[]): this;
+    useGlobalFilterTokens(...filterTokens: Array<Token<ExceptionFilter>>): this;
     private instantiate;
+    private instantiateMany;
+    private getRequestContainer;
     registerController(controller: Type): this;
     build(): Promise<Hono>;
     private createExecutionContext;
@@ -30,5 +41,6 @@ export declare class RouteManager {
     private registerRoute;
     private buildVersionedPaths;
     private joinPaths;
+    private matchesConsumerPath;
     getControllers(): ControllerRegistration[];
 }

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,51 +28,81 @@ 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;
     }
     useGlobalMiddleware(...middleware) {
-        for (const mw of middleware){
-            this.globalMiddleware.push(this.instantiate(mw));
-        }
+        this.globalMiddleware.push(...middleware);
+        return this;
+    }
+    useGlobalMiddlewareTokens(...middlewareTokens) {
+        this.globalMiddleware.push(...middlewareTokens);
         return this;
     }
     useGlobalPipes(...pipes) {
-        for (const pipe of pipes){
-            this.globalPipes.push(this.instantiate(pipe));
-        }
+        this.globalPipes.push(...pipes);
+        return this;
+    }
+    useGlobalPipeTokens(...pipeTokens) {
+        this.globalPipes.push(...pipeTokens);
         return this;
     }
     useGlobalGuards(...guards) {
-        for (const guard of guards){
-            this.globalGuards.push(this.instantiate(guard));
-        }
+        this.globalGuards.push(...guards);
+        return this;
+    }
+    useGlobalGuardTokens(...guardTokens) {
+        this.globalGuards.push(...guardTokens);
         return this;
     }
     useGlobalInterceptors(...interceptors) {
-        for (const interceptor of interceptors){
-            this.globalInterceptors.push(this.instantiate(interceptor));
-        }
+        this.globalInterceptors.push(...interceptors);
+        return this;
+    }
+    useGlobalInterceptorTokens(...interceptorTokens) {
+        this.globalInterceptors.push(...interceptorTokens);
         return this;
     }
     useGlobalFilters(...filters) {
-        for (const filter of filters){
-            this.globalFilters.push(this.instantiate(filter));
-        }
+        this.globalFilters.push(...filters);
+        return this;
+    }
+    useGlobalFilterTokens(...filterTokens) {
+        this.globalFilters.push(...filterTokens);
         return this;
     }
-    instantiate(classOrInstance) {
-        if (typeof classOrInstance !== 'function') {
-            return classOrInstance;
+    instantiate(classOrInstance, container) {
+        if (typeof classOrInstance === 'function') {
+            if (container.has(classOrInstance)) {
+                return container.resolve(classOrInstance);
+            }
+            return new classOrInstance();
         }
-        if (this.container.has(classOrInstance)) {
-            return this.container.resolve(classOrInstance);
+        if (container.has(classOrInstance)) {
+            return container.resolve(classOrInstance);
+        }
+        return classOrInstance;
+    }
+    instantiateMany(items, container) {
+        return items.map((item)=>this.instantiate(item, container));
+    }
+    getRequestContainer(c) {
+        const existing = c.get('container');
+        if (existing) {
+            return existing;
         }
-        return new classOrInstance();
+        const child = this.container.createChild();
+        c.set('container', child);
+        return child;
     }
     registerController(controller) {
         const prefix = MetadataRegistry.getControllerPath(controller);
@@ -94,12 +125,46 @@ export class RouteManager {
         const app = new Hono();
         // Register global middleware on the Hono app
         for (const mw of this.globalMiddleware){
-            app.use('*', (c, next)=>mw.use(c, next));
+            app.use('*', (c, next)=>{
+                const requestContainer = this.getRequestContainer(c);
+                const resolved = this.instantiate(mw, requestContainer);
+                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) {
-                const instance = this.container.resolve(controller);
                 const allParamMetadata = MetadataRegistry.getParameters(controller);
                 for (const route of routes){
                     // Determine effective version: route-level overrides controller-level
@@ -108,11 +173,14 @@ export class RouteManager {
                     const versionedPaths = this.buildVersionedPaths(this.globalPrefix, metadata.prefix, route.path, effectiveVersion);
                     // Register per-route middleware as Hono middleware before the handler
                     const middlewareItems = ComponentManager.getComponents('middleware', controller, route.handlerName);
-                    const resolvedMw = ComponentManager.resolveMiddleware(middlewareItems);
-                    const handler = this.createHandler(instance, route, controller, allParamMetadata);
+                    const handler = this.createHandler(route, controller, allParamMetadata);
                     for (const fullPath of versionedPaths){
-                        for (const mw of resolvedMw){
-                            app.use(fullPath, (c, next)=>mw.use(c, next));
+                        for (const middlewareItem of middlewareItems){
+                            app.use(fullPath, (c, next)=>{
+                                const requestContainer = this.getRequestContainer(c);
+                                const resolved = this.instantiate(middlewareItem, requestContainer);
+                                return resolved.use(c, next);
+                            });
                         }
                         this.registerRoute(app, route.method, fullPath, handler);
                     }
@@ -128,7 +196,7 @@ export class RouteManager {
                     const { buildCrudRoutes } = await import(pkg);
                     await buildCrudRoutes(app, controller, metadata.prefix, crudConfig, {
                         globalPrefix: this.globalPrefix,
-                        globalGuards: this.globalGuards,
+                        globalGuards: this.instantiateMany(this.globalGuards, this.container),
                         joinPaths: this.joinPaths.bind(this)
                     });
                 } catch  {
@@ -140,57 +208,57 @@ 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(instance, route, controller, allParamMetadata) {
+    createHandler(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
-        const paramTypes = Reflect.getMetadata('design:paramtypes', instance.constructor.prototype, route.handlerName);
-        // Pre-resolve controller + method level components at build time
+        const paramTypes = Reflect.getMetadata('design:paramtypes', controller.prototype, route.handlerName);
+        // Collect controller + method level components at build time
         const methodGuards = ComponentManager.getComponents('guard', controller, route.handlerName);
         const methodPipes = ComponentManager.getComponents('pipe', controller, route.handlerName);
         const methodInterceptors = ComponentManager.getComponents('interceptor', controller, route.handlerName);
-        const methodFilters = ComponentManager.getComponents('filter', controller, route.handlerName);
-        const resolvedMethodGuards = ComponentManager.resolveGuards(methodGuards);
-        const resolvedMethodPipes = ComponentManager.resolvePipes(methodPipes);
-        const resolvedMethodInterceptors = ComponentManager.resolveInterceptors(methodInterceptors);
         // Filters: reverse order (handler → controller → global) — closest to handler runs first
-        const resolvedMethodFilters = ComponentManager.resolveFilters([
-            ...methodFilters
-        ].reverse());
+        const methodFilters = [
+            ...ComponentManager.getComponents('filter', controller, route.handlerName)
+        ].reverse();
         // Read response decorators at build time
         const httpCode = getHttpCode(controller, route.handlerName);
         const responseHeaders = getResponseHeaders(controller, route.handlerName);
         const redirect = getRedirect(controller, route.handlerName);
         return async (c)=>{
-            // Create a child container for request-scoped providers
-            const requestContainer = this.container.createChild();
-            c.set('container', requestContainer);
             // Combine global + method at request time (allows post-create registration)
+            const requestContainer = this.getRequestContainer(c);
             const guards = [
-                ...this.globalGuards,
-                ...resolvedMethodGuards
+                ...this.instantiateMany(this.globalGuards, requestContainer),
+                ...this.instantiateMany(methodGuards, requestContainer)
             ];
             const pipes = [
-                ...this.globalPipes,
-                ...resolvedMethodPipes
+                ...this.instantiateMany(this.globalPipes, requestContainer),
+                ...this.instantiateMany(methodPipes, requestContainer)
             ];
             const interceptors = [
-                ...this.globalInterceptors,
-                ...resolvedMethodInterceptors
+                ...this.instantiateMany(this.globalInterceptors, requestContainer),
+                ...this.instantiateMany(methodInterceptors, requestContainer)
             ];
             const filters = [
-                ...resolvedMethodFilters,
-                ...this.globalFilters
+                ...this.instantiateMany(methodFilters, requestContainer),
+                ...this.instantiateMany(this.globalFilters, requestContainer)
             ];
             const executionContext = this.createExecutionContext(c, controller, route);
             try {
+                const instance = requestContainer.resolve(controller);
                 // 1. Extract args + run pipes
-                const args = await this.extractArguments(c, paramMetadata, pipes, paramTypes);
+                const args = await this.extractArguments(c, paramMetadata, pipes, requestContainer, paramTypes);
                 // 2. Guards (fail-fast)
                 for (const guard of guards){
                     const canActivate = await guard.canActivate(executionContext);
@@ -247,7 +315,7 @@ export class RouteManager {
             }
         };
     }
-    async extractArguments(c, paramMetadata, pipes, paramTypes) {
+    async extractArguments(c, paramMetadata, pipes, requestContainer, paramTypes) {
         if (paramMetadata.length === 0) {
             return [
                 c
@@ -269,7 +337,7 @@ export class RouteManager {
             // Run param-level pipes
             if (param.pipes && param.pipes.length > 0) {
                 for (const paramPipe of param.pipes){
-                    const pipeInstance = this.instantiate(paramPipe);
+                    const pipeInstance = this.instantiate(paramPipe, requestContainer);
                     value = await pipeInstance.transform(value, metadata);
                 }
             }
@@ -300,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) {
@@ -367,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,12 +10,19 @@ export declare class ModuleLoader {
     private collectedControllers;
     private registeredProviders;
     private moduleExportsCache;
+    private globalExports;
+    private consumerMiddlewareDefinitions;
+    private appProviderCounter;
+    private appProviderTokens;
     constructor(container: Container, router: RouteManager);
     load(rootModule: Type): void;
     private processModule;
     private registerProvider;
+    private isAppToken;
     private buildExportSet;
     getControllers(): Type[];
     getRegisteredProviders(): Token[];
-    resolveAllInstances(): unknown[];
+    getAppProviderTokens(token: Token): Token[];
+    getConsumerMiddlewareDefinitions(): MiddlewareRouteDefinition[];
+    resolveAllInstances(): Promise<unknown[]>;
 }