@mxweb/core 1.0.0

package/dist/controller.d.ts

@@ -0,0 +1,238 @@
+import { ExecuteContext } from "./execute";
+import { ClassContructor } from "./common";
+/**
+ * Type registry interface for InjectionRegistry.
+ * Services can augment this interface to provide type-safe injection by name.
+ *
+ * @remarks
+ * When using string-based injection (legacy pattern), augment this interface
+ * to get proper typing for injected properties.
+ *
+ * @example
+ * ```ts
+ * // In your service file
+ * declare module "@mxweb/core" {
+ *   interface InjectionTypeRegistry {
+ *     userService: UserService;
+ *     productService: ProductService;
+ *   }
+ * }
+ * ```
+ */
+export interface InjectionTypeRegistry {
+}
+/**
+ * Type for controller injection map configuration.
+ * Can be a static object mapping property names to service classes,
+ * or an async function that resolves the map with access to global injects.
+ *
+ * @template T - Record type mapping property names to class constructors
+ *
+ * @example
+ * ```ts
+ * // Static object
+ * const map: ControllerInjectMap<{ userService: typeof UserService }> = {
+ *   userService: UserService,
+ * };
+ *
+ * // Async function with access to global injects
+ * const map: ControllerInjectMap<{ userService: typeof UserService }> = async (injects) => {
+ *   const db = injects.get("db");
+ *   return { userService: UserService };
+ * };
+ * ```
+ */
+type ControllerInjectMap<T extends Record<string, ClassContructor<any>>> = T | ((injects: Map<string, unknown>) => T | Promise<T>);
+/**
+ * Utility type that builds property types from an array of injection names.
+ * Uses InjectionTypeRegistry for type lookup.
+ *
+ * @template Names - Readonly array of injection name strings
+ * @internal
+ */
+type InjectPropertiesByName<Names extends readonly string[]> = {
+    readonly [K in Names[number]]: K extends keyof InjectionTypeRegistry ? InjectionTypeRegistry[K] : unknown;
+};
+/**
+ * Utility type that builds property types from a class constructor map.
+ * Maps each property to the instance type of its corresponding class.
+ *
+ * @template T - Record type mapping property names to class constructors
+ * @internal
+ */
+type InjectPropertiesByClass<T extends Record<string, ClassContructor<any>>> = {
+    readonly [K in keyof T]: InstanceType<T[K]>;
+};
+/**
+ * Base Controller class providing dependency injection and request context access.
+ *
+ * This class serves as the foundation for all controllers in the framework.
+ * It provides:
+ * - Automatic dependency injection via static `injects` or `injectMap`
+ * - Access to the current request context via `this.context`
+ * - Lazy initialization of async dependencies
+ *
+ * @remarks
+ * Do not instantiate this class directly. Use the {@link controller} helper
+ * function to create a typed controller base class with injections.
+ *
+ * @example
+ * ```ts
+ * // Using controller() helper (recommended)
+ * const MyController = controller({
+ *   userService: UserService,
+ *   productService: ProductService,
+ * });
+ *
+ * export class ProductController extends MyController {
+ *   async findAll() {
+ *     // Access injected services
+ *     const products = await this.productService.findAll();
+ *
+ *     // Access request context
+ *     const query = this.context.switchHttp().query();
+ *
+ *     return products;
+ *   }
+ * }
+ * ```
+ */
+declare class BaseController {
+    /** Flag indicating if async dependencies have been initialized */
+    private _initialized;
+    /**
+     * Creates a new controller instance.
+     * Automatically injects dependencies defined in static `injects` array.
+     */
+    constructor();
+    /**
+     * Provides access to the current request's ExecuteContext.
+     * Use this to access request data, response helpers, and other context utilities.
+     *
+     * @returns The ExecuteContext singleton with current request scope
+     *
+     * @example
+     * ```ts
+     * async findById() {
+     *   const { id } = this.context.switchHttp().params();
+     *   const body = await this.context.switchHttp().json();
+     *   const headers = this.context.switchHttp().headers();
+     *   return this.service.findById(id);
+     * }
+     * ```
+     */
+    protected get context(): ExecuteContext;
+    /**
+     * Initializes async dependencies defined in static `injectMap`.
+     * This method is called automatically by the framework before handler execution.
+     *
+     * @remarks
+     * - Only runs once per controller instance
+     * - Resolves async inject map functions with access to global injects
+     * - Caches resolved maps for subsequent requests
+     *
+     * @internal
+     */
+    _initDependencies(): Promise<void>;
+    /**
+     * Injects dependencies by looking up names in the InjectionRegistry.
+     * Used for legacy string-based injection pattern.
+     *
+     * @param names - Array of injection names to look up and inject
+     * @internal
+     */
+    private injectDependenciesByName;
+    /**
+     * Injects dependencies from a property-name-to-class map.
+     * Creates singleton instances for each service class.
+     *
+     * @param map - Object mapping property names to service class constructors
+     * @internal
+     */
+    private injectDependenciesByMap;
+}
+/**
+ * Factory function to create a typed Controller base class with dependency injection.
+ *
+ * This is the recommended way to create controllers with injected services.
+ * It provides full TypeScript support for injected properties.
+ *
+ * @overload
+ * Creates a controller base class with object map injection (recommended).
+ *
+ * @template T - Record type mapping property names to service class constructors
+ * @param map - Object mapping property names to service classes, or async resolver function
+ * @returns A controller class constructor with typed injected properties
+ *
+ * @example
+ * ```ts
+ * // Static object map
+ * const ProductControllerBase = controller({
+ *   productService: ProductService,
+ *   categoryService: CategoryService,
+ * });
+ *
+ * export class ProductController extends ProductControllerBase {
+ *   async findAll() {
+ *     // this.productService is typed as ProductService
+ *     return this.productService.findAll();
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Async function with access to global injects
+ * const ProductControllerBase = controller(async (injects) => {
+ *   const db = injects.get("db") as DatabaseConnection;
+ *   console.log("DB type:", db.type);
+ *
+ *   return {
+ *     productService: ProductService,
+ *   };
+ * });
+ * ```
+ */
+export declare function controller<T extends Record<string, ClassContructor<any>>>(map: ControllerInjectMap<T>): new () => BaseController & InjectPropertiesByClass<T>;
+/**
+ * @overload
+ * Creates a controller base class with string array injection (legacy pattern).
+ *
+ * @template T - Readonly array of injection name strings
+ * @param injects - Array of injection names from InjectionRegistry
+ * @returns A controller class constructor with typed injected properties
+ *
+ * @example
+ * ```ts
+ * // Legacy pattern using InjectionRegistry
+ * const MyController = controller(["userService", "productService"] as const);
+ *
+ * export class ProductController extends MyController {
+ *   async findAll() {
+ *     return this.productService.findAll();
+ *   }
+ * }
+ * ```
+ */
+export declare function controller<const T extends readonly string[]>(injects: T): new () => BaseController & InjectPropertiesByName<T>;
+/**
+ * Base Controller class without any injections.
+ * Use this when you don't need dependency injection.
+ *
+ * @example
+ * ```ts
+ * export class SimpleController extends Controller {
+ *   async healthCheck() {
+ *     return { status: "ok" };
+ *   }
+ * }
+ * ```
+ */
+export declare const Controller: typeof BaseController;
+/**
+ * Type alias for a controller class constructor.
+ *
+ * @template T - The controller instance type (must extend BaseController)
+ */
+export type ControllerConstructor<T extends BaseController> = new () => T;
+export {};

