@dangao/bun-server 1.1.4 → 1.3.0

package/dist/index.js

@@ -774,6 +774,164 @@ class BunServer {
   }
 }
 
+// src/core/context-service.ts
+import { AsyncLocalStorage } from "async_hooks";
+
+// src/di/decorators.ts
+import"reflect-metadata";
+import { LoggerManager as LoggerManager2 } from "@dangao/logsmith";
+var DEPENDENCY_METADATA_KEY = Symbol("dependency:metadata");
+var INJECTABLE_METADATA_KEY = Symbol("injectable");
+var typeReferenceMap = new WeakMap;
+function Injectable(config) {
+  return function(target) {
+    Reflect.defineMetadata(INJECTABLE_METADATA_KEY, true, target);
+    if (config?.lifecycle) {
+      Reflect.defineMetadata("lifecycle", config.lifecycle, target);
+    }
+  };
+}
+function Inject(token) {
+  return function(target, _propertyKey, parameterIndex) {
+    const logger = LoggerManager2.getLogger();
+    const constructor = typeof target === "function" ? target : target?.constructor;
+    if (!constructor) {
+      return;
+    }
+    const paramTypes = Reflect.getMetadata("design:paramtypes", constructor);
+    const paramType = paramTypes?.[parameterIndex];
+    let metadata = Reflect.getMetadata(DEPENDENCY_METADATA_KEY, constructor) || [];
+    const paramCount = paramTypes?.length || 0;
+    while (metadata.length < paramCount) {
+      metadata.push(undefined);
+    }
+    let dependencyType;
+    let dependencyToken;
+    if (token) {
+      if (typeof token === "string" || typeof token === "symbol") {
+        dependencyToken = token;
+        dependencyType = paramType || Object;
+      } else {
+        dependencyType = token;
+      }
+    } else {
+      if (!paramType) {
+        throw new Error(`Cannot determine dependency type for parameter ${parameterIndex} of ${constructor.name}. ` + "Please provide explicit type using @Inject(Type) or ensure emitDecoratorMetadata is enabled.");
+      }
+      dependencyType = paramType;
+    }
+    if (!typeReferenceMap.has(constructor)) {
+      typeReferenceMap.set(constructor, new Map);
+    }
+    const typeRefs = typeReferenceMap.get(constructor);
+    typeRefs.set(String(parameterIndex), dependencyType);
+    metadata[parameterIndex] = {
+      index: parameterIndex,
+      type: dependencyType,
+      token: dependencyToken
+    };
+    if (constructor.name === "Service" || constructor.name === "Level2") {
+      logger.debug(`[DI Debug] @Inject(${token ? typeof token === "function" ? token.name : String(token) : "auto"}) on ${constructor.name}[${parameterIndex}]: saving metadata.length=${metadata.length}`);
+    }
+    Reflect.defineMetadata(DEPENDENCY_METADATA_KEY, metadata, constructor);
+    if (constructor.name === "Service" || constructor.name === "Level2") {
+      const savedMetadata = Reflect.getMetadata(DEPENDENCY_METADATA_KEY, constructor);
+      logger.debug(`[DI Debug] @Inject on ${constructor.name}: saved metadata.exists=${savedMetadata ? "yes" : "no"}, length=${savedMetadata?.length || 0}`);
+    }
+  };
+}
+function getDependencyMetadata(target) {
+  const constructor = typeof target === "function" ? target : target?.constructor;
+  if (!constructor) {
+    return [];
+  }
+  const rawMetadata = Reflect.getMetadata(DEPENDENCY_METADATA_KEY, constructor);
+  const metadata = rawMetadata || [];
+  if (constructor.name === "Service" || constructor.name === "Level2") {
+    LoggerManager2.getLogger().debug(`[DI Debug] getDependencyMetadata(${constructor.name}): rawMetadata=${rawMetadata ? "exists" : "undefined"}, length=${metadata.length}`);
+  }
+  const typeRefs = typeReferenceMap.get(constructor);
+  if (typeRefs) {
+    for (let i = 0;i < metadata.length; i++) {
+      const meta = metadata[i];
+      if (meta !== undefined && meta !== null) {
+        const typeRef = typeRefs.get(String(meta.index));
+        if (typeRef && typeof typeRef === "function") {
+          meta.type = typeRef;
+        }
+      }
+    }
+  }
+  return metadata;
+}
+function getLifecycle(target) {
+  return Reflect.getMetadata("lifecycle", target);
+}
+function getTypeReference(constructor, parameterIndex) {
+  const typeRefs = typeReferenceMap.get(constructor);
+  if (typeRefs) {
+    return typeRefs.get(String(parameterIndex));
+  }
+  return;
+}
+
+// src/core/context-service.ts
+var contextStore = new AsyncLocalStorage;
+var CONTEXT_SERVICE_TOKEN = Symbol("ContextService");
+
+class ContextService {
+  getContext() {
+    return contextStore.getStore();
+  }
+  getHeader(key) {
+    const context = this.getContext();
+    return context?.getHeader(key) ?? null;
+  }
+  getQuery(key) {
+    const context = this.getContext();
+    return context?.getQuery(key) ?? null;
+  }
+  getQueryAll() {
+    const context = this.getContext();
+    return context?.getQueryAll() ?? {};
+  }
+  getParam(key) {
+    const context = this.getContext();
+    return context?.getParam(key);
+  }
+  getBody() {
+    const context = this.getContext();
+    return context?.body ?? null;
+  }
+  getMethod() {
+    const context = this.getContext();
+    return context?.method ?? "";
+  }
+  getPath() {
+    const context = this.getContext();
+    return context?.path ?? "";
+  }
+  getUrl() {
+    const context = this.getContext();
+    return context?.url;
+  }
+  getClientIp() {
+    const context = this.getContext();
+    return context?.getClientIp() ?? "unknown";
+  }
+  setHeader(key, value) {
+    const context = this.getContext();
+    context?.setHeader(key, value);
+  }
+  setStatus(code) {
+    const context = this.getContext();
+    context?.setStatus(code);
+  }
+}
+ContextService = __legacyDecorateClassTS([
+  Injectable()
+], ContextService);
+
 // src/middleware/pipeline.ts
 class MiddlewarePipeline {
   middlewares = [];
@@ -1043,107 +1201,8 @@ var Lifecycle;
   Lifecycle2["Scoped"] = "scoped";
 })(Lifecycle ||= {});
 
