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

package/lib/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["NaviosError","inject","Injectable","InjectionToken","z","Logger","ConfigServiceOptionsSchema","record","string","unknown","ConfigServiceToken","create","Symbol","for","token","ConfigService","config","logger","context","name","getConfig","get","key","parts","String","split","value","part","undefined","error","debug","getOrDefault","defaultValue","getOrThrow","errorMessage","message","env","InjectionToken","z","ConfigServiceOptionsSchema","ConfigServiceToken","ConfigProviderOptions","object","load","function","output","provideConfig","options","factory","EnvConfigProvider","bound","HttpException","BadRequestException","message","HttpException","ForbiddenException","message","HttpException","InternalServerErrorException","message","error","HttpException","NotFoundException","response","error","HttpException","UnauthorizedException","message","error","HttpException","ConflictException","message","error","Injectable","ForbiddenResponderToken","token","priority","ForbiddenResponderService","getResponse","error","description","createResponse","response","detail","statusCode","payload","type","title","status","headers","Injectable","InternalServerErrorResponderToken","token","priority","InternalServerErrorResponderService","getResponse","error","description","message","Error","statusCode","payload","type","title","status","detail","headers","Injectable","NotFoundResponderToken","token","priority","NotFoundResponderService","getResponse","error","description","createResponse","response","detail","statusCode","payload","type","title","status","headers","Injectable","treeifyError","ZodError","ValidationErrorResponderToken","token","priority","ValidationErrorResponderService","getResponse","error","description","statusCode","payload","type","title","status","detail","errors","headers","Error","message","getControllerMetadata","getEndpointMetadata","getModuleMetadata","hasControllerMetadata","hasModuleMetadata","getManagedMetadata","hasManagedMetadata","AttributeFactory","createAttribute","token","schema","res","value","target","context","kind","Error","isController","isModule","isManaged","metadata","validatedValue","safeParse","success","toString","error","customAttributes","set","data","get","attribute","getAll","values","Array","from","entries","filter","key","map","length","getLast","i","has","Factory","inject","NaviosEnvironment","AdapterToken","token","AdapterFactory","environment","create","ctx","service","getToken","Error","Factory","inject","NaviosEnvironment","EndpointAdapterToken","token","EndpointAdapterFactory","environment","create","ctx","service","getToken","Error","Factory","inject","NaviosEnvironment","HttpAdapterToken","token","HttpAdapterFactory","environment","create","ctx","service","getToken","Error","Factory","inject","NaviosEnvironment","MultipartAdapterToken","token","MultipartAdapterFactory","environment","create","ctx","service","getToken","Error","Factory","inject","InjectableScope","NaviosEnvironment","Request","token","scope","RequestFactory","environment","create","ctx","service","getToken","Error","Factory","inject","InjectableScope","NaviosEnvironment","Reply","token","scope","Request","ReplyFactory","environment","create","ctx","service","getToken","Error","Factory","inject","NaviosEnvironment","StreamAdapterToken","token","StreamAdapterFactory","environment","create","ctx","service","getToken","Error","Factory","inject","NaviosEnvironment","XmlStreamAdapterToken","token","XmlStreamAdapterFactory","environment","create","ctx","service","getToken","Error"],"sources":["../src/config/utils/helpers.mts","../src/config/config.service.mts","../src/config/config.provider.mts","../src/exceptions/bad-request.exception.mts","../src/exceptions/forbidden.exception.mts","../src/exceptions/internal-server-error.exception.mts","../src/exceptions/not-found.exception.mts","../src/exceptions/unauthorized.exception.mts","../src/exceptions/conflict.exception.mts","../src/responders/services/forbidden-responder.service.mts","../src/responders/services/internal-server-error-responder.service.mts","../src/responders/services/not-found-responder.service.mts","../src/responders/services/validation-error-responder.service.mts","../src/attribute.factory.mts","../src/factories/adapter.factory.mts","../src/factories/endpoint-adapter.factory.mts","../src/factories/http-adapter.factory.mts","../src/factories/multipart-adapter.factory.mts","../src/factories/request.factory.mts","../src/factories/reply.factory.mts","../src/factories/stream-adapter.factory.mts","../src/factories/xml-stream-adapter.factory.mts"],"sourcesContent":["import { env } from 'node:process'\n\nexport function envInt(\n  key: keyof NodeJS.ProcessEnv,\n  defaultValue: number,\n): number {\n  const envKey = env[key] || process.env[key]\n\n  return envKey ? parseInt(envKey as string, 10) : defaultValue\n}\n\nexport function envString<\n  DefaultValue extends string | undefined,\n  Ensured = DefaultValue extends string ? true : false,\n>(\n  key: keyof NodeJS.ProcessEnv,\n  defaultValue?: DefaultValue,\n): Ensured extends true ? string : string | undefined {\n  return (env[key] ||\n    process.env[key] ||\n    defaultValue ||\n    undefined) as Ensured extends true ? string : string | undefined\n}\n","import { NaviosError } from '@navios/builder'\nimport { inject, Injectable, InjectionToken } from '@navios/di'\n\nimport { z } from 'zod/v4'\n\nimport type { ConfigServiceInterface as IConfigService } from './config-service.interface.mjs'\nimport type { Path, PathValue } from './types.mjs'\n\nimport { Logger } from '../logger/index.mjs'\n\n/**\n * Schema for validating configuration service options.\n */\nexport const ConfigServiceOptionsSchema = z.record(z.string(), z.unknown())\n/**\n * Type for configuration service options.\n */\nexport type ConfigServiceOptions = z.infer<typeof ConfigServiceOptionsSchema>\n\n/**\n * Injection token for ConfigService.\n */\nexport const ConfigServiceToken = InjectionToken.create<\n  IConfigService,\n  typeof ConfigServiceOptionsSchema\n>(Symbol.for('ConfigService'), ConfigServiceOptionsSchema)\n\n/**\n * Service for managing application configuration with type-safe access.\n *\n * Provides methods to access configuration values using dot-notation paths\n * with full TypeScript type inference.\n *\n * @typeParam Config - The configuration object type\n *\n * @example\n * ```typescript\n * interface AppConfig {\n *   database: {\n *     host: string\n *     port: number\n *   }\n *   api: {\n *     timeout: number\n *   }\n * }\n *\n * @Injectable()\n * export class DatabaseService {\n *   private config = inject(MyConfigService)\n *\n *   connect() {\n *     const host = this.config.getOrThrow('database.host')\n *     const port = this.config.getOrDefault('database.port', 5432)\n *     // host is typed as string, port is typed as number\n *   }\n * }\n * ```\n */\n@Injectable({\n  token: ConfigServiceToken,\n})\nexport class ConfigService<\n  Config extends ConfigServiceOptions = Record<string, unknown>,\n> implements IConfigService<Config> {\n  private readonly logger = inject(Logger, {\n    context: ConfigService.name,\n  })\n\n  /**\n   * Creates a new ConfigService instance.\n   *\n   * @param config - The configuration object\n   */\n  constructor(private config: Config = {} as Config) {}\n\n  /**\n   * Gets the entire configuration object.\n   *\n   * @returns The complete configuration object\n   */\n  getConfig(): Config {\n    return this.config\n  }\n\n  /**\n   * Gets a configuration value by key path.\n   *\n   * Returns `null` if the key is not found or if any part of the path is invalid.\n   *\n   * @param key - Dot-separated path to the configuration value (e.g., 'database.host')\n   * @returns The configuration value or `null` if not found\n   *\n   * @example\n   * ```typescript\n   * const host = config.get('database.host') // string | null\n   * const port = config.get('database.port') // number | null\n   * ```\n   */\n  get<Key extends Path<Config>>(key: Key): PathValue<Config, Key> | null {\n    try {\n      const parts = String(key).split('.')\n      let value: any = this.config\n\n      for (const part of parts) {\n        if (\n          value === null ||\n          value === undefined ||\n          typeof value !== 'object'\n        ) {\n          return null\n        }\n        value = value[part]\n      }\n\n      return (value as PathValue<Config, Key>) ?? null\n    } catch (error) {\n      this.logger.debug?.(\n        `Failed to get config value for key ${String(key)}`,\n        error,\n      )\n      return null\n    }\n  }\n\n  /**\n   * Gets a configuration value by key path, or returns a default value if not found.\n   *\n   * @param key - Dot-separated path to the configuration value\n   * @param defaultValue - Default value to return if the key is not found\n   * @returns The configuration value or the default value\n   *\n   * @example\n   * ```typescript\n   * const port = config.getOrDefault('database.port', 5432) // number\n   * ```\n   */\n  getOrDefault<Key extends Path<Config>>(\n    key: Key,\n    defaultValue: PathValue<Config, Key>,\n  ): PathValue<Config, Key> {\n    const value = this.get(key)\n    return value !== null ? value : defaultValue\n  }\n\n  /**\n   * Gets a configuration value by key path, or throws an error if not found.\n   *\n   * @param key - Dot-separated path to the configuration value\n   * @param errorMessage - Optional custom error message\n   * @returns The configuration value\n   * @throws Error if the key is not found\n   *\n   * @example\n   * ```typescript\n   * const host = config.getOrThrow('database.host') // string (throws if not found)\n   * const apiKey = config.getOrThrow('api.key', 'API key is required') // string\n   * ```\n   */\n  getOrThrow<Key extends Path<Config>>(\n    key: Key,\n    errorMessage?: string,\n  ): PathValue<Config, Key> {\n    const value = this.get(key)\n\n    if (value === null) {\n      const message =\n        errorMessage ||\n        `Configuration value for key \"${String(key)}\" is not defined`\n      this.logger.error(message)\n      throw new NaviosError(message)\n    }\n\n    return value\n  }\n}\n","import { env } from 'node:process'\n\nimport { FactoryInjectionToken, InjectionToken } from '@navios/di'\n\nimport { z } from 'zod/v4'\n\nimport type { ConfigServiceOptions } from './config.service.mjs'\n\nimport {\n  ConfigService,\n  ConfigServiceOptionsSchema,\n  ConfigServiceToken,\n} from './config.service.mjs'\n\n/**\n * Schema for configuration provider options.\n */\nexport const ConfigProviderOptions = z.object({\n  load: z.function({ output: ConfigServiceOptionsSchema }),\n})\n\n/**\n * Creates a factory injection token for ConfigService that loads configuration asynchronously.\n *\n * Use this when you need to load configuration from a file, database, or other async source.\n *\n * @param options - Configuration provider options\n * @param options.load - Async function that loads and returns the configuration object\n * @returns A factory injection token for ConfigService\n *\n * @example\n * ```typescript\n * const MyConfigService = provideConfig({\n *   load: async () => {\n *     const config = await loadConfigFromFile('config.json')\n *     return config\n *   },\n * })\n *\n * // Use in module setup\n * container.bind(ConfigServiceToken).toFactory(configProvider)\n * ```\n */\nexport function provideConfig<ConfigMap extends ConfigServiceOptions>(\n  options: z.input<typeof ConfigProviderOptions>,\n): FactoryInjectionToken<\n  ConfigService<ConfigMap>,\n  typeof ConfigServiceOptionsSchema\n> {\n  return InjectionToken.factory(ConfigServiceToken, async () => options.load())\n}\n\n/**\n * Pre-configured ConfigService provider that uses environment variables.\n *\n * Provides a ConfigService instance bound to `process.env`.\n *\n * @example\n * ```typescript\n * // Use environment variables as configuration\n * container.bind(ConfigServiceToken).toValue(EnvConfigProvider)\n * ```\n */\nexport const EnvConfigProvider = InjectionToken.bound<\n  ConfigService<Record<string, string>>,\n  typeof ConfigServiceOptionsSchema\n>(ConfigServiceToken, {\n  ...env,\n})\n","import { HttpException } from './http.exception.mjs'\n\n/**\n * Exception that represents a 400 Bad Request HTTP error.\n * \n * Use this exception when the client's request is malformed or invalid.\n * \n * @example\n * ```typescript\n * @Endpoint(createUserEndpoint)\n * async createUser(request: EndpointParams<typeof createUserEndpoint>) {\n *   if (!request.data.email) {\n *     throw new BadRequestException('Email is required')\n *   }\n *   // ...\n * }\n * ```\n */\nexport class BadRequestException extends HttpException {\n  /**\n   * Creates a new BadRequestException.\n   * \n   * @param message - Error message or response object\n   */\n  constructor(message: string | object) {\n    super(400, message)\n  }\n}\n","import { HttpException } from './http.exception.mjs'\n\n/**\n * Exception that represents a 403 Forbidden HTTP error.\n * \n * Use this exception when the client is authenticated but does not have\n * permission to access the requested resource.\n * \n * @example\n * ```typescript\n * @Endpoint(deleteUserEndpoint)\n * @UseGuards(AuthGuard, RoleGuard)\n * async deleteUser(request: EndpointParams<typeof deleteUserEndpoint>) {\n *   if (!this.userService.hasPermission(request.user, 'delete')) {\n *     throw new ForbiddenException('Insufficient permissions')\n *   }\n *   // ...\n * }\n * ```\n */\nexport class ForbiddenException extends HttpException {\n  /**\n   * Creates a new ForbiddenException.\n   * \n   * @param message - Error message\n   */\n  constructor(message: string) {\n    super(403, message)\n  }\n}\n","import { HttpException } from './http.exception.mjs'\n\n/**\n * Exception that represents a 500 Internal Server Error HTTP error.\n * \n * Use this exception when an unexpected error occurs on the server.\n * Generally, you should let unhandled errors bubble up rather than catching\n * and rethrowing as InternalServerErrorException, as Navios will handle them appropriately.\n * \n * @example\n * ```typescript\n * @Endpoint(processPaymentEndpoint)\n * async processPayment(request: EndpointParams<typeof processPaymentEndpoint>) {\n *   try {\n *     return await this.paymentService.process(request.data)\n *   } catch (error) {\n *     this.logger.error('Payment processing failed', error)\n *     throw new InternalServerErrorException('Payment processing failed', error)\n *   }\n * }\n * ```\n */\nexport class InternalServerErrorException extends HttpException {\n  /**\n   * Creates a new InternalServerErrorException.\n   * \n   * @param message - Error message or response object\n   * @param error - Optional underlying error for logging\n   */\n  constructor(message: string | object, error?: Error) {\n    super(500, message, error)\n  }\n}\n","import { HttpException } from './http.exception.mjs'\n\n/**\n * Exception that represents a 404 Not Found HTTP error.\n * \n * Use this exception when the requested resource does not exist.\n * \n * @example\n * ```typescript\n * @Endpoint(getUserEndpoint)\n * async getUser(request: EndpointParams<typeof getUserEndpoint>) {\n *   const user = await this.userService.findById(request.urlParams.userId)\n *   if (!user) {\n *     throw new NotFoundException('User not found')\n *   }\n *   return user\n * }\n * ```\n */\nexport class NotFoundException extends HttpException {\n  /**\n   * Creates a new NotFoundException.\n   * \n   * @param response - Error message or response object\n   * @param error - Optional underlying error for logging\n   */\n  constructor(\n    public readonly response: string | object,\n    public readonly error?: Error,\n  ) {\n    super(404, response, error)\n  }\n}\n","import { HttpException } from './http.exception.mjs'\n\n/**\n * Exception that represents a 401 Unauthorized HTTP error.\n * \n * Use this exception when the client is not authenticated or authentication failed.\n * \n * @example\n * ```typescript\n * @Endpoint(getUserEndpoint)\n * @UseGuards(AuthGuard)\n * async getUser(request: EndpointParams<typeof getUserEndpoint>) {\n *   if (!request.headers.authorization) {\n *     throw new UnauthorizedException('Authentication required')\n *   }\n *   // ...\n * }\n * ```\n */\nexport class UnauthorizedException extends HttpException {\n  /**\n   * Creates a new UnauthorizedException.\n   * \n   * @param message - Error message or response object\n   * @param error - Optional underlying error for logging\n   */\n  constructor(message: string | object, error?: Error) {\n    super(401, message, error)\n  }\n}\n","import { HttpException } from './http.exception.mjs'\n\n/**\n * Exception that represents a 409 Conflict HTTP error.\n * \n * Use this exception when the request conflicts with the current state of the resource\n * (e.g., trying to create a resource that already exists).\n * \n * @example\n * ```typescript\n * @Endpoint(createUserEndpoint)\n * async createUser(request: EndpointParams<typeof createUserEndpoint>) {\n *   const existing = await this.userService.findByEmail(request.data.email)\n *   if (existing) {\n *     throw new ConflictException('User with this email already exists')\n *   }\n *   // ...\n * }\n * ```\n */\nexport class ConflictException extends HttpException {\n  /**\n   * Creates a new ConflictException.\n   * \n   * @param message - Error message or response object\n   * @param error - Optional underlying error for logging\n   */\n  constructor(message: string | object, error?: Error) {\n    super(409, message, error)\n  }\n}\n","import { Injectable } from '@navios/di'\n\nimport type { ErrorResponder } from '../interfaces/error-responder.interface.mjs'\nimport type { ErrorResponse } from '../interfaces/error-response.interface.mjs'\nimport { ForbiddenResponderToken } from '../tokens/responder.tokens.mjs'\n\n/**\n * Default responder for forbidden errors (HTTP 403).\n *\n * Converts errors to RFC 7807 Problem Details format.\n * Used when access to a resource is denied (e.g., guard rejection).\n * Registered with low priority (-10) so it can be easily overridden.\n *\n * @example Override with custom implementation:\n * ```typescript\n * @Injectable({\n *   token: ForbiddenResponderToken,\n *   priority: 0,\n * })\n * export class CustomForbiddenResponder implements ErrorResponder {\n *   getResponse(error: unknown, description?: string): ErrorResponse {\n *     return {\n *       statusCode: 403,\n *       payload: {\n *         type: 'https://api.myapp.com/errors/forbidden',\n *         title: 'Access Denied',\n *         status: 403,\n *         detail: description ?? 'You do not have permission to access this resource',\n *       },\n *       headers: { 'Content-Type': 'application/problem+json' },\n *     }\n *   }\n * }\n * ```\n */\n@Injectable({\n  token: ForbiddenResponderToken,\n  priority: -10,\n})\nexport class ForbiddenResponderService implements ErrorResponder {\n  getResponse(error: unknown, description?: string): ErrorResponse {\n    // Explicit description takes priority\n    if (description) {\n      return this.createResponse(description)\n    }\n\n    // Try to extract detail from error with a response property (like ForbiddenException)\n    if (\n      error &&\n      typeof error === 'object' &&\n      'response' in error &&\n      error.response\n    ) {\n      if (typeof error.response === 'string') {\n        return this.createResponse(error.response)\n      }\n    }\n\n    // Default message\n    return this.createResponse('Access to this resource is forbidden')\n  }\n\n  private createResponse(detail: string): ErrorResponse {\n    return {\n      statusCode: 403,\n      payload: {\n        type: 'about:blank',\n        title: 'Forbidden',\n        status: 403,\n        detail,\n      },\n      headers: {\n        'Content-Type': 'application/problem+json',\n      },\n    }\n  }\n}\n","import { Injectable } from '@navios/di'\n\nimport type { ErrorResponder } from '../interfaces/error-responder.interface.mjs'\nimport type { ErrorResponse } from '../interfaces/error-response.interface.mjs'\nimport { InternalServerErrorResponderToken } from '../tokens/responder.tokens.mjs'\n\n/**\n * Default responder for internal server errors (HTTP 500).\n *\n * Converts generic errors to RFC 7807 Problem Details format.\n * Registered with low priority (-10) so it can be easily overridden.\n *\n * @example Override with custom implementation:\n * ```typescript\n * @Injectable({\n *   token: InternalServerErrorResponderToken,\n *   priority: 0,\n * })\n * export class CustomInternalErrorResponder implements ErrorResponder {\n *   getResponse(error: unknown, description?: string): ErrorResponse {\n *     return {\n *       statusCode: 500,\n *       payload: {\n *         type: 'https://api.myapp.com/errors/server-error',\n *         title: 'Server Error',\n *         status: 500,\n *         detail: description ?? 'An unexpected error occurred',\n *       },\n *       headers: { 'Content-Type': 'application/problem+json' },\n *     }\n *   }\n * }\n * ```\n */\n@Injectable({\n  token: InternalServerErrorResponderToken,\n  priority: -10,\n})\nexport class InternalServerErrorResponderService implements ErrorResponder {\n  getResponse(error: unknown, description?: string): ErrorResponse {\n    const message =\n      error instanceof Error ? error.message : 'Internal Server Error'\n\n    return {\n      statusCode: 500,\n      payload: {\n        type: 'about:blank',\n        title: 'Internal Server Error',\n        status: 500,\n        detail: description ?? message,\n      },\n      headers: {\n        'Content-Type': 'application/problem+json',\n      },\n    }\n  }\n}\n","import { Injectable } from '@navios/di'\n\nimport type { ErrorResponder } from '../interfaces/error-responder.interface.mjs'\nimport type { ErrorResponse } from '../interfaces/error-response.interface.mjs'\nimport { NotFoundResponderToken } from '../tokens/responder.tokens.mjs'\n\n/**\n * Default responder for not found errors (HTTP 404).\n *\n * Converts errors to RFC 7807 Problem Details format.\n * Registered with low priority (-10) so it can be easily overridden.\n *\n * @example Override with custom implementation:\n * ```typescript\n * @Injectable({\n *   token: NotFoundResponderToken,\n *   priority: 0,\n * })\n * export class CustomNotFoundResponder implements ErrorResponder {\n *   getResponse(error: unknown, description?: string): ErrorResponse {\n *     return {\n *       statusCode: 404,\n *       payload: {\n *         type: 'https://api.myapp.com/errors/not-found',\n *         title: 'Resource Not Found',\n *         status: 404,\n *         detail: description ?? 'The requested resource was not found',\n *       },\n *       headers: { 'Content-Type': 'application/problem+json' },\n *     }\n *   }\n * }\n * ```\n */\n@Injectable({\n  token: NotFoundResponderToken,\n  priority: -10,\n})\nexport class NotFoundResponderService implements ErrorResponder {\n  getResponse(error: unknown, description?: string): ErrorResponse {\n    // Explicit description takes priority\n    if (description) {\n      return this.createResponse(description)\n    }\n\n    // Try to extract detail from error with a response property (like NotFoundException)\n    if (\n      error &&\n      typeof error === 'object' &&\n      'response' in error &&\n      error.response\n    ) {\n      if (typeof error.response === 'string') {\n        return this.createResponse(error.response)\n      }\n    }\n\n    // Default message\n    return this.createResponse('The requested resource was not found')\n  }\n\n  private createResponse(detail: string): ErrorResponse {\n    return {\n      statusCode: 404,\n      payload: {\n        type: 'about:blank',\n        title: 'Not Found',\n        status: 404,\n        detail,\n      },\n      headers: {\n        'Content-Type': 'application/problem+json',\n      },\n    }\n  }\n}\n","import { Injectable } from '@navios/di'\nimport { treeifyError, ZodError } from 'zod/v4'\n\nimport type { ErrorResponder } from '../interfaces/error-responder.interface.mjs'\nimport type { ErrorResponse } from '../interfaces/error-response.interface.mjs'\nimport { ValidationErrorResponderToken } from '../tokens/responder.tokens.mjs'\n\n/**\n * Default responder for validation errors (HTTP 400).\n *\n * Converts Zod validation errors to RFC 7807 Problem Details format.\n * Includes the structured validation errors from treeifyError.\n * Registered with low priority (-10) so it can be easily overridden.\n *\n * @example Override with custom implementation:\n * ```typescript\n * @Injectable({\n *   token: ValidationErrorResponderToken,\n *   priority: 0,\n * })\n * export class CustomValidationResponder implements ErrorResponder {\n *   getResponse(error: unknown, description?: string): ErrorResponse {\n *     const zodError = error as ZodError\n *     return {\n *       statusCode: 422, // Use 422 instead of 400\n *       payload: {\n *         type: 'https://api.myapp.com/errors/validation',\n *         title: 'Unprocessable Entity',\n *         status: 422,\n *         detail: description ?? 'Validation failed',\n *         issues: zodError.issues,\n *       },\n *       headers: { 'Content-Type': 'application/problem+json' },\n *     }\n *   }\n * }\n * ```\n */\n@Injectable({\n  token: ValidationErrorResponderToken,\n  priority: -10,\n})\nexport class ValidationErrorResponderService implements ErrorResponder {\n  getResponse(error: unknown, description?: string): ErrorResponse {\n    // Handle ZodError specifically\n    if (error instanceof ZodError) {\n      return {\n        statusCode: 400,\n        payload: {\n          type: 'about:blank',\n          title: 'Validation Error',\n          status: 400,\n          detail: description ?? 'Request validation failed',\n          errors: treeifyError(error),\n        },\n        headers: {\n          'Content-Type': 'application/problem+json',\n        },\n      }\n    }\n\n    // Fallback for non-Zod validation errors\n    return {\n      statusCode: 400,\n      payload: {\n        type: 'about:blank',\n        title: 'Validation Error',\n        status: 400,\n        detail:\n          description ??\n          (error instanceof Error ? error.message : 'Validation failed'),\n      },\n      headers: {\n        'Content-Type': 'application/problem+json',\n      },\n    }\n  }\n}\n","import type { ClassType } from '@navios/di'\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 class 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 ClassAttribute = (() => <T>(\n  target: T,\n  context: ClassDecoratorContext | ClassMethodDecoratorContext,\n) => T) & {\n  token: symbol\n}\n\n/**\n * Type for a class attribute decorator with a validated value.\n * \n * @typeParam T - The Zod schema type for validation\n */\nexport type ClassSchemaAttribute<T extends ZodType> = ((\n  value: z.input<T>,\n) => <T>(\n  target: T,\n  context: ClassDecoratorContext | ClassMethodDecoratorContext,\n) => T) & {\n  token: symbol\n  schema: ZodType\n}\n\n/**\n * Factory for creating custom attribute decorators.\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 = AttributeFactory.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 (AttributeFactory.has(Public, controllerMetadata)) {\n *   // Skip authentication\n * }\n * ```\n * \n * @example\n * ```typescript\n * // Create an attribute with a validated value\n * const RateLimit = AttributeFactory.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 = AttributeFactory.get(RateLimit, endpointMetadata)\n * // limit is typed as { requests: number, window: number } | null\n * ```\n */\nexport class AttributeFactory {\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 = AttributeFactory.createAttribute(Symbol.for('Public'))\n   * \n   * @Public()\n   * @Controller()\n   * export class PublicController { }\n   * ```\n   */\n  static createAttribute(token: symbol): ClassAttribute\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 = AttributeFactory.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  ): ClassSchemaAttribute<T>\n  static createAttribute(token: symbol, schema?: ZodType) {\n    const res =\n      (value?: unknown) =>\n      (\n        target: any,\n        context: ClassDecoratorContext | ClassMethodDecoratorContext,\n      ) => {\n        if (context.kind !== 'class' && context.kind !== 'method') {\n          throw new Error(\n            '[Navios] Attribute can only be applied to classes or methods',\n          )\n        }\n        const isController =\n          context.kind === 'class' && hasControllerMetadata(target as ClassType)\n        const isModule =\n          context.kind === 'class' && hasModuleMetadata(target as ClassType)\n        const isManaged =\n          context.kind === 'class' && hasManagedMetadata(target as ClassType)\n        if (context.kind === 'class' && !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        let metadata =\n          context.kind === 'class'\n            ? isController\n              ? getControllerMetadata(target as any, context)\n              : isModule\n                ? getModuleMetadata(target as any, context)\n                : isManaged\n                  ? getManagedMetadata(target as any)!\n                  : null\n            : getEndpointMetadata(target, context)\n        \n        if (!metadata) {\n          throw new Error(\n            '[Navios] Could not determine metadata for attribute target',\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    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 = AttributeFactory.get(Public, controllerMetadata)\n   * // isPublic is true | null\n   * \n   * const rateLimit = AttributeFactory.get(RateLimit, endpointMetadata)\n   * // rateLimit is { requests: number, window: number } | null\n   * ```\n   */\n  static get(\n    attribute: ClassAttribute,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ): true | null\n  static get<T extends ZodType>(\n    attribute: ClassSchemaAttribute<T>,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ): z.output<T> | null\n  static get(\n    attribute: ClassAttribute | ClassSchemaAttribute<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 = AttributeFactory.getAll(Tag, endpointMetadata)\n   * // tags is string[] | null\n   * ```\n   */\n  static getAll(\n    attribute: ClassAttribute,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ): Array<true> | null\n  static getAll<T extends ZodType>(\n    attribute: ClassSchemaAttribute<T>,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ): Array<z.output<T>> | null\n  static getAll(\n    attribute: ClassAttribute | ClassSchemaAttribute<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 = AttributeFactory.getLast(RateLimit, [\n   *   moduleMetadata,\n   *   controllerMetadata,\n   *   endpointMetadata\n   * ])\n   * ```\n   */\n  static getLast(\n    attribute: ClassAttribute,\n    target: (ModuleMetadata | ControllerMetadata | HandlerMetadata<any>)[],\n  ): true | null\n  static getLast<T extends ZodType>(\n    attribute: ClassSchemaAttribute<T>,\n    target: (ModuleMetadata | ControllerMetadata | HandlerMetadata<any>)[],\n  ): z.output<T> | null\n  static getLast(\n    attribute: ClassAttribute | ClassSchemaAttribute<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 (AttributeFactory.has(Public, controllerMetadata)) {\n   *   // Skip authentication\n   * }\n   * ```\n   */\n  static has(\n    attribute: ClassAttribute,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ): boolean\n  static has<T extends ZodType>(\n    attribute: ClassSchemaAttribute<T>,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ): boolean\n  static has(\n    attribute: ClassAttribute | ClassSchemaAttribute<any>,\n    target: ModuleMetadata | ControllerMetadata | HandlerMetadata<any>,\n  ) {\n    return target.customAttributes.has(attribute.token)\n  }\n}\n","import type { FactoryContext } from '@navios/di'\n\nimport { Factory, inject, InjectionToken } from '@navios/di'\n\nimport { NaviosEnvironment } from '../navios.environment.mjs'\nimport { AdapterToken } from '../tokens/index.mjs'\n\n@Factory({\n  token: AdapterToken,\n})\nexport class AdapterFactory {\n  private readonly environment = inject(NaviosEnvironment)\n  create(ctx: FactoryContext) {\n    const service = this.environment.getToken(AdapterToken)\n    if (!service) {\n      throw new Error('AdapterToken service not found in environment')\n    }\n    return ctx.inject(service as InjectionToken<any, undefined>)\n  }\n}\n","import type { FactoryContext, InjectionToken } from '@navios/di'\n\nimport { Factory, inject } from '@navios/di'\n\nimport { NaviosEnvironment } from '../navios.environment.mjs'\nimport { EndpointAdapterToken } from '../tokens/index.mjs'\n\n@Factory({\n  token: EndpointAdapterToken,\n})\nexport class EndpointAdapterFactory {\n  private readonly environment = inject(NaviosEnvironment)\n\n  create(ctx: FactoryContext) {\n    const service = this.environment.getToken(EndpointAdapterToken)\n    if (!service) {\n      throw new Error('EndpointAdapterToken service not found in environment')\n    }\n    return ctx.inject(service as InjectionToken<any, undefined>)\n  }\n}\n","import type { FactoryContext } from '@navios/di'\n\nimport { Factory, inject, InjectionToken } from '@navios/di'\n\nimport { NaviosEnvironment } from '../navios.environment.mjs'\nimport { HttpAdapterToken } from '../tokens/index.mjs'\n\n@Factory({\n  token: HttpAdapterToken,\n})\nexport class HttpAdapterFactory {\n  private readonly environment = inject(NaviosEnvironment)\n  create(ctx: FactoryContext) {\n    const service = this.environment.getToken(HttpAdapterToken)\n    if (!service) {\n      throw new Error('HttpAdapterToken service not found in environment')\n    }\n    return ctx.inject(service as InjectionToken<any, undefined>)\n  }\n}\n","import type { FactoryContext, InjectionToken } from '@navios/di'\n\nimport { Factory, inject } from '@navios/di'\n\nimport { NaviosEnvironment } from '../navios.environment.mjs'\nimport { MultipartAdapterToken } from '../tokens/index.mjs'\n\n@Factory({\n  token: MultipartAdapterToken,\n})\nexport class MultipartAdapterFactory {\n  private readonly environment = inject(NaviosEnvironment)\n\n  create(ctx: FactoryContext) {\n    const service = this.environment.getToken(MultipartAdapterToken)\n    if (!service) {\n      throw new Error('MultipartAdapterToken service not found in environment')\n    }\n    return ctx.inject(service as InjectionToken<any, undefined>)\n  }\n}\n","import type { FactoryContext, InjectionToken } from '@navios/di'\n\nimport { Factory, inject, InjectableScope } from '@navios/di'\n\nimport { NaviosEnvironment } from '../navios.environment.mjs'\nimport { Request } from '../tokens/index.mjs'\n\n@Factory({\n  token: Request,\n  scope: InjectableScope.Request,\n})\nexport class RequestFactory {\n  private readonly environment = inject(NaviosEnvironment)\n  create(ctx: FactoryContext) {\n    const service = this.environment.getToken(Request)\n    if (!service) {\n      throw new Error('RequestToken service not found in environment')\n    }\n    return ctx.inject(service as InjectionToken<any, undefined>)\n  }\n}\n","import type { FactoryContext, InjectionToken } from '@navios/di'\n\nimport { Factory, inject, InjectableScope } from '@navios/di'\n\nimport { NaviosEnvironment } from '../navios.environment.mjs'\nimport { Reply } from '../tokens/index.mjs'\n\n@Factory({\n  token: Reply,\n  scope: InjectableScope.Request,\n})\nexport class ReplyFactory {\n  private readonly environment = inject(NaviosEnvironment)\n  create(ctx: FactoryContext) {\n    const service = this.environment.getToken(Reply)\n    if (!service) {\n      throw new Error('ReplyToken service not found in environment')\n    }\n    return ctx.inject(service as InjectionToken<any, undefined>)\n  }\n}\n","import type { FactoryContext, InjectionToken } from '@navios/di'\n\nimport { Factory, inject } from '@navios/di'\n\nimport { NaviosEnvironment } from '../navios.environment.mjs'\nimport { StreamAdapterToken } from '../tokens/index.mjs'\n\n@Factory({\n  token: StreamAdapterToken,\n})\nexport class StreamAdapterFactory {\n  private readonly environment = inject(NaviosEnvironment)\n  create(ctx: FactoryContext) {\n    const service = this.environment.getToken(StreamAdapterToken)\n    if (!service) {\n      throw new Error('StreamAdapterToken service not found in environment')\n    }\n    return ctx.inject(service as InjectionToken<any, undefined>)\n  }\n}\n","import type { FactoryContext, InjectionToken } from '@navios/di'\n\nimport { Factory, inject } from '@navios/di'\n\nimport { NaviosEnvironment } from '../navios.environment.mjs'\nimport { XmlStreamAdapterToken } from '../tokens/index.mjs'\n\n@Factory({\n  token: XmlStreamAdapterToken,\n})\nexport class XmlStreamAdapterFactory {\n  private readonly environment = inject(NaviosEnvironment)\n  create(ctx: FactoryContext) {\n    const service = this.environment.getToken(XmlStreamAdapterToken)\n    if (!service) {\n      throw new Error('XmlStreamAdapterToken service not found in environment')\n    }\n    return ctx.inject(service as InjectionToken<any, undefined>)\n  }\n}\n"],"mappings":"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"}