package/dist/controller.js

@@ -0,0 +1 @@
+"use strict";var t=require("./context.js"),e=require("./common.js");const n=new WeakMap,i=new WeakMap;class s{constructor(){this._initialized=!1;const t=this.constructor.injects||[];this.injectDependenciesByName(t)}get context(){return t.executeContext}async _initDependencies(){if(this._initialized)return;const e=this.constructor.injectMap;if(!e)return void(this._initialized=!0);let n;i.has(this.constructor)?n=i.get(this.constructor):(n="function"==typeof e?await e(t.executeContext.injections):e,i.set(this.constructor,n)),this.injectDependenciesByMap(n),this._initialized=!0}injectDependenciesByName(t){for(const n of t){const t=e.InjectionRegistry.get(n);if(t){const e=t.singleton();e&&(this[n]=e)}}}injectDependenciesByMap(t){for(const[e,i]of Object.entries(t))if(n.has(i))this[e]=n.get(i);else if("singleton"in i&&"function"==typeof i.singleton){const t=i.singleton();n.set(i,t),this[e]=t}else{const t=new i;n.set(i,t),this[e]=t}}}const c=s;exports.Controller=c,exports.controller=function(t){if(Array.isArray(t)&&(0===t.length||"string"==typeof t[0])){const e=t;class n extends s{}return n.injects=e,n}const e=t;class n extends s{}return n.injectMap=e,n};