-// src/di/decorators.ts
-import"reflect-metadata";
-import { LoggerManager as LoggerManager2 } from "@dangao/logsmith";
-var DEPENDENCY_METADATA_KEY = Symbol("dependency:metadata");
-var INJECTABLE_METADATA_KEY = Symbol("injectable");
-var typeReferenceMap = new WeakMap;
-function Injectable(config) {
-  return function(target) {
-    Reflect.defineMetadata(INJECTABLE_METADATA_KEY, true, target);
-    if (config?.lifecycle) {
-      Reflect.defineMetadata("lifecycle", config.lifecycle, target);
-    }
-  };
-}
-function Inject(token) {
-  return function(target, _propertyKey, parameterIndex) {
-    const logger = LoggerManager2.getLogger();
-    const constructor = typeof target === "function" ? target : target?.constructor;
-    if (!constructor) {
-      return;
-    }
-    const paramTypes = Reflect.getMetadata("design:paramtypes", constructor);
-    const paramType = paramTypes?.[parameterIndex];
-    let metadata = Reflect.getMetadata(DEPENDENCY_METADATA_KEY, constructor) || [];
-    const paramCount = paramTypes?.length || 0;
-    while (metadata.length < paramCount) {
-      metadata.push(undefined);
-    }
-    let dependencyType;
-    let dependencyToken;
-    if (token) {
-      if (typeof token === "string" || typeof token === "symbol") {
-        dependencyToken = token;
-        dependencyType = paramType || Object;
-      } else {
-        dependencyType = token;
-      }
-    } else {
-      if (!paramType) {
-        throw new Error(`Cannot determine dependency type for parameter ${parameterIndex} of ${constructor.name}. ` + "Please provide explicit type using @Inject(Type) or ensure emitDecoratorMetadata is enabled.");
-      }
-      dependencyType = paramType;
-    }
-    if (!typeReferenceMap.has(constructor)) {
-      typeReferenceMap.set(constructor, new Map);
-    }
-    const typeRefs = typeReferenceMap.get(constructor);
-    typeRefs.set(String(parameterIndex), dependencyType);
-    metadata[parameterIndex] = {
-      index: parameterIndex,
-      type: dependencyType,
-      token: dependencyToken
-    };
-    if (constructor.name === "Service" || constructor.name === "Level2") {
-      logger.debug(`[DI Debug] @Inject(${token ? typeof token === "function" ? token.name : String(token) : "auto"}) on ${constructor.name}[${parameterIndex}]: saving metadata.length=${metadata.length}`);
-    }
-    Reflect.defineMetadata(DEPENDENCY_METADATA_KEY, metadata, constructor);
-    if (constructor.name === "Service" || constructor.name === "Level2") {
-      const savedMetadata = Reflect.getMetadata(DEPENDENCY_METADATA_KEY, constructor);
-      logger.debug(`[DI Debug] @Inject on ${constructor.name}: saved metadata.exists=${savedMetadata ? "yes" : "no"}, length=${savedMetadata?.length || 0}`);
-    }
-  };
-}
-function getDependencyMetadata(target) {
-  const constructor = typeof target === "function" ? target : target?.constructor;
-  if (!constructor) {
-    return [];
-  }
-  const rawMetadata = Reflect.getMetadata(DEPENDENCY_METADATA_KEY, constructor);
-  const metadata = rawMetadata || [];
-  if (constructor.name === "Service" || constructor.name === "Level2") {
-    LoggerManager2.getLogger().debug(`[DI Debug] getDependencyMetadata(${constructor.name}): rawMetadata=${rawMetadata ? "exists" : "undefined"}, length=${metadata.length}`);
-  }
-  const typeRefs = typeReferenceMap.get(constructor);
-  if (typeRefs) {
-    for (let i = 0;i < metadata.length; i++) {
-      const meta = metadata[i];
-      if (meta !== undefined && meta !== null) {
-        const typeRef = typeRefs.get(String(meta.index));
-        if (typeRef && typeof typeRef === "function") {
-          meta.type = typeRef;
-        }
-      }
-    }
-  }
-  return metadata;
-}
-function getLifecycle(target) {
-  return Reflect.getMetadata("lifecycle", target);
-}
-function getTypeReference(constructor, parameterIndex) {
-  const typeRefs = typeReferenceMap.get(constructor);
-  if (typeRefs) {
-    return typeRefs.get(String(parameterIndex));
-  }
-  return;
-}
-
 // src/di/container.ts
 import { LoggerManager as LoggerManager3 } from "@dangao/logsmith";