package/lib/legacy-compat/index.cjs

@@ -1,61 +1,8 @@
-const require_src = require('../src-C46ePe3d.cjs');
-const require_use_guards_decorator = require('../use-guards.decorator-B6tghdxM.cjs');
-let _navios_di = require("@navios/di");
+const require_navios_factory = require('../navios.factory-BanZIvtR.cjs');
+const require_use_guards_decorator = require('../use-guards.decorator-DgD-kxF5.cjs');
+const require_tokens = require('../tokens-BuXXB01L.cjs');
+let _navios_di_legacy_compat = require("@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.
@@ -80,7 +27,7 @@ let _navios_di = require("@navios/di");
 	guards: []
 }) {
 	return function(target) {
-		const context = createClassContext(target);
+		const context = (0, _navios_di_legacy_compat.createClassContext)(target);
 		return require_use_guards_decorator.Module(options)(target, context);
 	};
 }
@@ -105,7 +52,7 @@ let _navios_di = require("@navios/di");
 * ```
 */ function Controller(options = {}) {
 	return function(target) {
-		const context = createClassContext(target);
+		const context = (0, _navios_di_legacy_compat.createClassContext)(target);
 		return require_use_guards_decorator.Controller(options)(target, context);
 	};
 }
@@ -135,7 +82,7 @@ let _navios_di = require("@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 = (0, _navios_di_legacy_compat.createMethodContext)(target, propertyKey, typedDescriptor);
 		const result = require_use_guards_decorator.Endpoint(endpoint)(typedDescriptor.value, context);
 		if (result !== typedDescriptor.value) typedDescriptor.value = result;
 		return typedDescriptor;
@@ -171,12 +118,12 @@ let _navios_di = require("@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 = (0, _navios_di_legacy_compat.createMethodContext)(target, propertyKey, descriptor);
 			const result = require_use_guards_decorator.UseGuards(...guards)(descriptor.value, context);
 			if (result !== descriptor.value) descriptor.value = result;
 			return descriptor;
 		} else {
-			const context = createClassContext(target);
+			const context = (0, _navios_di_legacy_compat.createClassContext)(target);
 			return require_use_guards_decorator.UseGuards(...guards)(target, context);
 		}
 	}
@@ -207,7 +154,7 @@ let _navios_di = require("@navios/di");
 * ```
 */ function Header(name, value) {
 	return function(target, propertyKey, descriptor) {
-		const context = createMethodContext(target, propertyKey, descriptor);
+		const context = (0, _navios_di_legacy_compat.createMethodContext)(target, propertyKey, descriptor);
 		const result = require_use_guards_decorator.Header(name, value)(descriptor.value, context);
 		if (result !== descriptor.value) descriptor.value = result;
 		return descriptor;
@@ -237,7 +184,7 @@ let _navios_di = require("@navios/di");
 * ```
 */ function HttpCode(code) {
 	return function(target, propertyKey, descriptor) {
-		const context = createMethodContext(target, propertyKey, descriptor);
+		const context = (0, _navios_di_legacy_compat.createMethodContext)(target, propertyKey, descriptor);
 		const result = require_use_guards_decorator.HttpCode(code)(descriptor.value, context);
 		if (result !== descriptor.value) descriptor.value = result;
 		return descriptor;
@@ -269,7 +216,7 @@ let _navios_di = require("@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 = (0, _navios_di_legacy_compat.createMethodContext)(target, propertyKey, descriptor);
 		const result = require_use_guards_decorator.Multipart(endpoint)(descriptor.value, context);
 		if (result !== descriptor.value) descriptor.value = result;
 		return descriptor;
@@ -302,65 +249,13 @@ let _navios_di = require("@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 = (0, _navios_di_legacy_compat.createMethodContext)(target, propertyKey, typedDescriptor);
 		const result = require_use_guards_decorator.Stream(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 ? (0, _navios_di.Injectable)() : (0, _navios_di.Injectable)(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 ? (0, _navios_di.Factory)() : (0, _navios_di.Factory)(options))(target, context);
-	};
-}
-
 //#endregion
 //#region src/legacy-compat/attribute.factory.mts
 /**
@@ -409,7 +304,7 @@ let _navios_di = require("@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 = (0, _navios_di_legacy_compat.createMethodContext)(target, propertyKey, descriptor);
 					const metadata = require_use_guards_decorator.getEndpointMetadata(descriptor.value, context);
 					if (schema) {
 						const validatedValue = schema.safeParse(value);
@@ -419,11 +314,11 @@ let _navios_di = require("@navios/di");
 					return descriptor;
 				} else {
 					const isController = require_use_guards_decorator.hasControllerMetadata(target);
-					const isModule = require_use_guards_decorator.hasModuleMetadata(target);
+					const isModule = require_tokens.hasModuleMetadata(target);
 					const isManaged = require_use_guards_decorator.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 metadata = isController ? require_use_guards_decorator.getControllerMetadata(target, context) : isModule ? require_use_guards_decorator.getModuleMetadata(target, context) : isManaged ? require_use_guards_decorator.getManagedMetadata(target) : null;
+					const context = (0, _navios_di_legacy_compat.createClassContext)(target);
+					const metadata = isController ? require_use_guards_decorator.getControllerMetadata(target, context) : isModule ? require_tokens.getModuleMetadata(target, context) : isManaged ? require_use_guards_decorator.getManagedMetadata(target) : null;
 					if (!metadata) throw new Error("[Navios] Could not determine metadata for attribute target");
 					if (schema) {
 						const validatedValue = schema.safeParse(value);
@@ -462,15 +357,35 @@ let _navios_di = require("@navios/di");
 exports.AttributeFactory = LegacyAttributeFactory;
 exports.Controller = Controller;
 exports.Endpoint = Endpoint;
-exports.Factory = Factory;
+Object.defineProperty(exports, 'Factory', {
+  enumerable: true,
+  get: function () {
+    return _navios_di_legacy_compat.Factory;
+  }
+});
 exports.Header = Header;
 exports.HttpCode = HttpCode;
-exports.Injectable = Injectable;
+Object.defineProperty(exports, 'Injectable', {
+  enumerable: true,
+  get: function () {
+    return _navios_di_legacy_compat.Injectable;
+  }
+});
 exports.LegacyAttributeFactory = LegacyAttributeFactory;
 exports.Module = Module;
 exports.Multipart = Multipart;
 exports.Stream = Stream;
 exports.UseGuards = UseGuards;
-exports.createClassContext = createClassContext;
-exports.createMethodContext = createMethodContext;
+Object.defineProperty(exports, 'createClassContext', {
+  enumerable: true,
+  get: function () {
+    return _navios_di_legacy_compat.createClassContext;
+  }
+});
+Object.defineProperty(exports, 'createMethodContext', {
+  enumerable: true,
+  get: function () {
+    return _navios_di_legacy_compat.createMethodContext;
+  }
+});
 //# sourceMappingURL=index.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","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.cjs","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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"}