package/dist/controller.mjs

@@ -0,0 +1 @@
+import{executeContext as t}from"./context.mjs";import{InjectionRegistry as e}from"./common.mjs";const n=new WeakMap,i=new WeakMap;class s{constructor(){this._initialized=!1;const t=this.constructor.injects||[];this.injectDependenciesByName(t)}get context(){return t}async _initDependencies(){if(this._initialized)return;const e=this.constructor.injectMap;if(!e)return void(this._initialized=!0);let n;i.has(this.constructor)?n=i.get(this.constructor):(n="function"==typeof e?await e(t.injections):e,i.set(this.constructor,n)),this.injectDependenciesByMap(n),this._initialized=!0}injectDependenciesByName(t){for(const n of t){const t=e.get(n);if(t){const e=t.singleton();e&&(this[n]=e)}}}injectDependenciesByMap(t){for(const[e,i]of Object.entries(t))if(n.has(i))this[e]=n.get(i);else if("singleton"in i&&"function"==typeof i.singleton){const t=i.singleton();n.set(i,t),this[e]=t}else{const t=new i;n.set(i,t),this[e]=t}}}function c(t){if(Array.isArray(t)&&(0===t.length||"string"==typeof t[0])){const e=t;class n extends s{}return n.injects=e,n}const e=t;class n extends s{}return n.injectMap=e,n}const o=s;export{o as Controller,c as controller};

package/dist/decorator.d.ts