-
 class Container {
   parent;
   constructor(options = {}) {
@@ -1151,6 +1210,7 @@ class Container {
   }
   providers = new Map;
   singletons = new Map;
+  scopedInstances = new WeakMap;
   typeToToken = new Map;
   dependencyPlans = new Map;
   register(token, config) {
@@ -1200,6 +1260,20 @@ class Container {
         return singleton;
       }
     }
+    if (provider.lifecycle === "scoped" /* Scoped */) {
+      const context = contextStore.getStore();
+      if (context) {
+        let scopedMap = this.scopedInstances.get(context);
+        if (!scopedMap) {
+          scopedMap = new Map;
+          this.scopedInstances.set(context, scopedMap);
+        }
+        const scopedInstance = scopedMap.get(tokenKey);
+        if (scopedInstance) {
+          return scopedInstance;
+        }
+      }
+    }
     let instance;
     if (provider.factory) {
       instance = provider.factory();
@@ -1213,6 +1287,17 @@ class Container {
     if (provider.lifecycle === "singleton" /* Singleton */) {
       this.singletons.set(tokenKey, instance);
     }
+    if (provider.lifecycle === "scoped" /* Scoped */) {
+      const context = contextStore.getStore();
+      if (context) {
+        let scopedMap = this.scopedInstances.get(context);
+        if (!scopedMap) {
+          scopedMap = new Map;
+          this.scopedInstances.set(context, scopedMap);
+        }
+        scopedMap.set(tokenKey, instance);
+      }
+    }
     return instance;
   }
   resolveInternal(token) {
@@ -1236,21 +1321,43 @@ class Container {
           return singleton;
         }
       }
-      if (provider.factory) {
-        const instance = provider.factory();
-        if (provider.lifecycle === "singleton" /* Singleton */) {
-          this.singletons.set(token, instance);
+      if (provider.lifecycle === "scoped" /* Scoped */) {
+        const context = contextStore.getStore();
+        if (context) {
+          let scopedMap = this.scopedInstances.get(context);
+          if (!scopedMap) {
+            scopedMap = new Map;
+            this.scopedInstances.set(context, scopedMap);
+          }
+          const scopedInstance = scopedMap.get(token);
+          if (scopedInstance) {
+            return scopedInstance;
+          }
         }
-        return instance;
       }
-      if (provider.implementation && typeof provider.implementation === "function") {
-        const instance = this.instantiate(provider.implementation);
-        if (provider.lifecycle === "singleton" /* Singleton */) {
-          this.singletons.set(token, instance);
+      let instance;
+      if (provider.factory) {
+        instance = provider.factory();
+      } else if (provider.implementation && typeof provider.implementation === "function") {
+        instance = this.instantiate(provider.implementation);
+      } else {
+        throw new Error(`Cannot instantiate token: ${String(token)}. Factory function required.`);
+      }
+      if (provider.lifecycle === "singleton" /* Singleton */) {
+        this.singletons.set(token, instance);
+      }
+      if (provider.lifecycle === "scoped" /* Scoped */) {
+        const context = contextStore.getStore();
+        if (context) {
+          let scopedMap = this.scopedInstances.get(context);
+          if (!scopedMap) {
+            scopedMap = new Map;
+            this.scopedInstances.set(context, scopedMap);
+          }
+          scopedMap.set(token, instance);
         }
-        return instance;
       }
-      throw new Error(`Cannot instantiate token: ${String(token)}. Factory function required.`);
+      return instance;
     }
     if (typeof token === "function") {
       return this.resolve(token);
@@ -1371,6 +1478,25 @@ function Param(key) {
 function Header(key) {
   return createParamDecorator("header" /* HEADER */, key);
 }
+function QueryMap(options) {
+  return function(target, propertyKey, parameterIndex) {
+    const existingParams = Reflect.getMetadata(PARAM_METADATA_KEY, target, propertyKey) || [];
+    const normalizedOptions = typeof options === "function" ? { transform: options } : options ?? {};
+    existingParams.push({ type: "query_map" /* QUERY_MAP */, index: parameterIndex, options: normalizedOptions });
+    Reflect.defineMetadata(PARAM_METADATA_KEY, existingParams, target, propertyKey);
+  };
+}
+function HeaderMap(options) {
+  return function(target, propertyKey, parameterIndex) {
+    const existingParams = Reflect.getMetadata(PARAM_METADATA_KEY, target, propertyKey) || [];
+    const normalizedOptions = typeof options === "function" ? { transform: options } : options ?? {};
+    existingParams.push({ type: "header_map" /* HEADER_MAP */, index: parameterIndex, options: normalizedOptions });
+    Reflect.defineMetadata(PARAM_METADATA_KEY, existingParams, target, propertyKey);
+  };
+}
+function Context2() {
+  return createParamDecorator("context" /* CONTEXT */);
+}
 function getParamMetadata(target, propertyKey) {
   return Reflect.getMetadata(PARAM_METADATA_KEY, target, propertyKey) || [];
 }
@@ -1578,6 +1704,12 @@ class ParamBinder {
           }
         } catch {}
         return;
+      case "context" /* CONTEXT */:
+        return contextStore.getStore() ?? context;
+      case "query_map" /* QUERY_MAP */:
+        return await this.getQueryMapValue(meta.options, context);
+      case "header_map" /* HEADER_MAP */:
+        return await this.getHeaderMapValue(meta.options, context);
       default:
         return;
     }
@@ -1601,6 +1733,52 @@ class ParamBinder {
   static getHeaderValue(key, context) {
     return context.getHeader(key);
   }
+  static async getQueryMapValue(options, context) {
+    const result = {};
+    const searchParams = context.query;
+    for (const key of searchParams.keys()) {
+      const values = searchParams.getAll(key);
+      if (values.length === 1) {
+        result[key] = values[0];
+      } else {
+        result[key] = values;
+      }
+    }
+    let output = result;
+    if (options?.transform) {
+      output = await options.transform(result);
+    }
+    if (options?.validate) {
+      await options.validate(output);
+    }
+    return output;
+  }
+  static async getHeaderMapValue(options, context) {
+    const normalize = options?.normalize ?? true;
+    const pick = options?.pick?.map((key) => key.toLowerCase());
+    const headers = context.headers;
+    const result = {};
+    headers.forEach((value, rawKey) => {
+      const key = normalize ? rawKey.toLowerCase() : rawKey;
+      if (pick && !pick.includes(key)) {
+        return;
+      }
+      const parts = value.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
+      if (parts.length <= 1) {
+        result[key] = parts[0] ?? "";
+      } else {
+        result[key] = parts;
+      }
+    });
+    let output = result;
+    if (options?.transform) {
+      output = await options.transform(result);
+    }
+    if (options?.validate) {
+      await options.validate(output);
+    }
+    return output;
+  }
 }
 
 // src/controller/metadata.ts
@@ -2903,6 +3081,7 @@ class Application {
     const container = ControllerRegistry.getInstance().getContainer();
     const interceptorRegistry = new InterceptorRegistry;
     container.registerInstance(INTERCEPTOR_REGISTRY_TOKEN, interceptorRegistry);
+    container.registerInstance(CONTEXT_SERVICE_TOKEN, new ContextService);
     this.registerExtension(new LoggerExtension);
   }
   use(middleware) {
@@ -2944,19 +3123,21 @@ class Application {
     }
   }
   async handleRequest(context) {
-    if (["POST", "PUT", "PATCH"].includes(context.method)) {
-      await context.getBody();
-    }
-    const registry = RouteRegistry.getInstance();
-    const router = registry.getRouter();
-    await router.preHandle(context);
-    return await this.middlewarePipeline.run(context, async () => {
-      const response = await router.handle(context);
-      if (response) {
-        return response;
-      }
-      context.setStatus(404);
-      return context.createResponse({ error: "Not Found" });
+    return await contextStore.run(context, async () => {
+      if (["POST", "PUT", "PATCH"].includes(context.method)) {
+        await context.getBody();
+      }
+      const registry = RouteRegistry.getInstance();
+      const router = registry.getRouter();
+      await router.preHandle(context);
+      return await this.middlewarePipeline.run(context, async () => {
+        const response = await router.handle(context);
+        if (response) {
+          return response;
+        }
+        context.setStatus(404);
+        return context.createResponse({ error: "Not Found" });
+      });
     });
   }
   registerController(controllerClass) {
@@ -3445,7 +3626,7 @@ SwaggerModule = __legacyDecorateClassTS([
   })
 ], SwaggerModule);
 // src/security/context.ts
-import { AsyncLocalStorage } from "async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
 
 class SecurityContextImpl {
   _authentication = null;
@@ -3470,7 +3651,7 @@ class SecurityContextImpl {
 }
 
 class SecurityContextHolder {
-  static storage = new AsyncLocalStorage;
+  static storage = new AsyncLocalStorage2;
   static getContext() {
     let context = this.storage.getStore();
     if (!context) {
@@ -6630,6 +6811,7 @@ export {
   createFileUploadMiddleware,
   createErrorHandlingMiddleware,
   createCorsMiddleware,
+  contextStore,
   checkRoles,
   WebSocketGatewayRegistry,
   WebSocketGateway,
@@ -6666,6 +6848,7 @@ export {
   QueueService,
   QueueModule,
   Queue,
+  QueryMap,
   Query,
   QUEUE_SERVICE_TOKEN,
   QUEUE_OPTIONS_TOKEN,
@@ -6726,6 +6909,7 @@ export {
   INTERCEPTOR_REGISTRY_TOKEN,
   HttpException,
   HealthModule,
+  HeaderMap,
   Header,
   HEALTH_OPTIONS_TOKEN,
   HEALTH_INDICATORS_TOKEN,
@@ -6745,6 +6929,8 @@ export {
   Cron,
   ControllerRegistry,
   Controller,
+  ContextService,
+  Context2 as ContextParam,
   Context,
   Container,
   ConnectionPool,
@@ -6758,6 +6944,7 @@ export {
   CacheInterceptor,
   CacheEvict,
   Cache,
+  CONTEXT_SERVICE_TOKEN,
   CONFIG_SERVICE_TOKEN,
   CACHE_SERVICE_TOKEN,
   CACHE_OPTIONS_TOKEN,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dangao/bun-server",
-  "version": "1.1.4",
+  "version": "1.3.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/controller/decorators.ts

@@ -14,6 +14,9 @@ export enum ParamType {
   PARAM = 'param',
   HEADER = 'header',
   SESSION = 'session',
+  CONTEXT = 'context',
+  QUERY_MAP = 'query_map',
+  HEADER_MAP = 'header_map',
 }
 
 /**
@@ -23,6 +26,7 @@ export interface ParamMetadata {
   type: ParamType;
   key?: string;
   index: number;
+  options?: unknown;
 }
 
 /**
@@ -72,6 +76,76 @@ export function Header(key: string) {
   return createParamDecorator(ParamType.HEADER, key);
 }
 
+/**
+ * QueryMap 注解选项
+ */
+export interface QueryMapOptions<T = unknown> {
+  transform?: (input: Record<string, string | string[]>) => T | Promise<T>;
+  validate?: (dto: T) => void | Promise<void>;
+}
+
+/**
+ * HeaderMap 注解选项
+ */
+export interface HeaderMapOptions<T = unknown> {
+  normalize?: boolean;
+  pick?: string[];
+  transform?: (input: Record<string, string | string[]>) => T | Promise<T>;
+  validate?: (dto: T) => void | Promise<void>;
+}
+
+/**
+ * QueryMap 参数装饰器
+ * 一次性注入完整查询对象
+ */
+export function QueryMap<T = Record<string, string | string[]>>(
+  options?: QueryMapOptions<T> | ((input: Record<string, string | string[]>) => T | Promise<T>),
+) {
+  return function (target: any, propertyKey: string | symbol | undefined, parameterIndex: number) {
+    const existingParams: ParamMetadata[] =
+      Reflect.getMetadata(PARAM_METADATA_KEY, target, propertyKey as string) || [];
+    const normalizedOptions: QueryMapOptions<T> =
+      typeof options === 'function' ? { transform: options } : options ?? {};
+    existingParams.push({ type: ParamType.QUERY_MAP, index: parameterIndex, options: normalizedOptions });
+    Reflect.defineMetadata(PARAM_METADATA_KEY, existingParams, target, propertyKey as string);
+  };
+}
+
+/**
+ * HeaderMap 参数装饰器
+ * 一次性注入完整 headers 对象
+ */
+export function HeaderMap<T = Record<string, string | string[]>>(
+  options?: HeaderMapOptions<T> | ((input: Record<string, string | string[]>) => T | Promise<T>),
+) {
+  return function (target: any, propertyKey: string | symbol | undefined, parameterIndex: number) {
+    const existingParams: ParamMetadata[] =
+      Reflect.getMetadata(PARAM_METADATA_KEY, target, propertyKey as string) || [];
+    const normalizedOptions: HeaderMapOptions<T> =
+      typeof options === 'function' ? { transform: options } : options ?? {};
+    existingParams.push({ type: ParamType.HEADER_MAP, index: parameterIndex, options: normalizedOptions });
+    Reflect.defineMetadata(PARAM_METADATA_KEY, existingParams, target, propertyKey as string);
+  };
+}
+
+/**
+ * Context 参数装饰器
+ * 用于在控制器方法中注入当前请求的 Context 对象
+ * 
+ * @example
+ * ```typescript
+ * @GET('/users/:id')
+ * public async getUser(@Param('id') id: string, @Context() context: Context) {
+ *   // 可以直接访问 context
+ *   const header = context.getHeader('Authorization');
+ *   return { id, header };
+ * }
+ * ```
+ */
+export function Context() {
+  return createParamDecorator(ParamType.CONTEXT);
+}
+
 /**
  * 获取参数元数据
  * @param target - 目标对象

package/src/controller/index.ts

@@ -1,5 +1,19 @@
-export { Body, Query, Param, Header, getParamMetadata, ParamType } from './decorators';
-export type { ParamMetadata } from './decorators';
+export {
+  Body,
+  Query,
+  QueryMap,
+  Param,
+  Header,
+  HeaderMap,
+  Context,
+  getParamMetadata,
+  ParamType,
+} from './decorators';
+export type {
+  ParamMetadata,
+  QueryMapOptions,
+  HeaderMapOptions,
+} from './decorators';
 export { ParamBinder } from './param-binder';
 export { Controller, ControllerRegistry } from './controller';
 export type { ControllerMetadata } from './controller';