@analogjs/vite-plugin-nitro 2.4.0-beta.9 → 3.0.0-alpha.2

package/src/lib/utils/renderers.d.ts

@@ -1,3 +1,42 @@
-export declare const ssrRenderer = "\nimport { eventHandler, getResponseHeader } from 'h3';\n// @ts-ignore\nimport renderer from '#analog/ssr';\n// @ts-ignore\nimport template from '#analog/index';\n\nexport default eventHandler(async (event) => {\n  const noSSR = getResponseHeader(event, 'x-analog-no-ssr');\n\n  if (noSSR === 'true') {\n    return template;\n  }\n\n  const html = await renderer(event.node.req.url, template, {\n    req: event.node.req,\n    res: event.node.res,\n  });\n\n  return html;\n});";
-export declare const clientRenderer = "\nimport { eventHandler } from 'h3';\n\n// @ts-ignore\nimport template from '#analog/index';\n\nexport default eventHandler(async () => {\n  return template;\n});\n";
-export declare const apiMiddleware = "\nimport { eventHandler, proxyRequest } from 'h3';\nimport { useRuntimeConfig } from '#imports';\n\nexport default eventHandler(async (event) => {\n  const prefix = useRuntimeConfig().prefix;\n  const apiPrefix = `${prefix}/${useRuntimeConfig().apiPrefix}`;\n\n  if (event.node.req.url?.startsWith(apiPrefix)) {\n    const reqUrl = event.node.req.url?.replace(apiPrefix, '');\n\n    if (\n      event.node.req.method === 'GET' &&\n      // in the case of XML routes, we want to proxy the request so that nitro gets the correct headers\n      // and can render the XML correctly as a static asset\n      !event.node.req.url?.endsWith('.xml')\n    ) {\n      return $fetch(reqUrl, { headers: event.node.req.headers });\n    }\n\n    return proxyRequest(event, reqUrl, {\n      // @ts-ignore\n      fetch: $fetch.native,\n    });\n  }\n});";
+/**
+ * SSR renderer virtual module content.
+ *
+ * This code runs inside Nitro's server runtime (Node.js context) where
+ * event.node is always populated. In h3 v2, event.node is typed as optional,
+ * so we use h3's first-class event properties (event.path, event.method) where
+ * possible and apply optional chaining when accessing the Node.js context for
+ * the Angular renderer which requires raw req/res objects.
+ *
+ * h3 v2 idiomatic APIs used:
+ * - defineHandler (replaces defineEventHandler / eventHandler)
+ * - event.path (replaces event.node.req.url)
+ * - getResponseHeader compat shim (still available in h3 v2)
+ */
+export declare function ssrRenderer(templatePath: string): string;
+/**
+ * Client-only renderer virtual module content.
+ *
+ * Used when SSR is disabled — simply serves the static index.html template
+ * for every route, letting the client-side Angular router handle navigation.
+ */
+export declare function clientRenderer(templatePath: string): string;
+/**
+ * API middleware virtual module content.
+ *
+ * Intercepts requests matching the configured API prefix and either:
+ * - Uses event-bound internal forwarding for GET requests (except .xml routes)
+ * - Uses request proxying for all other methods to forward the full request
+ *
+ * h3 v2 idiomatic APIs used:
+ * - defineHandler (replaces defineEventHandler / eventHandler)
+ * - event.path (replaces event.node.req.url)
+ * - event.method (replaces event.node.req.method)
+ * - proxyRequest is retained internally because it preserves Nitro route
+ *   matching for event-bound server requests during SSR/prerender
+ * - Object.fromEntries(event.req.headers.entries()) replaces direct event.node.req.headers access
+ *
+ * `fetchWithEvent` keeps the active event context while forwarding to a
+ * rewritten path, which avoids falling through to the HTML renderer when
+ * SSR code makes relative API requests.
+ */
+export declare const apiMiddleware = "\nimport { defineHandler, fetchWithEvent, proxyRequest } from 'nitro/h3';\nimport { useRuntimeConfig } from 'nitro/runtime-config';\n\nexport default defineHandler(async (event) => {\n  const prefix = useRuntimeConfig().prefix;\n  const apiPrefix = `${prefix}/${useRuntimeConfig().apiPrefix}`;\n\n  if (event.path?.startsWith(apiPrefix)) {\n    const reqUrl = event.path?.replace(apiPrefix, '');\n\n    if (\n      event.method === 'GET' &&\n      // in the case of XML routes, we want to proxy the request so that nitro gets the correct headers\n      // and can render the XML correctly as a static asset\n      !event.path?.endsWith('.xml')\n    ) {\n      return fetchWithEvent(event, reqUrl, {\n        headers: Object.fromEntries(event.req.headers.entries()),\n      });\n    }\n\n    return proxyRequest(event, reqUrl);\n  }\n});";