@@ -0,0 +1,349 @@
+/**
+ * @fileoverview Decorator utilities and context extractors for route handling.
+ *
+ * This module provides:
+ * - Route-level decorators for guards, filters, interceptors, pipes, and metadata
+ * - Context extractors for accessing request data (body, query, params, headers)
+ * - Custom decorator creation utilities
+ *
+ * @module decorator
+ */
+import { ExecuteContext, Filter, Guard, Interceptor } from "./execute";
+import { FeatureInject, Pipe } from "./common";
+/**
+ * Result object from decorator functions.
+ * Contains sets of guards, filters, interceptors, pipes, and metadata
+ * that will be applied to a route.
+ *
+ * @example
+ * ```ts
+ * const result: DecoratorResult = UseGuards(AuthGuard);
+ * // result.guards contains AuthGuard
+ * ```
+ */
+export interface DecoratorResult {
+    /** Set of guard classes to apply */
+    guards: Set<Guard>;
+    /** Set of exception filter classes to apply */
+    filters: Set<Filter>;
+    /** Set of interceptor classes to apply */
+    interceptors: Set<Interceptor>;
+    /** Set of pipe classes to apply */
+    pipes: Set<Pipe>;
+    /** Map of metadata key-value pairs */
+    metadata: Map<string, unknown>;
+}
+/**
+ * Sets custom metadata on a route.
+ * Metadata can be retrieved in guards, interceptors, or handlers via `Metadata()`.
+ *
+ * @param key - The metadata key
+ * @param value - The metadata value
+ * @returns DecoratorResult containing the metadata
+ *
+ * @example
+ * ```ts
+ * // In route definition
+ * Route.get("/admin", "dashboard", SetMetadata("roles", ["admin"]))
+ *
+ * // In guard
+ * const roles = Metadata<string[]>("roles"); // ["admin"]
+ * ```
+ */
+export declare function SetMetadata(key: string, value: unknown): DecoratorResult;
+/**
+ * Applies guard classes to a route.
+ * Guards determine if a request should be processed by the handler.
+ *
+ * @param guards - Guard classes to apply (executed in order)
+ * @returns DecoratorResult containing the guards
+ *
+ * @example
+ * ```ts
+ * Route.post("/products", "create", UseGuards(AuthGuard, RolesGuard))
+ * ```
+ */
+export declare function UseGuards(...guards: Guard[]): DecoratorResult;
+/**
+ * Applies exception filter classes to a route.
+ * Filters handle exceptions thrown during request processing.
+ *
+ * @param filters - Exception filter classes to apply
+ * @returns DecoratorResult containing the filters
+ *
+ * @example
+ * ```ts
+ * Route.get("/products", "findAll", UseFilters(HttpExceptionFilter))
+ * ```
+ */
+export declare function UseFilters(...filters: Filter[]): DecoratorResult;
+/**
+ * Applies interceptor classes to a route.
+ * Interceptors can transform the request/response or add extra logic.
+ *
+ * @param interceptors - Interceptor classes to apply
+ * @returns DecoratorResult containing the interceptors
+ *
+ * @example
+ * ```ts
+ * Route.get("/products", "findAll", UseInterceptors(LoggingInterceptor, CacheInterceptor))
+ * ```
+ */
+export declare function UseInterceptors(...interceptors: Interceptor[]): DecoratorResult;
+/**
+ * Applies pipe classes to a route.
+ * Pipes transform input data before it reaches the handler.
+ *
+ * @param pipes - Pipe classes to apply
+ * @returns DecoratorResult containing the pipes
+ *
+ * @example
+ * ```ts
+ * Route.post("/products", "create", UsePipes(ValidationPipe))
+ * ```
+ */
+export declare function UsePipes(...pipes: Pipe[]): DecoratorResult;
+/**
+ * Combines multiple decorator results into a single result.
+ * Use this to apply multiple decorators to a single route.
+ *
+ * @param results - Array of DecoratorResult objects to combine
+ * @returns Combined DecoratorResult with all guards, filters, interceptors, pipes, and metadata
+ *
+ * @example
+ * ```ts
+ * const AdminRoute = applyDecorators(
+ *   SetMetadata("roles", ["admin"]),
+ *   UseGuards(AuthGuard, RolesGuard),
+ *   UseInterceptors(LoggingInterceptor)
+ * );
+ *
+ * Route.get("/admin/dashboard", "dashboard", AdminRoute)
+ * ```
+ */
+export declare function applyDecorators(...results: DecoratorResult[]): DecoratorResult;
+/**
+ * Extracts and parses the JSON body from the request.
+ *
+ * @template T - Expected type of the parsed body
+ * @returns Promise resolving to the parsed JSON body
+ *
+ * @example
+ * ```ts
+ * async create() {
+ *   const body = await Body<CreateProductDto>();
+ *   return this.productService.create(body);
+ * }
+ * ```
+ */
+export declare function Body<T = unknown>(): Promise<T>;
+/**
+ * Extracts all query parameters from the request URL.
+ *
+ * @template T - Expected type of the query object
+ * @returns Object containing all query parameters
+ *
+ * @example
+ * ```ts
+ * findAll() {
+ *   const query = Query<{ page?: string; limit?: string }>();
+ *   const page = parseInt(query.page ?? "1");
+ *   return this.productService.findAll({ page });
+ * }
+ * ```
+ */
+export declare function Query<T extends Record<string, string> = Record<string, string>>(): T;
+/**
+ * Extracts all route parameters from the matched route.
+ *
+ * @template T - Expected type of the params object
+ * @returns Object containing all route parameters
+ *
+ * @example
+ * ```ts
+ * // Route: /products/:category/:id
+ * findOne() {
+ *   const params = Params<{ category: string; id: string }>();
+ *   return this.productService.findOne(params.category, params.id);
+ * }
+ * ```
+ */
+export declare function Params<T extends Record<string, string> = Record<string, string>>(): T;
+/**
+ * Extracts all headers from the request.
+ *
+ * @template T - Expected type of the headers object
+ * @returns Object containing all request headers (lowercase keys)
+ *
+ * @example
+ * ```ts
+ * findAll() {
+ *   const headers = Headers();
+ *   const authToken = headers["authorization"];
+ *   const contentType = headers["content-type"];
+ * }
+ * ```
+ */
+export declare function Headers<T extends Record<string, string> = Record<string, string>>(): T;
+/**
+ * Extracts a single route parameter by key.
+ *
+ * @param key - The parameter key to extract
+ * @returns The parameter value or undefined if not found
+ *
+ * @example
+ * ```ts
+ * // Route: /products/:id
+ * findById() {
+ *   const id = Param("id");
+ *   return this.productService.findById(id!);
+ * }
+ * ```
+ */
+export declare function Param(key: string): string | undefined;
+/**
+ * Extracts a single header by key.
+ *
+ * @param key - The header key to extract (case-insensitive)
+ * @returns The header value or undefined if not found
+ *
+ * @example
+ * ```ts
+ * findAll() {
+ *   const token = Header("Authorization");
+ *   const userAgent = Header("User-Agent");
+ * }
+ * ```
+ */
+export declare function Header(key: string): string | undefined;
+/**
+ * Extracts a single query parameter by key.
+ *
+ * @param key - The query parameter key to extract
+ * @returns The query parameter value or undefined if not found
+ *
+ * @example
+ * ```ts
+ * findAll() {
+ *   const page = QueryParam("page") ?? "1";
+ *   const limit = QueryParam("limit") ?? "10";
+ * }
+ * ```
+ */
+export declare function QueryParam(key: string): string | undefined;
+/**
+ * Extracts the raw Request object.
+ *
+ * @returns The underlying Request object (NextRequest)
+ *
+ * @example
+ * ```ts
+ * findAll() {
+ *   const request = Request();
+ *   const url = request.url;
+ *   const method = request.method;
+ * }
+ * ```
+ */
+export declare function Request(): globalThis.Request;
+/**
+ * Extracts and parses FormData from the request body.
+ *
+ * @returns Promise resolving to the FormData object
+ *
+ * @example
+ * ```ts
+ * async upload() {
+ *   const formData = await FormData();
+ *   const file = formData.get("file");
+ *   const name = formData.get("name");
+ * }
+ * ```
+ */
+export declare function FormData(): Promise<globalThis.FormData>;
+/**
+ * Extracts the raw text body from the request.
+ *
+ * @returns Promise resolving to the text body
+ *
+ * @example
+ * ```ts
+ * async webhook() {
+ *   const rawBody = await Text();
+ *   const signature = Header("x-signature");
+ *   // Verify webhook signature with raw body
+ * }
+ * ```
+ */
+export declare function Text(): Promise<string>;
+/**
+ * Retrieves a feature-local inject by name.
+ *
+ * @template T - Expected type of the inject (must extend FeatureInject)
+ * @param name - The name of the inject to retrieve
+ * @returns The inject instance or undefined if not found
+ *
+ * @example
+ * ```ts
+ * findAll() {
+ *   const repository = Inject<ProductRepository>("productRepository");
+ *   return repository?.findAll();
+ * }
+ * ```
+ */
+export declare function Inject<T extends FeatureInject = FeatureInject>(name: string): T | undefined;
+/**
+ * Retrieves route metadata by key.
+ * Use with `SetMetadata()` to pass data to handlers/guards.
+ *
+ * @template T - Expected type of the metadata value
+ * @param key - The metadata key to retrieve
+ * @returns The metadata value or undefined if not found
+ *
+ * @example
+ * ```ts
+ * // Route definition
+ * Route.get("/admin", "dashboard", SetMetadata("roles", ["admin"]))
+ *
+ * // In handler or guard
+ * const roles = Metadata<string[]>("roles"); // ["admin"]
+ * ```
+ */
+export declare function Metadata<T = unknown>(key: string): T | undefined;
+/**
+ * Type for custom decorator creator functions.
+ *
+ * @template Result - The return type of the decorator
+ * @template Data - Tuple type of arguments passed to the decorator
+ */
+export type DecoratorCreator<Result, Data extends any[] = []> = (context: ExecuteContext, data: Data) => Result | Promise<Result>;
+/**
+ * Factory function to create custom context extractors/decorators.
+ *
+ * @template Result - The return type of the custom decorator
+ * @template Data - Tuple type of arguments the decorator accepts
+ * @param callback - Function that receives ExecuteContext and arguments, returns result
+ * @returns A function that can be called with arguments to extract/compute data
+ *
+ * @example
+ * ```ts
+ * // Create a custom decorator to get current user
+ * const CurrentUser = createDecorator<User | null>((context) => {
+ *   const token = context.switchHttp().headers()["authorization"];
+ *   return token ? parseToken(token) : null;
+ * });
+ *
+ * // Create a decorator with arguments
+ * const HasRole = createDecorator<boolean, [string]>((context, [role]) => {
+ *   const user = getCurrentUser(context);
+ *   return user?.roles.includes(role) ?? false;
+ * });
+ *
+ * // Usage in handler
+ * async dashboard() {
+ *   const user = CurrentUser();
+ *   const isAdmin = HasRole("admin");
+ * }
+ * ```
+ */
+export declare function createDecorator<Result, Data extends any[] = []>(callback: DecoratorCreator<Result, Data>): (...args: Data) => Result | Promise<Result>;

