@solidjs/web 2.0.0-beta.31 → 2.0.0-beta.32

package/server-functions/dist/server.cjs

@@ -1,13 +1,17 @@
 'use strict';
 
-var solidJs = require('solid-js');
 var seroval = require('seroval');
 var web = require('seroval-plugins/web');
+var solidJs = require('solid-js');
 
 const ENVELOPE = Symbol.for("solid.ResponseEnvelope");
 function isResponseEnvelope(value) {
   return !!(value && typeof value === "object" && value[ENVELOPE]);
 }
+const SAFE_ERROR = Symbol.for("solid.SafeError");
+function isSafeError(value) {
+  return !!(value && (typeof value === "object" || typeof value === "function") && value[SAFE_ERROR]);
+}
 const REVALIDATE_HEADER = "X-Revalidate";
 
 seroval.Feature.AggregateError | seroval.Feature.BigIntTypedArray;
@@ -57,11 +61,6 @@ function createJSONDeserializer(options) {
   };
 }
 
-const RequestContext = Symbol.for("solid.RequestContext");
-function getRequestEvent() {
-  return globalThis[RequestContext] ? globalThis[RequestContext].getStore() || solidJs.sharedConfig.context && solidJs.sharedConfig.context.event || console.warn("RequestEvent is missing. This is most likely due to accessing `getRequestEvent` non-managed async scope in a partially polyfilled environment. Try moving it above all `await` calls.") : undefined;
-}
-
 const codecConfig = {
   codec: undefined
 };
@@ -126,10 +125,6 @@ const FLASH_MATCHER = new RegExp(`(?:^|;\\s*)${FLASH_COOKIE}=([^;]+)`);
 function hasFlashCookie(cookieHeader) {
   return !!cookieHeader && FLASH_MATCHER.test(cookieHeader);
 }
-function matchFlashCookie(cookieHeader) {
-  const match = cookieHeader && cookieHeader.match(FLASH_MATCHER);
-  return match ? match[1] : undefined;
-}
 function clearFlashCookie() {
   return `${FLASH_COOKIE}=; Max-Age=0; Path=/`;
 }
@@ -237,13 +232,11 @@ async function extractBody(source, codecOptions) {
   return undefined;
 }
 function createChunk(data) {
-  const encodeData = new TextEncoder().encode(data);
+  const encoder = new TextEncoder();
+  const encodeData = encoder.encode(data);
   const bytes = encodeData.length;
-  const baseHex = bytes.toString(16);
-  const totalHex = "00000000".substring(0, 8 - baseHex.length) + baseHex;
-  const head = new TextEncoder().encode(`;0x${totalHex};`);
   const chunk = new Uint8Array(12 + bytes);
-  chunk.set(head);
+  chunk.set(encoder.encode(`;0x${bytes.toString(16).padStart(8, "0")};`));
   chunk.set(encodeData, 12);
   return chunk;
 }
@@ -275,8 +268,8 @@ class ChunkReader {
       }
       await this.readChunk();
     }
-    const head = new TextDecoder().decode(this.buffer.subarray(1, 11));
-    const bytes = Number.parseInt(head, 16);
+    const decoder = new TextDecoder();
+    const bytes = Number.parseInt(decoder.decode(this.buffer.subarray(1, 11)), 16);
     if (Number.isNaN(bytes)) {
       throw new Error("Malformed server function stream.");
     }
@@ -286,7 +279,7 @@ class ChunkReader {
       }
       await this.readChunk();
     }
-    const partial = new TextDecoder().decode(this.buffer.subarray(12, 12 + bytes));
+    const partial = decoder.decode(this.buffer.subarray(12, 12 + bytes));
     this.buffer = this.buffer.subarray(12 + bytes);
     return {
       done: false,
@@ -357,6 +350,114 @@ async function decodeResponsePayload(response, codecOptions) {
   };
 }
 
