@navios/core 1.0.0-alpha.2 → 1.0.0-alpha.3

package/lib/legacy-compat/index.mjs

@@ -1,60 +1,6 @@
 import { M as getEndpointMetadata, O as getControllerMetadata, T as hasModuleMetadata, a as HttpCode$1, b as getManagedMetadata, i as Module$1, k as hasControllerMetadata, n as Stream$1, o as Header$1, r as Multipart$1, s as Endpoint$1, t as UseGuards$1, v as Controller$1, w as getModuleMetadata, x as hasManagedMetadata } from "../use-guards.decorator-Be_QUx6b.mjs";
-import { Factory as Factory$1, Injectable as Injectable$1 } from "@navios/di";
+import { Factory, Injectable, createClassContext, createClassContext as createClassContext$1, createMethodContext, createMethodContext as createMethodContext$1 } from "@navios/di/legacy-compat";
 
-//#region src/legacy-compat/context-compat.mts
-/**
-* Compatibility layer for converting legacy decorator signatures to Stage 3 format.
-*
-* This module provides utilities to create mock Stage 3 decorator contexts
-* from legacy decorator arguments, and manages metadata storage using WeakMap.
-*/ const classMetadataMap = /* @__PURE__ */ new WeakMap();
-/**
-* Gets the constructor from a prototype (for method decorators).
-*/ function getConstructor(prototype) {
-	if (!prototype || typeof prototype !== "object") return null;
-	const constructor = prototype.constructor;
-	if (constructor && typeof constructor === "function") return constructor;
-	return null;
-}
-/**
-* Creates a mock ClassDecoratorContext for legacy class decorators.
-* @internal
-*/ function createClassContext(target) {
-	if (!classMetadataMap.has(target)) classMetadataMap.set(target, {});
-	const metadata = classMetadataMap.get(target);
-	return {
-		kind: "class",
-		name: target.name,
-		metadata,
-		addInitializer() {}
-	};
-}
-/**
-* Creates a mock ClassMethodDecoratorContext for legacy method decorators.
-*
-* Note: Method decorators need to share metadata with the class context
-* because endpoint metadata is stored at the class level.
-* @internal
-*/ function createMethodContext(target, propertyKey, descriptor) {
-	const constructor = getConstructor(target);
-	if (!constructor) throw new Error("[Navios] Could not determine class constructor from method decorator target.");
-	if (!classMetadataMap.has(constructor)) classMetadataMap.set(constructor, {});
-	return {
-		kind: "method",
-		name: propertyKey,
-		metadata: classMetadataMap.get(constructor),
-		static: false,
-		private: false,
-		access: {
-			has: () => true,
-			get: () => descriptor.value,
-			set: () => {}
-		},
-		addInitializer() {}
-	};
-}
-
-//#endregion
 //#region src/legacy-compat/decorators/module.decorator.mts
 /**
 * Legacy-compatible Module decorator.
@@ -79,7 +25,7 @@ import { Factory as Factory$1, Injectable as Injectable$1 } from "@navios/di";
 	guards: []
 }) {
 	return function(target) {
-		const context = createClassContext(target);
+		const context = createClassContext$1(target);
 		return Module$1(options)(target, context);
 	};
 }
@@ -104,7 +50,7 @@ import { Factory as Factory$1, Injectable as Injectable$1 } from "@navios/di";
 * ```
 */ function Controller(options = {}) {
 	return function(target) {
-		const context = createClassContext(target);
+		const context = createClassContext$1(target);
 		return Controller$1(options)(target, context);
 	};
 }
