@navios/adapter-xml 0.7.0 → 0.8.0

package/lib/index.mjs

@@ -1,5 +1,5 @@
 import { a as isComponentClass, c as ClassComponent, i as Component, l as Fragment, o as AsyncComponent, s as CDataSymbol, t as createElement, u as RawXmlSymbol } from "./create-element-NZEYaRw5.mjs";
-import { Injectable, StreamAdapterToken, XmlStreamAdapterToken, getEndpointMetadata, inject } from "@navios/core";
+import { Injectable, InstanceResolverService, StreamAdapterToken, XmlStreamAdapterToken, getEndpointMetadata, inject } from "@navios/core";
 
 //#region src/runtime/special-nodes.mts
 /**
@@ -603,6 +603,7 @@ var XmlStreamAdapterService = class {
 		({c: [_XmlStreamAdapterService, _initClass]} = _apply_decs_2203_r(this, [], [_dec]));
 	}
 	/** Base stream adapter - we proxy hasSchema, prepareArguments, provideSchema to it */ streamAdapter = inject(StreamAdapterToken);
+	instanceResolver = inject(InstanceResolverService);
 	/**
 	* Prepares argument getters for parsing request data.
 	*
@@ -653,36 +654,88 @@ var XmlStreamAdapterService = class {
 	* @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) {
+	*/ async 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 hasArguments = getters.length > 0;
 		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
