@navios/core 0.7.0 → 0.8.0

package/lib/{src-DzPY5s6d.mjs → src-gBAChVRL.mjs}

@@ -1,5 +1,5 @@
-import { O as getEndpointMetadata, T as hasControllerMetadata, b as getModuleMetadata, c as XmlStreamAdapterToken, d as Reply, f as MultipartAdapterToken, g as EndpointAdapterToken, l as StreamAdapterToken, p as HttpAdapterToken, u as Request, w as getControllerMetadata, x as hasModuleMetadata, y as extractModuleMetadata } from "./use-guards.decorator-kZ3lNK8v.mjs";
-import { Container, Factory, Injectable, InjectableScope, InjectableType, InjectionToken, inject } from "@navios/di";
+import { E as hasControllerMetadata, S as hasModuleMetadata, T as getControllerMetadata, _ as EndpointAdapterToken, b as extractModuleMetadata, c as XmlStreamAdapterToken, d as Reply, f as NaviosOptionsToken, k as getEndpointMetadata, l as StreamAdapterToken, m as HttpAdapterToken, p as MultipartAdapterToken, u as Request, x as getModuleMetadata } from "./use-guards.decorator-CUww54Nt.mjs";
+import { Container, Factory, Injectable, InjectableScope, InjectableType, InjectionToken, getInjectableToken, inject } from "@navios/di";
 import { env } from "node:process";
 import z, { z as z$1 } from "zod/v4";
 import { NaviosError } from "@navios/builder";
@@ -110,6 +110,15 @@ const isSymbol = (val) => typeof val === "symbol";
 
 //#endregion
 //#region src/stores/request-id.store.mts
+let requestCounter = 0;
+/**
+* Generates a simple incremental request ID.
+* Much faster than crypto.randomUUID() and sufficient for request tracking.
+*
+* @returns A unique request ID string (e.g., "req-1", "req-2", ...)
+*/ function generateRequestId() {
+	return `req-${++requestCounter}`;
+}
 /**
 * AsyncLocalStorage store for the current request ID.
 *
@@ -129,22 +138,42 @@ const isSymbol = (val) => typeof val === "symbol";
 * // Get current request ID (returns undefined if not in a request context)
 * const currentId = getRequestId()
 * ```
-*/ const requestIdStore = new AsyncLocalStorage();
+*/ let requestIdStore = null;
+function getRequestIdStore() {
+	if (!requestIdStore) requestIdStore = new AsyncLocalStorage();
+	return requestIdStore;
+}
+/**
+* Whether request ID propagation is enabled.
+* When disabled, runWithRequestId is a pass-through for better performance.
+*/ let requestIdEnabled = false;
+/**
+* Enables or disables request ID propagation.
+* Called by NaviosFactory based on the enableRequestId option.
+*
+* @param enabled - Whether to enable request ID propagation
+*/ function setRequestIdEnabled(enabled) {
+	requestIdEnabled = enabled;
+}
 /**
 * Runs a function with a request ID in the async local storage context.
+* If request ID propagation is disabled, the function is called directly
+* without AsyncLocalStorage overhead.
 *
 * @param requestId - The request ID to set for this context
 * @param fn - The function to run within this context
 * @returns The return value of the function
 */ function runWithRequestId(requestId, fn) {
-	return requestIdStore.run(requestId, fn);
+	if (!requestIdEnabled) return fn();
+	return getRequestIdStore().run(requestId, fn);
 }
 /**
 * Gets the current request ID from the async local storage context.
 *
 * @returns The current request ID, or undefined if not in a request context
 */ function getRequestId() {
-	return requestIdStore.getStore();
+	if (!requestIdEnabled) return;
+	return getRequestIdStore().getStore();
 }
 
 //#endregion
@@ -172,7 +201,7 @@ const isSymbol = (val) => typeof val === "symbol";
 
 //#endregion
 //#region src/logger/console-logger.service.mts