package/src/lib/utils/renderers.js

@@ -1,58 +1,130 @@
-export const ssrRenderer = `
-import { eventHandler, getResponseHeader } from 'h3';
+/**
+ * SSR renderer virtual module content.
+ *
+ * This code runs inside Nitro's server runtime (Node.js context) where
+ * event.node is always populated. In h3 v2, event.node is typed as optional,
+ * so we use h3's first-class event properties (event.path, event.method) where
+ * possible and apply optional chaining when accessing the Node.js context for
+ * the Angular renderer which requires raw req/res objects.
+ *
+ * h3 v2 idiomatic APIs used:
+ * - defineHandler (replaces defineEventHandler / eventHandler)
+ * - event.path (replaces event.node.req.url)
+ * - getResponseHeader compat shim (still available in h3 v2)
+ */
+export function ssrRenderer(templatePath) {
+    return `
+import { readFileSync } from 'node:fs';
+import { createFetch } from 'ofetch';
+import { defineHandler, fetchWithEvent } from 'nitro/h3';
 // @ts-ignore
 import renderer from '#analog/ssr';
-// @ts-ignore
-import template from '#analog/index';
 
-export default eventHandler(async (event) => {
-  const noSSR = getResponseHeader(event, 'x-analog-no-ssr');
+const template = readFileSync(${JSON.stringify(templatePath)}, 'utf8');
+const normalizeHtmlRequestUrl = (url) =>
+  url.replace(/\\/index\\.html(?=$|[?#])/, '/');
+
+export default defineHandler(async (event) => {
+  event.res.headers.set('content-type', 'text/html; charset=utf-8');
+  const noSSR = event.res.headers.get('x-analog-no-ssr');
+  const requestPath = normalizeHtmlRequestUrl(event.path);
 
   if (noSSR === 'true') {
     return template;
   }
 
-  const html = await renderer(event.node.req.url, template, {
-    req: event.node.req,
-    res: event.node.res,
+  // event.path is the canonical h3 v2 way to access the request URL.
+  // event.node?.req and event.node?.res are needed by the Angular SSR renderer
+  // which operates on raw Node.js request/response objects.
+  // During prerendering (Nitro v3 fetch-based pipeline), event.node is undefined.
+  // The Angular renderer requires a req object with at least { headers, url },
+  // so we provide a minimal stub to avoid runtime errors in prerender context.
+  const req = event.node?.req
+    ? {
+        ...event.node.req,
+        url: requestPath,
+        originalUrl: requestPath,
+      }
+    : {
+    headers: { host: 'localhost' },
+    url: requestPath,
+    originalUrl: requestPath,
+    connection: {},
+  };
+  const res = event.node?.res;
+  const fetch = createFetch({
+    fetch: (resource, init) => {
+      const url = resource instanceof Request ? resource.url : resource.toString();
+      return fetchWithEvent(event, url, init);
+    }
   });
 
+  const html = await renderer(requestPath, template, { req, res, fetch });
+
   return html;
 });`;
-export const clientRenderer = `
-import { eventHandler } from 'h3';
+}
+/**
+ * Client-only renderer virtual module content.
+ *
+ * Used when SSR is disabled — simply serves the static index.html template
+ * for every route, letting the client-side Angular router handle navigation.
+ */
+export function clientRenderer(templatePath) {
+    return `
+import { readFileSync } from 'node:fs';
+import { defineHandler } from 'nitro/h3';
 
-// @ts-ignore
-import template from '#analog/index';
+const template = readFileSync(${JSON.stringify(templatePath)}, 'utf8');
 
-export default eventHandler(async () => {
+export default defineHandler(async (event) => {
+  event.res.headers.set('content-type', 'text/html; charset=utf-8');
   return template;
 });
 `;
+}
+/**
+ * API middleware virtual module content.
+ *
+ * Intercepts requests matching the configured API prefix and either:
+ * - Uses event-bound internal forwarding for GET requests (except .xml routes)
+ * - Uses request proxying for all other methods to forward the full request
+ *
+ * h3 v2 idiomatic APIs used:
+ * - defineHandler (replaces defineEventHandler / eventHandler)
+ * - event.path (replaces event.node.req.url)
+ * - event.method (replaces event.node.req.method)
+ * - proxyRequest is retained internally because it preserves Nitro route
+ *   matching for event-bound server requests during SSR/prerender
+ * - Object.fromEntries(event.req.headers.entries()) replaces direct event.node.req.headers access
+ *
+ * `fetchWithEvent` keeps the active event context while forwarding to a
+ * rewritten path, which avoids falling through to the HTML renderer when
+ * SSR code makes relative API requests.
+ */
 export const apiMiddleware = `
-import { eventHandler, proxyRequest } from 'h3';
-import { useRuntimeConfig } from '#imports';
+import { defineHandler, fetchWithEvent, proxyRequest } from 'nitro/h3';
+import { useRuntimeConfig } from 'nitro/runtime-config';
 
-export default eventHandler(async (event) => {
+export default defineHandler(async (event) => {
   const prefix = useRuntimeConfig().prefix;
   const apiPrefix = \`\${prefix}/\${useRuntimeConfig().apiPrefix}\`;
 
-  if (event.node.req.url?.startsWith(apiPrefix)) {
-    const reqUrl = event.node.req.url?.replace(apiPrefix, '');
+  if (event.path?.startsWith(apiPrefix)) {
+    const reqUrl = event.path?.replace(apiPrefix, '');
 
     if (
-      event.node.req.method === 'GET' &&
+      event.method === 'GET' &&
       // in the case of XML routes, we want to proxy the request so that nitro gets the correct headers
       // and can render the XML correctly as a static asset
-      !event.node.req.url?.endsWith('.xml')
+      !event.path?.endsWith('.xml')
     ) {
-      return $fetch(reqUrl, { headers: event.node.req.headers });
+      return fetchWithEvent(event, reqUrl, {
+        headers: Object.fromEntries(event.req.headers.entries()),
+      });
     }
 
-    return proxyRequest(event, reqUrl, {
-      // @ts-ignore
-      fetch: $fetch.native,
-    });
+    return proxyRequest(event, reqUrl);
   }
 });`;
 //# sourceMappingURL=renderers.js.map

package/src/lib/utils/renderers.js.map

@@ -1 +1 @@
-{"version":3,"file":"renderers.js","sourceRoot":"","sources":["../../../../../../packages/vite-plugin-nitro/src/lib/utils/renderers.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;IAoBvB,CAAC;AAEL,MAAM,CAAC,MAAM,cAAc,GAAG;;;;;;;;;CAS7B,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;IAyBzB,CAAC"}
+{"version":3,"file":"renderers.js","sourceRoot":"","sources":["../../../../../../packages/vite-plugin-nitro/src/lib/utils/renderers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,WAAW,CAAC,YAAoB;IAC9C,OAAO;;;;;;;gCAOuB,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA0CxD,CAAC;AACL,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,YAAoB;IACjD,OAAO;;;;gCAIuB,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;;;;;;CAM3D,CAAC;AACF,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;IAwBzB,CAAC"}

package/src/lib/vite-plugin-nitro.d.ts

@@ -1,4 +1,4 @@
-import { NitroConfig } from 'nitropack';
+import type { NitroConfig } from 'nitro/types';
 import type { Plugin } from 'vite';
 import { Options } from './options.js';
 export declare function nitro(options?: Options, nitroOptions?: NitroConfig): Plugin[];