@solidjs/vite-plugin 3.0.0-next.29 → 3.0.0-next.30

package/dist/cjs/index.cjs

@@ -45,24 +45,54 @@ var babel__namespace = /*#__PURE__*/_interopNamespaceDefault(babel);
  * different URL than the one node saw — the dev middlewares use it to
  * restore the configured Vite `base` that the dev/preview base middleware
  * stripped, so the handler always sees production-shaped URLs.
+ *
+ * Handles plain HTTP/1 *and* the HTTP/2 compat API: Vite's dev server uses
+ * `http2.createSecureServer({ allowHTTP1: true })` whenever `server.https`
+ * is set without a proxy, so under https the middlewares receive
+ * `Http2ServerRequest`s. The h2/protocol/abort techniques here are
+ * reimplemented from srvx's Node adapter (github.com/h3js/srvx,
+ * src/adapters/_node) — reference, not copied code.
  */
-function webRequestFromNode(req, urlPath) {
-  const url = new URL(urlPath ?? req.url ?? '/', `http://${req.headers.host || 'localhost'}`);
+function webRequestFromNode(req, urlPath, res) {
+  // TLS sockets (https and h2) expose `encrypted`; a Request whose url says
+  // http: on a TLS connection breaks secure-cookie logic, absolute
+  // redirects, and origin checks in application code.
+  const protocol = req.socket?.encrypted ? 'https' : 'http';
+  // HTTP/2 has no Host header — the authority travels in the `:authority`
+  // pseudo-header instead.
+  const host = req.headers.host ?? req.headers[':authority'] ?? 'localhost';
+  const url = new URL(urlPath ?? req.url ?? '/', `${protocol}://${host}`);
   const headers = new Headers();
   for (const [key, value] of Object.entries(req.headers)) {
     if (value === undefined) continue;
+    // HTTP/2 pseudo-headers (:method, :path, :authority, :scheme) are not
+    // legal field names — Headers#append throws a TypeError on them.
+    if (key[0] === ':') continue;
     if (Array.isArray(value)) {
       for (const item of value) headers.append(key, item);
     } else {
       headers.append(key, value);
     }
   }
+  // Surface client disconnects as the request's AbortSignal so handlers can
+  // cancel work (streamed SSR renders, in-flight fetches). The response's
+  // 'close' fires on normal completion too; `writableEnded` distinguishes a
+  // finished response from a client that went away.
+  let signal;
+  if (res) {
+    const controller = new AbortController();
+    res.once('close', () => {
+      if (!res.writableEnded) controller.abort();
+    });
+    signal = controller.signal;
+  }
   const method = req.method || 'GET';
   const body = method === 'GET' || method === 'HEAD' ? undefined : node_stream.Readable.toWeb(req);
   return new Request(url, {
     method,
     headers,
     body,
+    signal,
     // undici requires half-duplex for streamed request bodies.
     ...(body ? {
       duplex: 'half'
@@ -77,7 +107,11 @@ async function sendWebResponse(res, response) {
     if (key !== 'set-cookie') res.setHeader(key, value);
   });
   if (cookies && cookies.length) res.setHeader('set-cookie', cookies);
-  if (!response.body) {
+  // HEAD gets the head only — and the body must be *cancelled*, not pumped:
+  // node discards HEAD body writes, so streaming a long (or endless) body
+  // into the void just burns the render. (Technique from srvx.)
+  if (!response.body || res.req?.method === 'HEAD') {
+    response.body?.cancel().catch(() => {});
     res.end();
     return;
   }
@@ -1034,7 +1068,7 @@ function serverFunctions(options = {}, internal = {}) {
                 nativeEvent: req
               }
             };
-            const response = internal.ssrHandler ? await handler.handleRequest(webRequestFromNode(req, dispatchUrl), dispatchOptions) : await handler.handleServerFunctionRequest(webRequestFromNode(req, dispatchUrl), dispatchOptions);
+            const response = internal.ssrHandler ? await handler.handleRequest(webRequestFromNode(req, dispatchUrl, res), dispatchOptions) : await handler.handleServerFunctionRequest(webRequestFromNode(req, dispatchUrl, res), dispatchOptions);
             await sendWebResponse(res, response);
           })().catch(error => {
             if (error instanceof Error) server.ssrFixStacktrace(error);
@@ -1828,7 +1862,7 @@ function startServe(options, internal = {}) {
             // server-function endpoint) and hands the URL to application
             // code, so restore the base — the deployed production handler
             // receives base-prefixed URLs and preview must match it.
-            const response = await handler.handleRequest(webRequestFromNode(req, joinBase(base, req.url || '/')),
+            const response = await handler.handleRequest(webRequestFromNode(req, joinBase(base, req.url || '/'), res),
             // Same event extension the dev middleware and a production
             // Node entry pass: the raw Node request as `nativeEvent`.
             {
@@ -1885,7 +1919,7 @@ function startServe(options, internal = {}) {
             // the configured `base` from req.url; restore it so the app
             // sees the same URLs in dev as in production (where the
             // deployed handler receives base-prefixed requests).
-            const response = await handler.handleRequest(webRequestFromNode(req, joinBase(base, req.url || '/')), {
+            const response = await handler.handleRequest(webRequestFromNode(req, joinBase(base, req.url || '/'), res), {
               devHead,
               pageRequest,
               // The raw Node request on the event, matching what a