-function applyDecs2203RFactory$13() {
+function applyDecs2203RFactory$14() {
 	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
 		return function addInitializer(initializer) {
 			assertNotFinished(decoratorFinishedRef, "addInitializer");
@@ -446,10 +475,10 @@ function applyDecs2203RFactory$13() {
 		};
 	};
 }
-function _apply_decs_2203_r$13(targetClass, memberDecs, classDecs, parentClass) {
-	return (_apply_decs_2203_r$13 = applyDecs2203RFactory$13())(targetClass, memberDecs, classDecs, parentClass);
+function _apply_decs_2203_r$14(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r$14 = applyDecs2203RFactory$14())(targetClass, memberDecs, classDecs, parentClass);
 }
-var _dec$13, _initClass$13;
+var _dec$14, _initClass$14;
 const DEFAULT_DEPTH = 5;
 const DEFAULT_LOG_LEVELS = [
 	"log",
@@ -468,10 +497,10 @@ const dateTimeFormatter = new Intl.DateTimeFormat(void 0, {
 	month: "2-digit"
 });
 let _ConsoleLogger;
-_dec$13 = Injectable({ token: LoggerOutput });
+_dec$14 = Injectable({ token: LoggerOutput });
 var ConsoleLogger = class {
 	static {
-		({c: [_ConsoleLogger, _initClass$13]} = _apply_decs_2203_r$13(this, [], [_dec$13]));
+		({c: [_ConsoleLogger, _initClass$14]} = _apply_decs_2203_r$14(this, [], [_dec$14]));
 	}
 	/**
 	* The options of the logger.
@@ -720,13 +749,13 @@ var ConsoleLogger = class {
 		}
 	}
 	static {
-		_initClass$13();
+		_initClass$14();
 	}
 };
 
 //#endregion
 //#region src/logger/logger.service.mts
-function applyDecs2203RFactory$12() {
+function applyDecs2203RFactory$13() {
 	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
 		return function addInitializer(initializer) {
 			assertNotFinished(decoratorFinishedRef, "addInitializer");
@@ -1000,15 +1029,15 @@ function applyDecs2203RFactory$12() {
 		};
 	};
 }
-function _apply_decs_2203_r$12(targetClass, memberDecs, classDecs, parentClass) {
-	return (_apply_decs_2203_r$12 = applyDecs2203RFactory$12())(targetClass, memberDecs, classDecs, parentClass);
+function _apply_decs_2203_r$13(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r$13 = applyDecs2203RFactory$13())(targetClass, memberDecs, classDecs, parentClass);
 }
-var _dec$12, _initClass$12;
+var _dec$13, _initClass$13;
 let _LoggerInstance;
-_dec$12 = Injectable({ token: Logger });
+_dec$13 = Injectable({ token: Logger });
 var LoggerInstance = class {
 	static {
-		({c: [_LoggerInstance, _initClass$12]} = _apply_decs_2203_r$12(this, [], [_dec$12]));
+		({c: [_LoggerInstance, _initClass$13]} = _apply_decs_2203_r$13(this, [], [_dec$13]));
 	}
 	constructor(config = {}) {
 		this.context = config.context;
@@ -1040,13 +1069,13 @@ var LoggerInstance = class {
 		this.localInstance?.fatal?.(message, ...optionalParams);
 	}
 	static {
-		_initClass$12();
+		_initClass$13();
 	}
 };
 
 //#endregion
 //#region src/config/config.service.mts
-function applyDecs2203RFactory$11() {
+function applyDecs2203RFactory$12() {
 	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
 		return function addInitializer(initializer) {
 			assertNotFinished(decoratorFinishedRef, "addInitializer");
@@ -1320,10 +1349,10 @@ function applyDecs2203RFactory$11() {
 		};
 	};
 }
-function _apply_decs_2203_r$11(targetClass, memberDecs, classDecs, parentClass) {
-	return (_apply_decs_2203_r$11 = applyDecs2203RFactory$11())(targetClass, memberDecs, classDecs, parentClass);
+function _apply_decs_2203_r$12(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r$12 = applyDecs2203RFactory$12())(targetClass, memberDecs, classDecs, parentClass);
 }
-var _dec$11, _initClass$11;
+var _dec$12, _initClass$12;
 /**
 * Schema for validating configuration service options.
 */ const ConfigServiceOptionsSchema = z$1.record(z$1.string(), z$1.unknown());
@@ -1331,11 +1360,11 @@ var _dec$11, _initClass$11;
 * Injection token for ConfigService.
 */ const ConfigServiceToken = InjectionToken.create(Symbol.for("ConfigService"), ConfigServiceOptionsSchema);
 let _ConfigService;
-_dec$11 = Injectable({ token: ConfigServiceToken });
+_dec$12 = Injectable({ token: ConfigServiceToken });
 var ConfigService = class {
 	config;
 	static {
-		({c: [_ConfigService, _initClass$11]} = _apply_decs_2203_r$11(this, [], [_dec$11]));
+		({c: [_ConfigService, _initClass$12]} = _apply_decs_2203_r$12(this, [], [_dec$12]));
 	}
 	/**
 	* Creates a new ConfigService instance.
@@ -1417,7 +1446,7 @@ var ConfigService = class {
 		return value;
 	}
 	static {
-		_initClass$11();
+		_initClass$12();
 	}
 };
 
@@ -1677,6 +1706,360 @@ var ConfigService = class {
 	}
 };
 
+//#endregion
+//#region src/services/instance-resolver.service.mts
+function applyDecs2203RFactory$11() {
+	function createAddInitializerMethod(initializers, decoratorFinishedRef) {
+		return function addInitializer(initializer) {
+			assertNotFinished(decoratorFinishedRef, "addInitializer");
+			assertCallable(initializer, "An initializer");
+			initializers.push(initializer);
+		};
+	}
+	function memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value) {
+		var kindStr;
+		switch (kind) {
+			case 1:
+				kindStr = "accessor";
+				break;
+			case 2:
+				kindStr = "method";
+				break;
+			case 3:
+				kindStr = "getter";
+				break;
+			case 4:
+				kindStr = "setter";
+				break;
+			default: kindStr = "field";
+		}
+		var ctx = {
+			kind: kindStr,
+			name: isPrivate ? "#" + name : name,
+			static: isStatic,
+			private: isPrivate,
+			metadata
+		};
+		var decoratorFinishedRef = { v: false };
+		ctx.addInitializer = createAddInitializerMethod(initializers, decoratorFinishedRef);
+		var get, set;
+		if (kind === 0) if (isPrivate) {
+			get = desc.get;
+			set = desc.set;
+		} else {
+			get = function() {
+				return this[name];
+			};
+			set = function(v) {
+				this[name] = v;
+			};
+		}
+		else if (kind === 2) get = function() {
+			return desc.value;
+		};
+		else {
+			if (kind === 1 || kind === 3) get = function() {
+				return desc.get.call(this);
+			};
+			if (kind === 1 || kind === 4) set = function(v) {
+				desc.set.call(this, v);
+			};
+		}
+		ctx.access = get && set ? {
+			get,
+			set
+		} : get ? { get } : { set };
+		try {
+			return dec(value, ctx);
+		} finally {
+			decoratorFinishedRef.v = true;
+		}
+	}
+	function assertNotFinished(decoratorFinishedRef, fnName) {
+		if (decoratorFinishedRef.v) throw new Error("attempted to call " + fnName + " after decoration was finished");
+	}
+	function assertCallable(fn, hint) {
+		if (typeof fn !== "function") throw new TypeError(hint + " must be a function");
+	}
+	function assertValidReturnValue(kind, value) {
+		var type = typeof value;
+		if (kind === 1) {
+			if (type !== "object" || value === null) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0");
+			if (value.get !== void 0) assertCallable(value.get, "accessor.get");
+			if (value.set !== void 0) assertCallable(value.set, "accessor.set");
+			if (value.init !== void 0) assertCallable(value.init, "accessor.init");
+		} else if (type !== "function") {
+			var hint;
+			if (kind === 0) hint = "field";
+			else if (kind === 10) hint = "class";
+			else hint = "method";
+			throw new TypeError(hint + " decorators must return a function or void 0");
+		}
+	}
+	function applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata) {
+		var decs = decInfo[0];
+		var desc, init, value;
+		if (isPrivate) if (kind === 0 || kind === 1) desc = {
+			get: decInfo[3],
+			set: decInfo[4]
+		};
+		else if (kind === 3) desc = { get: decInfo[3] };
+		else if (kind === 4) desc = { set: decInfo[3] };
+		else desc = { value: decInfo[3] };
+		else if (kind !== 0) desc = Object.getOwnPropertyDescriptor(base, name);
+		if (kind === 1) value = {
+			get: desc.get,
+			set: desc.set
+		};
+		else if (kind === 2) value = desc.value;
+		else if (kind === 3) value = desc.get;
+		else if (kind === 4) value = desc.set;
+		var newValue, get, set;
+		if (typeof decs === "function") {
+			newValue = memberDec(decs, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				if (kind === 0) init = newValue;
+				else if (kind === 1) {
+					init = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+			}
+		} else for (var i = decs.length - 1; i >= 0; i--) {
+			var dec = decs[i];
+			newValue = memberDec(dec, name, desc, initializers, kind, isStatic, isPrivate, metadata, value);
+			if (newValue !== void 0) {
+				assertValidReturnValue(kind, newValue);
+				var newInit;
+				if (kind === 0) newInit = newValue;
+				else if (kind === 1) {
+					newInit = newValue.init;
+					get = newValue.get || value.get;
+					set = newValue.set || value.set;
+					value = {
+						get,
+						set
+					};
+				} else value = newValue;
+				if (newInit !== void 0) if (init === void 0) init = newInit;
+				else if (typeof init === "function") init = [init, newInit];
+				else init.push(newInit);
+			}
+		}
+		if (kind === 0 || kind === 1) {
+			if (init === void 0) init = function(instance, init$1) {
+				return init$1;
+			};
+			else if (typeof init !== "function") {
+				var ownInitializers = init;
+				init = function(instance, init$1) {
+					var value$1 = init$1;
+					for (var i$1 = 0; i$1 < ownInitializers.length; i$1++) value$1 = ownInitializers[i$1].call(instance, value$1);
+					return value$1;
+				};
+			} else {
+				var originalInitializer = init;
+				init = function(instance, init$1) {
+					return originalInitializer.call(instance, init$1);
+				};
+			}
+			ret.push(init);
+		}
+		if (kind !== 0) {
+			if (kind === 1) {
+				desc.get = value.get;
+				desc.set = value.set;
+			} else if (kind === 2) desc.value = value;
+			else if (kind === 3) desc.get = value;
+			else if (kind === 4) desc.set = value;
+			if (isPrivate) if (kind === 1) {
+				ret.push(function(instance, args) {
+					return value.get.call(instance, args);
+				});
+				ret.push(function(instance, args) {
+					return value.set.call(instance, args);
+				});
+			} else if (kind === 2) ret.push(value);
+			else ret.push(function(instance, args) {
+				return value.call(instance, args);
+			});
+			else Object.defineProperty(base, name, desc);
+		}
+	}
+	function applyMemberDecs(Class, decInfos, metadata) {
+		var ret = [];
+		var protoInitializers;
+		var staticInitializers;
+		var existingProtoNonFields = /* @__PURE__ */ new Map();
+		var existingStaticNonFields = /* @__PURE__ */ new Map();
+		for (var i = 0; i < decInfos.length; i++) {
+			var decInfo = decInfos[i];
+			if (!Array.isArray(decInfo)) continue;
+			var kind = decInfo[1];
+			var name = decInfo[2];
+			var isPrivate = decInfo.length > 3;
+			var isStatic = kind >= 5;
+			var base;
+			var initializers;
+			if (isStatic) {
+				base = Class;
+				kind = kind - 5;
+				staticInitializers = staticInitializers || [];
+				initializers = staticInitializers;
+			} else {
+				base = Class.prototype;
+				protoInitializers = protoInitializers || [];
+				initializers = protoInitializers;
+			}
+			if (kind !== 0 && !isPrivate) {
+				var existingNonFields = isStatic ? existingStaticNonFields : existingProtoNonFields;
+				var existingKind = existingNonFields.get(name) || 0;
+				if (existingKind === true || existingKind === 3 && kind !== 4 || existingKind === 4 && kind !== 3) throw new Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + name);
+				else if (!existingKind && kind > 2) existingNonFields.set(name, kind);
+				else existingNonFields.set(name, true);
+			}
+			applyMemberDec(ret, base, decInfo, name, kind, isStatic, isPrivate, initializers, metadata);
+		}
+		pushInitializers(ret, protoInitializers);
+		pushInitializers(ret, staticInitializers);
+		return ret;
+	}
+	function pushInitializers(ret, initializers) {
+		if (initializers) ret.push(function(instance) {
+			for (var i = 0; i < initializers.length; i++) initializers[i].call(instance);
+			return instance;
+		});
+	}
+	function applyClassDecs(targetClass, classDecs, metadata) {
+		if (classDecs.length > 0) {
+			var initializers = [];
+			var newClass = targetClass;
+			var name = targetClass.name;
+			for (var i = classDecs.length - 1; i >= 0; i--) {
+				var decoratorFinishedRef = { v: false };
+				try {
+					var nextNewClass = classDecs[i](newClass, {
+						kind: "class",
+						name,
+						addInitializer: createAddInitializerMethod(initializers, decoratorFinishedRef),
+						metadata
+					});
+				} finally {
+					decoratorFinishedRef.v = true;
+				}
+				if (nextNewClass !== void 0) {
+					assertValidReturnValue(10, nextNewClass);
+					newClass = nextNewClass;
+				}
+			}
+			return [defineMetadata(newClass, metadata), function() {
+				for (var i$1 = 0; i$1 < initializers.length; i$1++) initializers[i$1].call(newClass);
+			}];
+		}
+	}
+	function defineMetadata(Class, metadata) {
+		return Object.defineProperty(Class, Symbol.metadata || Symbol.for("Symbol.metadata"), {
+			configurable: true,
+			enumerable: true,
+			value: metadata
+		});
+	}
+	return function applyDecs2203R(targetClass, memberDecs, classDecs, parentClass) {
+		if (parentClass !== void 0) var parentMetadata = parentClass[Symbol.metadata || Symbol.for("Symbol.metadata")];
+		var metadata = Object.create(parentMetadata === void 0 ? null : parentMetadata);
+		var e = applyMemberDecs(targetClass, memberDecs, metadata);
+		if (!classDecs.length) defineMetadata(targetClass, metadata);
+		return {
+			e,
+			get c() {
+				return applyClassDecs(targetClass, classDecs, metadata);
+			}
+		};
+	};
+}
+function _apply_decs_2203_r$11(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r$11 = applyDecs2203RFactory$11())(targetClass, memberDecs, classDecs, parentClass);
+}
+var _dec$11, _initClass$11;
+let _InstanceResolverService;
+_dec$11 = Injectable();
+var InstanceResolverService = class {
+	static {
+		({c: [_InstanceResolverService, _initClass$11]} = _apply_decs_2203_r$11(this, [], [_dec$11]));
+	}
+	container = inject(Container);
+	/**
+	* Attempts to resolve a class instance, automatically detecting if it needs
+	* request scope based on its dependencies.
+	*
+	* @param classType - The class to resolve
+	* @returns A resolution result containing either a cached instance or resolver function
+	*/ async resolve(classType) {
+		let cachedInstance = null;
+		try {
+			cachedInstance = await this.container.get(classType);
+		} catch {
+			const token = getInjectableToken(classType);
+			this.container.getRegistry().updateScope(token, InjectableScope.Request);
+		}
+		return {
+			cached: cachedInstance !== null,
+			instance: cachedInstance,
+			resolve: (scoped) => scoped.get(classType)
+		};
+	}
+	/**
+	* Attempts to resolve multiple class instances, automatically detecting if any need
+	* request scope based on their dependencies.
+	*
+	* Returns `cached: true` only if ALL classes can be resolved as singletons.
+	* If any class has request-scoped dependencies, returns `cached: false`.
+	*
+	* @param classTypes - The classes to resolve
+	* @returns A resolution result containing either all cached instances or resolver function
+	*/ async resolveMany(classTypes) {
+		if (classTypes.length === 0) return {
+			cached: true,
+			instances: [],
+			classTypes: [],
+			resolve: async () => []
+		};
+		const results = await Promise.all(classTypes.map(async (classType) => {
+			try {
+				return {
+					success: true,
+					instance: await this.container.get(classType)
+				};
+			} catch {
+				const token = getInjectableToken(classType);
+				this.container.getRegistry().updateScope(token, InjectableScope.Request);
+				return {
+					success: false,
+					instance: null
+				};
+			}
+		}));
+		const allCached = results.every((r) => r.success);
+		return {
+			cached: allCached,
+			instances: allCached ? results.map((r) => r.instance) : null,
+			classTypes,
+			resolve: (scoped) => Promise.all(classTypes.map((classType) => scoped.get(classType)))
+		};
+	}
+	static {
+		_initClass$11();
+	}
+};
+/**
+* @deprecated Use InstanceResolverService instead
+*/ const ControllerResolverService = _InstanceResolverService;
+
 //#endregion
 //#region src/services/guard-runner.service.mts
 function applyDecs2203RFactory$10() {
@@ -1964,23 +2347,40 @@ var GuardRunnerService = class {
 		({c: [_GuardRunnerService, _initClass$10]} = _apply_decs_2203_r$10(this, [], [_dec$10]));
 	}
 	logger = inject(Logger, { context: _GuardRunnerService.name });
-	async runGuards(allGuards, executionContext, context) {
-		let canActivate = true;
-		for (const guard of Array.from(allGuards).reverse()) {
+	/**
+	* Runs guards that need to be resolved from a scoped container.
+	* Use this when guards have request-scoped dependencies.
+	*/ async runGuards(allGuards, executionContext, context) {
+		const guardsArray = Array.from(allGuards).reverse();
+		const guardInstances = await Promise.all(guardsArray.map(async (guard) => {
 			const guardInstance = await context.get(guard);
 			if (!guardInstance.canActivate) throw new Error(`[Navios] Guard ${guard.name} does not implement canActivate()`);
-			try {
-				canActivate = await guardInstance.canActivate(executionContext);
-				if (!canActivate) break;
-			} catch (error) {
-				if (error instanceof HttpException) {
-					executionContext.getReply().status(error.statusCode).send(error.response);
-					return false;
-				} else {
-					this.logger.error("Error running guard", error);
-					executionContext.getReply().status(500).send({ message: "Internal server error" });
-					return false;
-				}
+			return guardInstance;
+		}));
+		return this.executeGuards(guardInstances, executionContext);
+	}
+	/**
+	* Runs pre-resolved guard instances.
+	* Use this when all guards are singletons and have been pre-resolved at startup.
+	*/ async runGuardsStatic(guardInstances, executionContext) {
+		return this.executeGuards(guardInstances, executionContext);
+	}
+	/**
+	* Shared guard execution logic.
+	* Iterates through guard instances and calls canActivate on each.
+	*/ async executeGuards(guardInstances, executionContext) {
+		let canActivate = true;
+		for (const guardInstance of guardInstances) try {
+			canActivate = await guardInstance.canActivate(executionContext);
+			if (!canActivate) break;
+		} catch (error) {
+			if (error instanceof HttpException) {
+				executionContext.getReply().status(error.statusCode).send(error.response);
+				return false;
+			} else {
+				this.logger.error("Error running guard", error);
+				executionContext.getReply().status(500).send({ message: "Internal server error" });
+				return false;
 			}
 		}
 		if (!canActivate) {
@@ -2300,6 +2700,49 @@ var ModuleLoaderService = class {
 		await this.traverseModules(appModule);
 		this.initialized = true;
 	}
+	/**
+	* Extends the module tree with additional modules or controllers.
+	*
+	* This method is designed to be called by plugins during registration,
+	* which happens after initial module loading but before route registration.
+	*
+	* @param extensions - Array of module extensions to add
+	* @throws Error if not initialized (loadModules must be called first)
+	*
+	* @example
+	* ```typescript
+	* // In plugin registration
+	* const moduleLoader = await context.container.get(ModuleLoaderService)
+	* await moduleLoader.extendModules([{
+	*   controllers: [OpenApiJsonController, OpenApiYamlController],
+	*   moduleName: 'OpenApiBunModule',
+	* }])
+	* ```
+	*/ async extendModules(extensions) {
+		if (!this.initialized) throw new Error("ModuleLoaderService must be initialized before extending. Call loadModules() first.");
+		for (const extension of extensions) if (extension.module) await this.traverseModules(extension.module);
+		else if (extension.controllers && extension.moduleName) await this.registerControllers(extension.controllers, extension.moduleName);
+		else if (extension.controllers) throw new Error("moduleName is required when providing controllers without a module");
+	}
+	/**
+	* Registers controllers under a synthetic module.
+	* Used when plugins want to add controllers without a full module class.
+	*/ async registerControllers(controllers, moduleName) {
+		if (this.modulesMetadata.has(moduleName)) {
+			const existing = this.modulesMetadata.get(moduleName);
+			for (const controller of controllers) existing.controllers.add(controller);
+			this.logger.debug(`Extended module ${moduleName} with ${controllers.length} controllers`);
+		} else {
+			const metadata = {
+				controllers: new Set(controllers),
+				imports: /* @__PURE__ */ new Set(),
+				guards: /* @__PURE__ */ new Set(),
+				customAttributes: /* @__PURE__ */ new Map()
+			};
+			this.modulesMetadata.set(moduleName, metadata);
+			this.logger.debug(`Created module ${moduleName} with ${controllers.length} controllers`);
+		}
+	}
 	async traverseModules(module, parentMetadata) {
 		const metadata = extractModuleMetadata(module);
 		if (parentMetadata) this.mergeMetadata(metadata, parentMetadata);
@@ -5097,6 +5540,7 @@ var NaviosApplication = class {
 	container = inject(Container);
 	appModule = null;
 	options = { adapter: [] };
+	plugins = [];
 	/**
 	* Indicates whether the application has been initialized.
 	* Set to `true` after `init()` completes successfully.
@@ -5104,7 +5548,7 @@ var NaviosApplication = class {
 	/**
 	* Sets up the application with the provided module and options.
 	* This is called automatically by NaviosFactory.create().
-	* 
+	*
 	* @param appModule - The root application module
 	* @param options - Application configuration options
 	* @internal
@@ -5115,24 +5559,46 @@ var NaviosApplication = class {
 	}
 	/**
 	* Gets the dependency injection container used by this application.
-	* 
+	*
 	* @returns The Container instance
 	*/ getContainer() {
 		return this.container;
 	}
 	/**
+	* Registers a plugin to be initialized after modules are loaded.
+	*
+	* Plugins are initialized in the order they are registered,
+	* after all modules are loaded but before the server starts listening.
+	*
+	* @param definition - Plugin definition with options
+	* @returns this for method chaining
+	*
+	* @example
+	* ```typescript
+	* import { defineOpenApiPlugin } from '@navios/openapi-fastify'
+	*
+	* app.usePlugin(defineOpenApiPlugin({
+	*   info: { title: 'My API', version: '1.0.0' },
+	* }))
+	* ```
+	*/ usePlugin(definition) {
+		this.plugins.push(definition);
+		return this;
+	}
+	/**
 	* Initializes the application.
-	* 
+	*
 	* This method:
 	* - Loads all modules and their dependencies
 	* - Sets up the HTTP server if an adapter is configured
 	* - Calls onModuleInit hooks on all modules
+	* - Initializes registered plugins
 	* - Marks the application as initialized
-	* 
+	*
 	* Must be called before `listen()`.
-	* 
+	*
 	* @throws Error if app module is not set
-	* 
+	*
 	* @example
 	* ```typescript
 	* const app = await NaviosFactory.create(AppModule, {
@@ -5145,6 +5611,7 @@ var NaviosApplication = class {
 		if (!this.appModule) throw new Error("App module is not set. Call setAppModule() first.");
 		await this.moduleLoader.loadModules(this.appModule);
 		if (this.environment.hasHttpSetup()) await this.httpApplication?.setupHttpServer(this.options);
+		await this.initPlugins();
 		await this.initModules();
 		if (this.environment.hasHttpSetup()) await this.httpApplication?.ready();
 		this.isInitialized = true;
@@ -5154,12 +5621,30 @@ var NaviosApplication = class {
 		const modules = this.moduleLoader.getAllModules();
 		await this.httpApplication?.onModulesInit(modules);
 	}
+	async initPlugins() {
+		if (this.plugins.length === 0) return;
+		let server = null;
+		try {
+			server = this.httpApplication?.getServer() ?? null;
+		} catch {}
+		const context = {
+			modules: this.moduleLoader.getAllModules(),
+			server,
+			container: this.container,
+			globalPrefix: this.httpApplication?.getGlobalPrefix() ?? "",
+			moduleLoader: this.moduleLoader
+		};
+		for (const { plugin, options } of this.plugins) {
+			this.logger.debug(`Initializing plugin: ${plugin.name}`);
+			await plugin.register(context, options);
+		}
+	}
 	/**
 	* Enables CORS (Cross-Origin Resource Sharing) for the application.
-	* 
+	*
 	* @param options - CORS configuration options (adapter-specific)
 	* @throws Error if HTTP application is not set
-	* 
+	*
 	* @example
 	* ```typescript
 	* app.enableCors({
@@ -5174,10 +5659,10 @@ var NaviosApplication = class {
 	}
 	/**
 	* Enables multipart/form-data support for file uploads.
-	* 
+	*
 	* @param options - Multipart configuration options (adapter-specific)
 	* @throws Error if HTTP application is not set
-	* 
+	*
 	* @example
 	* ```typescript
 	* app.enableMultipart({
@@ -5192,10 +5677,10 @@ var NaviosApplication = class {
 	}
 	/**
 	* Sets a global prefix for all routes.
-	* 
+	*
 	* @param prefix - The prefix to prepend to all route URLs (e.g., '/api')
 	* @throws Error if HTTP application is not set
-	* 
+	*
 	* @example
 	* ```typescript
 	* app.setGlobalPrefix('/api/v1')
@@ -5207,14 +5692,14 @@ var NaviosApplication = class {
 	}
 	/**
 	* Gets the underlying HTTP server instance.
-	* 
+	*
 	* The type of the returned server depends on the adapter used:
 	* - Fastify adapter: Returns FastifyInstance
 	* - Bun adapter: Returns Bun.Server
-	* 
+	*
 	* @returns The HTTP server instance
 	* @throws Error if HTTP application is not set
-	* 
+	*
 	* @example
 	* ```typescript
 	* const server = app.getServer()
@@ -5226,10 +5711,10 @@ var NaviosApplication = class {
 	}
 	/**
 	* Starts the HTTP server and begins listening for requests.
-	* 
+	*
 	* @param options - Listen options (port, host, etc.)
 	* @throws Error if HTTP application is not set
-	* 
+	*
 	* @example
 	* ```typescript
 	* await app.listen({ port: 3000, host: '0.0.0.0' })
@@ -5240,7 +5725,7 @@ var NaviosApplication = class {
 	}
 	/**
 	* Disposes of application resources.
-	* 
+	*
 	* Cleans up the HTTP server and module loader.
 	* This method is called automatically by `close()`.
 	*/ async dispose() {
@@ -5249,9 +5734,9 @@ var NaviosApplication = class {
 	}
 	/**
 	* Closes the application and cleans up all resources.
-	* 
+	*
 	* This is an alias for `dispose()`.
-	* 
+	*
 	* @example
 	* ```typescript
 	* // Graceful shutdown
@@ -5272,31 +5757,31 @@ var NaviosApplication = class {
 //#region src/navios.factory.mts
 /**
 * Factory class for creating and configuring Navios applications.
-* 
+*
 * This is the main entry point for bootstrapping a Navios application.
 * It handles dependency injection container setup, adapter registration,
 * and logger configuration.
-* 
+*
 * @example
 * ```typescript
 * import { NaviosFactory } from '@navios/core'
 * import { defineFastifyEnvironment } from '@navios/adapter-fastify'
-* 
+*
 * const app = await NaviosFactory.create(AppModule, {
 *   adapter: defineFastifyEnvironment(),
 *   logger: ['log', 'error', 'warn'],
 * })
-* 
+*
 * await app.init()
 * await app.listen({ port: 3000 })
 * ```
 */ var NaviosFactory = class {
 	/**
 	* Creates a new Navios application instance.
-	* 
+	*
 	* This method sets up the dependency injection container, registers the HTTP adapter,
 	* configures logging, and initializes the application with the provided module.
-	* 
+	*
 	* @param appModule - The root application module class decorated with @Module()
 	* @param options - Configuration options for the application
 	* @param options.adapter - HTTP adapter environment (required for HTTP server functionality)
@@ -5306,20 +5791,20 @@ var NaviosApplication = class {
 	*   - `false` to disable logging
 	* @param options.container - Optional custom dependency injection container (useful for testing)
 	* @returns A configured NaviosApplication instance ready to be initialized
-	* 
+	*
 	* @example
 	* ```typescript
 	* // Basic setup with Fastify adapter
 	* const app = await NaviosFactory.create(AppModule, {
 	*   adapter: defineFastifyEnvironment(),
 	* })
-	* 
+	*
 	* // With custom logger configuration
 	* const app = await NaviosFactory.create(AppModule, {
 	*   adapter: defineFastifyEnvironment(),
 	*   logger: ['error', 'warn', 'log'],
 	* })
-	* 
+	*
 	* // With custom container for testing
 	* const container = new Container()
 	* const app = await NaviosFactory.create(AppModule, {
@@ -5329,6 +5814,8 @@ var NaviosApplication = class {
 	* ```
 	*/ static async create(appModule, options = { adapter: [] }) {
 		const container = options.container ?? new Container();
+		if (options.enableRequestId === true) setRequestIdEnabled(true);
+		container.getServiceLocator().getManager().storeCreatedHolder(NaviosOptionsToken.toString(), options, InjectableType.Class, InjectableScope.Singleton);
 		await this.registerLoggerConfiguration(container, options);
 		const adapters = Array.isArray(options.adapter) ? options.adapter : [options.adapter];
 		for (const adapter of adapters) await this.registerEnvironment(container, adapter);
@@ -5343,11 +5830,14 @@ var NaviosApplication = class {
 	}
 	static async registerLoggerConfiguration(container, options) {
 		const { logger } = options;
-		if (Array.isArray(logger) || isNil(logger)) (await container.get(LoggerOutput))?.setup({ logLevels: logger });
+		if (Array.isArray(logger) || isNil(logger)) {
+			(await container.get(LoggerOutput))?.setup({ logLevels: logger });
+			return;
+		}
 		if (logger !== true && !isNil(logger)) container.getServiceLocator().getManager().storeCreatedHolder(LoggerOutput.toString(), logger, InjectableType.Class, InjectableScope.Singleton);
 	}
 };
 
 //#endregion
-export { envInt as $, loggerOptionsSchema as A, isObject as B, ConfigServiceOptionsSchema as C, _ConsoleLogger as D, _LoggerInstance as E, isConstructor as F, normalizePath as G, isString as H, isEmpty as I, filterLogLevels as J, stripEndSlash as K, isFunction as L, requestIdStore as M, runWithRequestId as N, Logger as O, addLeadingSlash as P, yellow as Q, isNil as R, provideConfig as S, _ConfigService as T, isSymbol as U, isPlainObject as V, isUndefined as W, LOG_LEVELS as X, isLogLevel as Y, clc as Z, ForbiddenException as _, _ReplyFactory as a, ConfigProviderOptions as b, _HttpAdapterFactory as c, _ModuleLoaderService as d, envString as et, _GuardRunnerService as f, InternalServerErrorException as g, NotFoundException as h, _StreamAdapterFactory as i, getRequestId as j, LoggerOutput as k, _EndpointAdapterFactory as l, UnauthorizedException as m, _NaviosApplication as n, _RequestFactory as o, ConflictException as p, isLogLevelEnabled as q, _XmlStreamAdapterFactory as r, _MultipartAdapterFactory as s, NaviosFactory as t, AttributeFactory as u, BadRequestException as v, ConfigServiceToken as w, EnvConfigProvider as x, HttpException as y, isNumber as z };
-//# sourceMappingURL=src-DzPY5s6d.mjs.map
+export { LOG_LEVELS as $, Logger as A, isFunction as B, EnvConfigProvider as C, _ConfigService as D, ConfigServiceToken as E, runWithRequestId as F, isString as G, isNumber as H, setRequestIdEnabled as I, normalizePath as J, isSymbol as K, addLeadingSlash as L, loggerOptionsSchema as M, generateRequestId as N, _LoggerInstance as O, getRequestId as P, isLogLevel as Q, isConstructor as R, ConfigProviderOptions as S, ConfigServiceOptionsSchema as T, isObject as U, isNil as V, isPlainObject as W, isLogLevelEnabled as X, stripEndSlash as Y, filterLogLevels as Z, NotFoundException as _, _ReplyFactory as a, BadRequestException as b, _HttpAdapterFactory as c, _ModuleLoaderService as d, clc as et, _GuardRunnerService as f, UnauthorizedException as g, ConflictException as h, _StreamAdapterFactory as i, LoggerOutput as j, _ConsoleLogger as k, _EndpointAdapterFactory as l, _InstanceResolverService as m, _NaviosApplication as n, envInt as nt, _RequestFactory as o, ControllerResolverService as p, isUndefined as q, _XmlStreamAdapterFactory as r, envString as rt, _MultipartAdapterFactory as s, NaviosFactory as t, yellow as tt, AttributeFactory as u, InternalServerErrorException as v, provideConfig as w, HttpException as x, ForbiddenException as y, isEmpty as z };
+//# sourceMappingURL=src-gBAChVRL.mjs.map