package/dist/decorator.js

@@ -0,0 +1 @@
+"use strict";var e=require("./context.js");exports.Body=function(){return e.executeContext.switchHttp().json()},exports.FormData=function(){return e.executeContext.switchHttp().formData()},exports.Header=function(t){return e.executeContext.switchHttp().headers()[t.toLowerCase()]},exports.Headers=function(){return e.executeContext.switchHttp().headers()},exports.Inject=function(t){return e.executeContext.getLocalInject(t)},exports.Metadata=function(t){return e.executeContext.getMetadata(t)},exports.Param=function(t){return e.executeContext.switchHttp().params()[t]},exports.Params=function(){return e.executeContext.switchHttp().params()},exports.Query=function(){return e.executeContext.switchHttp().query()},exports.QueryParam=function(t){return e.executeContext.switchHttp().query()[t]},exports.Request=function(){return e.executeContext.switchHttp().getRequest()},exports.SetMetadata=function(e,t){return{guards:new Set,filters:new Set,interceptors:new Set,pipes:new Set,metadata:new Map([[e,t]])}},exports.Text=function(){return e.executeContext.switchHttp().text()},exports.UseFilters=function(...e){return{guards:new Set,filters:new Set(e),interceptors:new Set,pipes:new Set,metadata:new Map}},exports.UseGuards=function(...e){return{guards:new Set(e),filters:new Set,interceptors:new Set,pipes:new Set,metadata:new Map}},exports.UseInterceptors=function(...e){return{guards:new Set,filters:new Set,interceptors:new Set(e),pipes:new Set,metadata:new Map}},exports.UsePipes=function(...e){return{guards:new Set,filters:new Set,interceptors:new Set,pipes:new Set(e),metadata:new Map}},exports.applyDecorators=function(...e){const t=new Set,r=new Set,n=new Set,s=new Set,a=new Map;return e.forEach(e=>{e.guards.forEach(e=>t.add(e)),e.filters.forEach(e=>r.add(e)),e.interceptors.forEach(e=>n.add(e)),e.pipes.forEach(e=>s.add(e)),e.metadata.forEach((e,t)=>a.set(t,e))}),{guards:t,filters:r,interceptors:n,pipes:s,metadata:a}},exports.createDecorator=function(t){return(...r)=>t(e.executeContext,r)};