+		const methodName = handlerMetadata.classMethod;
+		const sendResponse = (xml, reply, headers) => {
+			if (reply === void 0) return new Response(xml, {
+				status: handlerMetadata.successStatusCode,
+				headers
 			});
-			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);
+			else reply.status(handlerMetadata.successStatusCode).header("Content-Type", contentType).headers(handlerMetadata.headers).send(xml);
+		};
+		const headersTemplate = { "Content-Type": contentType };
+		for (const [key, value] of Object.entries(handlerMetadata.headers)) if (value != null) headersTemplate[key] = String(value);
+		const resolution = await this.instanceResolver.resolve(controller);
+		const renderOptions = {
+			declaration: config.xmlDeclaration ?? true,
+			encoding: config.encoding ?? "UTF-8"
+		};
+		if (hasArguments) {
+			const formatArguments = getters.some((g) => g.constructor.name === "AsyncFunction") ? 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;
+			} : (request) => {
+				const argument = {};
+				for (const getter of getters) getter(argument, request);
+				return argument;
+			};
+			if (resolution.cached) {
+				const cachedController = resolution.instance;
+				const boundMethod = cachedController[methodName].bind(cachedController);
+				return {
+					isStatic: false,
+					handler: async (context, request, reply) => {
+						return sendResponse(await renderToXml(await boundMethod(await formatArguments(request)), {
+							...renderOptions,
+							container: context
+						}), reply, headersTemplate);
+					}
+				};
+			}
+			return {
+				isStatic: false,
+				handler: async (context, request, reply) => {
+					const controllerInstance = await resolution.resolve(context);
+					const argument = await formatArguments(request);
+					return sendResponse(await renderToXml(await controllerInstance[methodName](argument), {
+						...renderOptions,
+						container: context
+					}), reply, headersTemplate);
+				}
+			};
+		}
+		const emptyArgs = Object.freeze({});
+		if (resolution.cached) {
+			const cachedController = resolution.instance;
+			const boundMethod = cachedController[methodName].bind(cachedController);
+			return {
+				isStatic: false,
+				handler: async (context, _request, reply) => {
+					return sendResponse(await renderToXml(await boundMethod(emptyArgs), {
+						...renderOptions,
+						container: context
+					}), reply, headersTemplate);
+				}
+			};
+		}
+		return {
+			isStatic: false,
+			handler: async (context, _request, reply) => {
+				return sendResponse(await renderToXml(await (await resolution.resolve(context))[methodName](emptyArgs), {
+					...renderOptions,
+					container: context
+				}), reply, headersTemplate);
+			}
 		};
 	}
 	static {

package/lib/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["AsyncComponent","CDataSymbol","ClassComponent","Fragment","RawXmlSymbol","MissingContainerError","Error","componentName","name","renderToXml","node","options","declaration","encoding","pretty","container","xml","renderNode","indent","escapeXml","String","isClassComponentNode","componentClass","instance","get","props","result","render","resolved","Promise","isAsyncNode","promise","isCDataNode","renderCData","content","isRawXmlNode","type","children","renderedChildren","all","filter","c","map","join","prefix","repeat","newline","attrs","Object","entries","_","v","k","escapeAttr","length","childIndent","resolvedChildren","childContent","hasOnlySimpleContent","every","includes","escaped","replace","str","defineTag","name","propsSchema","component","props","children","rest","parse","type","Array","isArray","tagName","getEndpointMetadata","XmlStreamAdapterToken","XmlStream","endpoint","target","context","Error","kind","config","metadata","endpointMetadata","url","method","adapterToken","classMethod","name","httpMethod","declareXmlStream","config","inject","Injectable","StreamAdapterToken","XmlStreamAdapterToken","renderToXml","token","XmlStreamAdapterService","streamAdapter","prepareArguments","handlerMetadata","provideSchema","hasSchema","provideHandler","controller","getters","config","formatArguments","request","argument","promises","getter","res","Promise","push","all","contentType","context","reply","controllerInstance","get","xmlNode","classMethod","xml","declaration","xmlDeclaration","encoding","container","isHttpStandardEnvironment","undefined","headers","key","value","Object","entries","String","Response","status","successStatusCode","header","send","XmlStreamAdapterToken","XmlStreamAdapterService","defineXmlEnvironment","httpTokens","Map"],"sources":["../src/runtime/special-nodes.mts","../src/runtime/render-to-xml.mts","../src/tags/define-tag.mts","../src/decorators/xml-stream.decorator.mts","../src/handlers/xml-stream.mts","../src/adapters/xml-stream-adapter.service.mts","../src/define-environment.mts"],"sourcesContent":["import type { CDataNode, RawXmlNode } from '../types/xml-node.mjs'\nimport { CDataSymbol, RawXmlSymbol } from '../types/xml-node.mjs'\n\n/**\n * CDATA component - wraps content in <![CDATA[...]]>\n * Use for text content that may contain characters like < > &\n * that would otherwise need escaping.\n *\n * Note: If content contains \"]]>\", it will be split into multiple CDATA sections.\n */\nexport function CData({ children }: { children: string }): CDataNode {\n  return {\n    type: CDataSymbol,\n    content: String(children),\n  }\n}\n\n/**\n * DangerouslyInsertRawXml - inserts raw XML/HTML without any escaping or wrapping\n *\n * WARNING: This bypasses all XML escaping. Only use with trusted content!\n * Use cases:\n * - Pre-rendered XML fragments\n * - HTML content in RSS/Atom feeds (in description/content:encoded)\n * - Including XML from external sources that's already valid\n */\nexport function DangerouslyInsertRawXml({ children }: { children: string }): RawXmlNode {\n  return {\n    type: RawXmlSymbol,\n    content: String(children),\n  }\n}\n","import type { Container, ScopedContainer } from '@navios/core'\n\nimport type { XmlComponent } from '../types/component.mjs'\nimport type {\n  AnyXmlNode,\n  AsyncXmlNode,\n  CDataNode,\n  ClassComponentNode,\n  RawXmlNode,\n} from '../types/xml-node.mjs'\n\nimport {\n  AsyncComponent,\n  CDataSymbol,\n  ClassComponent,\n  Fragment,\n  RawXmlSymbol,\n} from '../types/xml-node.mjs'\n\n/**\n * Options for rendering XML from JSX nodes.\n *\n * @example\n * ```ts\n * const xml = await renderToXml(<rss version=\"2.0\">...</rss>, {\n *   declaration: true,\n *   encoding: 'UTF-8',\n *   pretty: true,\n *   container: myContainer, // Required for class components\n * })\n * ```\n */\nexport interface RenderOptions {\n  /** Include XML declaration (<?xml version=\"1.0\"?>) - defaults to true */\n  declaration?: boolean\n  /** XML encoding, defaults to 'UTF-8' */\n  encoding?: string\n  /** Pretty print with indentation */\n  pretty?: boolean\n  /**\n   * DI container for resolving class components.\n   * Required if the tree contains any class components.\n   */\n  container?: Container | ScopedContainer\n}\n\n/**\n * Error thrown when attempting to render a class component without a container.\n *\n * Class components require a dependency injection container to be instantiated.\n * This error is thrown when `renderToXml` is called with a class component in\n * the tree but no container is provided in the options.\n *\n * @example\n * ```ts\n * try {\n *   await renderToXml(<MyClassComponent />)\n * } catch (error) {\n *   if (error instanceof MissingContainerError) {\n *     // Provide a container\n *     await renderToXml(<MyClassComponent />, { container })\n *   }\n * }\n * ```\n */\nexport class MissingContainerError extends Error {\n  constructor(componentName: string) {\n    super(\n      `[@navios/adapter-xml] Cannot render class component \"${componentName}\" without a container. ` +\n        `Pass a container to renderToXml options: renderToXml(node, { container })`,\n    )\n    this.name = 'MissingContainerError'\n  }\n}\n\n/**\n * Renders a JSX XML node tree to an XML string.\n *\n * This function handles:\n * - Regular XML nodes (tags with props and children)\n * - Async components (resolves promises in parallel)\n * - Class components (resolves via DI container)\n * - CDATA sections\n * - Raw XML content\n * - Fragments\n * - Text content with proper escaping\n *\n * @param node - The root XML node (JSX element) to render.\n * @param options - Rendering options including declaration, encoding, pretty printing, and container.\n * @returns A promise that resolves to the XML string.\n *\n * @throws {MissingContainerError} If the tree contains class components but no container is provided.\n *\n * @example\n * ```ts\n * // Simple rendering\n * const xml = await renderToXml(<rss version=\"2.0\"><channel>...</channel></rss>)\n *\n * // With options\n * const xml = await renderToXml(<feed>...</feed>, {\n *   declaration: true,\n *   encoding: 'UTF-8',\n *   pretty: true,\n * })\n *\n * // With class components (requires container)\n * const container = new Container()\n * container.beginRequest('request-id')\n * const xml = await renderToXml(<MyClassComponent />, { container })\n * ```\n */\nexport async function renderToXml(\n  node: AnyXmlNode,\n  options: RenderOptions = {},\n): Promise<string> {\n  const {\n    declaration = true,\n    encoding = 'UTF-8',\n    pretty = false,\n    container,\n  } = options\n\n  let xml = ''\n  if (declaration) {\n    xml += `<?xml version=\"1.0\" encoding=\"${encoding}\"?>`\n    if (pretty) xml += '\\n'\n  }\n\n  xml += await renderNode(node, pretty ? 0 : -1, container)\n  return xml\n}\n\nasync function renderNode(\n  node: AnyXmlNode,\n  indent: number,\n  container: Container | ScopedContainer | undefined,\n): Promise<string> {\n  if (node == null) return ''\n  if (typeof node === 'string') return escapeXml(node)\n  if (typeof node === 'number') return String(node)\n\n  // Handle class components - resolve via DI container\n  if (isClassComponentNode(node)) {\n    if (!container) {\n      throw new MissingContainerError(node.componentClass.name)\n    }\n\n    // Resolve the component instance from the container, passing props as schema args\n    // This validates props via Zod schema if defined on the component\n    const instance = (await container.get(\n      node.componentClass as any,\n      node.props,\n    )) as XmlComponent\n\n    // Call render() - no arguments, props are already in the instance\n    const result = instance.render()\n\n    // Handle async render methods\n    const resolved = result instanceof Promise ? await result : result\n\n    // Recursively render the result\n    return renderNode(resolved, indent, container)\n  }\n\n  // Handle async components - resolve the promise first\n  if (isAsyncNode(node)) {\n    const resolved = await node.promise\n    return renderNode(resolved, indent, container)\n  }\n\n  // Handle CDATA nodes\n  if (isCDataNode(node)) {\n    return renderCData(node.content)\n  }\n\n  // Handle Raw XML nodes - no escaping\n  if (isRawXmlNode(node)) {\n    return node.content\n  }\n\n  const { type, props, children } = node\n\n  if (type === Fragment) {\n    const renderedChildren = await Promise.all(\n      children\n        .filter((c) => c != null)\n        .map((c) => renderNode(c, indent, container)),\n    )\n    return renderedChildren.join('')\n  }\n\n  const prefix = indent >= 0 ? '  '.repeat(indent) : ''\n  const newline = indent >= 0 ? '\\n' : ''\n\n  const attrs = Object.entries(props)\n    .filter(([_, v]) => v != null)\n    .map(([k, v]) => ` ${k}=\"${escapeAttr(String(v))}\"`)\n    .join('')\n\n  if (children.length === 0) {\n    return `${prefix}<${type}${attrs}/>${newline}`\n  }\n\n  const childIndent = indent >= 0 ? indent + 1 : -1\n\n  // Resolve all children (including async and class components) in parallel\n  const resolvedChildren = await Promise.all(\n    children\n      .filter((c) => c != null)\n      .map((c) => renderNode(c, childIndent, container)),\n  )\n  const childContent = resolvedChildren.join('')\n\n  // Check if children are simple (text, numbers, CDATA, or raw XML)\n  const hasOnlySimpleContent = children.every(\n    (c) =>\n      typeof c === 'string' ||\n      typeof c === 'number' ||\n      isCDataNode(c) ||\n      isRawXmlNode(c),\n  )\n  if (hasOnlySimpleContent) {\n    return `${prefix}<${type}${attrs}>${childContent}</${type}>${newline}`\n  }\n\n  return `${prefix}<${type}${attrs}>${newline}${childContent}${prefix}</${type}>${newline}`\n}\n\nfunction isClassComponentNode(node: unknown): node is ClassComponentNode {\n  return (\n    node !== null &&\n    typeof node === 'object' &&\n    'type' in node &&\n    node.type === ClassComponent\n  )\n}\n\nfunction isAsyncNode(node: unknown): node is AsyncXmlNode {\n  return (\n    node !== null &&\n    typeof node === 'object' &&\n    'type' in node &&\n    node.type === AsyncComponent\n  )\n}\n\nfunction isCDataNode(node: any): node is CDataNode {\n  return node && typeof node === 'object' && node.type === CDataSymbol\n}\n\nfunction isRawXmlNode(node: any): node is RawXmlNode {\n  return node && typeof node === 'object' && node.type === RawXmlSymbol\n}\n\n/**\n * Renders content as CDATA section.\n * If content contains \"]]>\", splits into multiple CDATA sections.\n * The technique is to end the CDATA section before ]]>, then start a new one.\n */\nfunction renderCData(content: string): string {\n  // Handle the edge case where content contains \"]]>\"\n  // We split on \"]]>\" and join with \"]]]]><![CDATA[>\" which effectively\n  // ends the CDATA section after \"]]\" and starts a new one for \">\"\n  if (content.includes(']]>')) {\n    // Replace ]]> with ]]]]><![CDATA[> which closes CDATA before > and reopens it\n    const escaped = content.replace(/]]>/g, ']]]]><![CDATA[>')\n    return `<![CDATA[${escaped}]]>`\n  }\n  return `<![CDATA[${content}]]>`\n}\n\nfunction escapeXml(str: string): string {\n  return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')\n}\n\nfunction escapeAttr(str: string): string {\n  return str\n    .replace(/&/g, '&amp;')\n    .replace(/</g, '&lt;')\n    .replace(/>/g, '&gt;')\n    .replace(/\"/g, '&quot;')\n}\n","import type { ZodObject, ZodRawShape } from 'zod/v4'\nimport type { z } from 'zod/v4'\n\nimport type { AnyXmlNode, XmlNode } from '../types/xml-node.mjs'\n\n/**\n * Type for XML tag components created by `defineTag`.\n *\n * Tag components are functions that accept props and children, and return\n * an XML node. They also have a `tagName` property for identification.\n *\n * @template Props - The props type for the tag component.\n */\nexport interface TagComponent<Props extends Record<string, unknown>> {\n  (props: Props & { children?: AnyXmlNode | AnyXmlNode[] }): XmlNode\n  tagName: string\n}\n\n/**\n * Creates a type-safe XML tag component with optional Zod schema validation.\n *\n * @param name - The tag name (supports namespace prefixes like 'atom:link')\n * @param propsSchema - Optional Zod schema for validating props\n * @returns A component function that can be used in JSX\n *\n * @example\n * ```tsx\n * // Simple tag\n * const item = defineTag('item')\n * <item>Content</item>\n *\n * // Namespaced tag with Zod validation\n * const atomLink = defineTag('atom:link', z.object({\n *   href: z.string().url(),\n *   rel: z.enum(['self', 'alternate']),\n *   type: z.string().optional(),\n * }))\n * <atomLink href=\"https://example.com/feed\" rel=\"self\" />\n * ```\n */\nexport function defineTag<T extends ZodRawShape>(\n  name: string,\n  propsSchema?: ZodObject<T>,\n): TagComponent<T extends ZodRawShape ? z.infer<ZodObject<T>> : Record<string, never>> {\n  const component = (props: any): XmlNode => {\n    const { children, ...rest } = props ?? {}\n\n    // Validate props if schema provided\n    if (propsSchema) {\n      propsSchema.parse(rest)\n    }\n\n    return {\n      type: name,\n      props: rest,\n      children: Array.isArray(children) ? children : children ? [children] : [],\n    }\n  }\n\n  component.tagName = name\n  return component as any\n}\n","import type { EndpointFunctionArgs, HttpMethod, Util_FlatObject } from '@navios/builder'\nimport type { ZodObject, ZodType } from 'zod/v4'\n\nimport { getEndpointMetadata, XmlStreamAdapterToken } from '@navios/core'\n\nimport type { BaseXmlStreamConfig } from '../types/config.mjs'\n\n/**\n * Type helper that extracts the parameter types for an XML Stream endpoint handler.\n *\n * This type automatically infers the correct parameter types based on the endpoint\n * configuration, including URL parameters, query parameters, and request body.\n *\n * @template EndpointDeclaration - The endpoint declaration type from `declareXmlStream`.\n * @template Url - The URL path pattern.\n * @template QuerySchema - The query parameter schema type.\n *\n * @example\n * ```typescript\n * const getFeed = declareXmlStream({\n *   method: 'GET',\n *   url: '/feed/:category',\n *   querySchema: z.object({ page: z.string() }),\n * })\n *\n * // XmlStreamParams<typeof getFeed> resolves to:\n * // { urlParams: { category: string }, query: { page: string } }\n * ```\n */\nexport type XmlStreamParams<\n  EndpointDeclaration extends {\n    config: BaseXmlStreamConfig<any, any, any, any>\n  },\n  Url extends string = EndpointDeclaration['config']['url'],\n  QuerySchema = EndpointDeclaration['config']['querySchema'],\n> = QuerySchema extends ZodObject\n  ? EndpointDeclaration['config']['requestSchema'] extends ZodType\n    ? Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, EndpointDeclaration['config']['requestSchema'], true>>\n    : Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, undefined, true>>\n  : EndpointDeclaration['config']['requestSchema'] extends ZodType\n    ? Util_FlatObject<EndpointFunctionArgs<Url, undefined, EndpointDeclaration['config']['requestSchema'], true>>\n    : Util_FlatObject<EndpointFunctionArgs<Url, undefined, undefined, true>>\n\n/**\n * Decorator for XML Stream endpoints that return JSX-based XML responses.\n *\n * This decorator marks controller methods that return JSX elements, which will be\n * automatically rendered to XML and sent with the appropriate Content-Type header.\n * The method can be async and can contain async components, class components, and\n * regular JSX elements.\n *\n * @template Method - The HTTP method (GET, POST, etc.).\n * @template Url - The URL path pattern (supports parameters like `/posts/:id`).\n * @template QuerySchema - Optional Zod schema for query parameter validation.\n * @template RequestSchema - Optional Zod schema for request body validation.\n *\n * @param endpoint - The endpoint declaration created with `declareXmlStream`.\n * @returns A method decorator function.\n *\n * @throws {Error} If used on a non-function or non-method.\n * @throws {Error} If the endpoint URL already exists.\n *\n * @example\n * ```typescript\n * import { XmlStream, declareXmlStream } from '@navios/adapter-xml'\n * import { Controller } from '@navios/core'\n *\n * const getRssFeed = declareXmlStream({\n *   method: 'GET',\n *   url: '/feed.xml',\n *   contentType: 'application/rss+xml',\n * })\n *\n * @Controller('/api')\n * class FeedController {\n *   @XmlStream(getRssFeed)\n *   async getFeed() {\n *     return (\n *       <rss version=\"2.0\">\n *         <channel>\n *           <title>My Feed</title>\n *         </channel>\n *       </rss>\n *     )\n *   }\n * }\n * ```\n *\n * @example\n * ```typescript\n * // With query parameters\n * const getSitemap = declareXmlStream({\n *   method: 'GET',\n *   url: '/sitemap.xml',\n *   querySchema: z.object({ page: z.string().optional() }),\n * })\n *\n * @Controller()\n * class SitemapController {\n *   @XmlStream(getSitemap)\n *   async getSitemap(params: { query?: { page?: string } }) {\n *     const page = params.query?.page\n *     return <urlset>...</urlset>\n *   }\n * }\n * ```\n */\nexport function XmlStream<\n  Method extends HttpMethod = HttpMethod,\n  Url extends string = string,\n  QuerySchema = undefined,\n  RequestSchema = ZodType,\n>(endpoint: { config: BaseXmlStreamConfig<Method, Url, QuerySchema, RequestSchema> }) {\n  return (\n    target: (\n      params: QuerySchema extends ZodObject\n        ? RequestSchema extends ZodType\n          ? Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true>>\n          : Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, undefined, true>>\n        : RequestSchema extends ZodType\n          ? Util_FlatObject<EndpointFunctionArgs<Url, undefined, RequestSchema, true>>\n          : Util_FlatObject<EndpointFunctionArgs<Url, undefined, undefined, true>>,\n    ) => Promise<any>, // Returns XmlNode\n    context: ClassMethodDecoratorContext,\n  ) => {\n    if (typeof target !== 'function') {\n      throw new Error('[Navios] XmlStream decorator can only be used on functions.')\n    }\n    if (context.kind !== 'method') {\n      throw new Error('[Navios] XmlStream decorator can only be used on methods.')\n    }\n\n    const config = endpoint.config\n    if (context.metadata) {\n      const endpointMetadata = getEndpointMetadata<BaseXmlStreamConfig>(target, context)\n      if (endpointMetadata.config && endpointMetadata.config.url) {\n        throw new Error(`[Navios] Endpoint ${config.method} ${config.url} already exists.`)\n      }\n      // @ts-expect-error We don't need to set correctly in the metadata\n      endpointMetadata.config = config\n      endpointMetadata.adapterToken = XmlStreamAdapterToken\n      endpointMetadata.classMethod = target.name\n      endpointMetadata.httpMethod = config.method\n      endpointMetadata.url = config.url\n    }\n    return target\n  }\n}\n","import type { HttpMethod } from '@navios/builder'\n\nimport type { BaseXmlStreamConfig } from '../types/config.mjs'\n\n/**\n * Declares an XML Stream endpoint configuration for use with `@XmlStream` decorator.\n *\n * This function creates an endpoint declaration that can be used with the `@XmlStream`\n * decorator to mark controller methods that return JSX-based XML responses.\n *\n * @template Method - The HTTP method (GET, POST, etc.).\n * @template Url - The URL path pattern (supports parameters like `/posts/:id`).\n * @template QuerySchema - Optional Zod schema for query parameter validation.\n * @template RequestSchema - Optional Zod schema for request body validation.\n *\n * @param config - The endpoint configuration including method, URL, schemas, and XML options.\n * @returns An endpoint declaration object to be used with `@XmlStream` decorator.\n *\n * @example\n * ```typescript\n * import { declareXmlStream } from '@navios/adapter-xml'\n * import { z } from 'zod/v4'\n *\n * // Simple endpoint\n * export const getRssFeed = declareXmlStream({\n *   method: 'GET',\n *   url: '/feed.xml',\n *   contentType: 'application/rss+xml',\n * })\n *\n * // With query parameters\n * export const getSitemap = declareXmlStream({\n *   method: 'GET',\n *   url: '/sitemap.xml',\n *   querySchema: z.object({\n *     page: z.string().optional(),\n *   }),\n *   contentType: 'application/xml',\n *   xmlDeclaration: true,\n *   encoding: 'UTF-8',\n * })\n * ```\n */\nexport function declareXmlStream<\n  Method extends HttpMethod,\n  Url extends string,\n  QuerySchema = undefined,\n  RequestSchema = undefined,\n>(\n  config: BaseXmlStreamConfig<Method, Url, QuerySchema, RequestSchema>,\n): { config: BaseXmlStreamConfig<Method, Url, QuerySchema, RequestSchema> } {\n  return { config }\n}\n","import type {\n  AbstractHttpHandlerAdapterInterface,\n  ClassType,\n  HandlerMetadata,\n  ScopedContainer,\n} from '@navios/core'\n\nimport {\n  inject,\n  Injectable,\n  StreamAdapterToken,\n  XmlStreamAdapterToken,\n} from '@navios/core'\n\nimport type { BaseXmlStreamConfig } from '../types/config.mjs'\nimport type { AnyXmlNode } from '../types/xml-node.mjs'\n\nimport { renderToXml } from '../runtime/render-to-xml.mjs'\n\n/**\n * Adapter service for handling XML Stream endpoints in Navios.\n *\n * This service integrates with the base stream adapter (Fastify or Bun) to handle\n * XML endpoints that return JSX-based XML responses. It automatically renders JSX\n * nodes to XML strings and sends them with the appropriate Content-Type headers.\n *\n * The service supports:\n * - Async components (resolved in parallel)\n * - Class components (resolved via DI container)\n * - Regular JSX elements\n * - CDATA sections\n * - Raw XML content\n *\n * @implements {AbstractHttpHandlerAdapterInterface}\n *\n * @example\n * ```ts\n * // This service is automatically registered when using defineXmlEnvironment()\n * // and is used by endpoints decorated with @XmlStream()\n * ```\n */\n@Injectable({\n  token: XmlStreamAdapterToken,\n})\nexport class XmlStreamAdapterService implements AbstractHttpHandlerAdapterInterface {\n  /** Base stream adapter - we proxy hasSchema, prepareArguments, provideSchema to it */\n  protected streamAdapter = inject(StreamAdapterToken)\n\n  /**\n   * Prepares argument getters for parsing request data.\n   *\n   * Proxies to the base stream adapter to reuse existing argument preparation logic\n   * that handles query parameters, request body, and URL parameters for both\n   * Fastify and Bun adapters.\n   *\n   * @param handlerMetadata - The handler metadata with schemas and configuration.\n   * @returns An array of getter functions that populate request arguments.\n   */\n  prepareArguments(handlerMetadata: HandlerMetadata<BaseXmlStreamConfig>) {\n    return this.streamAdapter.prepareArguments?.(handlerMetadata) ?? []\n  }\n\n  /**\n   * Provides schema information for the handler.\n   *\n   * Proxies to the base stream adapter to reuse existing schema generation logic.\n   * For Fastify, this enables built-in validation. For Bun, this returns an empty object.\n   *\n   * @param handlerMetadata - The handler metadata containing configuration and schemas.\n   * @returns Schema information (Fastify route schema or empty object for Bun).\n   */\n  provideSchema(\n    handlerMetadata: HandlerMetadata<BaseXmlStreamConfig>,\n  ): Record<string, any> {\n    if (\n      'provideSchema' in this.streamAdapter &&\n      typeof this.streamAdapter.provideSchema === 'function'\n    ) {\n      return this.streamAdapter.provideSchema(handlerMetadata)\n    }\n    return {}\n  }\n\n  /**\n   * Checks if the handler has any validation schemas defined.\n   *\n   * Proxies to the base stream adapter to check for query or request schemas.\n   *\n   * @param handlerMetadata - The handler metadata containing configuration.\n   * @returns `true` if the handler has any schemas (query or request).\n   */\n  hasSchema(handlerMetadata: HandlerMetadata<any>): boolean {\n    if (\n      'hasSchema' in this.streamAdapter &&\n      typeof this.streamAdapter.hasSchema === 'function'\n    ) {\n      return this.streamAdapter.hasSchema(handlerMetadata)\n    }\n    return false\n  }\n\n  /**\n   * Creates a request handler function for XML Stream endpoints.\n   *\n   * This method generates a handler that:\n   * 1. Parses and validates request data (body, query, URL params) using the base adapter\n   * 2. Invokes the controller method with validated arguments (returns JSX)\n   * 3. Renders the JSX tree to XML string (resolves async and class components)\n   * 4. Sends the XML response with appropriate Content-Type header\n   *\n   * The handler automatically detects the environment (Fastify vs Bun) and uses the\n   * appropriate response mechanism (reply object vs Response object).\n   *\n   * @param controller - The controller class containing the handler method.\n   * @param handlerMetadata - The handler metadata with configuration and schemas.\n   * @returns A function that handles incoming requests and sends XML responses.\n   */\n  provideHandler(\n    controller: ClassType,\n    handlerMetadata: HandlerMetadata<BaseXmlStreamConfig>,\n  ): (context: ScopedContainer, request: any, reply: any) => Promise<any> {\n    const getters = this.prepareArguments(handlerMetadata)\n    const config = handlerMetadata.config\n\n    const formatArguments = async (request: any) => {\n      const argument: Record<string, any> = {}\n      const promises: Promise<void>[] = []\n      for (const getter of getters) {\n        const res = getter(argument, request)\n        if (res instanceof Promise) {\n          promises.push(res)\n        }\n      }\n      await Promise.all(promises)\n      return argument\n    }\n\n    const contentType = config.contentType ?? 'application/xml'\n\n    return async (context: ScopedContainer, request: any, reply: any) => {\n      const controllerInstance = await context.get(controller)\n      const argument = await formatArguments(request)\n\n      // Call controller method - returns XmlNode (JSX), may contain async/class components\n      const xmlNode: AnyXmlNode =\n        await controllerInstance[handlerMetadata.classMethod](argument)\n\n      // Render JSX to XML string (async - resolves all async and class components)\n      const xml = await renderToXml(xmlNode, {\n        declaration: config.xmlDeclaration ?? true,\n        encoding: config.encoding ?? 'UTF-8',\n        container: context,\n      })\n\n      // Environment detection: Bun doesn't have reply\n      const isHttpStandardEnvironment = reply === undefined\n\n      if (isHttpStandardEnvironment) {\n        // Bun: return Response object\n        const headers: Record<string, string> = {\n          'Content-Type': contentType,\n        }\n        for (const [key, value] of Object.entries(handlerMetadata.headers)) {\n          if (value != null) {\n            headers[key] = String(value)\n          }\n        }\n        return new Response(xml, {\n          status: handlerMetadata.successStatusCode,\n          headers,\n        })\n      } else {\n        // Fastify: use reply object\n        reply\n          .status(handlerMetadata.successStatusCode)\n          .header('Content-Type', contentType)\n          .headers(handlerMetadata.headers)\n          .send(xml)\n      }\n    }\n  }\n}\n","import type { AnyInjectableType } from '@navios/core'\n\nimport { InjectionToken, XmlStreamAdapterToken } from '@navios/core'\n\nimport { XmlStreamAdapterService } from './adapters/index.mjs'\n\n/**\n * Creates the XML environment configuration to be merged with base adapter (Fastify/Bun).\n *\n * @example\n * ```typescript\n * import { defineFastifyEnvironment } from '@navios/adapter-fastify'\n * import { defineXmlEnvironment } from '@navios/adapter-xml'\n * import { NaviosFactory } from '@navios/core'\n *\n * const fastifyEnv = defineFastifyEnvironment()\n * const xmlEnv = defineXmlEnvironment()\n *\n * // Merge environments\n * const mergedEnv = {\n *   httpTokens: new Map([\n *     ...fastifyEnv.httpTokens,\n *     ...xmlEnv.httpTokens,\n *   ]),\n * }\n *\n * const app = await NaviosFactory.create(AppModule, {\n *   adapter: mergedEnv,\n * })\n * ```\n */\nexport function defineXmlEnvironment() {\n  const httpTokens = new Map<InjectionToken<any, undefined>, AnyInjectableType>(\n    [[XmlStreamAdapterToken, XmlStreamAdapterService]],\n  )\n  return {\n    httpTokens,\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":["AsyncComponent","CDataSymbol","ClassComponent","Fragment","RawXmlSymbol","MissingContainerError","Error","componentName","name","renderToXml","node","options","declaration","encoding","pretty","container","xml","renderNode","indent","escapeXml","String","isClassComponentNode","componentClass","instance","get","props","result","render","resolved","Promise","isAsyncNode","promise","isCDataNode","renderCData","content","isRawXmlNode","type","children","renderedChildren","all","filter","c","map","join","prefix","repeat","newline","attrs","Object","entries","_","v","k","escapeAttr","length","childIndent","resolvedChildren","childContent","hasOnlySimpleContent","every","includes","escaped","replace","str","defineTag","name","propsSchema","component","props","children","rest","parse","type","Array","isArray","tagName","getEndpointMetadata","XmlStreamAdapterToken","XmlStream","endpoint","target","context","Error","kind","config","metadata","endpointMetadata","url","method","adapterToken","classMethod","name","httpMethod","declareXmlStream","config","InstanceResolverService","inject","Injectable","StreamAdapterToken","XmlStreamAdapterToken","renderToXml","token","XmlStreamAdapterService","streamAdapter","instanceResolver","prepareArguments","handlerMetadata","provideSchema","hasSchema","provideHandler","controller","getters","config","hasArguments","length","contentType","methodName","classMethod","sendResponse","xml","reply","headers","isHttpStandardEnvironment","undefined","Response","status","successStatusCode","header","send","headersTemplate","key","value","Object","entries","String","resolution","resolve","renderOptions","declaration","xmlDeclaration","encoding","hasAsyncGetters","some","g","name","formatArguments","request","argument","promises","getter","res","Promise","push","all","cached","cachedController","instance","boundMethod","bind","isStatic","handler","context","xmlNode","container","controllerInstance","emptyArgs","freeze","_request","XmlStreamAdapterToken","XmlStreamAdapterService","defineXmlEnvironment","httpTokens","Map"],"sources":["../src/runtime/special-nodes.mts","../src/runtime/render-to-xml.mts","../src/tags/define-tag.mts","../src/decorators/xml-stream.decorator.mts","../src/handlers/xml-stream.mts","../src/adapters/xml-stream-adapter.service.mts","../src/define-environment.mts"],"sourcesContent":["import type { CDataNode, RawXmlNode } from '../types/xml-node.mjs'\nimport { CDataSymbol, RawXmlSymbol } from '../types/xml-node.mjs'\n\n/**\n * CDATA component - wraps content in <![CDATA[...]]>\n * Use for text content that may contain characters like < > &\n * that would otherwise need escaping.\n *\n * Note: If content contains \"]]>\", it will be split into multiple CDATA sections.\n */\nexport function CData({ children }: { children: string }): CDataNode {\n  return {\n    type: CDataSymbol,\n    content: String(children),\n  }\n}\n\n/**\n * DangerouslyInsertRawXml - inserts raw XML/HTML without any escaping or wrapping\n *\n * WARNING: This bypasses all XML escaping. Only use with trusted content!\n * Use cases:\n * - Pre-rendered XML fragments\n * - HTML content in RSS/Atom feeds (in description/content:encoded)\n * - Including XML from external sources that's already valid\n */\nexport function DangerouslyInsertRawXml({ children }: { children: string }): RawXmlNode {\n  return {\n    type: RawXmlSymbol,\n    content: String(children),\n  }\n}\n","import type { Container, ScopedContainer } from '@navios/core'\n\nimport type { XmlComponent } from '../types/component.mjs'\nimport type {\n  AnyXmlNode,\n  AsyncXmlNode,\n  CDataNode,\n  ClassComponentNode,\n  RawXmlNode,\n} from '../types/xml-node.mjs'\n\nimport {\n  AsyncComponent,\n  CDataSymbol,\n  ClassComponent,\n  Fragment,\n  RawXmlSymbol,\n} from '../types/xml-node.mjs'\n\n/**\n * Options for rendering XML from JSX nodes.\n *\n * @example\n * ```ts\n * const xml = await renderToXml(<rss version=\"2.0\">...</rss>, {\n *   declaration: true,\n *   encoding: 'UTF-8',\n *   pretty: true,\n *   container: myContainer, // Required for class components\n * })\n * ```\n */\nexport interface RenderOptions {\n  /** Include XML declaration (<?xml version=\"1.0\"?>) - defaults to true */\n  declaration?: boolean\n  /** XML encoding, defaults to 'UTF-8' */\n  encoding?: string\n  /** Pretty print with indentation */\n  pretty?: boolean\n  /**\n   * DI container for resolving class components.\n   * Required if the tree contains any class components.\n   */\n  container?: Container | ScopedContainer\n}\n\n/**\n * Error thrown when attempting to render a class component without a container.\n *\n * Class components require a dependency injection container to be instantiated.\n * This error is thrown when `renderToXml` is called with a class component in\n * the tree but no container is provided in the options.\n *\n * @example\n * ```ts\n * try {\n *   await renderToXml(<MyClassComponent />)\n * } catch (error) {\n *   if (error instanceof MissingContainerError) {\n *     // Provide a container\n *     await renderToXml(<MyClassComponent />, { container })\n *   }\n * }\n * ```\n */\nexport class MissingContainerError extends Error {\n  constructor(componentName: string) {\n    super(\n      `[@navios/adapter-xml] Cannot render class component \"${componentName}\" without a container. ` +\n        `Pass a container to renderToXml options: renderToXml(node, { container })`,\n    )\n    this.name = 'MissingContainerError'\n  }\n}\n\n/**\n * Renders a JSX XML node tree to an XML string.\n *\n * This function handles:\n * - Regular XML nodes (tags with props and children)\n * - Async components (resolves promises in parallel)\n * - Class components (resolves via DI container)\n * - CDATA sections\n * - Raw XML content\n * - Fragments\n * - Text content with proper escaping\n *\n * @param node - The root XML node (JSX element) to render.\n * @param options - Rendering options including declaration, encoding, pretty printing, and container.\n * @returns A promise that resolves to the XML string.\n *\n * @throws {MissingContainerError} If the tree contains class components but no container is provided.\n *\n * @example\n * ```ts\n * // Simple rendering\n * const xml = await renderToXml(<rss version=\"2.0\"><channel>...</channel></rss>)\n *\n * // With options\n * const xml = await renderToXml(<feed>...</feed>, {\n *   declaration: true,\n *   encoding: 'UTF-8',\n *   pretty: true,\n * })\n *\n * // With class components (requires container)\n * const container = new Container()\n * container.beginRequest('request-id')\n * const xml = await renderToXml(<MyClassComponent />, { container })\n * ```\n */\nexport async function renderToXml(\n  node: AnyXmlNode,\n  options: RenderOptions = {},\n): Promise<string> {\n  const {\n    declaration = true,\n    encoding = 'UTF-8',\n    pretty = false,\n    container,\n  } = options\n\n  let xml = ''\n  if (declaration) {\n    xml += `<?xml version=\"1.0\" encoding=\"${encoding}\"?>`\n    if (pretty) xml += '\\n'\n  }\n\n  xml += await renderNode(node, pretty ? 0 : -1, container)\n  return xml\n}\n\nasync function renderNode(\n  node: AnyXmlNode,\n  indent: number,\n  container: Container | ScopedContainer | undefined,\n): Promise<string> {\n  if (node == null) return ''\n  if (typeof node === 'string') return escapeXml(node)\n  if (typeof node === 'number') return String(node)\n\n  // Handle class components - resolve via DI container\n  if (isClassComponentNode(node)) {\n    if (!container) {\n      throw new MissingContainerError(node.componentClass.name)\n    }\n\n    // Resolve the component instance from the container, passing props as schema args\n    // This validates props via Zod schema if defined on the component\n    const instance = (await container.get(\n      node.componentClass as any,\n      node.props,\n    )) as XmlComponent\n\n    // Call render() - no arguments, props are already in the instance\n    const result = instance.render()\n\n    // Handle async render methods\n    const resolved = result instanceof Promise ? await result : result\n\n    // Recursively render the result\n    return renderNode(resolved, indent, container)\n  }\n\n  // Handle async components - resolve the promise first\n  if (isAsyncNode(node)) {\n    const resolved = await node.promise\n    return renderNode(resolved, indent, container)\n  }\n\n  // Handle CDATA nodes\n  if (isCDataNode(node)) {\n    return renderCData(node.content)\n  }\n\n  // Handle Raw XML nodes - no escaping\n  if (isRawXmlNode(node)) {\n    return node.content\n  }\n\n  const { type, props, children } = node\n\n  if (type === Fragment) {\n    const renderedChildren = await Promise.all(\n      children\n        .filter((c) => c != null)\n        .map((c) => renderNode(c, indent, container)),\n    )\n    return renderedChildren.join('')\n  }\n\n  const prefix = indent >= 0 ? '  '.repeat(indent) : ''\n  const newline = indent >= 0 ? '\\n' : ''\n\n  const attrs = Object.entries(props)\n    .filter(([_, v]) => v != null)\n    .map(([k, v]) => ` ${k}=\"${escapeAttr(String(v))}\"`)\n    .join('')\n\n  if (children.length === 0) {\n    return `${prefix}<${type}${attrs}/>${newline}`\n  }\n\n  const childIndent = indent >= 0 ? indent + 1 : -1\n\n  // Resolve all children (including async and class components) in parallel\n  const resolvedChildren = await Promise.all(\n    children\n      .filter((c) => c != null)\n      .map((c) => renderNode(c, childIndent, container)),\n  )\n  const childContent = resolvedChildren.join('')\n\n  // Check if children are simple (text, numbers, CDATA, or raw XML)\n  const hasOnlySimpleContent = children.every(\n    (c) =>\n      typeof c === 'string' ||\n      typeof c === 'number' ||\n      isCDataNode(c) ||\n      isRawXmlNode(c),\n  )\n  if (hasOnlySimpleContent) {\n    return `${prefix}<${type}${attrs}>${childContent}</${type}>${newline}`\n  }\n\n  return `${prefix}<${type}${attrs}>${newline}${childContent}${prefix}</${type}>${newline}`\n}\n\nfunction isClassComponentNode(node: unknown): node is ClassComponentNode {\n  return (\n    node !== null &&\n    typeof node === 'object' &&\n    'type' in node &&\n    node.type === ClassComponent\n  )\n}\n\nfunction isAsyncNode(node: unknown): node is AsyncXmlNode {\n  return (\n    node !== null &&\n    typeof node === 'object' &&\n    'type' in node &&\n    node.type === AsyncComponent\n  )\n}\n\nfunction isCDataNode(node: any): node is CDataNode {\n  return node && typeof node === 'object' && node.type === CDataSymbol\n}\n\nfunction isRawXmlNode(node: any): node is RawXmlNode {\n  return node && typeof node === 'object' && node.type === RawXmlSymbol\n}\n\n/**\n * Renders content as CDATA section.\n * If content contains \"]]>\", splits into multiple CDATA sections.\n * The technique is to end the CDATA section before ]]>, then start a new one.\n */\nfunction renderCData(content: string): string {\n  // Handle the edge case where content contains \"]]>\"\n  // We split on \"]]>\" and join with \"]]]]><![CDATA[>\" which effectively\n  // ends the CDATA section after \"]]\" and starts a new one for \">\"\n  if (content.includes(']]>')) {\n    // Replace ]]> with ]]]]><![CDATA[> which closes CDATA before > and reopens it\n    const escaped = content.replace(/]]>/g, ']]]]><![CDATA[>')\n    return `<![CDATA[${escaped}]]>`\n  }\n  return `<![CDATA[${content}]]>`\n}\n\nfunction escapeXml(str: string): string {\n  return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')\n}\n\nfunction escapeAttr(str: string): string {\n  return str\n    .replace(/&/g, '&amp;')\n    .replace(/</g, '&lt;')\n    .replace(/>/g, '&gt;')\n    .replace(/\"/g, '&quot;')\n}\n","import type { ZodObject, ZodRawShape } from 'zod/v4'\nimport type { z } from 'zod/v4'\n\nimport type { AnyXmlNode, XmlNode } from '../types/xml-node.mjs'\n\n/**\n * Type for XML tag components created by `defineTag`.\n *\n * Tag components are functions that accept props and children, and return\n * an XML node. They also have a `tagName` property for identification.\n *\n * @template Props - The props type for the tag component.\n */\nexport interface TagComponent<Props extends Record<string, unknown>> {\n  (props: Props & { children?: AnyXmlNode | AnyXmlNode[] }): XmlNode\n  tagName: string\n}\n\n/**\n * Creates a type-safe XML tag component with optional Zod schema validation.\n *\n * @param name - The tag name (supports namespace prefixes like 'atom:link')\n * @param propsSchema - Optional Zod schema for validating props\n * @returns A component function that can be used in JSX\n *\n * @example\n * ```tsx\n * // Simple tag\n * const item = defineTag('item')\n * <item>Content</item>\n *\n * // Namespaced tag with Zod validation\n * const atomLink = defineTag('atom:link', z.object({\n *   href: z.string().url(),\n *   rel: z.enum(['self', 'alternate']),\n *   type: z.string().optional(),\n * }))\n * <atomLink href=\"https://example.com/feed\" rel=\"self\" />\n * ```\n */\nexport function defineTag<T extends ZodRawShape>(\n  name: string,\n  propsSchema?: ZodObject<T>,\n): TagComponent<T extends ZodRawShape ? z.infer<ZodObject<T>> : Record<string, never>> {\n  const component = (props: any): XmlNode => {\n    const { children, ...rest } = props ?? {}\n\n    // Validate props if schema provided\n    if (propsSchema) {\n      propsSchema.parse(rest)\n    }\n\n    return {\n      type: name,\n      props: rest,\n      children: Array.isArray(children) ? children : children ? [children] : [],\n    }\n  }\n\n  component.tagName = name\n  return component as any\n}\n","import type { EndpointFunctionArgs, HttpMethod, Util_FlatObject } from '@navios/builder'\nimport type { ZodObject, ZodType } from 'zod/v4'\n\nimport { getEndpointMetadata, XmlStreamAdapterToken } from '@navios/core'\n\nimport type { BaseXmlStreamConfig } from '../types/config.mjs'\n\n/**\n * Type helper that extracts the parameter types for an XML Stream endpoint handler.\n *\n * This type automatically infers the correct parameter types based on the endpoint\n * configuration, including URL parameters, query parameters, and request body.\n *\n * @template EndpointDeclaration - The endpoint declaration type from `declareXmlStream`.\n * @template Url - The URL path pattern.\n * @template QuerySchema - The query parameter schema type.\n *\n * @example\n * ```typescript\n * const getFeed = declareXmlStream({\n *   method: 'GET',\n *   url: '/feed/:category',\n *   querySchema: z.object({ page: z.string() }),\n * })\n *\n * // XmlStreamParams<typeof getFeed> resolves to:\n * // { urlParams: { category: string }, query: { page: string } }\n * ```\n */\nexport type XmlStreamParams<\n  EndpointDeclaration extends {\n    config: BaseXmlStreamConfig<any, any, any, any>\n  },\n  Url extends string = EndpointDeclaration['config']['url'],\n  QuerySchema = EndpointDeclaration['config']['querySchema'],\n> = QuerySchema extends ZodObject\n  ? EndpointDeclaration['config']['requestSchema'] extends ZodType\n    ? Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, EndpointDeclaration['config']['requestSchema'], true>>\n    : Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, undefined, true>>\n  : EndpointDeclaration['config']['requestSchema'] extends ZodType\n    ? Util_FlatObject<EndpointFunctionArgs<Url, undefined, EndpointDeclaration['config']['requestSchema'], true>>\n    : Util_FlatObject<EndpointFunctionArgs<Url, undefined, undefined, true>>\n\n/**\n * Decorator for XML Stream endpoints that return JSX-based XML responses.\n *\n * This decorator marks controller methods that return JSX elements, which will be\n * automatically rendered to XML and sent with the appropriate Content-Type header.\n * The method can be async and can contain async components, class components, and\n * regular JSX elements.\n *\n * @template Method - The HTTP method (GET, POST, etc.).\n * @template Url - The URL path pattern (supports parameters like `/posts/:id`).\n * @template QuerySchema - Optional Zod schema for query parameter validation.\n * @template RequestSchema - Optional Zod schema for request body validation.\n *\n * @param endpoint - The endpoint declaration created with `declareXmlStream`.\n * @returns A method decorator function.\n *\n * @throws {Error} If used on a non-function or non-method.\n * @throws {Error} If the endpoint URL already exists.\n *\n * @example\n * ```typescript\n * import { XmlStream, declareXmlStream } from '@navios/adapter-xml'\n * import { Controller } from '@navios/core'\n *\n * const getRssFeed = declareXmlStream({\n *   method: 'GET',\n *   url: '/feed.xml',\n *   contentType: 'application/rss+xml',\n * })\n *\n * @Controller('/api')\n * class FeedController {\n *   @XmlStream(getRssFeed)\n *   async getFeed() {\n *     return (\n *       <rss version=\"2.0\">\n *         <channel>\n *           <title>My Feed</title>\n *         </channel>\n *       </rss>\n *     )\n *   }\n * }\n * ```\n *\n * @example\n * ```typescript\n * // With query parameters\n * const getSitemap = declareXmlStream({\n *   method: 'GET',\n *   url: '/sitemap.xml',\n *   querySchema: z.object({ page: z.string().optional() }),\n * })\n *\n * @Controller()\n * class SitemapController {\n *   @XmlStream(getSitemap)\n *   async getSitemap(params: { query?: { page?: string } }) {\n *     const page = params.query?.page\n *     return <urlset>...</urlset>\n *   }\n * }\n * ```\n */\nexport function XmlStream<\n  Method extends HttpMethod = HttpMethod,\n  Url extends string = string,\n  QuerySchema = undefined,\n  RequestSchema = ZodType,\n>(endpoint: { config: BaseXmlStreamConfig<Method, Url, QuerySchema, RequestSchema> }) {\n  return (\n    target: (\n      params: QuerySchema extends ZodObject\n        ? RequestSchema extends ZodType\n          ? Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, RequestSchema, true>>\n          : Util_FlatObject<EndpointFunctionArgs<Url, QuerySchema, undefined, true>>\n        : RequestSchema extends ZodType\n          ? Util_FlatObject<EndpointFunctionArgs<Url, undefined, RequestSchema, true>>\n          : Util_FlatObject<EndpointFunctionArgs<Url, undefined, undefined, true>>,\n    ) => Promise<any>, // Returns XmlNode\n    context: ClassMethodDecoratorContext,\n  ) => {\n    if (typeof target !== 'function') {\n      throw new Error('[Navios] XmlStream decorator can only be used on functions.')\n    }\n    if (context.kind !== 'method') {\n      throw new Error('[Navios] XmlStream decorator can only be used on methods.')\n    }\n\n    const config = endpoint.config\n    if (context.metadata) {\n      const endpointMetadata = getEndpointMetadata<BaseXmlStreamConfig>(target, context)\n      if (endpointMetadata.config && endpointMetadata.config.url) {\n        throw new Error(`[Navios] Endpoint ${config.method} ${config.url} already exists.`)\n      }\n      // @ts-expect-error We don't need to set correctly in the metadata\n      endpointMetadata.config = config\n      endpointMetadata.adapterToken = XmlStreamAdapterToken\n      endpointMetadata.classMethod = target.name\n      endpointMetadata.httpMethod = config.method\n      endpointMetadata.url = config.url\n    }\n    return target\n  }\n}\n","import type { HttpMethod } from '@navios/builder'\n\nimport type { BaseXmlStreamConfig } from '../types/config.mjs'\n\n/**\n * Declares an XML Stream endpoint configuration for use with `@XmlStream` decorator.\n *\n * This function creates an endpoint declaration that can be used with the `@XmlStream`\n * decorator to mark controller methods that return JSX-based XML responses.\n *\n * @template Method - The HTTP method (GET, POST, etc.).\n * @template Url - The URL path pattern (supports parameters like `/posts/:id`).\n * @template QuerySchema - Optional Zod schema for query parameter validation.\n * @template RequestSchema - Optional Zod schema for request body validation.\n *\n * @param config - The endpoint configuration including method, URL, schemas, and XML options.\n * @returns An endpoint declaration object to be used with `@XmlStream` decorator.\n *\n * @example\n * ```typescript\n * import { declareXmlStream } from '@navios/adapter-xml'\n * import { z } from 'zod/v4'\n *\n * // Simple endpoint\n * export const getRssFeed = declareXmlStream({\n *   method: 'GET',\n *   url: '/feed.xml',\n *   contentType: 'application/rss+xml',\n * })\n *\n * // With query parameters\n * export const getSitemap = declareXmlStream({\n *   method: 'GET',\n *   url: '/sitemap.xml',\n *   querySchema: z.object({\n *     page: z.string().optional(),\n *   }),\n *   contentType: 'application/xml',\n *   xmlDeclaration: true,\n *   encoding: 'UTF-8',\n * })\n * ```\n */\nexport function declareXmlStream<\n  Method extends HttpMethod,\n  Url extends string,\n  QuerySchema = undefined,\n  RequestSchema = undefined,\n>(\n  config: BaseXmlStreamConfig<Method, Url, QuerySchema, RequestSchema>,\n): { config: BaseXmlStreamConfig<Method, Url, QuerySchema, RequestSchema> } {\n  return { config }\n}\n","import type {\n  AbstractHttpHandlerAdapterInterface,\n  ClassType,\n  HandlerMetadata,\n  HandlerResult,\n  ScopedContainer,\n} from '@navios/core'\n\nimport {\n  InstanceResolverService,\n  inject,\n  Injectable,\n  StreamAdapterToken,\n  XmlStreamAdapterToken,\n} from '@navios/core'\n\nimport type { BaseXmlStreamConfig } from '../types/config.mjs'\nimport type { AnyXmlNode } from '../types/xml-node.mjs'\n\nimport { renderToXml } from '../runtime/render-to-xml.mjs'\n\n/**\n * Adapter service for handling XML Stream endpoints in Navios.\n *\n * This service integrates with the base stream adapter (Fastify or Bun) to handle\n * XML endpoints that return JSX-based XML responses. It automatically renders JSX\n * nodes to XML strings and sends them with the appropriate Content-Type headers.\n *\n * The service supports:\n * - Async components (resolved in parallel)\n * - Class components (resolved via DI container)\n * - Regular JSX elements\n * - CDATA sections\n * - Raw XML content\n *\n * @implements {AbstractHttpHandlerAdapterInterface}\n *\n * @example\n * ```ts\n * // This service is automatically registered when using defineXmlEnvironment()\n * // and is used by endpoints decorated with @XmlStream()\n * ```\n */\n@Injectable({\n  token: XmlStreamAdapterToken,\n})\nexport class XmlStreamAdapterService implements AbstractHttpHandlerAdapterInterface {\n  /** Base stream adapter - we proxy hasSchema, prepareArguments, provideSchema to it */\n  protected streamAdapter = inject(StreamAdapterToken)\n  protected instanceResolver = inject(InstanceResolverService)\n\n  /**\n   * Prepares argument getters for parsing request data.\n   *\n   * Proxies to the base stream adapter to reuse existing argument preparation logic\n   * that handles query parameters, request body, and URL parameters for both\n   * Fastify and Bun adapters.\n   *\n   * @param handlerMetadata - The handler metadata with schemas and configuration.\n   * @returns An array of getter functions that populate request arguments.\n   */\n  prepareArguments(handlerMetadata: HandlerMetadata<BaseXmlStreamConfig>) {\n    return this.streamAdapter.prepareArguments?.(handlerMetadata) ?? []\n  }\n\n  /**\n   * Provides schema information for the handler.\n   *\n   * Proxies to the base stream adapter to reuse existing schema generation logic.\n   * For Fastify, this enables built-in validation. For Bun, this returns an empty object.\n   *\n   * @param handlerMetadata - The handler metadata containing configuration and schemas.\n   * @returns Schema information (Fastify route schema or empty object for Bun).\n   */\n  provideSchema(\n    handlerMetadata: HandlerMetadata<BaseXmlStreamConfig>,\n  ): Record<string, any> {\n    if (\n      'provideSchema' in this.streamAdapter &&\n      typeof this.streamAdapter.provideSchema === 'function'\n    ) {\n      return this.streamAdapter.provideSchema(handlerMetadata)\n    }\n    return {}\n  }\n\n  /**\n   * Checks if the handler has any validation schemas defined.\n   *\n   * Proxies to the base stream adapter to check for query or request schemas.\n   *\n   * @param handlerMetadata - The handler metadata containing configuration.\n   * @returns `true` if the handler has any schemas (query or request).\n   */\n  hasSchema(handlerMetadata: HandlerMetadata<any>): boolean {\n    if (\n      'hasSchema' in this.streamAdapter &&\n      typeof this.streamAdapter.hasSchema === 'function'\n    ) {\n      return this.streamAdapter.hasSchema(handlerMetadata)\n    }\n    return false\n  }\n\n  /**\n   * Creates a request handler function for XML Stream endpoints.\n   *\n   * This method generates a handler that:\n   * 1. Parses and validates request data (body, query, URL params) using the base adapter\n   * 2. Invokes the controller method with validated arguments (returns JSX)\n   * 3. Renders the JSX tree to XML string (resolves async and class components)\n   * 4. Sends the XML response with appropriate Content-Type header\n   *\n   * The handler automatically detects the environment (Fastify vs Bun) and uses the\n   * appropriate response mechanism (reply object vs Response object).\n   *\n   * @param controller - The controller class containing the handler method.\n   * @param handlerMetadata - The handler metadata with configuration and schemas.\n   * @returns A function that handles incoming requests and sends XML responses.\n   */\n  async provideHandler(\n    controller: ClassType,\n    handlerMetadata: HandlerMetadata<BaseXmlStreamConfig>,\n  ): Promise<HandlerResult> {\n    const getters = this.prepareArguments(handlerMetadata)\n    const config = handlerMetadata.config\n    const hasArguments = getters.length > 0\n\n    const contentType = config.contentType ?? 'application/xml'\n\n    // Cache method name for faster property access\n    const methodName = handlerMetadata.classMethod\n\n    // Helper to send response based on environment\n    const sendResponse = (\n      xml: string,\n      reply: any,\n      headers: Record<string, string>,\n    ) => {\n      // Environment detection: Bun doesn't have reply\n      const isHttpStandardEnvironment = reply === undefined\n\n      if (isHttpStandardEnvironment) {\n        // Bun: return Response object\n        return new Response(xml, {\n          status: handlerMetadata.successStatusCode,\n          headers,\n        })\n      } else {\n        // Fastify: use reply object\n        reply\n          .status(handlerMetadata.successStatusCode)\n          .header('Content-Type', contentType)\n          .headers(handlerMetadata.headers)\n          .send(xml)\n      }\n    }\n\n    // Pre-compute headers\n    const headersTemplate: Record<string, string> = {\n      'Content-Type': contentType,\n    }\n    for (const [key, value] of Object.entries(handlerMetadata.headers)) {\n      if (value != null) {\n        headersTemplate[key] = String(value)\n      }\n    }\n\n    // Resolve controller with automatic scope detection\n    const resolution = await this.instanceResolver.resolve(controller)\n\n    // XML adapter always returns dynamic handler because renderToXml needs ScopedContainer\n    // for resolving class components. Even if the controller is cached, we still need\n    // the scoped container for the XML rendering phase.\n\n    // Pre-compute render options\n    const renderOptions = {\n      declaration: config.xmlDeclaration ?? true,\n      encoding: config.encoding ?? 'UTF-8',\n    }\n\n    // Branch based on hasArguments to skip formatArguments entirely when not needed\n    if (hasArguments) {\n      // Detect if any getter is async at registration time\n      const hasAsyncGetters = getters.some(\n        (g) => g.constructor.name === 'AsyncFunction',\n      )\n\n      const formatArguments = hasAsyncGetters\n        ? async (request: any) => {\n            const argument: Record<string, any> = {}\n            const promises: Promise<void>[] = []\n            for (const getter of getters) {\n              const res = getter(argument, request)\n              if (res instanceof Promise) {\n                promises.push(res)\n              }\n            }\n            await Promise.all(promises)\n            return argument\n          }\n        : (request: any) => {\n            const argument: Record<string, any> = {}\n            for (const getter of getters) {\n              getter(argument, request)\n            }\n            return argument\n          }\n\n      if (resolution.cached) {\n        const cachedController = resolution.instance as any\n        // Pre-bind method for faster invocation\n        const boundMethod = cachedController[methodName].bind(cachedController)\n        return {\n          isStatic: false,\n          handler: async (\n            context: ScopedContainer,\n            request: any,\n            reply: any,\n          ) => {\n            const argument = await formatArguments(request)\n            const xmlNode: AnyXmlNode = await boundMethod(argument)\n            const xml = await renderToXml(xmlNode, {\n              ...renderOptions,\n              container: context,\n            })\n            return sendResponse(xml, reply, headersTemplate)\n          },\n        }\n      }\n\n      return {\n        isStatic: false,\n        handler: async (context: ScopedContainer, request: any, reply: any) => {\n          const controllerInstance = (await resolution.resolve(context)) as any\n          const argument = await formatArguments(request)\n          const xmlNode: AnyXmlNode =\n            await controllerInstance[methodName](argument)\n          const xml = await renderToXml(xmlNode, {\n            ...renderOptions,\n            container: context,\n          })\n          return sendResponse(xml, reply, headersTemplate)\n        },\n      }\n    }\n\n    // No arguments path - skip formatArguments entirely\n    const emptyArgs = Object.freeze({})\n    if (resolution.cached) {\n      const cachedController = resolution.instance as any\n      // Pre-bind method for faster invocation\n      const boundMethod = cachedController[methodName].bind(cachedController)\n      return {\n        isStatic: false,\n        handler: async (\n          context: ScopedContainer,\n          _request: any,\n          reply: any,\n        ) => {\n          const xmlNode: AnyXmlNode = await boundMethod(emptyArgs)\n          const xml = await renderToXml(xmlNode, {\n            ...renderOptions,\n            container: context,\n          })\n          return sendResponse(xml, reply, headersTemplate)\n        },\n      }\n    }\n\n    return {\n      isStatic: false,\n      handler: async (context: ScopedContainer, _request: any, reply: any) => {\n        const controllerInstance = (await resolution.resolve(context)) as any\n        const xmlNode: AnyXmlNode =\n          await controllerInstance[methodName](emptyArgs)\n        const xml = await renderToXml(xmlNode, {\n          ...renderOptions,\n          container: context,\n        })\n        return sendResponse(xml, reply, headersTemplate)\n      },\n    }\n  }\n}\n","import type { AnyInjectableType } from '@navios/core'\n\nimport { InjectionToken, XmlStreamAdapterToken } from '@navios/core'\n\nimport { XmlStreamAdapterService } from './adapters/index.mjs'\n\n/**\n * Creates the XML environment configuration to be merged with base adapter (Fastify/Bun).\n *\n * @example\n * ```typescript\n * import { defineFastifyEnvironment } from '@navios/adapter-fastify'\n * import { defineXmlEnvironment } from '@navios/adapter-xml'\n * import { NaviosFactory } from '@navios/core'\n *\n * const fastifyEnv = defineFastifyEnvironment()\n * const xmlEnv = defineXmlEnvironment()\n *\n * // Merge environments\n * const mergedEnv = {\n *   httpTokens: new Map([\n *     ...fastifyEnv.httpTokens,\n *     ...xmlEnv.httpTokens,\n *   ]),\n * }\n *\n * const app = await NaviosFactory.create(AppModule, {\n *   adapter: mergedEnv,\n * })\n * ```\n */\nexport function defineXmlEnvironment() {\n  const httpTokens = new Map<InjectionToken<any, undefined>, AnyInjectableType>(\n    [[XmlStreamAdapterToken, XmlStreamAdapterService]],\n  )\n  return {\n    httpTokens,\n  }\n}\n"],"mappings":"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"}

package/lib/jsx-dev-runtime.cjs

@@ -1,4 +1,4 @@
-const require_create_element = require('./create-element-CTOxv6Df.cjs');
+const require_create_element = require('./create-element-DiOt_-Vs.cjs');
 
 //#region src/jsx-dev-runtime.mts
 const jsxDEV = require_create_element.jsx;

package/lib/jsx-runtime.cjs

@@ -1,4 +1,4 @@
-const require_create_element = require('./create-element-CTOxv6Df.cjs');
+const require_create_element = require('./create-element-DiOt_-Vs.cjs');
 
 exports.Fragment = require_create_element.Fragment;
 exports.jsx = require_create_element.jsx;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@navios/adapter-xml",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "author": {
     "name": "Oleksandr Hanzha",
     "email": "alex@granted.name"
@@ -12,12 +12,12 @@
   },
   "license": "MIT",
   "peerDependencies": {
-    "@navios/builder": "^0.5.0",
-    "@navios/core": "^0.7.0",
-    "@navios/di": "^0.6.0"
+    "@navios/builder": "^0.5.2",
+    "@navios/core": "^0.8.0",
+    "@navios/di": "^0.8.0"
   },
   "typings": "./lib/index.d.mts",
