@velajs/vela 0.4.3 → 0.5.1

package/dist/http/decorators.d.ts

@@ -38,12 +38,60 @@ export declare const Patch: (path?: string) => MethodDecorator;
 export declare const Delete: (path?: string) => MethodDecorator;
 export declare const Options: (path?: string) => MethodDecorator;
 export declare const Head: (path?: string) => MethodDecorator;
+export declare const All: (path?: string) => MethodDecorator;
 export declare const Sse: (path?: string) => MethodDecorator;
 export declare const Param: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
 export declare const Query: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
 export declare const Body: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
 export declare const Headers: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
 export declare const Req: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
+/**
+ * Injects the Hono `Context` as the response handle.
+ * In Hono, request and response state are unified in the `Context` object,
+ * so `@Res()` and `@Req()` both return it.
+ *
+ * Use `c.header()`, `c.setCookie()`, `c.redirect()`, etc. for response control.
+ *
+ * @example
+ * ```ts
+ * @Get('/set-cookie')
+ * handle(@Res() c: Context) {
+ *   c.setCookie('session', 'abc123', { httpOnly: true });
+ *   return { ok: true };
+ * }
+ * ```
+ */
+export declare const Res: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
+export declare const Ip: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
+export declare const Cookie: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
+/**
+ * Injects all cookies as a `Record<string, string>`, or a single cookie value by name.
+ *
+ * - `@Cookie()` — all cookies as an object
+ * - `@Cookie('token')` — the value of the `token` cookie
+ *
+ * @example
+ * ```ts
+ * @Get('/me')
+ * handle(@Cookie('session') session: string) { ... }
+ * ```
+ */
+export declare const Cookies: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
+/**
+ * Injects the raw request body as a `Uint8Array`.
+ * Useful for webhook HMAC verification (Stripe, GitHub, etc.) where you
+ * need the raw bytes before any JSON parsing.
+ *
+ * @example
+ * ```ts
+ * @Post('/webhook')
+ * async handle(@RawBody() body: Uint8Array) {
+ *   const sig = new TextDecoder().decode(body);
+ *   // verify HMAC...
+ * }
+ * ```
+ */
+export declare function RawBody(): ParameterDecorator;
 /**
  * Factory for creating custom parameter decorators.
  *
@@ -120,4 +168,21 @@ export declare function getRedirect(target: Constructor, method: string | symbol
     url: string;
     statusCode: number;
 } | undefined;
+/**
+ * Composes multiple decorators into one. Applies them in order (top to bottom),
+ * matching how stacked decorators behave when written separately.
+ *
+ * @example
+ * ```ts
+ * const Auth = (...roles: string[]) => applyDecorators(
+ *   UseGuards(JwtGuard, RolesGuard),
+ *   SetMetadata('roles', roles),
+ * );
+ *
+ * @Auth('admin')
+ * @Get('/admin')
+ * handle() { ... }
+ * ```
+ */
+export declare function applyDecorators(...decorators: Array<ClassDecorator | MethodDecorator | PropertyDecorator | ParameterDecorator>): ClassDecorator & MethodDecorator & PropertyDecorator;
 export declare function isController(target: Constructor): boolean;

package/dist/http/decorators.js