@@ -134,7 +80,7 @@ import { Factory as Factory$1, Injectable as Injectable$1 } from "@navios/di";
 	return function(target, propertyKey, descriptor) {
 		if (!descriptor) throw new Error("[Navios] @Endpoint decorator requires a method descriptor. Make sure experimentalDecorators is enabled.");
 		const typedDescriptor = descriptor;
-		const context = createMethodContext(target, propertyKey, typedDescriptor);
+		const context = createMethodContext$1(target, propertyKey, typedDescriptor);
 		const result = Endpoint$1(endpoint)(typedDescriptor.value, context);
 		if (result !== typedDescriptor.value) typedDescriptor.value = result;
 		return typedDescriptor;
@@ -170,12 +116,12 @@ import { Factory as Factory$1, Injectable as Injectable$1 } from "@navios/di";
 */ function UseGuards(...guards) {
 	function decoratorImpl(target, propertyKey, descriptor) {
 		if (propertyKey !== void 0 && descriptor !== void 0) {
-			const context = createMethodContext(target, propertyKey, descriptor);
+			const context = createMethodContext$1(target, propertyKey, descriptor);
 			const result = UseGuards$1(...guards)(descriptor.value, context);
 			if (result !== descriptor.value) descriptor.value = result;
 			return descriptor;
 		} else {
-			const context = createClassContext(target);
+			const context = createClassContext$1(target);
 			return UseGuards$1(...guards)(target, context);
 		}
 	}
@@ -206,7 +152,7 @@ import { Factory as Factory$1, Injectable as Injectable$1 } from "@navios/di";
 * ```
 */ function Header(name, value) {
 	return function(target, propertyKey, descriptor) {
-		const context = createMethodContext(target, propertyKey, descriptor);
+		const context = createMethodContext$1(target, propertyKey, descriptor);
 		const result = Header$1(name, value)(descriptor.value, context);
 		if (result !== descriptor.value) descriptor.value = result;
 		return descriptor;
@@ -236,7 +182,7 @@ import { Factory as Factory$1, Injectable as Injectable$1 } from "@navios/di";
 * ```
 */ function HttpCode(code) {
 	return function(target, propertyKey, descriptor) {
-		const context = createMethodContext(target, propertyKey, descriptor);
+		const context = createMethodContext$1(target, propertyKey, descriptor);
 		const result = HttpCode$1(code)(descriptor.value, context);
 		if (result !== descriptor.value) descriptor.value = result;
 		return descriptor;
@@ -268,7 +214,7 @@ import { Factory as Factory$1, Injectable as Injectable$1 } from "@navios/di";
 */ function Multipart(endpoint) {
 	return function(target, propertyKey, descriptor) {
 		if (!descriptor) throw new Error("[Navios] @Multipart decorator requires a method descriptor. Make sure experimentalDecorators is enabled.");
-		const context = createMethodContext(target, propertyKey, descriptor);
+		const context = createMethodContext$1(target, propertyKey, descriptor);
 		const result = Multipart$1(endpoint)(descriptor.value, context);
 		if (result !== descriptor.value) descriptor.value = result;
 		return descriptor;
@@ -301,65 +247,13 @@ import { Factory as Factory$1, Injectable as Injectable$1 } from "@navios/di";
 	return function(target, propertyKey, descriptor) {
 		if (!descriptor || !descriptor.value) throw new Error("[Navios] @Stream decorator requires a method descriptor. Make sure experimentalDecorators is enabled.");
 		const typedDescriptor = descriptor;
-		const context = createMethodContext(target, propertyKey, typedDescriptor);
+		const context = createMethodContext$1(target, propertyKey, typedDescriptor);
 		const result = Stream$1(endpoint)(typedDescriptor.value, context);
 		if (result && result !== typedDescriptor.value) typedDescriptor.value = result;
 		return typedDescriptor;
 	};
 }
 
-//#endregion
-//#region src/legacy-compat/decorators/injectable.decorator.mts
-/**
-* Legacy-compatible Injectable decorator.
-*
-* Works with TypeScript experimental decorators (legacy API).
-*
-* @param options - Injectable configuration options
-* @returns A class decorator compatible with legacy decorator API
-*
-* @example
-* ```typescript
-* @Injectable()
-* export class UserService {
-*   getUser(id: string) {
-*     return { id, name: 'John' }
-*   }
-* }
-* ```
-*/ function Injectable(options = {}) {
-	return function(target) {
-		const context = createClassContext(target);
-		return (Object.keys(options).length === 0 ? Injectable$1() : Injectable$1(options))(target, context);
-	};
-}
-
-//#endregion
-//#region src/legacy-compat/decorators/factory.decorator.mts
-/**
-* Legacy-compatible Factory decorator.
-*
-* Works with TypeScript experimental decorators (legacy API).
-*
-* @param options - Factory configuration options
-* @returns A class decorator compatible with legacy decorator API
-*
-* @example
-* ```typescript
-* @Factory()
-* export class DatabaseConnectionFactory {
-*   create() {
-*     return { host: 'localhost', port: 5432 }
-*   }
-* }
-* ```
-*/ function Factory(options = {}) {
-	return function(target) {
-		const context = createClassContext(target);
-		return (Object.keys(options).length === 0 ? Factory$1() : Factory$1(options))(target, context);
-	};
-}
-
 //#endregion
 //#region src/legacy-compat/attribute.factory.mts
 /**
@@ -408,7 +302,7 @@ import { Factory as Factory$1, Injectable as Injectable$1 } from "@navios/di";
 		const res = (value) => {
 			function decorator(target, propertyKey, descriptor) {
 				if (propertyKey !== void 0 && descriptor !== void 0) {
-					const context = createMethodContext(target, propertyKey, descriptor);
+					const context = createMethodContext$1(target, propertyKey, descriptor);
 					const metadata = getEndpointMetadata(descriptor.value, context);
 					if (schema) {
 						const validatedValue = schema.safeParse(value);
@@ -421,7 +315,7 @@ import { Factory as Factory$1, Injectable as Injectable$1 } from "@navios/di";
 					const isModule = hasModuleMetadata(target);
 					const isManaged = hasManagedMetadata(target);
 					if (!isController && !isModule && !isManaged) throw new Error("[Navios] Attribute can only be applied to classes with @Controller, @Module, or other Navios-managed decorators");
-					const context = createClassContext(target);
+					const context = createClassContext$1(target);
 					const metadata = isController ? getControllerMetadata(target, context) : isModule ? getModuleMetadata(target, context) : isManaged ? getManagedMetadata(target) : null;
 					if (!metadata) throw new Error("[Navios] Could not determine metadata for attribute target");
 					if (schema) {

package/lib/legacy-compat/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["classMetadataMap","WeakMap","getConstructor","prototype","constructor","createClassContext","target","has","set","metadata","get","kind","name","addInitializer","createMethodContext","propertyKey","descriptor","Error","static","private","access","value","Module","OriginalModule","createClassContext","options","controllers","imports","guards","target","context","originalDecorator","Controller","OriginalController","createClassContext","options","target","context","originalDecorator","Endpoint","OriginalEndpoint","createMethodContext","endpoint","target","propertyKey","descriptor","Error","typedDescriptor","context","originalDecorator","result","value","UseGuards","OriginalUseGuards","createClassContext","createMethodContext","guards","decoratorImpl","target","propertyKey","descriptor","undefined","context","originalDecorator","result","value","Header","OriginalHeader","createMethodContext","name","value","target","propertyKey","descriptor","context","originalDecorator","result","HttpCode","OriginalHttpCode","createMethodContext","code","target","propertyKey","descriptor","context","originalDecorator","result","value","Multipart","OriginalMultipart","createMethodContext","endpoint","target","propertyKey","descriptor","Error","context","originalDecorator","result","value","Stream","OriginalStream","createMethodContext","endpoint","target","propertyKey","descriptor","value","Error","typedDescriptor","context","originalDecorator","result","Injectable","OriginalInjectable","createClassContext","options","target","context","originalDecorator","Object","keys","length","Factory","OriginalFactory","createClassContext","options","target","context","originalDecorator","Object","keys","length","getControllerMetadata","getEndpointMetadata","getModuleMetadata","hasControllerMetadata","hasModuleMetadata","getManagedMetadata","hasManagedMetadata","createClassContext","createMethodContext","LegacyAttributeFactory","createAttribute","token","schema","res","value","decorator","target","propertyKey","descriptor","isMethodDecorator","undefined","context","metadata","validatedValue","safeParse","success","Error","toString","error","customAttributes","set","data","isController","isModule","isManaged","get","attribute","getAll","values","Array","from","entries","filter","key","map","length","getLast","i","has","AttributeFactory"],"sources":["../../src/legacy-compat/context-compat.mts","../../src/legacy-compat/decorators/module.decorator.mts","../../src/legacy-compat/decorators/controller.decorator.mts","../../src/legacy-compat/decorators/endpoint.decorator.mts","../../src/legacy-compat/decorators/use-guards.decorator.mts","../../src/legacy-compat/decorators/header.decorator.mts","../../src/legacy-compat/decorators/http-code.decorator.mts","../../src/legacy-compat/decorators/multipart.decorator.mts","../../src/legacy-compat/decorators/stream.decorator.mts","../../src/legacy-compat/decorators/injectable.decorator.mts","../../src/legacy-compat/decorators/factory.decorator.mts","../../src/legacy-compat/attribute.factory.mts"],"sourcesContent":["/**\n * Compatibility layer for converting legacy decorator signatures to Stage 3 format.\n *\n * This module provides utilities to create mock Stage 3 decorator contexts\n * from legacy decorator arguments, and manages metadata storage using WeakMap.\n */\n\nimport type { ClassType } from '@navios/di'\n\n// WeakMap to store metadata for legacy decorators\n// Keyed by class constructor for class decorators\n// For method decorators, we use the class constructor (extracted from the prototype)\nconst classMetadataMap = new WeakMap<ClassType, Record<string | symbol, any>>()\n\n/**\n * Gets the constructor from a prototype (for method decorators).\n */\nfunction getConstructor(prototype: any): ClassType | null {\n  if (!prototype || typeof prototype !== 'object') {\n    return null\n  }\n  // In legacy decorators, target is the prototype\n  // The constructor is typically available via prototype.constructor\n  const constructor = prototype.constructor\n  if (constructor && typeof constructor === 'function') {\n    return constructor as ClassType\n  }\n  return null\n}\n\n/**\n * Creates a mock ClassDecoratorContext for legacy class decorators.\n * @internal\n */\nexport function createClassContext(target: ClassType): ClassDecoratorContext {\n  // Get or create metadata storage for this class\n  if (!classMetadataMap.has(target)) {\n    classMetadataMap.set(target, {})\n  }\n  const metadata = classMetadataMap.get(target)!\n\n  return {\n    kind: 'class',\n    name: target.name,\n    metadata,\n    addInitializer() {\n      // Legacy decorators don't support initializers\n    },\n  } as ClassDecoratorContext\n}\n\n/**\n * Creates a mock ClassMethodDecoratorContext for legacy method decorators.\n *\n * Note: Method decorators need to share metadata with the class context\n * because endpoint metadata is stored at the class level.\n * @internal\n */\nexport function createMethodContext(\n  target: any,\n  propertyKey: string | symbol,\n  descriptor: PropertyDescriptor,\n): ClassMethodDecoratorContext {\n  // For method decorators, target is the prototype\n  // We need to get the class constructor to access class-level metadata\n  const constructor = getConstructor(target)\n  if (!constructor) {\n    throw new Error(\n      '[Navios] Could not determine class constructor from method decorator target.',\n    )\n  }\n\n  // Get or create metadata storage for the class\n  // Method decorators share metadata with the class\n  if (!classMetadataMap.has(constructor)) {\n    classMetadataMap.set(constructor, {})\n  }\n  const metadata = classMetadataMap.get(constructor)!\n\n  return {\n    kind: 'method',\n    name: propertyKey,\n    metadata,\n    static: false, // We can't determine this from legacy decorators\n    private: false, // We can't determine this from legacy decorators\n    access: {\n      has: () => true,\n      get: () => descriptor.value,\n      set: () => {},\n    },\n    addInitializer() {\n      // Legacy decorators don't support initializers\n    },\n  } as ClassMethodDecoratorContext\n}\n","import type { ClassType } from '@navios/di'\n\nimport { Module as OriginalModule, type ModuleOptions } from '../../decorators/module.decorator.mjs'\nimport { createClassContext } from '../context-compat.mjs'\n\n/**\n * Legacy-compatible Module decorator.\n * \n * Works with TypeScript experimental decorators (legacy API).\n * \n * @param options - Module configuration options\n * @returns A class decorator compatible with legacy decorator API\n * \n * @example\n * ```typescript\n * @Module({\n *   controllers: [UserController, AuthController],\n *   imports: [DatabaseModule],\n *   guards: [AuthGuard],\n * })\n * export class AppModule {}\n * ```\n */\nexport function Module(\n  options: ModuleOptions = {\n    controllers: [],\n    imports: [],\n    guards: [],\n  },\n) {\n  return function (target: ClassType) {\n    const context = createClassContext(target)\n    const originalDecorator = OriginalModule(options)\n    return originalDecorator(target, context)\n  }\n}\n\n","import type { ClassType } from '@navios/di'\n\nimport type { ControllerOptions } from '../../decorators/controller.decorator.mjs'\n\nimport { Controller as OriginalController } from '../../decorators/controller.decorator.mjs'\nimport { createClassContext } from '../context-compat.mjs'\n\n/**\n * Legacy-compatible Controller decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n *\n * @param options - Controller configuration options\n * @returns A class decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * @Controller({ guards: [AuthGuard] })\n * export class UserController {\n *   @Endpoint(getUserEndpoint)\n *   async getUser() { }\n * }\n * ```\n */\nexport function Controller(options: ControllerOptions = {}) {\n  return function (target: ClassType) {\n    const context = createClassContext(target)\n    const originalDecorator = OriginalController(options)\n    return originalDecorator(target, context)\n  }\n}\n","import type {\n  EndpointHandler,\n  EndpointOptions,\n  RequestArgs,\n} from '@navios/builder'\nimport type { z } from 'zod/v4'\n\nimport { Endpoint as OriginalEndpoint } from '../../decorators/endpoint.decorator.mjs'\nimport { createMethodContext } from '../context-compat.mjs'\n\n/**\n * Type helper to constrain a PropertyDescriptor's value to match an endpoint signature.\n * Note: In legacy decorators, type constraints are checked when the decorator is applied,\n * but may not be preserved perfectly when decorators are stacked.\n */\ntype EndpointMethodDescriptor<Config extends EndpointOptions> =\n  TypedPropertyDescriptor<\n    (\n      params: RequestArgs<\n        Config['url'],\n        Config['querySchema'],\n        Config['requestSchema'],\n        Config['urlParamsSchema'],\n        true\n      >,\n    ) => Promise<z.input<Config['responseSchema']>>\n  >\n\n/**\n * Legacy-compatible Endpoint decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n * Provides type safety by ensuring method signatures match the endpoint configuration.\n *\n * @param endpoint - The endpoint declaration from @navios/builder\n * @returns A method decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * @Controller()\n * export class UserController {\n *   @Endpoint(getUserEndpoint)\n *   async getUser(request: EndpointParams<typeof getUserEndpoint>): EndpointResult<typeof getUserEndpoint> {\n *     return { id: '1', name: 'John' }\n *   }\n * }\n * ```\n */\nexport function Endpoint<const Config extends EndpointOptions>(\n  endpoint: EndpointHandler<Config, false>,\n) {\n  return function (\n    target: any,\n    propertyKey: string | symbol,\n    descriptor: EndpointMethodDescriptor<Config>,\n  ): PropertyDescriptor | void {\n    if (!descriptor) {\n      throw new Error(\n        '[Navios] @Endpoint decorator requires a method descriptor. Make sure experimentalDecorators is enabled.',\n      )\n    }\n    // Type check the descriptor value matches expected signature\n    const typedDescriptor = descriptor as EndpointMethodDescriptor<Config>\n    const context = createMethodContext(target, propertyKey, typedDescriptor)\n    const originalDecorator = OriginalEndpoint(endpoint)\n    // @ts-expect-error - we don't need to type the value\n    const result = originalDecorator(typedDescriptor.value, context)\n    if (result !== typedDescriptor.value) {\n      typedDescriptor.value = result as any\n    }\n    return typedDescriptor\n  }\n}\n","import type {\n  ClassType,\n  ClassTypeWithInstance,\n  InjectionToken,\n} from '@navios/di'\n\nimport type { CanActivate } from '../../interfaces/index.mjs'\n\nimport { UseGuards as OriginalUseGuards } from '../../decorators/use-guards.decorator.mjs'\nimport { createClassContext, createMethodContext } from '../context-compat.mjs'\n\n/**\n * Legacy-compatible UseGuards decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n * Can be applied to classes or methods.\n *\n * @param guards - Guard classes or injection tokens to apply\n * @returns A class or method decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * // Apply to a controller\n * @Controller()\n * @UseGuards(AuthGuard, RoleGuard)\n * export class UserController { }\n *\n * // Apply to a specific endpoint\n * @Controller()\n * export class UserController {\n *   @Endpoint(getUserEndpoint)\n *   @UseGuards(AuthGuard)\n *   async getUser() { }\n * }\n * ```\n */\nexport function UseGuards(\n  ...guards: (\n    | ClassTypeWithInstance<CanActivate>\n    | InjectionToken<CanActivate, undefined>\n  )[]\n) {\n  // Create the decorator function\n  // Note: TypeScript's legacy decorator system has strict type checking for decorators\n  // We use a flexible implementation that works for both class and method decorators\n  function decoratorImpl(\n    target: ClassType | Function,\n    propertyKey?: string | symbol,\n    descriptor?: PropertyDescriptor,\n  ): any {\n    // Determine if this is a class or method decorator\n    if (propertyKey !== undefined && descriptor !== undefined) {\n      // Method decorator\n      const context = createMethodContext(\n        target as Function,\n        propertyKey,\n        descriptor,\n      )\n      const originalDecorator = OriginalUseGuards(...guards)\n      const result = originalDecorator(descriptor.value, context)\n      if (result !== descriptor.value) {\n        descriptor.value = result\n      }\n      return descriptor\n    } else {\n      // Class decorator\n      const context = createClassContext(target as ClassType)\n      const originalDecorator = OriginalUseGuards(...guards)\n      return originalDecorator(target as ClassType, context)\n    }\n  }\n\n  // Return with 'any' type to work around TypeScript's strict decorator checking\n  // TypeScript's legacy decorator system cannot properly type-check decorators\n  // that work as both class and method decorators. The runtime behavior is correct.\n  // When used as a class decorator, it returns the class (preserving type at runtime)\n  // When used as a method decorator, it returns the PropertyDescriptor\n  // @ts-ignore - TypeScript limitation with dual-purpose legacy decorators\n  return decoratorImpl as any\n}\n","import type { HttpHeader } from '../../interfaces/index.mjs'\n\nimport { Header as OriginalHeader } from '../../decorators/header.decorator.mjs'\nimport { createMethodContext } from '../context-compat.mjs'\n\n/**\n * Legacy-compatible Header decorator.\n * \n * Works with TypeScript experimental decorators (legacy API).\n * \n * @param name - The header name (e.g., 'Content-Type', 'Cache-Control')\n * @param value - The header value (string, number, or array of strings)\n * @returns A method decorator compatible with legacy decorator API\n * \n * @example\n * ```typescript\n * @Controller()\n * export class UserController {\n *   @Endpoint(getUserEndpoint)\n *   @Header('Cache-Control', 'max-age=3600')\n *   async getUser() {\n *     return { id: '1', name: 'John' }\n *   }\n * }\n * ```\n */\nexport function Header(name: HttpHeader, value: string | number | string[]) {\n  return function <T extends object>(\n    target: T,\n    propertyKey: string | symbol,\n    descriptor: PropertyDescriptor,\n  ) {\n    const context = createMethodContext(target, propertyKey, descriptor)\n    const originalDecorator = OriginalHeader(name, value)\n    const result = originalDecorator(descriptor.value, context)\n    if (result !== descriptor.value) {\n      descriptor.value = result\n    }\n    return descriptor\n  }\n}\n\n","import { HttpCode as OriginalHttpCode } from '../../decorators/http-code.decorator.mjs'\nimport { createMethodContext } from '../context-compat.mjs'\n\n/**\n * Legacy-compatible HttpCode decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n *\n * @param code - The HTTP status code to return (e.g., 201, 204, 202)\n * @returns A method decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * @Controller()\n * export class UserController {\n *   @Endpoint(createUserEndpoint)\n *   @HttpCode(201)\n *   async createUser() {\n *     return { id: '1', name: 'John' }\n *   }\n * }\n * ```\n */\nexport function HttpCode(code: number) {\n  return function <T extends object>(\n    target: T,\n    propertyKey: string | symbol,\n    descriptor: PropertyDescriptor,\n  ) {\n    const context = createMethodContext(target, propertyKey, descriptor)\n    const originalDecorator = OriginalHttpCode(code)\n    const result = originalDecorator(descriptor.value, context)\n    if (result !== descriptor.value) {\n      descriptor.value = result\n    }\n    return descriptor\n  }\n}\n","import type {\n  EndpointHandler,\n  EndpointOptions,\n  RequestArgs,\n} from '@navios/builder'\nimport type { z } from 'zod/v4'\n\nimport { Multipart as OriginalMultipart } from '../../decorators/multipart.decorator.mjs'\nimport { createMethodContext } from '../context-compat.mjs'\n\n/**\n * Type helper to constrain a PropertyDescriptor's value to match a multipart endpoint signature.\n * Note: In legacy decorators, type constraints are checked when the decorator is applied,\n * but may not be preserved perfectly when decorators are stacked.\n */\ntype MultipartMethodDescriptor<Config extends EndpointOptions> =\n  TypedPropertyDescriptor<\n    (\n      params: RequestArgs<\n        Config['url'],\n        Config['querySchema'],\n        Config['requestSchema'],\n        Config['urlParamsSchema'],\n        true\n      >,\n    ) => Promise<z.input<Config['responseSchema']>>\n  >\n\n/**\n * Legacy-compatible Multipart decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n * Provides type safety by ensuring method signatures match the endpoint configuration.\n *\n * @param endpoint - The multipart endpoint declaration from @navios/builder\n * @returns A method decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * @Controller()\n * export class FileController {\n *   @Multipart(uploadFileEndpoint)\n *   async uploadFile(request: MultipartParams<typeof uploadFileEndpoint>): MultipartResult<typeof uploadFileEndpoint> {\n *     const { file } = request.data\n *     return { url: 'https://example.com/file.jpg' }\n *   }\n * }\n * ```\n */\nexport function Multipart<const Config extends EndpointOptions>(\n  endpoint: EndpointHandler<Config, false>,\n) {\n  return function <T extends object>(\n    target: T,\n    propertyKey: string | symbol,\n    descriptor: MultipartMethodDescriptor<Config>,\n  ): PropertyDescriptor | void {\n    if (!descriptor) {\n      throw new Error(\n        '[Navios] @Multipart decorator requires a method descriptor. Make sure experimentalDecorators is enabled.',\n      )\n    }\n    const context = createMethodContext(target, propertyKey, descriptor)\n    const originalDecorator = OriginalMultipart(endpoint)\n    // @ts-expect-error - we don't need to type the value\n    const result = originalDecorator(descriptor.value, context)\n    if (result !== descriptor.value) {\n      descriptor.value = result as any\n    }\n    return descriptor\n  }\n}\n","import type {\n  BaseEndpointOptions,\n  RequestArgs,\n  StreamHandler,\n} from '@navios/builder'\n\nimport { Stream as OriginalStream } from '../../decorators/stream.decorator.mjs'\nimport { createMethodContext } from '../context-compat.mjs'\n\n/**\n * Type helper to constrain a PropertyDescriptor's value to match a stream endpoint signature.\n * Supports both with and without reply parameter (Bun doesn't use reply parameter).\n * Note: In legacy decorators, type constraints are checked when the decorator is applied,\n * but may not be preserved perfectly when decorators are stacked.\n */\ntype StreamMethodDescriptor<Config extends BaseEndpointOptions> =\n  | TypedPropertyDescriptor<\n      (\n        params: RequestArgs<\n          Config['url'],\n          Config['querySchema'],\n          Config['requestSchema'],\n          Config['urlParamsSchema'],\n          true\n        >,\n        reply: any,\n      ) => any\n    >\n  | TypedPropertyDescriptor<\n      (\n        params: RequestArgs<\n          Config['url'],\n          Config['querySchema'],\n          Config['requestSchema'],\n          Config['urlParamsSchema'],\n          true\n        >,\n      ) => any\n    >\n\n/**\n * Legacy-compatible Stream decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n * Provides type safety by ensuring method signatures match the endpoint configuration.\n *\n * @param endpoint - The stream endpoint declaration from @navios/builder\n * @returns A method decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * @Controller()\n * export class FileController {\n *   @Stream(downloadFileEndpoint)\n *   async downloadFile(request: StreamParams<typeof downloadFileEndpoint>, reply: any) {\n *     const { fileId } = request.urlParams\n *     // Stream file data to reply\n *   }\n * }\n * ```\n */\nexport function Stream<const Config extends BaseEndpointOptions>(\n  endpoint: StreamHandler<Config, false>,\n) {\n  return function (\n    target: any,\n    propertyKey: string | symbol,\n    descriptor: StreamMethodDescriptor<Config>,\n  ): PropertyDescriptor | void {\n    if (!descriptor || !descriptor.value) {\n      throw new Error(\n        '[Navios] @Stream decorator requires a method descriptor. Make sure experimentalDecorators is enabled.',\n      )\n    }\n    // Type check the descriptor value matches expected signature\n    const typedDescriptor = descriptor as StreamMethodDescriptor<Config>\n    const context = createMethodContext(target, propertyKey, typedDescriptor)\n    const originalDecorator = OriginalStream(endpoint)\n    // Stage3 decorator returns void in type signature but actually returns the function\n    // We know value is defined because we checked above\n    const result = originalDecorator(typedDescriptor.value!, context) as\n      | typeof typedDescriptor.value\n      | void\n    if (result && result !== typedDescriptor.value) {\n      typedDescriptor.value = result as any\n    }\n    return typedDescriptor\n  }\n}\n","import type { ClassType } from '@navios/di'\n\nimport {\n  Injectable as OriginalInjectable,\n  type InjectableOptions,\n} from '@navios/di'\n\nimport { createClassContext } from '../context-compat.mjs'\n\nexport type { InjectableOptions }\n\n/**\n * Legacy-compatible Injectable decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n *\n * @param options - Injectable configuration options\n * @returns A class decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * @Injectable()\n * export class UserService {\n *   getUser(id: string) {\n *     return { id, name: 'John' }\n *   }\n * }\n * ```\n */\nexport function Injectable(options: InjectableOptions = {}) {\n  return function (target: ClassType) {\n    const context = createClassContext(target)\n    // Use the no-args overload when options is empty, otherwise pass options\n    const originalDecorator =\n      Object.keys(options).length === 0\n        ? OriginalInjectable()\n        : // @ts-expect-error - InjectableOptions is a union type, we let runtime handle it\n          OriginalInjectable(options)\n    return originalDecorator(target, context)\n  }\n}\n","import type { ClassType, FactoryOptions } from '@navios/di'\n\nimport { Factory as OriginalFactory } from '@navios/di'\n\nimport { createClassContext } from '../context-compat.mjs'\n\nexport type { FactoryOptions }\n\n/**\n * Legacy-compatible Factory decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n *\n * @param options - Factory configuration options\n * @returns A class decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * @Factory()\n * export class DatabaseConnectionFactory {\n *   create() {\n *     return { host: 'localhost', port: 5432 }\n *   }\n * }\n * ```\n */\nexport function Factory(options: FactoryOptions = {}) {\n  return function (target: ClassType) {\n    const context = createClassContext(target)\n    // Use the no-args overload when options is empty, otherwise pass options\n    const originalDecorator =\n      Object.keys(options).length === 0\n        ? OriginalFactory()\n        : OriginalFactory(options)\n    return originalDecorator(target, context)\n  }\n}\n","import type { z, ZodType } from 'zod/v4'\nimport type { ClassType } from '@navios/di'\n\nimport type {\n  ControllerMetadata,\n  HandlerMetadata,\n  ModuleMetadata,\n} from '../metadata/index.mjs'\n\nimport {\n  getControllerMetadata,\n  getEndpointMetadata,\n  getModuleMetadata,\n  hasControllerMetadata,\n  hasModuleMetadata,\n} from '../metadata/index.mjs'\nimport {\n  getManagedMetadata,\n  hasManagedMetadata,\n} from '../metadata/navios-managed.metadata.mjs'\nimport { createClassContext, createMethodContext } from './context-compat.mjs'\n\n/**\n * Type for a legacy class/method attribute decorator without a value.\n *\n * Attributes are custom metadata decorators that can be applied to modules,\n * controllers, and endpoints.\n */\nexport type LegacyClassAttribute = {\n  (): ClassDecorator & MethodDecorator\n  token: symbol\n}\n\n/**\n * Type for a legacy class/method attribute decorator with a validated value.\n *\n * @typeParam S - The Zod schema type for validation\n */\nexport type LegacyClassSchemaAttribute<S extends ZodType> = {\n  (value: z.input<S>): ClassDecorator & MethodDecorator\n  token: symbol\n  schema: ZodType\n}\n\n/**\n * Legacy-compatible factory for creating custom attribute decorators.\n *\n * Works with TypeScript experimental decorators (legacy API).\n *\n * Attributes allow you to add custom metadata to modules, controllers, and endpoints.\n * This is useful for cross-cutting concerns like rate limiting, caching, API versioning, etc.\n *\n * @example\n * ```typescript\n * // Create a simple boolean attribute\n * const Public = LegacyAttributeFactory.createAttribute(Symbol.for('Public'))\n *\n * // Use it as a decorator\n * @Controller()\n * @Public()\n * export class PublicController { }\n *\n * // Check if attribute exists\n * if (LegacyAttributeFactory.has(Public, controllerMetadata)) {\n *   // Skip authentication\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Create an attribute with a validated value\n * const RateLimit = LegacyAttributeFactory.createAttribute(\n *   Symbol.for('RateLimit'),\n *   z.object({ requests: z.number(), window: z.number() })\n * )\n *\n * // Use it with a value\n * @Endpoint(apiEndpoint)\n * @RateLimit({ requests: 100, window: 60000 })\n * async handler() { }\n *\n * // Get the value\n * const limit = LegacyAttributeFactory.get(RateLimit, endpointMetadata)\n * // limit is typed as { requests: number, window: number } | null\n * ```\n */\nexport class LegacyAttributeFactory {\n  /**\n   * Creates a simple attribute decorator without a value.\n   *\n   * @param token - A unique symbol to identify this attribute\n   * @returns A decorator function that can be applied to classes or methods\n   *\n   * @example\n   * ```typescript\n   * const Public = LegacyAttributeFactory.createAttribute(Symbol.for('Public'))\n   *\n   * @Public()\n   * @Controller()\n   * export class PublicController { }\n   * ```\n   */\n  static createAttribute(token: symbol): LegacyClassAttribute\n  /**\n   * Creates an attribute decorator with a validated value.\n   *\n   * @param token - A unique symbol to identify this attribute\n   * @param schema - A Zod schema to validate the attribute value\n   * @returns A decorator function that accepts a value and can be applied to classes or methods\n   *\n   * @example\n   * ```typescript\n   * const RateLimit = LegacyAttributeFactory.createAttribute(\n   *   Symbol.for('RateLimit'),\n   *   z.object({ requests: z.number(), window: z.number() })\n   * )\n   *\n   * @RateLimit({ requests: 100, window: 60000 })\n   * @Endpoint(apiEndpoint)\n   * async handler() { }\n   * ```\n   */\n  static createAttribute<T extends ZodType>(\n    token: symbol,\n    schema: T,\n  ): LegacyClassSchemaAttribute<T>\n\n  static createAttribute(token: symbol, schema?: ZodType) {\n    const res = (value?: unknown) => {\n      // Return a decorator that can handle both class and method targets\n      function decorator(target: any): any\n      function decorator(\n        target: any,\n        propertyKey: string | symbol,\n        descriptor: PropertyDescriptor,\n      ): PropertyDescriptor\n      function decorator(\n        target: any,\n        propertyKey?: string | symbol,\n        descriptor?: PropertyDescriptor,\n      ): any {\n        const isMethodDecorator =\n          propertyKey !== undefined && descriptor !== undefined\n\n        if (isMethodDecorator) {\n          // Method decorator - apply to endpoint\n          const context = createMethodContext(target, propertyKey, descriptor)\n          const metadata = getEndpointMetadata(descriptor.value, context)\n\n          if (schema) {\n            const validatedValue = schema.safeParse(value)\n            if (!validatedValue.success) {\n              throw new Error(\n                `[Navios] Invalid value for attribute ${token.toString()}: ${validatedValue.error}`,\n              )\n            }\n            metadata.customAttributes.set(token, validatedValue.data)\n          } else {\n            metadata.customAttributes.set(token, true)\n          }\n          return descriptor\n        } else {\n          // Class decorator\n          const isController = hasControllerMetadata(target as ClassType)\n          const isModule = hasModuleMetadata(target as ClassType)\n          const isManaged = hasManagedMetadata(target as ClassType)\n\n          if (!isController && !isModule && !isManaged) {\n            throw new Error(\n              '[Navios] Attribute can only be applied to classes with @Controller, @Module, or other Navios-managed decorators',\n            )\n          }\n\n          const context = createClassContext(target)\n          const metadata = isController\n            ? getControllerMetadata(target, context)\n            : isModule\n              ? getModuleMetadata(target, context)\n              : isManaged\n                ? getManagedMetadata(target)!\n                : null\n\n          if (!metadata) {\n            throw new Error(\n              '[Navios] Could not determine metadata for attribute target',\n            )\n          }\n\n          if (schema) {\n            const validatedValue = schema.safeParse(value)\n            if (!validatedValue.success) {\n              throw new Error(\n                `[Navios] Invalid value for attribute ${token.toString()}: ${validatedValue.error}`,\n              )\n            }\n            metadata.customAttributes.set(token, validatedValue.data)\n          } else {\n            metadata.customAttributes.set(token, true)\n          }\n          return target\n        }\n      }\n      return decorator\n    }\n    res.token = token\n    if (schema) {\n      res.schema = schema\n    }\n    return res\n  }\n\n  /**\n   * Gets the value of an attribute from metadata.\n   *\n   * Returns `null` if the attribute is not present.\n   * For simple attributes (without values), returns `true` if present.\n   *\n   * @param attribute - The attribute decorator\n   * @param target - The metadata object (module, controller, or handler)\n   * @returns The attribute value, `true` for simple attributes, or `null` if not found\n   *\n   * @example\n   * ```typescript\n   * const isPublic = LegacyAttributeFactory.get(Public, controllerMetadata)\n   * // isPublic is true | null\n   *\n   * const rateLimit = LegacyAttributeFactory.get(RateLimit, endpointMetadata)\n   * // rateLimit is { requests: number, window: number } | null\n   * ```\n   */\n  static get(\n    attribute: LegacyClassAttribute,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ): true | null\n  static get<T extends ZodType>(\n    attribute: LegacyClassSchemaAttribute<T>,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ): z.output<T> | null\n  static get(\n    attribute: LegacyClassAttribute | LegacyClassSchemaAttribute<any>,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ) {\n    return target.customAttributes.get(attribute.token) ?? null\n  }\n\n  /**\n   * Gets all values of an attribute from metadata (useful when an attribute can appear multiple times).\n   *\n   * Returns `null` if the attribute is not present.\n   *\n   * @param attribute - The attribute decorator\n   * @param target - The metadata object (module, controller, or handler)\n   * @returns An array of attribute values, or `null` if not found\n   *\n   * @example\n   * ```typescript\n   * const tags = LegacyAttributeFactory.getAll(Tag, endpointMetadata)\n   * // tags is string[] | null\n   * ```\n   */\n  static getAll(\n    attribute: LegacyClassAttribute,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ): Array<true> | null\n  static getAll<T extends ZodType>(\n    attribute: LegacyClassSchemaAttribute<T>,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ): Array<z.output<T>> | null\n  static getAll(\n    attribute: LegacyClassAttribute | LegacyClassSchemaAttribute<any>,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ) {\n    const values = Array.from(target.customAttributes.entries())\n      .filter(([key]) => key === attribute.token)\n      .map(([, value]) => value)\n    return values.length > 0 ? values : null\n  }\n\n  /**\n   * Gets the last value of an attribute from an array of metadata objects.\n   *\n   * Searches from the end of the array backwards, useful for finding the most\n   * specific attribute value (e.g., endpoint-level overrides module-level).\n   *\n   * @param attribute - The attribute decorator\n   * @param target - An array of metadata objects (typically [module, controller, handler])\n   * @returns The last attribute value found, or `null` if not found\n   *\n   * @example\n   * ```typescript\n   * // Check attribute hierarchy: endpoint -> controller -> module\n   * const rateLimit = LegacyAttributeFactory.getLast(RateLimit, [\n   *   moduleMetadata,\n   *   controllerMetadata,\n   *   endpointMetadata\n   * ])\n   * ```\n   */\n  static getLast(\n    attribute: LegacyClassAttribute,\n    target: (ModuleMetadata | ControllerMetadata | HandlerMetadata<any>)[],\n  ): true | null\n  static getLast<T extends ZodType>(\n    attribute: LegacyClassSchemaAttribute<T>,\n    target: (ModuleMetadata | ControllerMetadata | HandlerMetadata<any>)[],\n  ): z.output<T> | null\n  static getLast(\n    attribute: LegacyClassAttribute | LegacyClassSchemaAttribute<any>,\n    target: (ModuleMetadata | ControllerMetadata | HandlerMetadata<any>)[],\n  ) {\n    for (let i = target.length - 1; i >= 0; i--) {\n      const value = target[i].customAttributes.get(attribute.token)\n      if (value) {\n        return value\n      }\n    }\n    return null\n  }\n\n  /**\n   * Checks if an attribute is present on the metadata object.\n   *\n   * @param attribute - The attribute decorator\n   * @param target - The metadata object (module, controller, or handler)\n   * @returns `true` if the attribute is present, `false` otherwise\n   *\n   * @example\n   * ```typescript\n   * if (LegacyAttributeFactory.has(Public, controllerMetadata)) {\n   *   // Skip authentication\n   * }\n   * ```\n   */\n  static has(\n    attribute: LegacyClassAttribute,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ): boolean\n  static has<T extends ZodType>(\n    attribute: LegacyClassSchemaAttribute<T>,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ): boolean\n  static has(\n    attribute: LegacyClassAttribute | LegacyClassSchemaAttribute<any>,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ) {\n    return target.customAttributes.has(attribute.token)\n  }\n}\n\n// Re-export as AttributeFactory for convenience\nexport { LegacyAttributeFactory as AttributeFactory }\n"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":["createClassContext","Module","OriginalModule","options","controllers","imports","guards","target","context","originalDecorator","createClassContext","Controller","OriginalController","options","target","context","originalDecorator","createMethodContext","Endpoint","OriginalEndpoint","endpoint","target","propertyKey","descriptor","Error","typedDescriptor","context","originalDecorator","result","value","createClassContext","createMethodContext","UseGuards","OriginalUseGuards","guards","decoratorImpl","target","propertyKey","descriptor","undefined","context","originalDecorator","result","value","createMethodContext","Header","OriginalHeader","name","value","target","propertyKey","descriptor","context","originalDecorator","result","createMethodContext","HttpCode","OriginalHttpCode","code","target","propertyKey","descriptor","context","originalDecorator","result","value","createMethodContext","Multipart","OriginalMultipart","endpoint","target","propertyKey","descriptor","Error","context","originalDecorator","result","value","createMethodContext","Stream","OriginalStream","endpoint","target","propertyKey","descriptor","value","Error","typedDescriptor","context","originalDecorator","result","createClassContext","createMethodContext","getControllerMetadata","getEndpointMetadata","getModuleMetadata","hasControllerMetadata","hasModuleMetadata","getManagedMetadata","hasManagedMetadata","LegacyAttributeFactory","createAttribute","token","schema","res","value","decorator","target","propertyKey","descriptor","isMethodDecorator","undefined","context","metadata","validatedValue","safeParse","success","Error","toString","error","customAttributes","set","data","isController","isModule","isManaged","get","attribute","getAll","values","Array","from","entries","filter","key","map","length","getLast","i","has","AttributeFactory"],"sources":["../../src/legacy-compat/decorators/module.decorator.mts","../../src/legacy-compat/decorators/controller.decorator.mts","../../src/legacy-compat/decorators/endpoint.decorator.mts","../../src/legacy-compat/decorators/use-guards.decorator.mts","../../src/legacy-compat/decorators/header.decorator.mts","../../src/legacy-compat/decorators/http-code.decorator.mts","../../src/legacy-compat/decorators/multipart.decorator.mts","../../src/legacy-compat/decorators/stream.decorator.mts","../../src/legacy-compat/attribute.factory.mts"],"sourcesContent":["import type { ClassType } from '@navios/di'\nimport { createClassContext } from '@navios/di/legacy-compat'\n\nimport { Module as OriginalModule, type ModuleOptions } from '../../decorators/module.decorator.mjs'\n\n/**\n * Legacy-compatible Module decorator.\n * \n * Works with TypeScript experimental decorators (legacy API).\n * \n * @param options - Module configuration options\n * @returns A class decorator compatible with legacy decorator API\n * \n * @example\n * ```typescript\n * @Module({\n *   controllers: [UserController, AuthController],\n *   imports: [DatabaseModule],\n *   guards: [AuthGuard],\n * })\n * export class AppModule {}\n * ```\n */\nexport function Module(\n  options: ModuleOptions = {\n    controllers: [],\n    imports: [],\n    guards: [],\n  },\n) {\n  return function (target: ClassType) {\n    const context = createClassContext(target)\n    const originalDecorator = OriginalModule(options)\n    return originalDecorator(target, context)\n  }\n}\n\n","import type { ClassType } from '@navios/di'\nimport { createClassContext } from '@navios/di/legacy-compat'\n\nimport type { ControllerOptions } from '../../decorators/controller.decorator.mjs'\n\nimport { Controller as OriginalController } from '../../decorators/controller.decorator.mjs'\n\n/**\n * Legacy-compatible Controller decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n *\n * @param options - Controller configuration options\n * @returns A class decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * @Controller({ guards: [AuthGuard] })\n * export class UserController {\n *   @Endpoint(getUserEndpoint)\n *   async getUser() { }\n * }\n * ```\n */\nexport function Controller(options: ControllerOptions = {}) {\n  return function (target: ClassType) {\n    const context = createClassContext(target)\n    const originalDecorator = OriginalController(options)\n    return originalDecorator(target, context)\n  }\n}\n","import type {\n  EndpointHandler,\n  EndpointOptions,\n  RequestArgs,\n} from '@navios/builder'\nimport { createMethodContext } from '@navios/di/legacy-compat'\nimport type { z } from 'zod/v4'\n\nimport { Endpoint as OriginalEndpoint } from '../../decorators/endpoint.decorator.mjs'\n\n/**\n * Type helper to constrain a PropertyDescriptor's value to match an endpoint signature.\n * Note: In legacy decorators, type constraints are checked when the decorator is applied,\n * but may not be preserved perfectly when decorators are stacked.\n */\ntype EndpointMethodDescriptor<Config extends EndpointOptions> =\n  TypedPropertyDescriptor<\n    (\n      params: RequestArgs<\n        Config['url'],\n        Config['querySchema'],\n        Config['requestSchema'],\n        Config['urlParamsSchema'],\n        true\n      >,\n    ) => Promise<z.input<Config['responseSchema']>>\n  >\n\n/**\n * Legacy-compatible Endpoint decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n * Provides type safety by ensuring method signatures match the endpoint configuration.\n *\n * @param endpoint - The endpoint declaration from @navios/builder\n * @returns A method decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * @Controller()\n * export class UserController {\n *   @Endpoint(getUserEndpoint)\n *   async getUser(request: EndpointParams<typeof getUserEndpoint>): EndpointResult<typeof getUserEndpoint> {\n *     return { id: '1', name: 'John' }\n *   }\n * }\n * ```\n */\nexport function Endpoint<const Config extends EndpointOptions>(\n  endpoint: EndpointHandler<Config, false>,\n) {\n  return function (\n    target: any,\n    propertyKey: string | symbol,\n    descriptor: EndpointMethodDescriptor<Config>,\n  ): PropertyDescriptor | void {\n    if (!descriptor) {\n      throw new Error(\n        '[Navios] @Endpoint decorator requires a method descriptor. Make sure experimentalDecorators is enabled.',\n      )\n    }\n    // Type check the descriptor value matches expected signature\n    const typedDescriptor = descriptor as EndpointMethodDescriptor<Config>\n    const context = createMethodContext(target, propertyKey, typedDescriptor)\n    const originalDecorator = OriginalEndpoint(endpoint)\n    // @ts-expect-error - we don't need to type the value\n    const result = originalDecorator(typedDescriptor.value, context)\n    if (result !== typedDescriptor.value) {\n      typedDescriptor.value = result as any\n    }\n    return typedDescriptor\n  }\n}\n","import type {\n  ClassType,\n  ClassTypeWithInstance,\n  InjectionToken,\n} from '@navios/di'\nimport { createClassContext, createMethodContext } from '@navios/di/legacy-compat'\n\nimport type { CanActivate } from '../../interfaces/index.mjs'\n\nimport { UseGuards as OriginalUseGuards } from '../../decorators/use-guards.decorator.mjs'\n\n/**\n * Legacy-compatible UseGuards decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n * Can be applied to classes or methods.\n *\n * @param guards - Guard classes or injection tokens to apply\n * @returns A class or method decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * // Apply to a controller\n * @Controller()\n * @UseGuards(AuthGuard, RoleGuard)\n * export class UserController { }\n *\n * // Apply to a specific endpoint\n * @Controller()\n * export class UserController {\n *   @Endpoint(getUserEndpoint)\n *   @UseGuards(AuthGuard)\n *   async getUser() { }\n * }\n * ```\n */\nexport function UseGuards(\n  ...guards: (\n    | ClassTypeWithInstance<CanActivate>\n    | InjectionToken<CanActivate, undefined>\n  )[]\n) {\n  // Create the decorator function\n  // Note: TypeScript's legacy decorator system has strict type checking for decorators\n  // We use a flexible implementation that works for both class and method decorators\n  function decoratorImpl(\n    target: ClassType | Function,\n    propertyKey?: string | symbol,\n    descriptor?: PropertyDescriptor,\n  ): any {\n    // Determine if this is a class or method decorator\n    if (propertyKey !== undefined && descriptor !== undefined) {\n      // Method decorator\n      const context = createMethodContext(\n        target as Function,\n        propertyKey,\n        descriptor,\n      )\n      const originalDecorator = OriginalUseGuards(...guards)\n      const result = originalDecorator(descriptor.value, context)\n      if (result !== descriptor.value) {\n        descriptor.value = result\n      }\n      return descriptor\n    } else {\n      // Class decorator\n      const context = createClassContext(target as ClassType)\n      const originalDecorator = OriginalUseGuards(...guards)\n      return originalDecorator(target as ClassType, context)\n    }\n  }\n\n  // Return with 'any' type to work around TypeScript's strict decorator checking\n  // TypeScript's legacy decorator system cannot properly type-check decorators\n  // that work as both class and method decorators. The runtime behavior is correct.\n  // When used as a class decorator, it returns the class (preserving type at runtime)\n  // When used as a method decorator, it returns the PropertyDescriptor\n  // @ts-ignore - TypeScript limitation with dual-purpose legacy decorators\n  return decoratorImpl as any\n}\n","import { createMethodContext } from '@navios/di/legacy-compat'\n\nimport type { HttpHeader } from '../../interfaces/index.mjs'\n\nimport { Header as OriginalHeader } from '../../decorators/header.decorator.mjs'\n\n/**\n * Legacy-compatible Header decorator.\n * \n * Works with TypeScript experimental decorators (legacy API).\n * \n * @param name - The header name (e.g., 'Content-Type', 'Cache-Control')\n * @param value - The header value (string, number, or array of strings)\n * @returns A method decorator compatible with legacy decorator API\n * \n * @example\n * ```typescript\n * @Controller()\n * export class UserController {\n *   @Endpoint(getUserEndpoint)\n *   @Header('Cache-Control', 'max-age=3600')\n *   async getUser() {\n *     return { id: '1', name: 'John' }\n *   }\n * }\n * ```\n */\nexport function Header(name: HttpHeader, value: string | number | string[]) {\n  return function <T extends object>(\n    target: T,\n    propertyKey: string | symbol,\n    descriptor: PropertyDescriptor,\n  ) {\n    const context = createMethodContext(target, propertyKey, descriptor)\n    const originalDecorator = OriginalHeader(name, value)\n    const result = originalDecorator(descriptor.value, context)\n    if (result !== descriptor.value) {\n      descriptor.value = result\n    }\n    return descriptor\n  }\n}\n\n","import { createMethodContext } from '@navios/di/legacy-compat'\n\nimport { HttpCode as OriginalHttpCode } from '../../decorators/http-code.decorator.mjs'\n\n/**\n * Legacy-compatible HttpCode decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n *\n * @param code - The HTTP status code to return (e.g., 201, 204, 202)\n * @returns A method decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * @Controller()\n * export class UserController {\n *   @Endpoint(createUserEndpoint)\n *   @HttpCode(201)\n *   async createUser() {\n *     return { id: '1', name: 'John' }\n *   }\n * }\n * ```\n */\nexport function HttpCode(code: number) {\n  return function <T extends object>(\n    target: T,\n    propertyKey: string | symbol,\n    descriptor: PropertyDescriptor,\n  ) {\n    const context = createMethodContext(target, propertyKey, descriptor)\n    const originalDecorator = OriginalHttpCode(code)\n    const result = originalDecorator(descriptor.value, context)\n    if (result !== descriptor.value) {\n      descriptor.value = result\n    }\n    return descriptor\n  }\n}\n","import type {\n  EndpointHandler,\n  EndpointOptions,\n  RequestArgs,\n} from '@navios/builder'\nimport { createMethodContext } from '@navios/di/legacy-compat'\nimport type { z } from 'zod/v4'\n\nimport { Multipart as OriginalMultipart } from '../../decorators/multipart.decorator.mjs'\n\n/**\n * Type helper to constrain a PropertyDescriptor's value to match a multipart endpoint signature.\n * Note: In legacy decorators, type constraints are checked when the decorator is applied,\n * but may not be preserved perfectly when decorators are stacked.\n */\ntype MultipartMethodDescriptor<Config extends EndpointOptions> =\n  TypedPropertyDescriptor<\n    (\n      params: RequestArgs<\n        Config['url'],\n        Config['querySchema'],\n        Config['requestSchema'],\n        Config['urlParamsSchema'],\n        true\n      >,\n    ) => Promise<z.input<Config['responseSchema']>>\n  >\n\n/**\n * Legacy-compatible Multipart decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n * Provides type safety by ensuring method signatures match the endpoint configuration.\n *\n * @param endpoint - The multipart endpoint declaration from @navios/builder\n * @returns A method decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * @Controller()\n * export class FileController {\n *   @Multipart(uploadFileEndpoint)\n *   async uploadFile(request: MultipartParams<typeof uploadFileEndpoint>): MultipartResult<typeof uploadFileEndpoint> {\n *     const { file } = request.data\n *     return { url: 'https://example.com/file.jpg' }\n *   }\n * }\n * ```\n */\nexport function Multipart<const Config extends EndpointOptions>(\n  endpoint: EndpointHandler<Config, false>,\n) {\n  return function <T extends object>(\n    target: T,\n    propertyKey: string | symbol,\n    descriptor: MultipartMethodDescriptor<Config>,\n  ): PropertyDescriptor | void {\n    if (!descriptor) {\n      throw new Error(\n        '[Navios] @Multipart decorator requires a method descriptor. Make sure experimentalDecorators is enabled.',\n      )\n    }\n    const context = createMethodContext(target, propertyKey, descriptor)\n    const originalDecorator = OriginalMultipart(endpoint)\n    // @ts-expect-error - we don't need to type the value\n    const result = originalDecorator(descriptor.value, context)\n    if (result !== descriptor.value) {\n      descriptor.value = result as any\n    }\n    return descriptor\n  }\n}\n","import type {\n  BaseEndpointOptions,\n  RequestArgs,\n  StreamHandler,\n} from '@navios/builder'\nimport { createMethodContext } from '@navios/di/legacy-compat'\n\nimport { Stream as OriginalStream } from '../../decorators/stream.decorator.mjs'\n\n/**\n * Type helper to constrain a PropertyDescriptor's value to match a stream endpoint signature.\n * Supports both with and without reply parameter (Bun doesn't use reply parameter).\n * Note: In legacy decorators, type constraints are checked when the decorator is applied,\n * but may not be preserved perfectly when decorators are stacked.\n */\ntype StreamMethodDescriptor<Config extends BaseEndpointOptions> =\n  | TypedPropertyDescriptor<\n      (\n        params: RequestArgs<\n          Config['url'],\n          Config['querySchema'],\n          Config['requestSchema'],\n          Config['urlParamsSchema'],\n          true\n        >,\n        reply: any,\n      ) => any\n    >\n  | TypedPropertyDescriptor<\n      (\n        params: RequestArgs<\n          Config['url'],\n          Config['querySchema'],\n          Config['requestSchema'],\n          Config['urlParamsSchema'],\n          true\n        >,\n      ) => any\n    >\n\n/**\n * Legacy-compatible Stream decorator.\n *\n * Works with TypeScript experimental decorators (legacy API).\n * Provides type safety by ensuring method signatures match the endpoint configuration.\n *\n * @param endpoint - The stream endpoint declaration from @navios/builder\n * @returns A method decorator compatible with legacy decorator API\n *\n * @example\n * ```typescript\n * @Controller()\n * export class FileController {\n *   @Stream(downloadFileEndpoint)\n *   async downloadFile(request: StreamParams<typeof downloadFileEndpoint>, reply: any) {\n *     const { fileId } = request.urlParams\n *     // Stream file data to reply\n *   }\n * }\n * ```\n */\nexport function Stream<const Config extends BaseEndpointOptions>(\n  endpoint: StreamHandler<Config, false>,\n) {\n  return function (\n    target: any,\n    propertyKey: string | symbol,\n    descriptor: StreamMethodDescriptor<Config>,\n  ): PropertyDescriptor | void {\n    if (!descriptor || !descriptor.value) {\n      throw new Error(\n        '[Navios] @Stream decorator requires a method descriptor. Make sure experimentalDecorators is enabled.',\n      )\n    }\n    // Type check the descriptor value matches expected signature\n    const typedDescriptor = descriptor as StreamMethodDescriptor<Config>\n    const context = createMethodContext(target, propertyKey, typedDescriptor)\n    const originalDecorator = OriginalStream(endpoint)\n    // Stage3 decorator returns void in type signature but actually returns the function\n    // We know value is defined because we checked above\n    const result = originalDecorator(typedDescriptor.value!, context) as\n      | typeof typedDescriptor.value\n      | void\n    if (result && result !== typedDescriptor.value) {\n      typedDescriptor.value = result as any\n    }\n    return typedDescriptor\n  }\n}\n","import type { ClassType } from '@navios/di'\nimport { createClassContext, createMethodContext } from '@navios/di/legacy-compat'\nimport type { z, ZodType } from 'zod/v4'\n\nimport type {\n  ControllerMetadata,\n  HandlerMetadata,\n  ModuleMetadata,\n} from '../metadata/index.mjs'\n\nimport {\n  getControllerMetadata,\n  getEndpointMetadata,\n  getModuleMetadata,\n  hasControllerMetadata,\n  hasModuleMetadata,\n} from '../metadata/index.mjs'\nimport {\n  getManagedMetadata,\n  hasManagedMetadata,\n} from '../metadata/navios-managed.metadata.mjs'\n\n/**\n * Type for a legacy class/method attribute decorator without a value.\n *\n * Attributes are custom metadata decorators that can be applied to modules,\n * controllers, and endpoints.\n */\nexport type LegacyClassAttribute = {\n  (): ClassDecorator & MethodDecorator\n  token: symbol\n}\n\n/**\n * Type for a legacy class/method attribute decorator with a validated value.\n *\n * @typeParam S - The Zod schema type for validation\n */\nexport type LegacyClassSchemaAttribute<S extends ZodType> = {\n  (value: z.input<S>): ClassDecorator & MethodDecorator\n  token: symbol\n  schema: ZodType\n}\n\n/**\n * Legacy-compatible factory for creating custom attribute decorators.\n *\n * Works with TypeScript experimental decorators (legacy API).\n *\n * Attributes allow you to add custom metadata to modules, controllers, and endpoints.\n * This is useful for cross-cutting concerns like rate limiting, caching, API versioning, etc.\n *\n * @example\n * ```typescript\n * // Create a simple boolean attribute\n * const Public = LegacyAttributeFactory.createAttribute(Symbol.for('Public'))\n *\n * // Use it as a decorator\n * @Controller()\n * @Public()\n * export class PublicController { }\n *\n * // Check if attribute exists\n * if (LegacyAttributeFactory.has(Public, controllerMetadata)) {\n *   // Skip authentication\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Create an attribute with a validated value\n * const RateLimit = LegacyAttributeFactory.createAttribute(\n *   Symbol.for('RateLimit'),\n *   z.object({ requests: z.number(), window: z.number() })\n * )\n *\n * // Use it with a value\n * @Endpoint(apiEndpoint)\n * @RateLimit({ requests: 100, window: 60000 })\n * async handler() { }\n *\n * // Get the value\n * const limit = LegacyAttributeFactory.get(RateLimit, endpointMetadata)\n * // limit is typed as { requests: number, window: number } | null\n * ```\n */\nexport class LegacyAttributeFactory {\n  /**\n   * Creates a simple attribute decorator without a value.\n   *\n   * @param token - A unique symbol to identify this attribute\n   * @returns A decorator function that can be applied to classes or methods\n   *\n   * @example\n   * ```typescript\n   * const Public = LegacyAttributeFactory.createAttribute(Symbol.for('Public'))\n   *\n   * @Public()\n   * @Controller()\n   * export class PublicController { }\n   * ```\n   */\n  static createAttribute(token: symbol): LegacyClassAttribute\n  /**\n   * Creates an attribute decorator with a validated value.\n   *\n   * @param token - A unique symbol to identify this attribute\n   * @param schema - A Zod schema to validate the attribute value\n   * @returns A decorator function that accepts a value and can be applied to classes or methods\n   *\n   * @example\n   * ```typescript\n   * const RateLimit = LegacyAttributeFactory.createAttribute(\n   *   Symbol.for('RateLimit'),\n   *   z.object({ requests: z.number(), window: z.number() })\n   * )\n   *\n   * @RateLimit({ requests: 100, window: 60000 })\n   * @Endpoint(apiEndpoint)\n   * async handler() { }\n   * ```\n   */\n  static createAttribute<T extends ZodType>(\n    token: symbol,\n    schema: T,\n  ): LegacyClassSchemaAttribute<T>\n\n  static createAttribute(token: symbol, schema?: ZodType) {\n    const res = (value?: unknown) => {\n      // Return a decorator that can handle both class and method targets\n      function decorator(target: any): any\n      function decorator(\n        target: any,\n        propertyKey: string | symbol,\n        descriptor: PropertyDescriptor,\n      ): PropertyDescriptor\n      function decorator(\n        target: any,\n        propertyKey?: string | symbol,\n        descriptor?: PropertyDescriptor,\n      ): any {\n        const isMethodDecorator =\n          propertyKey !== undefined && descriptor !== undefined\n\n        if (isMethodDecorator) {\n          // Method decorator - apply to endpoint\n          const context = createMethodContext(target, propertyKey, descriptor)\n          const metadata = getEndpointMetadata(descriptor.value, context)\n\n          if (schema) {\n            const validatedValue = schema.safeParse(value)\n            if (!validatedValue.success) {\n              throw new Error(\n                `[Navios] Invalid value for attribute ${token.toString()}: ${validatedValue.error}`,\n              )\n            }\n            metadata.customAttributes.set(token, validatedValue.data)\n          } else {\n            metadata.customAttributes.set(token, true)\n          }\n          return descriptor\n        } else {\n          // Class decorator\n          const isController = hasControllerMetadata(target as ClassType)\n          const isModule = hasModuleMetadata(target as ClassType)\n          const isManaged = hasManagedMetadata(target as ClassType)\n\n          if (!isController && !isModule && !isManaged) {\n            throw new Error(\n              '[Navios] Attribute can only be applied to classes with @Controller, @Module, or other Navios-managed decorators',\n            )\n          }\n\n          const context = createClassContext(target)\n          const metadata = isController\n            ? getControllerMetadata(target, context)\n            : isModule\n              ? getModuleMetadata(target, context)\n              : isManaged\n                ? getManagedMetadata(target)!\n                : null\n\n          if (!metadata) {\n            throw new Error(\n              '[Navios] Could not determine metadata for attribute target',\n            )\n          }\n\n          if (schema) {\n            const validatedValue = schema.safeParse(value)\n            if (!validatedValue.success) {\n              throw new Error(\n                `[Navios] Invalid value for attribute ${token.toString()}: ${validatedValue.error}`,\n              )\n            }\n            metadata.customAttributes.set(token, validatedValue.data)\n          } else {\n            metadata.customAttributes.set(token, true)\n          }\n          return target\n        }\n      }\n      return decorator\n    }\n    res.token = token\n    if (schema) {\n      res.schema = schema\n    }\n    return res\n  }\n\n  /**\n   * Gets the value of an attribute from metadata.\n   *\n   * Returns `null` if the attribute is not present.\n   * For simple attributes (without values), returns `true` if present.\n   *\n   * @param attribute - The attribute decorator\n   * @param target - The metadata object (module, controller, or handler)\n   * @returns The attribute value, `true` for simple attributes, or `null` if not found\n   *\n   * @example\n   * ```typescript\n   * const isPublic = LegacyAttributeFactory.get(Public, controllerMetadata)\n   * // isPublic is true | null\n   *\n   * const rateLimit = LegacyAttributeFactory.get(RateLimit, endpointMetadata)\n   * // rateLimit is { requests: number, window: number } | null\n   * ```\n   */\n  static get(\n    attribute: LegacyClassAttribute,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ): true | null\n  static get<T extends ZodType>(\n    attribute: LegacyClassSchemaAttribute<T>,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ): z.output<T> | null\n  static get(\n    attribute: LegacyClassAttribute | LegacyClassSchemaAttribute<any>,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ) {\n    return target.customAttributes.get(attribute.token) ?? null\n  }\n\n  /**\n   * Gets all values of an attribute from metadata (useful when an attribute can appear multiple times).\n   *\n   * Returns `null` if the attribute is not present.\n   *\n   * @param attribute - The attribute decorator\n   * @param target - The metadata object (module, controller, or handler)\n   * @returns An array of attribute values, or `null` if not found\n   *\n   * @example\n   * ```typescript\n   * const tags = LegacyAttributeFactory.getAll(Tag, endpointMetadata)\n   * // tags is string[] | null\n   * ```\n   */\n  static getAll(\n    attribute: LegacyClassAttribute,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ): Array<true> | null\n  static getAll<T extends ZodType>(\n    attribute: LegacyClassSchemaAttribute<T>,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ): Array<z.output<T>> | null\n  static getAll(\n    attribute: LegacyClassAttribute | LegacyClassSchemaAttribute<any>,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ) {\n    const values = Array.from(target.customAttributes.entries())\n      .filter(([key]) => key === attribute.token)\n      .map(([, value]) => value)\n    return values.length > 0 ? values : null\n  }\n\n  /**\n   * Gets the last value of an attribute from an array of metadata objects.\n   *\n   * Searches from the end of the array backwards, useful for finding the most\n   * specific attribute value (e.g., endpoint-level overrides module-level).\n   *\n   * @param attribute - The attribute decorator\n   * @param target - An array of metadata objects (typically [module, controller, handler])\n   * @returns The last attribute value found, or `null` if not found\n   *\n   * @example\n   * ```typescript\n   * // Check attribute hierarchy: endpoint -> controller -> module\n   * const rateLimit = LegacyAttributeFactory.getLast(RateLimit, [\n   *   moduleMetadata,\n   *   controllerMetadata,\n   *   endpointMetadata\n   * ])\n   * ```\n   */\n  static getLast(\n    attribute: LegacyClassAttribute,\n    target: (ModuleMetadata | ControllerMetadata | HandlerMetadata<any>)[],\n  ): true | null\n  static getLast<T extends ZodType>(\n    attribute: LegacyClassSchemaAttribute<T>,\n    target: (ModuleMetadata | ControllerMetadata | HandlerMetadata<any>)[],\n  ): z.output<T> | null\n  static getLast(\n    attribute: LegacyClassAttribute | LegacyClassSchemaAttribute<any>,\n    target: (ModuleMetadata | ControllerMetadata | HandlerMetadata<any>)[],\n  ) {\n    for (let i = target.length - 1; i >= 0; i--) {\n      const value = target[i].customAttributes.get(attribute.token)\n      if (value) {\n        return value\n      }\n    }\n    return null\n  }\n\n  /**\n   * Checks if an attribute is present on the metadata object.\n   *\n   * @param attribute - The attribute decorator\n   * @param target - The metadata object (module, controller, or handler)\n   * @returns `true` if the attribute is present, `false` otherwise\n   *\n   * @example\n   * ```typescript\n   * if (LegacyAttributeFactory.has(Public, controllerMetadata)) {\n   *   // Skip authentication\n   * }\n   * ```\n   */\n  static has(\n    attribute: LegacyClassAttribute,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ): boolean\n  static has<T extends ZodType>(\n    attribute: LegacyClassSchemaAttribute<T>,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ): boolean\n  static has(\n    attribute: LegacyClassAttribute | LegacyClassSchemaAttribute<any>,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ) {\n    return target.customAttributes.has(attribute.token)\n  }\n}\n\n// Re-export as AttributeFactory for convenience\nexport { LegacyAttributeFactory as AttributeFactory }\n"],"mappings":"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"}

package/lib/{src-C46ePe3d.cjs → src-CC5lmk_Q.cjs}

@@ -25,7 +25,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-const require_use_guards_decorator = require('./use-guards.decorator-B6tghdxM.cjs');
+const require_use_guards_decorator = require('./use-guards.decorator-DtCGXcWZ.cjs');
 let _navios_di = require("@navios/di");
 let node_process = require("node:process");
 let zod_v4 = require("zod/v4");
@@ -3802,6 +3802,165 @@ var InstanceResolverService = class {
 * @deprecated Use InstanceResolverService instead
 */ const ControllerResolverService = _InstanceResolverService;
 
+//#endregion
+//#region src/services/abstract-handler-adapter.service.mts
+const defaultOptions = {
+	adapter: [],
+	validateResponses: true,
+	enableRequestId: false
+};
+/**
+* Abstract base class for HTTP handler adapter services.
+*
+* Provides shared logic for:
+* - Controller resolution (singleton vs request-scoped)
+* - Argument formatting (sync/async detection)
+* - Handler generation with static/dynamic branching
+* - Standardized error handling
+*
+* Adapters implement abstract methods for framework-specific behavior:
+* - Request parsing (query, body, URL params)
+* - Response creation
+* - Schema provision
+*
+* Supports all adapter types:
+* - Endpoint adapters: JSON request/response with validation
+* - Stream adapters: Streaming responses with extra context
+* - Multipart adapters: Form data parsing (extends endpoint)
+*
+* @typeParam TRequest - Framework request type (BunRequest, FastifyRequest)
+* @typeParam TReply - Framework reply type (void for Bun, FastifyReply)
+* @typeParam TConfig - Endpoint configuration type
+*/ var AbstractHandlerAdapterService = class {
+	instanceResolver = (0, _navios_di.inject)(_InstanceResolverService);
+	options = (0, _navios_di.optional)(require_use_guards_decorator.NaviosOptionsToken) ?? defaultOptions;
+	/**
+	* Prepares argument getters for parsing request data.
+	*
+	* Public alias for createArgumentGetters to satisfy interface contracts.
+	* Subclasses should override createArgumentGetters instead.
+	*
+	* @param handlerMetadata - Handler metadata with schemas and configuration
+	* @returns Array of getter functions
+	*/ prepareArguments(handlerMetadata) {
+		return this.createArgumentGetters(handlerMetadata);
+	}
+	/**
+	* Checks if the handler has any validation schemas defined.
+	*
+	* Override in subclasses to add additional schema checks
+	* (e.g., response schema validation for endpoint adapters).
+	*
+	* @param handlerMetadata - Handler metadata with configuration
+	* @returns true if handler has schemas
+	*/ hasSchema(handlerMetadata) {
+		const config = handlerMetadata.config;
+		return !!config.requestSchema || !!config.querySchema;
+	}
+	/**
+	* Provides schema information for the framework's validation system.
+	*
+	* Override in subclasses for frameworks that support schema registration
+	* (e.g., Fastify). Default returns empty object (suitable for Bun).
+	*
+	* @param handlerMetadata - Handler metadata with configuration
+	* @returns Schema object for framework registration
+	*/ provideSchema(_handlerMetadata) {
+		return {};
+	}
+	/**
+	* Creates a request handler function for the endpoint.
+	*
+	* This method orchestrates the entire handler creation:
+	* 1. Prepares argument getters for request parsing
+	* 2. Builds optimized formatArguments function (sync/async)
+	* 3. Resolves the controller (singleton vs request-scoped)
+	* 4. Creates appropriate handler (static or dynamic)
+	*
+	* @param controller - Controller class containing the handler method
+	* @param handlerMetadata - Handler metadata with configuration
+	* @returns Handler result (static or dynamic)
+	*/ async provideHandler(controller, handlerMetadata) {
+		const getters = this.createArgumentGetters(handlerMetadata);
+		const formatArguments = this.buildFormatArguments(getters);
+		const hasArguments = getters.length > 0;
+		const context = {
+			methodName: handlerMetadata.classMethod,
+			statusCode: handlerMetadata.successStatusCode,
+			headers: handlerMetadata.headers,
+			handlerMetadata,
+			hasArguments
+		};
+		const resolution = await this.instanceResolver.resolve(controller);
+		if (resolution.cached) {
+			const cachedController = resolution.instance;
+			const boundMethod = cachedController[context.methodName].bind(cachedController);
+			return this.createStaticHandler(boundMethod, formatArguments, context);
+		}
+		return this.createDynamicHandler(resolution, formatArguments, context);
+	}
+	/**
+	* Builds a formatArguments function from argument getters.
+	*
+	* Automatically detects sync vs async getters and optimizes accordingly:
+	* - If all getters are sync: returns sync function (no Promise overhead)
+	* - If any getter is async: returns async function with Promise.all
+	* - If no getters: returns frozen empty object (zero allocation)
+	*
+	* This method is public to allow composition-based adapters (like XML adapter)
+	* to reuse the optimized formatArguments logic without inheritance.
+	*
+	* @param getters - Array of argument getter functions
+	* @returns Function to format arguments from request
+	*/ buildFormatArguments(getters) {
+		if (getters.length === 0) {
+			const emptyArgs = Object.freeze({});
+			return () => emptyArgs;
+		}
+		if (getters.some((g) => g.constructor.name === "AsyncFunction")) return async (request) => {
+			const argument = {};
+			const promises = [];
+			for (const getter of getters) {
+				const res = getter(argument, request);
+				if (res instanceof Promise) promises.push(res);
+			}
+			await Promise.all(promises);
+			return argument;
+		};
+		return (request) => {
+			const argument = {};
+			for (const getter of getters) getter(argument, request);
+			return argument;
+		};
+	}
+	/**
+	* Checks if the URL pattern contains URL parameters.
+	*
+	* @param config - Endpoint configuration
+	* @returns true if URL contains '$' parameter markers
+	*/ hasUrlParams(config) {
+		return config.url.includes("$");
+	}
+	/**
+	* Wraps handler execution with standardized error handling.
+	*
+	* Re-throws HttpExceptions as-is for framework error handlers.
+	* Other errors are re-thrown for global error handling.
+	*
+	* @param fn - Handler function to wrap
+	* @returns Wrapped function with error handling
+	*/ wrapWithErrorHandling(fn) {
+		return async (...args) => {
+			try {
+				return await fn(...args);
+			} catch (error) {
+				if (error && typeof error === "object" && "statusCode" in error) throw error;
+				throw error;
+			}
+		};
+	}
+};
+
 //#endregion
 //#region src/services/guard-runner.service.mts
 function applyDecs2203RFactory$10() {
@@ -7611,6 +7770,12 @@ var NaviosApplication = class {
 };
 
 //#endregion
+Object.defineProperty(exports, 'AbstractHandlerAdapterService', {
+  enumerable: true,
+  get: function () {
+    return AbstractHandlerAdapterService;
+  }
+});
 Object.defineProperty(exports, 'AttributeFactory', {
   enumerable: true,
   get: function () {
@@ -8019,4 +8184,4 @@ Object.defineProperty(exports, 'yellow', {
     return yellow;
   }
 });
-//# sourceMappingURL=src-C46ePe3d.cjs.map
+//# sourceMappingURL=src-CC5lmk_Q.cjs.map