-  "main": "./lib/index.js",
+  "main": "./lib/index.cjs",
   "module": "./lib/index.mjs",
   "exports": {
     ".": {
@@ -26,8 +26,8 @@
         "default": "./lib/index.mjs"
       },
       "require": {
-        "types": "./lib/index.d.ts",
-        "default": "./lib/index.js"
+        "types": "./lib/index.d.cts",
+        "default": "./lib/index.cjs"
       }
     },
     "./jsx-runtime": {
@@ -36,8 +36,8 @@
         "default": "./lib/jsx-runtime.mjs"
       },
       "require": {
-        "types": "./lib/jsx-runtime.d.ts",
-        "default": "./lib/jsx-runtime.js"
+        "types": "./lib/jsx-runtime.d.cts",
+        "default": "./lib/jsx-runtime.cjs"
       }
     },
     "./jsx-dev-runtime": {
@@ -46,8 +46,8 @@
         "default": "./lib/jsx-dev-runtime.mjs"
       },
       "require": {
-        "types": "./lib/jsx-dev-runtime.d.ts",
-        "default": "./lib/jsx-dev-runtime.js"
+        "types": "./lib/jsx-dev-runtime.d.cts",
+        "default": "./lib/jsx-dev-runtime.cjs"
       }
     },
     "./jsx": {
@@ -57,24 +57,24 @@
       },
       "require": {
         "types": "./jsx.d.ts",
-        "default": "./lib/jsx.js"
+        "default": "./lib/jsx.cjs"
       }
     }
   },
   "devDependencies": {
-    "@navios/adapter-bun": "^0.7.0",
-    "@navios/adapter-fastify": "^0.7.0",
-    "@navios/builder": "^0.5.0",
-    "@navios/core": "^0.7.0",
-    "@navios/di": "^0.6.0",
-    "@types/bun": "^1.3.4",
+    "@navios/adapter-bun": "^0.8.0",
+    "@navios/adapter-fastify": "^0.8.0",
+    "@navios/builder": "^0.5.2",
+    "@navios/core": "^0.8.0",
+    "@navios/di": "^0.8.0",
+    "@types/bun": "^1.3.5",
     "@types/supertest": "^6.0.3",
     "supertest": "^7.1.4",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "vitest": "^3.2.4"
+    "vitest": "^4.0.16"
   },
   "dependencies": {
-    "zod": "^4.1.13"
+    "zod": "^4.2.1"
   }
 }