@@ -22,7 +22,7 @@ function normalizePath(path) {
         if (typeof prefixOrOptions === 'string') {
             prefix = prefixOrOptions;
         } else if (prefixOrOptions) {
-            prefix = prefixOrOptions.prefix ?? '';
+            prefix = prefixOrOptions.path ?? prefixOrOptions.prefix ?? '';
             version = prefixOrOptions.version;
         } else {
             prefix = '';
@@ -96,6 +96,7 @@ export const Patch = createMethodDecorator(HttpMethod.PATCH);
 export const Delete = createMethodDecorator(HttpMethod.DELETE);
 export const Options = createMethodDecorator(HttpMethod.OPTIONS);
 export const Head = createMethodDecorator(HttpMethod.HEAD);
+export const All = createMethodDecorator(HttpMethod.ALL);
 export const Sse = createMethodDecorator(HttpMethod.GET);
 // Parameter decorators
 const CUSTOM_PARAM_TYPE = 'custom';
@@ -136,6 +137,60 @@ export const Query = createBuiltinParamDecorator(ParamType.QUERY);
 export const Body = createBuiltinParamDecorator(ParamType.BODY);
 export const Headers = createBuiltinParamDecorator(ParamType.HEADERS);
 export const Req = createBuiltinParamDecorator(ParamType.REQUEST);
+/**
+ * Injects the Hono `Context` as the response handle.
+ * In Hono, request and response state are unified in the `Context` object,
+ * so `@Res()` and `@Req()` both return it.
+ *
+ * Use `c.header()`, `c.setCookie()`, `c.redirect()`, etc. for response control.
+ *
+ * @example
+ * ```ts
+ * @Get('/set-cookie')
+ * handle(@Res() c: Context) {
+ *   c.setCookie('session', 'abc123', { httpOnly: true });
+ *   return { ok: true };
+ * }
+ * ```
+ */ export const Res = createBuiltinParamDecorator(ParamType.RESPONSE);
+export const Ip = createBuiltinParamDecorator(ParamType.IP);
+export const Cookie = createBuiltinParamDecorator(ParamType.COOKIE);
+/**
+ * Injects all cookies as a `Record<string, string>`, or a single cookie value by name.
+ *
+ * - `@Cookie()` — all cookies as an object
+ * - `@Cookie('token')` — the value of the `token` cookie
+ *
+ * @example
+ * ```ts
+ * @Get('/me')
+ * handle(@Cookie('session') session: string) { ... }
+ * ```
+ */ export const Cookies = Cookie;
+/**
+ * Injects the raw request body as a `Uint8Array`.
+ * Useful for webhook HMAC verification (Stripe, GitHub, etc.) where you
+ * need the raw bytes before any JSON parsing.
+ *
+ * @example
+ * ```ts
+ * @Post('/webhook')
+ * async handle(@RawBody() body: Uint8Array) {
+ *   const sig = new TextDecoder().decode(body);
+ *   // verify HMAC...
+ * }
+ * ```
+ */ export function RawBody() {
+    return (target, propertyKey, parameterIndex)=>{
+        if (propertyKey === undefined) {
+            throw new Error('Parameter decorators can only be used on method parameters');
+        }
+        MetadataRegistry.addParameter(target.constructor, propertyKey, {
+            index: parameterIndex,
+            type: ParamType.RAW_BODY
+        });
+    };
+}
 /**
  * Factory for creating custom parameter decorators.
  *
@@ -175,10 +230,15 @@ export const Req = createBuiltinParamDecorator(ParamType.REQUEST);
                 factory: (_unused, ctx)=>{
                     const honoCtx = ctx;
                     const execCtx = {
+                        getType: ()=>'http',
                         getClass: ()=>target.constructor,
                         getHandler: ()=>propertyKey,
                         getContext: ()=>honoCtx,
-                        getRequest: ()=>honoCtx.req.raw
+                        getRequest: ()=>honoCtx.req.raw,
+                        switchToHttp: ()=>({
+                                getRequest: ()=>honoCtx.req.raw,
+                                getResponse: ()=>honoCtx
+                            })
                     };
                     return factory(data, execCtx);
                 },
@@ -271,6 +331,35 @@ export function getRedirect(target, method) {
     if (meta?.redirect) return meta.redirect;
     return getMetadata(METADATA_KEYS.REDIRECT, target, method);
 }
+/**
+ * Composes multiple decorators into one. Applies them in order (top to bottom),
+ * matching how stacked decorators behave when written separately.
+ *
+ * @example
+ * ```ts
+ * const Auth = (...roles: string[]) => applyDecorators(
+ *   UseGuards(JwtGuard, RolesGuard),
+ *   SetMetadata('roles', roles),
+ * );
+ *
+ * @Auth('admin')
+ * @Get('/admin')
+ * handle() { ... }
+ * ```
+ */ export function applyDecorators(...decorators) {
+    const composed = (target, propertyKey, descriptor)=>{
+        for (const decorator of decorators){
+            if (propertyKey === undefined && typeof descriptor !== 'number') {
+                decorator(target);
+            } else if (typeof descriptor === 'number') {
+                decorator(target, propertyKey, descriptor);
+            } else {
+                decorator(target, propertyKey, descriptor);
+            }
+        }
+    };
+    return composed;
+}
 // Helpers
 export function isController(target) {
     return MetadataRegistry.getControllerPath(target) !== '' || MetadataRegistry.getRoutes(target).length > 0;

package/dist/http/index.d.ts

@@ -1,3 +1,5 @@
 export { RouteManager } from './route.manager';
-export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Sse, Param, Query, Body, Headers, Req, HttpCode, Header, Redirect, createParamDecorator, isController, } from './decorators';
+export { MiddlewareBuilder, RequestMethod } from './middleware-consumer';
+export type { MiddlewareConsumer, MiddlewareConfigProxy, RouteInfo, NestModule, MiddlewareRouteDefinition } from './middleware-consumer';
+export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, All, Sse, Param, Query, Body, Headers, Req, Res, Ip, Cookie, Cookies, RawBody, HttpCode, Header, Redirect, createParamDecorator, applyDecorators, isController, } from './decorators';
 export type { RouteMetadata, ControllerMetadata, ControllerOptions, ParamMetadata, ControllerRegistration, } from './types';

package/dist/http/index.js

@@ -1,2 +1,3 @@
 export { RouteManager } from "./route.manager.js";
-export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Sse, Param, Query, Body, Headers, Req, HttpCode, Header, Redirect, createParamDecorator, isController } from "./decorators.js";
+export { MiddlewareBuilder, RequestMethod } from "./middleware-consumer.js";
+export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, All, Sse, Param, Query, Body, Headers, Req, Res, Ip, Cookie, Cookies, RawBody, HttpCode, Header, Redirect, createParamDecorator, applyDecorators, isController } from "./decorators.js";