package/dist/decorator.mjs

@@ -0,0 +1 @@
+import{executeContext as t}from"./context.mjs";function e(t,e){return{guards:new Set,filters:new Set,interceptors:new Set,pipes:new Set,metadata:new Map([[t,e]])}}function n(...t){return{guards:new Set(t),filters:new Set,interceptors:new Set,pipes:new Set,metadata:new Map}}function r(...t){return{guards:new Set,filters:new Set(t),interceptors:new Set,pipes:new Set,metadata:new Map}}function a(...t){return{guards:new Set,filters:new Set,interceptors:new Set(t),pipes:new Set,metadata:new Map}}function i(...t){return{guards:new Set,filters:new Set,interceptors:new Set,pipes:new Set(t),metadata:new Map}}function s(...t){const e=new Set,n=new Set,r=new Set,a=new Set,i=new Map;return t.forEach(t=>{t.guards.forEach(t=>e.add(t)),t.filters.forEach(t=>n.add(t)),t.interceptors.forEach(t=>r.add(t)),t.pipes.forEach(t=>a.add(t)),t.metadata.forEach((t,e)=>i.set(e,t))}),{guards:e,filters:n,interceptors:r,pipes:a,metadata:i}}function u(){return t.switchHttp().json()}function c(){return t.switchHttp().query()}function o(){return t.switchHttp().params()}function p(){return t.switchHttp().headers()}function w(e){return t.switchHttp().params()[e]}function f(e){return t.switchHttp().headers()[e.toLowerCase()]}function d(e){return t.switchHttp().query()[e]}function S(){return t.switchHttp().getRequest()}function h(){return t.switchHttp().formData()}function m(){return t.switchHttp().text()}function g(e){return t.getLocalInject(e)}function H(e){return t.getMetadata(e)}function l(e){return(...n)=>e(t,n)}export{u as Body,h as FormData,f as Header,p as Headers,g as Inject,H as Metadata,w as Param,o as Params,c as Query,d as QueryParam,S as Request,e as SetMetadata,m as Text,r as UseFilters,n as UseGuards,a as UseInterceptors,i as UsePipes,s as applyDecorators,l as createDecorator};