+function parseCookieHeader(header) {
+  const cookies = {};
+  if (!header) return cookies;
+  for (const part of header.split(";")) {
+    const eq = part.indexOf("=");
+    if (eq < 0) continue;
+    const name = decodeSafe(part.slice(0, eq).trim());
+    let value = part.slice(eq + 1).trim();
+    if (value.length > 1 && value[0] === '"' && value[value.length - 1] === '"') {
+      value = value.slice(1, -1);
+    }
+    cookies[name] = decodeSafe(value);
+  }
+  return cookies;
+}
+function decodeSafe(text) {
+  try {
+    return decodeURIComponent(text);
+  } catch {
+    return text;
+  }
+}
+function serializeCookie(name, value, options = {}) {
+  let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+  cookie += `; Path=${options.path === undefined ? "/" : options.path}`;
+  if (options.domain) cookie += `; Domain=${options.domain}`;
+  if (options.maxAge !== undefined) cookie += `; Max-Age=${Math.trunc(options.maxAge)}`;
+  if (options.expires) cookie += `; Expires=${options.expires.toUTCString()}`;
+  if (options.httpOnly) cookie += "; HttpOnly";
+  if (options.secure) cookie += "; Secure";
+  if (options.sameSite) {
+    const sameSite = options.sameSite.toLowerCase();
+    cookie += `; SameSite=${sameSite === "none" ? "None" : sameSite === "strict" ? "Strict" : "Lax"}`;
+  }
+  return cookie;
+}
+
+const RequestContext = Symbol.for("solid.RequestContext");
+function getRequestEvent() {
+  return globalThis[RequestContext] ? globalThis[RequestContext].getStore() || solidJs.sharedConfig.context && solidJs.sharedConfig.context.event || console.warn("RequestEvent is missing. This is most likely due to accessing `getRequestEvent` non-managed async scope in a partially polyfilled environment. Try moving it above all `await` calls.") : undefined;
+}
+function reportLostHeaderWrite(method, name) {
+  const message = `Response header write dropped: headers.${method}(${JSON.stringify(String(name))}) ` + "ran after the response head was sent. Write headers before the shell flushes " + "(or before the handler returns).";
+  console.error(message);
+}
+function commitResponseStub(stub, {
+  allowLateLocation = false
+} = {}) {
+  if (!stub || stub.committed) return stub;
+  stub.committed = true;
+  const headers = stub.headers;
+  if (!headers || typeof headers.set !== "function") return stub;
+  for (const method of ["set", "append", "delete"]) {
+    const original = headers[method].bind(headers);
+    headers[method] = function (name, ...rest) {
+      if (allowLateLocation && method === "set" && String(name).toLowerCase() === "location") {
+        return original(name, ...rest);
+      }
+      reportLostHeaderWrite(method, name);
+    };
+  }
+  return stub;
+}
+function copyInitHeaders(init) {
+  if (!init || !init.getSetCookie) return new Headers(init);
+  const headers = new Headers();
+  init.forEach((value, key) => {
+    if (key !== "set-cookie") headers.append(key, value);
+  });
+  for (const cookie of init.getSetCookie()) headers.append("Set-Cookie", cookie);
+  return headers;
+}
+const STUB_GAP_FILL_EXCLUDED = /*#__PURE__*/new Set([ERROR_HEADER, BODY_FORMAT_HEADER, SINGLE_FLIGHT_HEADER, REVALIDATE_HEADER, "Location"].map(header => header.toLowerCase()));
+function fillsStubGap(key, headers, response) {
+  if (key === "set-cookie" || STUB_GAP_FILL_EXCLUDED.has(key)) return false;
+  if (response.body === null && (key === "content-type" || key === "content-length")) return false;
+  return !headers.has(key);
+}
+function commitEventResponse(response, event = getRequestEvent()) {
+  const stub = event && event.response;
+  if (!stub || !stub.headers || stub.committed) return response;
+  const cookies = stub.headers.getSetCookie ? stub.headers.getSetCookie() : [];
+  commitResponseStub(stub);
+  let hasGaps = false;
+  stub.headers.forEach((value, key) => {
+    if (fillsStubGap(key, response.headers, response)) hasGaps = true;
+  });
+  if (!cookies.length && !hasGaps) return response;
+  try {
+    for (const cookie of cookies) response.headers.append("Set-Cookie", cookie);
+    stub.headers.forEach((value, key) => {
+      if (fillsStubGap(key, response.headers, response)) response.headers.set(key, value);
+    });
+    return response;
+  } catch {
+    const headers = copyInitHeaders(response.headers);
+    for (const cookie of cookies) headers.append("Set-Cookie", cookie);
+    stub.headers.forEach((value, key) => {
+      if (fillsStubGap(key, headers, response)) headers.set(key, value);
+    });
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  }
+}
+
 function encodeInputValue(value) {
   if (value instanceof FormData) return {
     $f: [...value.entries()].filter(([, v]) => typeof v === "string")
@@ -386,13 +487,16 @@ function encodeFlashCookie(url, result, input, thrown) {
     thrown: !!thrown,
     input: input.map(encodeInputValue)
   };
-  return `${FLASH_COOKIE}=${encodeURIComponent(JSON.stringify(payload))}; Secure; HttpOnly; Path=/`;
+  return serializeCookie(FLASH_COOKIE, JSON.stringify(payload), {
+    secure: true,
+    httpOnly: true
+  });
 }
 function decodeFlashCookie(cookieHeader) {
-  const match = matchFlashCookie(cookieHeader);
+  const match = parseCookieHeader(cookieHeader)[FLASH_COOKIE];
   if (!match) return;
   try {
-    const payload = JSON.parse(decodeURIComponent(match));
+    const payload = JSON.parse(match);
     if (!payload || !payload.result) return;
     const result = payload.error ? new Error(payload.result) : payload.result;
     return {
@@ -408,6 +512,7 @@ function decodeFlashCookie(cookieHeader) {
 
 const config = {
   provideEvent: undefined,
+  wrapInvocation: undefined,
   collectFlightData: undefined,
   transformResult: undefined,
   transformFlightResult: undefined,
@@ -417,6 +522,7 @@ const config = {
 };
 function configureServerFunctionsServer({
   provideEvent,
+  wrapInvocation,
   collectFlightData,
   transformResult,
   transformFlightResult,
@@ -426,6 +532,7 @@ function configureServerFunctionsServer({
   codec
 } = {}) {
   if (provideEvent !== undefined) config.provideEvent = provideEvent;
+  if (wrapInvocation !== undefined) config.wrapInvocation = wrapInvocation;
   if (collectFlightData !== undefined) config.collectFlightData = collectFlightData;
   if (transformResult !== undefined) config.transformResult = transformResult;
   if (transformFlightResult !== undefined) config.transformFlightResult = transformFlightResult;
@@ -491,7 +598,13 @@ function createServerReference({
       });
       evt.serverOnly = true;
       const result = provideEvent(evt, () => {
-        return fn.apply(thisArg, args);
+        const run = () => fn.apply(thisArg, args);
+        return config.wrapInvocation ? config.wrapInvocation(run, {
+          id,
+          args,
+          event: evt,
+          direct: true
+        }) : run();
       });
       const transform = config.transformDirectResult;
       if (transform && result && typeof result.then === "function") {
@@ -633,6 +746,16 @@ function foldSetCookies(headers, setCookies) {
   if (serialized) folded.set("cookie", serialized);
   return folded;
 }
+function mergeResponseHeaders(target, source) {
+  source.forEach((value, key) => {
+    if (key !== "set-cookie") target.append(key, value);
+  });
+  if (source.getSetCookie) {
+    for (const cookie of source.getSetCookie()) target.append("Set-Cookie", cookie);
+  } else if (source.has("set-cookie")) {
+    target.append("Set-Cookie", source.get("set-cookie"));
+  }
+}
 const validRedirectStatuses = new Set([301, 302, 303, 307, 308]);
 function createNoJSHandler({
   base = ""
@@ -647,7 +770,8 @@ function createNoJSHandler({
     let status = 303;
     let headers;
     if (result instanceof Response) {
-      headers = new Headers(result.headers);
+      headers = new Headers();
+      mergeResponseHeaders(headers, result.headers);
       if (result.headers.has("Location")) {
         headers.set("Location", new URL(result.headers.get("Location"), url.origin + base).toString());
         if (validRedirectStatuses.has(result.status)) status = result.status;
@@ -700,13 +824,23 @@ function encodeResult(value, headers, status, codec) {
     headers
   });
 }
+const GENERIC_SERVER_ERROR_MESSAGE = "Internal Server Error";
+let DEV = false === true;
+function setServerFunctionsDev(dev) {
+  DEV = !!dev;
+}
+function sanitizeServerError(value) {
+  if (DEV) return value;
+  if (isSafeError(value)) return value;
+  return new Error(GENERIC_SERVER_ERROR_MESSAGE);
+}
 async function handleServerFunctionRequest(request, options = {}) {
   const codec = options.codec !== undefined ? options.codec : getServerFunctionsCodec();
   const url = new URL(request.url);
   const instance = request.headers.get(INSTANCE_HEADER);
   const functionId = resolveFunctionId(request, url);
   if (!functionId) {
-    return new Response(process.env.NODE_ENV === "development" ? "Server function not found" : null, {
+    return new Response(DEV ? "Server function not found" : null, {
       status: 404
     });
   }
@@ -714,12 +848,12 @@ async function handleServerFunctionRequest(request, options = {}) {
   try {
     serverFunction = getServerFunction(functionId);
   } catch {
-    return new Response(process.env.NODE_ENV === "development" ? `Unknown server function: ${functionId}` : null, {
+    return new Response(DEV ? `Unknown server function: ${functionId}` : null, {
       status: 404
     });
   }
   if (request.method === "GET" && METHODS.get(functionId) !== "GET") {
-    return new Response(process.env.NODE_ENV === "development" ? `Method not allowed for server function: ${functionId}` : null, {
+    return new Response(DEV ? `Method not allowed for server function: ${functionId}` : null, {
       status: 405,
       headers: {
         Allow: "POST"
@@ -733,6 +867,7 @@ async function handleServerFunctionRequest(request, options = {}) {
   const provide = options.provideEvent || provideEvent;
   const flightHook = options.collectFlightData !== undefined ? options.collectFlightData : config.collectFlightData;
   const transformResult = options.transformResult !== undefined ? options.transformResult : config.transformResult;
+  const wrapInvocation = options.wrapInvocation !== undefined ? options.wrapInvocation : config.wrapInvocation;
   const transformFlightResult = options.transformFlightResult !== undefined ? options.transformFlightResult : config.transformFlightResult;
   const handleNoJS = options.handleNoJS !== undefined ? options.handleNoJS : config.handleNoJS !== undefined ? config.handleNoJS : isFormPost(request) ? defaultNoJSHandler || (defaultNoJSHandler = createNoJSHandler()) : undefined;
   const collectsFlight = !!(flightHook && instance && request.headers.has(SINGLE_FLIGHT_HEADER));
@@ -747,136 +882,148 @@ async function handleServerFunctionRequest(request, options = {}) {
     transformFlightResult
   };
   const headers = new Headers();
-  try {
-    let result = await provide(event, async () => {
-      INVOCATIONS.set(event, {
-        id: functionId
+  const dispatch = async () => {
+    try {
+      let result = await provide(event, async () => {
+        INVOCATIONS.set(event, {
+          id: functionId
+        });
+        const run = () => serverFunction(...parsed);
+        return wrapInvocation ? wrapInvocation(run, {
+          id: functionId,
+          args: parsed,
+          event,
+          request,
+          direct: false
+        }) : run();
       });
-      return serverFunction(...parsed);
-    });
-    if (transformResult) {
-      result = await transformResult(event, result, flightContext);
-    }
-    let status = 200;
-    let metadata;
-    if (isResponseEnvelope(result)) {
-      const {
-        response,
-        value
-      } = result;
-      if (!instance && !handleNoJS && response && response.body) {
-        return response;
-      }
-      if (response && response.headers) {
-        response.headers.forEach((val, key) => headers.append(key, val));
-      }
-      if (response && response.status && (response.status < 300 || response.status >= 400)) {
-        status = response.status;
-      }
-      metadata = response;
-      result = value;
-    } else if (result instanceof Response) {
-      if (result.headers && result.headers.has("X-Content-Raw")) return result;
-      if (instance) {
-        if (result.headers) {
-          result.headers.forEach((value, key) => headers.append(key, value));
-        }
-        if (result.status && (result.status < 300 || result.status >= 400)) {
-          status = result.status;
-        }
-        metadata = result;
-        if (result.body == null) {
-          result = null;
-        }
-      }
-    }
-    if (collectsFlight) {
-      result = await foldFlightData(flightHook, event, headers, {
-        id: functionId,
-        value: result,
-        response: metadata,
-        request,
-        thrown: false
-      }, flightContext);
-      if (result instanceof Response && result.headers.has("X-Content-Raw")) return result;
-    }
-    if (!instance) {
-      if (handleNoJS) return handleNoJS(result, request, parsed);
-      if (result instanceof Response) return result;
-      return encodeResult(result, headers, 200, codec);
-    }
-    return encodeResult(result, headers, status, codec);
-  } catch (x) {
-    if (x instanceof Response || isResponseEnvelope(x)) {
       if (transformResult) {
-        x = await transformResult(event, x, {
-          ...flightContext,
-          thrown: true
-        });
+        result = await transformResult(event, result, flightContext);
       }
       let status = 200;
       let metadata;
-      if (isResponseEnvelope(x)) {
+      if (isResponseEnvelope(result)) {
         const {
           response,
           value
-        } = x;
+        } = result;
+        if (!instance && !handleNoJS && response && response.body) {
+          return response;
+        }
         if (response && response.headers) {
-          response.headers.forEach((val, key) => headers.append(key, val));
+          mergeResponseHeaders(headers, response.headers);
         }
-        if (response && response.status && (!instance || response.status < 300 || response.status >= 400)) {
+        if (response && response.status && (response.status < 300 || response.status >= 400)) {
           status = response.status;
         }
         metadata = response;
-        x = value;
-      } else if (x instanceof Response) {
-        if (x.headers) {
-          x.headers.forEach((value, key) => headers.append(key, value));
-        }
-        if (x.status && (!instance || x.status < 300 || x.status >= 400)) {
-          status = x.status;
-        }
-        metadata = x;
-        if (x.body == null) {
-          x = null;
+        result = value;
+      } else if (result instanceof Response) {
+        if (result.headers && result.headers.has("X-Content-Raw")) return result;
+        if (instance) {
+          if (result.headers) {
+            mergeResponseHeaders(headers, result.headers);
+          }
+          if (result.status && (result.status < 300 || result.status >= 400)) {
+            status = result.status;
+          }
+          metadata = result;
+          if (result.body == null) {
+            result = null;
+          }
         }
       }
       if (collectsFlight) {
-        x = await foldFlightData(flightHook, event, headers, {
+        result = await foldFlightData(flightHook, event, headers, {
           id: functionId,
-          value: x,
+          value: result,
           response: metadata,
           request,
-          thrown: true
+          thrown: false
         }, flightContext);
-        if (x instanceof Response && x.headers.has("X-Content-Raw")) {
-          x.headers.set(ERROR_HEADER, "true");
-          return x;
+        if (result instanceof Response && result.headers.has("X-Content-Raw")) return result;
+      }
+      if (!instance) {
+        if (handleNoJS) return handleNoJS(result, request, parsed);
+        if (result instanceof Response) return result;
+        return encodeResult(result, headers, 200, codec);
+      }
+      return encodeResult(result, headers, status, codec);
+    } catch (x) {
+      if (x instanceof Response || isResponseEnvelope(x)) {
+        if (transformResult) {
+          x = await transformResult(event, x, {
+            ...flightContext,
+            thrown: true
+          });
+        }
+        let status = 200;
+        let metadata;
+        if (isResponseEnvelope(x)) {
+          const {
+            response,
+            value
+          } = x;
+          if (response && response.headers) {
+            mergeResponseHeaders(headers, response.headers);
+          }
+          if (response && response.status && (!instance || response.status < 300 || response.status >= 400)) {
+            status = response.status;
+          }
+          metadata = response;
+          x = value;
+        } else if (x instanceof Response) {
+          if (x.headers) {
+            mergeResponseHeaders(headers, x.headers);
+          }
+          if (x.status && (!instance || x.status < 300 || x.status >= 400)) {
+            status = x.status;
+          }
+          metadata = x;
+          if (x.body == null) {
+            x = null;
+          }
+        }
+        if (collectsFlight) {
+          x = await foldFlightData(flightHook, event, headers, {
+            id: functionId,
+            value: x,
+            response: metadata,
+            request,
+            thrown: true
+          }, flightContext);
+          if (x instanceof Response && x.headers.has("X-Content-Raw")) {
+            x.headers.set(ERROR_HEADER, "true");
+            return x;
+          }
+        }
+        headers.set(ERROR_HEADER, "true");
+        if (!instance) {
+          if (handleNoJS) return handleNoJS(x ?? metadata, request, parsed, true);
+          if (x instanceof Response) return x;
         }
+        return encodeResult(x, headers, status, codec);
       }
-      headers.set(ERROR_HEADER, "true");
+      const safe = sanitizeServerError(x);
       if (!instance) {
-        if (handleNoJS) return handleNoJS(x ?? metadata, request, parsed, true);
-        if (x instanceof Response) return x;
+        if (handleNoJS) return handleNoJS(safe, request, parsed, true);
+        const message = safe instanceof Error ? safe.message : String(safe);
+        return new Response(DEV ? message : null, {
+          status: 500
+        });
       }
-      return encodeResult(x, headers, status, codec);
-    }
-    if (!instance) {
-      if (handleNoJS) return handleNoJS(x, request, parsed, true);
-      const message = x instanceof Error ? x.message : String(x);
-      return new Response(process.env.NODE_ENV === "development" ? message : null, {
-        status: 500
-      });
+      const error = safe instanceof Error ? safe.message : typeof safe === "string" ? safe : "true";
+      headers.set(ERROR_HEADER, encodeErrorHeaderValue(error));
+      return encodeResult(safe, headers, 200, codec);
     }
-    const error = x instanceof Error ? x.message : typeof x === "string" ? x : "true";
-    headers.set(ERROR_HEADER, encodeErrorHeaderValue(error));
-    return encodeResult(x, headers, 200, codec);
-  }
+  };
+  return commitEventResponse(await dispatch(), event);
 }
 
 exports.ERROR_HEADER = ERROR_HEADER;
 exports.FLASH_COOKIE = FLASH_COOKIE;
 exports.FUNCTION_HEADER = FUNCTION_HEADER;
+exports.GENERIC_SERVER_ERROR_MESSAGE = GENERIC_SERVER_ERROR_MESSAGE;
 exports.GET = GET;
 exports.INSTANCE_HEADER = INSTANCE_HEADER;
 exports.SINGLE_FLIGHT_HEADER = SINGLE_FLIGHT_HEADER;
@@ -900,5 +1047,7 @@ exports.hasFlashCookie = hasFlashCookie;
 exports.isServerFunction = isServerFunction;
 exports.registerServerFunction = registerServerFunction;
 exports.registerServerReference = registerServerReference;
+exports.sanitizeServerError = sanitizeServerError;
+exports.setServerFunctionsDev = setServerFunctionsDev;
 exports.subscribeFlightData = subscribeFlightData;
 exports.withMeta = withMeta;