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

package/lib/{src-K2k0riYJ.mjs → src-j1cBuAgy.mjs}

@@ -1,5 +1,5 @@
 import { C as extractModuleMetadata, M as getEndpointMetadata, O as getControllerMetadata, T as hasModuleMetadata, _ as EndpointAdapterToken, b as getManagedMetadata, c as XmlStreamAdapterToken, d as Reply, f as NaviosOptionsToken, k as hasControllerMetadata, l as StreamAdapterToken, m as HttpAdapterToken, p as MultipartAdapterToken, u as Request, w as getModuleMetadata, x as hasManagedMetadata } from "./use-guards.decorator-Be_QUx6b.mjs";
-import { Container, Factory, Injectable, InjectableScope, InjectionToken, getInjectableToken, inject } from "@navios/di";
+import { Container, Factory, Injectable, InjectableScope, InjectionToken, getInjectableToken, inject, optional } from "@navios/di";
 import { env } from "node:process";
 import z, { ZodError, treeifyError, z as z$1 } from "zod/v4";
 import { NaviosError } from "@navios/builder";
@@ -3774,6 +3774,165 @@ var InstanceResolverService = class {
 * @deprecated Use InstanceResolverService instead
 */ const ControllerResolverService = _InstanceResolverService;
 
+//#endregion
+//#region src/services/abstract-handler-adapter.service.mts
+const defaultOptions = {
+	adapter: [],
+	validateResponses: true,
+	enableRequestId: false
+};
+/**
+* Abstract base class for HTTP handler adapter services.
+*
+* Provides shared logic for:
+* - Controller resolution (singleton vs request-scoped)
+* - Argument formatting (sync/async detection)
+* - Handler generation with static/dynamic branching
+* - Standardized error handling
+*
+* Adapters implement abstract methods for framework-specific behavior:
+* - Request parsing (query, body, URL params)
+* - Response creation
+* - Schema provision
+*
+* Supports all adapter types:
+* - Endpoint adapters: JSON request/response with validation
+* - Stream adapters: Streaming responses with extra context
+* - Multipart adapters: Form data parsing (extends endpoint)
+*
+* @typeParam TRequest - Framework request type (BunRequest, FastifyRequest)
+* @typeParam TReply - Framework reply type (void for Bun, FastifyReply)
+* @typeParam TConfig - Endpoint configuration type
+*/ var AbstractHandlerAdapterService = class {
+	instanceResolver = inject(_InstanceResolverService);
+	options = optional(NaviosOptionsToken) ?? defaultOptions;
+	/**
+	* Prepares argument getters for parsing request data.
+	*
+	* Public alias for createArgumentGetters to satisfy interface contracts.
+	* Subclasses should override createArgumentGetters instead.
+	*
+	* @param handlerMetadata - Handler metadata with schemas and configuration
+	* @returns Array of getter functions
+	*/ prepareArguments(handlerMetadata) {
+		return this.createArgumentGetters(handlerMetadata);
+	}
+	/**
+	* Checks if the handler has any validation schemas defined.
+	*
+	* Override in subclasses to add additional schema checks
+	* (e.g., response schema validation for endpoint adapters).
+	*
+	* @param handlerMetadata - Handler metadata with configuration
+	* @returns true if handler has schemas
+	*/ hasSchema(handlerMetadata) {
+		const config = handlerMetadata.config;
+		return !!config.requestSchema || !!config.querySchema;
+	}
+	/**
+	* Provides schema information for the framework's validation system.
+	*
+	* Override in subclasses for frameworks that support schema registration
+	* (e.g., Fastify). Default returns empty object (suitable for Bun).
+	*
+	* @param handlerMetadata - Handler metadata with configuration
+	* @returns Schema object for framework registration
+	*/ provideSchema(_handlerMetadata) {
+		return {};
+	}
+	/**
+	* Creates a request handler function for the endpoint.
+	*
+	* This method orchestrates the entire handler creation:
+	* 1. Prepares argument getters for request parsing
+	* 2. Builds optimized formatArguments function (sync/async)
+	* 3. Resolves the controller (singleton vs request-scoped)
+	* 4. Creates appropriate handler (static or dynamic)
+	*
+	* @param controller - Controller class containing the handler method
+	* @param handlerMetadata - Handler metadata with configuration
+	* @returns Handler result (static or dynamic)
+	*/ async provideHandler(controller, handlerMetadata) {
+		const getters = this.createArgumentGetters(handlerMetadata);
+		const formatArguments = this.buildFormatArguments(getters);
+		const hasArguments = getters.length > 0;
+		const context = {
+			methodName: handlerMetadata.classMethod,
+			statusCode: handlerMetadata.successStatusCode,
+			headers: handlerMetadata.headers,
+			handlerMetadata,
+			hasArguments
+		};
+		const resolution = await this.instanceResolver.resolve(controller);
+		if (resolution.cached) {
+			const cachedController = resolution.instance;
+			const boundMethod = cachedController[context.methodName].bind(cachedController);
+			return this.createStaticHandler(boundMethod, formatArguments, context);
+		}
+		return this.createDynamicHandler(resolution, formatArguments, context);
+	}
+	/**
+	* Builds a formatArguments function from argument getters.
+	*
+	* Automatically detects sync vs async getters and optimizes accordingly:
+	* - If all getters are sync: returns sync function (no Promise overhead)
+	* - If any getter is async: returns async function with Promise.all
+	* - If no getters: returns frozen empty object (zero allocation)
+	*
+	* This method is public to allow composition-based adapters (like XML adapter)
+	* to reuse the optimized formatArguments logic without inheritance.
+	*
+	* @param getters - Array of argument getter functions
+	* @returns Function to format arguments from request
+	*/ buildFormatArguments(getters) {
+		if (getters.length === 0) {
+			const emptyArgs = Object.freeze({});
+			return () => emptyArgs;
+		}
+		if (getters.some((g) => g.constructor.name === "AsyncFunction")) return async (request) => {
+			const argument = {};
+			const promises = [];
+			for (const getter of getters) {
+				const res = getter(argument, request);
+				if (res instanceof Promise) promises.push(res);
+			}
+			await Promise.all(promises);
+			return argument;
+		};
+		return (request) => {
+			const argument = {};
+			for (const getter of getters) getter(argument, request);
+			return argument;
+		};
+	}
+	/**
+	* Checks if the URL pattern contains URL parameters.
+	*
+	* @param config - Endpoint configuration
+	* @returns true if URL contains '$' parameter markers
+	*/ hasUrlParams(config) {
+		return config.url.includes("$");
+	}
+	/**
+	* Wraps handler execution with standardized error handling.
+	*
+	* Re-throws HttpExceptions as-is for framework error handlers.
+	* Other errors are re-thrown for global error handling.
+	*
+	* @param fn - Handler function to wrap
+	* @returns Wrapped function with error handling
+	*/ wrapWithErrorHandling(fn) {
+		return async (...args) => {
+			try {
+				return await fn(...args);
+			} catch (error) {
+				if (error && typeof error === "object" && "statusCode" in error) throw error;
+				throw error;
+			}
+		};
+	}
+};
+
 //#endregion
 //#region src/services/guard-runner.service.mts
 function applyDecs2203RFactory$10() {
@@ -7583,5 +7742,5 @@ var NaviosApplication = class {
 };
 
 //#endregion
-export { isObject as $, BadRequestException as A, Logger as B, ValidationErrorResponderToken as C, NotFoundException as D, UnauthorizedException as E, ConfigServiceOptionsSchema as F, runWithRequestId as G, loggerOptionsSchema as H, ConfigServiceToken as I, isConstructor as J, setRequestIdEnabled as K, _ConfigService as L, ConfigProviderOptions as M, EnvConfigProvider as N, InternalServerErrorException as O, provideConfig as P, isNumber as Q, _LoggerInstance as R, NotFoundResponderToken as S, ConflictException as T, generateRequestId as U, LoggerOutput as V, getRequestId as W, isFunction as X, isEmpty as Y, isNil as Z, _InternalServerErrorResponderService as _, _ReplyFactory as a, stripEndSlash as at, ForbiddenResponderToken as b, _HttpAdapterFactory as c, isLogLevel as ct, _ModuleLoaderService as d, yellow as dt, isPlainObject as et, _GuardRunnerService as f, envInt as ft, _NotFoundResponderService as g, _ValidationErrorResponderService as h, _StreamAdapterFactory as i, normalizePath as it, HttpException as j, ForbiddenException as k, _EndpointAdapterFactory as l, LOG_LEVELS as lt, _InstanceResolverService as m, _NaviosApplication as n, isSymbol as nt, _RequestFactory as o, isLogLevelEnabled as ot, ControllerResolverService as p, envString as pt, addLeadingSlash as q, _XmlStreamAdapterFactory as r, isUndefined as rt, _MultipartAdapterFactory as s, filterLogLevels as st, NaviosFactory as t, isString as tt, AttributeFactory as u, clc as ut, _ForbiddenResponderService as v, FrameworkError as w, InternalServerErrorResponderToken as x, _ErrorResponseProducerService as y, _ConsoleLogger as z };
-//# sourceMappingURL=src-K2k0riYJ.mjs.map
+export { isNumber as $, ForbiddenException as A, _ConsoleLogger as B, NotFoundResponderToken as C, UnauthorizedException as D, ConflictException as E, provideConfig as F, getRequestId as G, LoggerOutput as H, ConfigServiceOptionsSchema as I, addLeadingSlash as J, runWithRequestId as K, ConfigServiceToken as L, HttpException as M, ConfigProviderOptions as N, NotFoundException as O, EnvConfigProvider as P, isNil as Q, _ConfigService as R, InternalServerErrorResponderToken as S, FrameworkError as T, loggerOptionsSchema as U, Logger as V, generateRequestId as W, isEmpty as X, isConstructor as Y, isFunction as Z, _NotFoundResponderService as _, _ReplyFactory as a, normalizePath as at, _ErrorResponseProducerService as b, _HttpAdapterFactory as c, filterLogLevels as ct, _ModuleLoaderService as d, clc as dt, isObject as et, _GuardRunnerService as f, yellow as ft, _ValidationErrorResponderService as g, _InstanceResolverService as h, _StreamAdapterFactory as i, isUndefined as it, BadRequestException as j, InternalServerErrorException as k, _EndpointAdapterFactory as l, isLogLevel as lt, ControllerResolverService as m, envString as mt, _NaviosApplication as n, isString as nt, _RequestFactory as o, stripEndSlash as ot, AbstractHandlerAdapterService as p, envInt as pt, setRequestIdEnabled as q, _XmlStreamAdapterFactory as r, isSymbol as rt, _MultipartAdapterFactory as s, isLogLevelEnabled as st, NaviosFactory as t, isPlainObject as tt, AttributeFactory as u, LOG_LEVELS as ut, _InternalServerErrorResponderService as v, ValidationErrorResponderToken as w, ForbiddenResponderToken as x, _ForbiddenResponderService as y, _LoggerInstance as z };
+//# sourceMappingURL=src-j1cBuAgy.mjs.map