@navios/adapter-xml 0.1.0 → 0.7.0

package/lib/index.cjs

@@ -0,0 +1,746 @@
+const require_create_element = require('./create-element-CTOxv6Df.cjs');
+let __navios_core = require("@navios/core");
+
+//#region src/runtime/special-nodes.mts
+/**
+* CDATA component - wraps content in <![CDATA[...]]>
+* Use for text content that may contain characters like < > &
+* that would otherwise need escaping.
+*
+* Note: If content contains "]]>", it will be split into multiple CDATA sections.
+*/
+function CData({ children }) {
+	return {
+		type: require_create_element.CDataSymbol,
+		content: String(children)
+	};
+}
+/**
+* DangerouslyInsertRawXml - inserts raw XML/HTML without any escaping or wrapping
+*
+* WARNING: This bypasses all XML escaping. Only use with trusted content!
+* Use cases:
+* - Pre-rendered XML fragments
+* - HTML content in RSS/Atom feeds (in description/content:encoded)
+* - Including XML from external sources that's already valid
+*/
+function DangerouslyInsertRawXml({ children }) {
+	return {
+		type: require_create_element.RawXmlSymbol,
+		content: String(children)
+	};
+}
+
+//#endregion
+//#region src/runtime/render-to-xml.mts
+/**
+* Error thrown when attempting to render a class component without a container.
+*
+* Class components require a dependency injection container to be instantiated.
+* This error is thrown when `renderToXml` is called with a class component in
+* the tree but no container is provided in the options.
+*
+* @example
+* ```ts
+* try {
+*   await renderToXml(<MyClassComponent />)
+* } catch (error) {
+*   if (error instanceof MissingContainerError) {
+*     // Provide a container
+*     await renderToXml(<MyClassComponent />, { container })
+*   }
+* }
+* ```
+*/ var MissingContainerError = class extends Error {
+	constructor(componentName) {
+		super(`[@navios/adapter-xml] Cannot render class component "${componentName}" without a container. Pass a container to renderToXml options: renderToXml(node, { container })`);
+		this.name = "MissingContainerError";
+	}
+};
+/**
+* Renders a JSX XML node tree to an XML string.
+*
+* This function handles:
+* - Regular XML nodes (tags with props and children)
+* - Async components (resolves promises in parallel)
+* - Class components (resolves via DI container)
+* - CDATA sections
+* - Raw XML content
+* - Fragments
+* - Text content with proper escaping
+*
+* @param node - The root XML node (JSX element) to render.
+* @param options - Rendering options including declaration, encoding, pretty printing, and container.
+* @returns A promise that resolves to the XML string.
+*
+* @throws {MissingContainerError} If the tree contains class components but no container is provided.
+*
+* @example
+* ```ts
+* // Simple rendering
+* const xml = await renderToXml(<rss version="2.0"><channel>...</channel></rss>)
+*
+* // With options
+* const xml = await renderToXml(<feed>...</feed>, {
+*   declaration: true,
+*   encoding: 'UTF-8',
+*   pretty: true,
+* })
+*
+* // With class components (requires container)
+* const container = new Container()
+* container.beginRequest('request-id')
+* const xml = await renderToXml(<MyClassComponent />, { container })
+* ```
+*/ async function renderToXml(node, options = {}) {
+	const { declaration = true, encoding = "UTF-8", pretty = false, container } = options;
+	let xml = "";
+	if (declaration) {
+		xml += `<?xml version="1.0" encoding="${encoding}"?>`;
+		if (pretty) xml += "\n";
+	}
+	xml += await renderNode(node, pretty ? 0 : -1, container);
+	return xml;
+}
+async function renderNode(node, indent, container) {
+	if (node == null) return "";
+	if (typeof node === "string") return escapeXml(node);
+	if (typeof node === "number") return String(node);
+	if (isClassComponentNode(node)) {
+		if (!container) throw new MissingContainerError(node.componentClass.name);
+		const result = (await container.get(node.componentClass, node.props)).render();
+		return renderNode(result instanceof Promise ? await result : result, indent, container);
+	}
+	if (isAsyncNode(node)) return renderNode(await node.promise, indent, container);
+	if (isCDataNode(node)) return renderCData(node.content);
+	if (isRawXmlNode(node)) return node.content;
+	const { type, props, children } = node;
+	if (type === require_create_element.Fragment) return (await Promise.all(children.filter((c) => c != null).map((c) => renderNode(c, indent, container)))).join("");
+	const prefix = indent >= 0 ? "  ".repeat(indent) : "";
+	const newline = indent >= 0 ? "\n" : "";
+	const attrs = Object.entries(props).filter(([_, v]) => v != null).map(([k, v]) => ` ${k}="${escapeAttr(String(v))}"`).join("");
+	if (children.length === 0) return `${prefix}<${type}${attrs}/>${newline}`;
+	const childIndent = indent >= 0 ? indent + 1 : -1;
+	const childContent = (await Promise.all(children.filter((c) => c != null).map((c) => renderNode(c, childIndent, container)))).join("");
+	if (children.every((c) => typeof c === "string" || typeof c === "number" || isCDataNode(c) || isRawXmlNode(c))) return `${prefix}<${type}${attrs}>${childContent}</${type}>${newline}`;
+	return `${prefix}<${type}${attrs}>${newline}${childContent}${prefix}</${type}>${newline}`;
+}
+function isClassComponentNode(node) {
+	return node !== null && typeof node === "object" && "type" in node && node.type === require_create_element.ClassComponent;
+}
+function isAsyncNode(node) {
+	return node !== null && typeof node === "object" && "type" in node && node.type === require_create_element.AsyncComponent;
+}
+function isCDataNode(node) {
+	return node && typeof node === "object" && node.type === require_create_element.CDataSymbol;
+}
+function isRawXmlNode(node) {
+	return node && typeof node === "object" && node.type === require_create_element.RawXmlSymbol;
+}
+/**
+* Renders content as CDATA section.
+* If content contains "]]>", splits into multiple CDATA sections.
+* The technique is to end the CDATA section before ]]>, then start a new one.
+*/ function renderCData(content) {
+	if (content.includes("]]>")) return `<![CDATA[${content.replace(/]]>/g, "]]]]><![CDATA[>")}]]>`;
+	return `<![CDATA[${content}]]>`;
+}
+function escapeXml(str) {
+	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr(str) {
+	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+//#endregion
+//#region src/tags/define-tag.mts
+/**
+* Creates a type-safe XML tag component with optional Zod schema validation.
+*
+* @param name - The tag name (supports namespace prefixes like 'atom:link')
+* @param propsSchema - Optional Zod schema for validating props
+* @returns A component function that can be used in JSX
+*
+* @example
+* ```tsx
+* // Simple tag
+* const item = defineTag('item')
+* <item>Content</item>
+*
+* // Namespaced tag with Zod validation
+* const atomLink = defineTag('atom:link', z.object({
+*   href: z.string().url(),
+*   rel: z.enum(['self', 'alternate']),
+*   type: z.string().optional(),
+* }))
+* <atomLink href="https://example.com/feed" rel="self" />
+* ```
+*/ function defineTag(name, propsSchema) {
+	const component = (props) => {
+		const { children, ...rest } = props ?? {};
+		if (propsSchema) propsSchema.parse(rest);
+		return {
+			type: name,
+			props: rest,
+			children: Array.isArray(children) ? children : children ? [children] : []
+		};
+	};
+	component.tagName = name;
+	return component;
+}
+
+//#endregion
+//#region src/decorators/xml-stream.decorator.mts
+/**
+* Decorator for XML Stream endpoints that return JSX-based XML responses.
+*
+* This decorator marks controller methods that return JSX elements, which will be
+* automatically rendered to XML and sent with the appropriate Content-Type header.
+* The method can be async and can contain async components, class components, and
+* regular JSX elements.
+*
+* @template Method - The HTTP method (GET, POST, etc.).
+* @template Url - The URL path pattern (supports parameters like `/posts/:id`).
+* @template QuerySchema - Optional Zod schema for query parameter validation.
+* @template RequestSchema - Optional Zod schema for request body validation.
+*
+* @param endpoint - The endpoint declaration created with `declareXmlStream`.
+* @returns A method decorator function.
+*
+* @throws {Error} If used on a non-function or non-method.
+* @throws {Error} If the endpoint URL already exists.
+*
+* @example
+* ```typescript
+* import { XmlStream, declareXmlStream } from '@navios/adapter-xml'
+* import { Controller } from '@navios/core'
+*
+* const getRssFeed = declareXmlStream({
+*   method: 'GET',
+*   url: '/feed.xml',
+*   contentType: 'application/rss+xml',
+* })
+*
+* @Controller('/api')
+* class FeedController {
+*   @XmlStream(getRssFeed)
+*   async getFeed() {
+*     return (
+*       <rss version="2.0">
+*         <channel>
+*           <title>My Feed</title>
+*         </channel>
+*       </rss>
+*     )
+*   }
+* }
+* ```
+*
+* @example
+* ```typescript
+* // With query parameters
+* const getSitemap = declareXmlStream({
+*   method: 'GET',
+*   url: '/sitemap.xml',
+*   querySchema: z.object({ page: z.string().optional() }),
+* })
+*
+* @Controller()
+* class SitemapController {
+*   @XmlStream(getSitemap)
+*   async getSitemap(params: { query?: { page?: string } }) {
+*     const page = params.query?.page
+*     return <urlset>...</urlset>
+*   }
+* }
+* ```
+*/ function XmlStream(endpoint) {
+	return (target, context) => {
+		if (typeof target !== "function") throw new Error("[Navios] XmlStream decorator can only be used on functions.");
+		if (context.kind !== "method") throw new Error("[Navios] XmlStream decorator can only be used on methods.");
+		const config = endpoint.config;
+		if (context.metadata) {
+			const endpointMetadata = (0, __navios_core.getEndpointMetadata)(target, context);
+			if (endpointMetadata.config && endpointMetadata.config.url) throw new Error(`[Navios] Endpoint ${config.method} ${config.url} already exists.`);
+			endpointMetadata.config = config;
+			endpointMetadata.adapterToken = __navios_core.XmlStreamAdapterToken;
+			endpointMetadata.classMethod = target.name;
+			endpointMetadata.httpMethod = config.method;
+			endpointMetadata.url = config.url;
+		}
+		return target;
+	};
+}
+
+//#endregion
+//#region src/handlers/xml-stream.mts
+/**
+* Declares an XML Stream endpoint configuration for use with `@XmlStream` decorator.
+*
+* This function creates an endpoint declaration that can be used with the `@XmlStream`
+* decorator to mark controller methods that return JSX-based XML responses.
+*
+* @template Method - The HTTP method (GET, POST, etc.).
+* @template Url - The URL path pattern (supports parameters like `/posts/:id`).
+* @template QuerySchema - Optional Zod schema for query parameter validation.
+* @template RequestSchema - Optional Zod schema for request body validation.
+*
+* @param config - The endpoint configuration including method, URL, schemas, and XML options.
+* @returns An endpoint declaration object to be used with `@XmlStream` decorator.
+*
+* @example
+* ```typescript
+* import { declareXmlStream } from '@navios/adapter-xml'
+* import { z } from 'zod/v4'
+*
+* // Simple endpoint
+* export const getRssFeed = declareXmlStream({
+*   method: 'GET',
+*   url: '/feed.xml',
+*   contentType: 'application/rss+xml',
+* })
+*
+* // With query parameters
+* export const getSitemap = declareXmlStream({
+*   method: 'GET',
+*   url: '/sitemap.xml',
+*   querySchema: z.object({
+*     page: z.string().optional(),
+*   }),
+*   contentType: 'application/xml',
+*   xmlDeclaration: true,
+*   encoding: 'UTF-8',
+* })
+* ```
+*/ function declareXmlStream(config) {
+	return { config };
+}
+
+//#endregion
+//#region src/adapters/xml-stream-adapter.service.mts
+function applyDecs2203RFactory() {
+	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(targetClass, memberDecs, classDecs, parentClass) {
+	return (_apply_decs_2203_r = applyDecs2203RFactory())(targetClass, memberDecs, classDecs, parentClass);
+}
+var _dec, _initClass;
+let _XmlStreamAdapterService;
+_dec = (0, __navios_core.Injectable)({ token: __navios_core.XmlStreamAdapterToken });
+var XmlStreamAdapterService = class {
+	static {
+		({c: [_XmlStreamAdapterService, _initClass]} = _apply_decs_2203_r(this, [], [_dec]));
+	}
+	/** Base stream adapter - we proxy hasSchema, prepareArguments, provideSchema to it */ streamAdapter = (0, __navios_core.inject)(__navios_core.StreamAdapterToken);
+	/**
+	* Prepares argument getters for parsing request data.
+	*
+	* Proxies to the base stream adapter to reuse existing argument preparation logic
+	* that handles query parameters, request body, and URL parameters for both
+	* Fastify and Bun adapters.
+	*
+	* @param handlerMetadata - The handler metadata with schemas and configuration.
+	* @returns An array of getter functions that populate request arguments.
+	*/ prepareArguments(handlerMetadata) {
+		return this.streamAdapter.prepareArguments?.(handlerMetadata) ?? [];
+	}
+	/**
+	* Provides schema information for the handler.
+	*
+	* Proxies to the base stream adapter to reuse existing schema generation logic.
+	* For Fastify, this enables built-in validation. For Bun, this returns an empty object.
+	*
+	* @param handlerMetadata - The handler metadata containing configuration and schemas.
+	* @returns Schema information (Fastify route schema or empty object for Bun).
+	*/ provideSchema(handlerMetadata) {
+		if ("provideSchema" in this.streamAdapter && typeof this.streamAdapter.provideSchema === "function") return this.streamAdapter.provideSchema(handlerMetadata);
+		return {};
+	}
+	/**
+	* Checks if the handler has any validation schemas defined.
+	*
+	* Proxies to the base stream adapter to check for query or request schemas.
+	*
+	* @param handlerMetadata - The handler metadata containing configuration.
+	* @returns `true` if the handler has any schemas (query or request).
+	*/ hasSchema(handlerMetadata) {
+		if ("hasSchema" in this.streamAdapter && typeof this.streamAdapter.hasSchema === "function") return this.streamAdapter.hasSchema(handlerMetadata);
+		return false;
+	}
+	/**
+	* Creates a request handler function for XML Stream endpoints.
+	*
+	* This method generates a handler that:
+	* 1. Parses and validates request data (body, query, URL params) using the base adapter
+	* 2. Invokes the controller method with validated arguments (returns JSX)
+	* 3. Renders the JSX tree to XML string (resolves async and class components)
+	* 4. Sends the XML response with appropriate Content-Type header
+	*
+	* The handler automatically detects the environment (Fastify vs Bun) and uses the
+	* appropriate response mechanism (reply object vs Response object).
+	*
+	* @param controller - The controller class containing the handler method.
+	* @param handlerMetadata - The handler metadata with configuration and schemas.
+	* @returns A function that handles incoming requests and sends XML responses.
+	*/ provideHandler(controller, handlerMetadata) {
+		const getters = this.prepareArguments(handlerMetadata);
+		const config = handlerMetadata.config;
+		const formatArguments = 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;
+		};
+		const contentType = config.contentType ?? "application/xml";
+		return async (context, request, reply) => {
+			const controllerInstance = await context.get(controller);
+			const argument = await formatArguments(request);
+			const xml = await renderToXml(await controllerInstance[handlerMetadata.classMethod](argument), {
+				declaration: config.xmlDeclaration ?? true,
+				encoding: config.encoding ?? "UTF-8",
+				container: context
+			});
+			if (reply === void 0) {
+				const headers = { "Content-Type": contentType };
+				for (const [key, value] of Object.entries(handlerMetadata.headers)) if (value != null) headers[key] = String(value);
+				return new Response(xml, {
+					status: handlerMetadata.successStatusCode,
+					headers
+				});
+			} else reply.status(handlerMetadata.successStatusCode).header("Content-Type", contentType).headers(handlerMetadata.headers).send(xml);
+		};
+	}
+	static {
+		_initClass();
+	}
+};
+
+//#endregion
+//#region src/define-environment.mts
+/**
+* Creates the XML environment configuration to be merged with base adapter (Fastify/Bun).
+*
+* @example
+* ```typescript
+* import { defineFastifyEnvironment } from '@navios/adapter-fastify'
+* import { defineXmlEnvironment } from '@navios/adapter-xml'
+* import { NaviosFactory } from '@navios/core'
+*
+* const fastifyEnv = defineFastifyEnvironment()
+* const xmlEnv = defineXmlEnvironment()
+*
+* // Merge environments
+* const mergedEnv = {
+*   httpTokens: new Map([
+*     ...fastifyEnv.httpTokens,
+*     ...xmlEnv.httpTokens,
+*   ]),
+* }
+*
+* const app = await NaviosFactory.create(AppModule, {
+*   adapter: mergedEnv,
+* })
+* ```
+*/ function defineXmlEnvironment() {
+	return { httpTokens: new Map([[__navios_core.XmlStreamAdapterToken, _XmlStreamAdapterService]]) };
+}
+
+//#endregion
+exports.AsyncComponent = require_create_element.AsyncComponent;
+exports.CData = CData;
+exports.CDataSymbol = require_create_element.CDataSymbol;
+exports.ClassComponent = require_create_element.ClassComponent;
+exports.Component = require_create_element.Component;
+exports.DangerouslyInsertRawXml = DangerouslyInsertRawXml;
+exports.Fragment = require_create_element.Fragment;
+exports.MissingContainerError = MissingContainerError;
+exports.RawXmlSymbol = require_create_element.RawXmlSymbol;
+exports.XmlStream = XmlStream;
+Object.defineProperty(exports, 'XmlStreamAdapterService', {
+  enumerable: true,
+  get: function () {
+    return _XmlStreamAdapterService;
+  }
+});
+exports.createElement = require_create_element.createElement;
+exports.declareXmlStream = declareXmlStream;
+exports.defineTag = defineTag;
+exports.defineXmlEnvironment = defineXmlEnvironment;
+exports.isComponentClass = require_create_element.isComponentClass;
+exports.renderToXml = renderToXml;
+//# sourceMappingURL=index.cjs.map