package/src/adapters/xml-stream-adapter.service.mts

@@ -2,10 +2,12 @@ import type {
   AbstractHttpHandlerAdapterInterface,
   ClassType,
   HandlerMetadata,
+  HandlerResult,
   ScopedContainer,
 } from '@navios/core'
 
 import {
+  InstanceResolverService,
   inject,
   Injectable,
   StreamAdapterToken,
@@ -45,6 +47,7 @@ import { renderToXml } from '../runtime/render-to-xml.mjs'
 export class XmlStreamAdapterService implements AbstractHttpHandlerAdapterInterface {
   /** Base stream adapter - we proxy hasSchema, prepareArguments, provideSchema to it */
   protected streamAdapter = inject(StreamAdapterToken)
+  protected instanceResolver = inject(InstanceResolverService)
 
   /**
    * Prepares argument getters for parsing request data.
@@ -115,56 +118,30 @@ export class XmlStreamAdapterService implements AbstractHttpHandlerAdapterInterf
    * @param handlerMetadata - The handler metadata with configuration and schemas.
    * @returns A function that handles incoming requests and sends XML responses.
    */
-  provideHandler(
+  async provideHandler(
     controller: ClassType,
     handlerMetadata: HandlerMetadata<BaseXmlStreamConfig>,
-  ): (context: ScopedContainer, request: any, reply: any) => Promise<any> {
+  ): Promise<HandlerResult> {
     const getters = this.prepareArguments(handlerMetadata)
     const config = handlerMetadata.config
-
-    const formatArguments = async (request: any) => {
-      const argument: Record<string, any> = {}
-      const promises: Promise<void>[] = []
-      for (const getter of getters) {
-        const res = getter(argument, request)
-        if (res instanceof Promise) {
-          promises.push(res)
-        }
-      }
-      await Promise.all(promises)
-      return argument
-    }
+    const hasArguments = getters.length > 0
 
     const contentType = config.contentType ?? 'application/xml'
 
-    return async (context: ScopedContainer, request: any, reply: any) => {
-      const controllerInstance = await context.get(controller)
-      const argument = await formatArguments(request)
-
-      // Call controller method - returns XmlNode (JSX), may contain async/class components
-      const xmlNode: AnyXmlNode =
-        await controllerInstance[handlerMetadata.classMethod](argument)
-
-      // Render JSX to XML string (async - resolves all async and class components)
-      const xml = await renderToXml(xmlNode, {
-        declaration: config.xmlDeclaration ?? true,
-        encoding: config.encoding ?? 'UTF-8',
-        container: context,
-      })
+    // Cache method name for faster property access
+    const methodName = handlerMetadata.classMethod
 
+    // Helper to send response based on environment
+    const sendResponse = (
+      xml: string,
+      reply: any,
+      headers: Record<string, string>,
+    ) => {
       // Environment detection: Bun doesn't have reply
       const isHttpStandardEnvironment = reply === undefined
 
       if (isHttpStandardEnvironment) {
         // Bun: return Response object
-        const headers: Record<string, string> = {
-          '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,
@@ -178,5 +155,131 @@ export class XmlStreamAdapterService implements AbstractHttpHandlerAdapterInterf
           .send(xml)
       }
     }
+
+    // Pre-compute headers
+    const headersTemplate: Record<string, string> = {
+      'Content-Type': contentType,
+    }
+    for (const [key, value] of Object.entries(handlerMetadata.headers)) {
+      if (value != null) {
+        headersTemplate[key] = String(value)
+      }
+    }
+
+    // Resolve controller with automatic scope detection
+    const resolution = await this.instanceResolver.resolve(controller)
+
+    // XML adapter always returns dynamic handler because renderToXml needs ScopedContainer
+    // for resolving class components. Even if the controller is cached, we still need
+    // the scoped container for the XML rendering phase.
+
+    // Pre-compute render options
+    const renderOptions = {
+      declaration: config.xmlDeclaration ?? true,
+      encoding: config.encoding ?? 'UTF-8',
+    }
+
+    // Branch based on hasArguments to skip formatArguments entirely when not needed
+    if (hasArguments) {
+      // Detect if any getter is async at registration time
+      const hasAsyncGetters = getters.some(
+        (g) => g.constructor.name === 'AsyncFunction',
+      )
+
+      const formatArguments = hasAsyncGetters
+        ? async (request: any) => {
+            const argument: Record<string, any> = {}
+            const promises: Promise<void>[] = []
+            for (const getter of getters) {
+              const res = getter(argument, request)
+              if (res instanceof Promise) {
+                promises.push(res)
+              }
+            }
+            await Promise.all(promises)
+            return argument
+          }
+        : (request: any) => {
+            const argument: Record<string, any> = {}
+            for (const getter of getters) {
+              getter(argument, request)
+            }
+            return argument
+          }
+
+      if (resolution.cached) {
+        const cachedController = resolution.instance as any
+        // Pre-bind method for faster invocation
+        const boundMethod = cachedController[methodName].bind(cachedController)
+        return {
+          isStatic: false,
+          handler: async (
+            context: ScopedContainer,
+            request: any,
+            reply: any,
+          ) => {
+            const argument = await formatArguments(request)
+            const xmlNode: AnyXmlNode = await boundMethod(argument)
+            const xml = await renderToXml(xmlNode, {
+              ...renderOptions,
+              container: context,
+            })
+            return sendResponse(xml, reply, headersTemplate)
+          },
+        }
+      }
+
+      return {
+        isStatic: false,
+        handler: async (context: ScopedContainer, request: any, reply: any) => {
+          const controllerInstance = (await resolution.resolve(context)) as any
+          const argument = await formatArguments(request)
+          const xmlNode: AnyXmlNode =
+            await controllerInstance[methodName](argument)
+          const xml = await renderToXml(xmlNode, {
+            ...renderOptions,
+            container: context,
+          })
+          return sendResponse(xml, reply, headersTemplate)
+        },
+      }
+    }
+
+    // No arguments path - skip formatArguments entirely
+    const emptyArgs = Object.freeze({})
+    if (resolution.cached) {
+      const cachedController = resolution.instance as any
+      // Pre-bind method for faster invocation
+      const boundMethod = cachedController[methodName].bind(cachedController)
+      return {
+        isStatic: false,
+        handler: async (
+          context: ScopedContainer,
+          _request: any,
+          reply: any,
+        ) => {
+          const xmlNode: AnyXmlNode = await boundMethod(emptyArgs)
+          const xml = await renderToXml(xmlNode, {
+            ...renderOptions,
+            container: context,
+          })
+          return sendResponse(xml, reply, headersTemplate)
+        },
+      }
+    }
+
+    return {
+      isStatic: false,
+      handler: async (context: ScopedContainer, _request: any, reply: any) => {
+        const controllerInstance = (await resolution.resolve(context)) as any
+        const xmlNode: AnyXmlNode =
+          await controllerInstance[methodName](emptyArgs)
+        const xml = await renderToXml(xmlNode, {
+          ...renderOptions,
+          container: context,
+        })
+        return sendResponse(xml, reply, headersTemplate)
+      },
+    }
   }
 }

package/dist/tsup.config.d.mts

@@ -1,3 +0,0 @@
-declare const _default: import("tsup").Options | import("tsup").Options[] | ((overrideOptions: import("tsup").Options) => import("tsup").Options | import("tsup").Options[] | Promise<import("tsup").Options | import("tsup").Options[]>);
-export default _default;
-//# sourceMappingURL=tsup.config.d.mts.map