package/dist/http/middleware-consumer.d.ts

@@ -0,0 +1,36 @@
+import type { NestMiddleware } from '../pipeline/types';
+import type { Type } from '../registry/types';
+export declare enum RequestMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    DELETE = "DELETE",
+    PATCH = "PATCH",
+    OPTIONS = "OPTIONS",
+    HEAD = "HEAD",
+    ALL = "ALL"
+}
+export interface RouteInfo {
+    path: string;
+    method?: RequestMethod;
+}
+export interface MiddlewareRouteDefinition {
+    middleware: Array<Type<NestMiddleware> | NestMiddleware>;
+    routes: RouteInfo[];
+    excludes: RouteInfo[];
+}
+export interface MiddlewareConfigProxy {
+    exclude(...routes: Array<string | RouteInfo>): MiddlewareConfigProxy;
+    forRoutes(...routes: Array<string | Function | RouteInfo>): MiddlewareConsumer;
+}
+export interface MiddlewareConsumer {
+    apply(...middleware: Array<Type<NestMiddleware> | NestMiddleware>): MiddlewareConfigProxy;
+}
+export interface NestModule {
+    configure(consumer: MiddlewareConsumer): void;
+}
+export declare class MiddlewareBuilder implements MiddlewareConsumer {
+    private definitions;
+    apply(...middleware: Array<Type<NestMiddleware> | NestMiddleware>): MiddlewareConfigProxy;
+    getDefinitions(): MiddlewareRouteDefinition[];
+}

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,7 @@
 import { Hono } from 'hono';
 import type { Container } from '../container/container';
 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';
@@ -13,7 +14,9 @@ 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;
@@ -38,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,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) {
@@ -310,10 +352,17 @@ export class RouteManager {
             case ParamType.QUERY:
                 return param.name ? c.req.query(param.name) : c.req.query();
             case ParamType.BODY:
-                try {
-                    return await c.req.json();
-                } catch  {
-                    return undefined;
+                {
+                    let body;
+                    try {
+                        body = await c.req.json();
+                    } catch  {
+                        return undefined;
+                    }
+                    if (param.name && body !== null && typeof body === 'object') {
+                        return body[param.name];
+                    }
+                    return body;
                 }
             case ParamType.HEADERS:
                 if (param.name) {
@@ -326,6 +375,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) {
@@ -368,7 +439,11 @@ export class RouteManager {
                 app.options(normalizedPath, handler);
                 break;
             case HttpMethod.HEAD:
-                app.on('HEAD', normalizedPath, handler);
+                // Hono converts HEAD to GET internally, so register as GET
+                app.get(normalizedPath, handler);
+                break;
+            case HttpMethod.ALL:
+                app.all(normalizedPath, handler);
                 break;
             default:
                 app.on(method.toUpperCase(), normalizedPath, handler);
@@ -393,6 +468,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/http/types.d.ts

@@ -9,6 +9,7 @@ export interface RouteMetadata {
 }
 export interface ControllerOptions {
     prefix?: string;
+    path?: string;
     version?: number | number[];
 }
 export interface ControllerMetadata {

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, All, 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, All, 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;