@solidjs/web 2.0.0-rc.5 → 2.0.0-rc.6

package/frames/dist/server.js

@@ -99,6 +99,8 @@ const ContainerTracePlugin = {
   }
 };
 
+const COMPOSED_BODY_FRAMING = /*#__PURE__*/new Set(["content-length", "content-encoding", "transfer-encoding"]);
+
 setContainerTraceStreamMint(iterable => {
   const stream = createStream();
   (async () => {
@@ -2789,8 +2791,55 @@ function resolveSSRSync(node) {
   if (!res.h.length) return res.t[0];
   throw new Error("This value cannot be rendered synchronously. Are you missing a boundary?");
 }
-/*#__PURE__*/new Set([ERROR_HEADER, BODY_FORMAT_HEADER, SINGLE_FLIGHT_HEADER, REVALIDATE_HEADER, REDIRECT_HEADER, "Location"].map(header => header.toLowerCase()));
+/*#__PURE__*/new Set([ERROR_HEADER, BODY_FORMAT_HEADER, SINGLE_FLIGHT_HEADER, REVALIDATE_HEADER, REDIRECT_HEADER, "Location",
+...COMPOSED_BODY_FRAMING].map(header => header.toLowerCase()));
 
+function scopeDeferredResult(value, scope) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") return value;
+  const promised = scope(() => nativePromise(value));
+  if (promised) {
+    return promised.then(result => scope(() => scopeDeferredResult(result, scope)));
+  }
+  if (typeof ReadableStream !== "undefined" && value instanceof ReadableStream) {
+    let reader;
+    return new ReadableStream({
+      async pull(controller) {
+        try {
+          const step = await scope(() => {
+            if (!reader) reader = value.getReader();
+            return reader.read();
+          });
+          if (step.done) controller.close();else controller.enqueue(step.value);
+        } catch (error) {
+          controller.error(error);
+        }
+      },
+      cancel(reason) {
+        return scope(() => reader ? reader.cancel(reason) : value.cancel(reason));
+      }
+    }, {
+      highWaterMark: 0
+    });
+  }
+  const scopedIterator = symbol => ({
+    [symbol]() {
+      const iterator = scope(() => value[symbol]());
+      return new Proxy(iterator, {
+        get(target, property) {
+          const member = Reflect.get(target, property, target);
+          return typeof member === "function" && (property === "next" || property === "return" || property === "throw") ? (...args) => scope(() => member.apply(target, args)) : member;
+        }
+      });
+    }
+  });
+  if (typeof value[Symbol.asyncIterator] === "function") {
+    return scopedIterator(Symbol.asyncIterator);
+  }
+  if (typeof value[Symbol.iterator] === "function" && !Array.isArray(value) && !(value instanceof Map) && !(value instanceof Set) && !ArrayBuffer.isView(value)) {
+    return scopedIterator(Symbol.iterator);
+  }
+  return value;
+}
 const INVOCATIONS = new WeakMap();
 function getEventServerFunctionInvocation(event) {
   return event && INVOCATIONS.get(event);
@@ -2855,14 +2904,11 @@ function guardFailures(value, state) {
         top.next.add(guarded);
         if (guarded !== original) top.changed = true;
       } else if (guarded !== original || top.accessorRead === i) {
-        Object.defineProperty(top.next, items[i], top.accessorRead === i ? {
-          enumerable: true,
-          configurable: true,
+        Object.defineProperty(top.next, items[i], {
+          value: guarded,
           writable: true,
-          value: guarded
-        } : {
-          ...top.descriptors[items[i]],
-          value: guarded
+          configurable: true,
+          enumerable: top.descriptors[items[i]].enumerable
         });
         top.changed = true;
       }
@@ -2897,6 +2943,9 @@ class Frame {
     this.pendingKey = undefined;
   }
 }
+function guardOperation(state, run) {
+  return state.scope ? state.scope(run) : run();
+}
 function enterGuard(value, state) {
   if (value === null || typeof value !== "object") return value;
   if (state.seen.has(value)) {
@@ -2911,7 +2960,7 @@ function enterGuard(value, state) {
       if (finished) return;
       finished = true;
       try {
-        const cancelled = reader ? reader.cancel() : value.cancel();
+        const cancelled = guardOperation(state, () => reader ? reader.cancel() : value.cancel());
         if (cancelled && typeof cancelled.then === "function") cancelled.then(undefined, () => {});
       } catch {}
     };
@@ -2923,19 +2972,19 @@ function enterGuard(value, state) {
             controller.close();
             return;
           }
-          if (!reader) reader = value.getReader();
+          if (!reader) reader = guardOperation(state, () => value.getReader());
           const {
             done,
             value: chunk
-          } = await reader.read();
-          done ? controller.close() : controller.enqueue(guardFailures(chunk, state));
+          } = await guardOperation(state, () => reader.read());
+          done ? controller.close() : controller.enqueue(guardOperation(state, () => guardFailures(chunk, state)));
         } catch (error) {
-          controller.error(sanitizeServerError(error));
+          controller.error(guardOperation(state, () => sanitizeServerError(error)));
         }
       },
       cancel(reason) {
         finished = true;
-        return reader ? reader.cancel(reason) : value.cancel(reason);
+        return guardOperation(state, () => reader ? reader.cancel(reason) : value.cancel(reason));
       }
     });
     if (gate) gate.onOpen(close);
@@ -2943,9 +2992,10 @@ function enterGuard(value, state) {
     return guardedStream;
   }
   if (typeof value.then === "function") {
-    const guardedPromise = Promise.resolve(value).then(resolved => guardFailures(resolved, state), error => {
-      throw sanitizeServerError(error);
+    const guardedPromise = Promise.resolve(value).then(resolved => guardOperation(state, () => guardFailures(resolved, state)), error => {
+      throw guardOperation(state, () => sanitizeServerError(error));
     });
+    guardedPromise.catch(() => {});
     state.seen.set(value, guardedPromise);
     return guardedPromise;
   }
@@ -2954,13 +3004,13 @@ function enterGuard(value, state) {
     const gate = state.gate;
     const guardedIterable = {
       [Symbol.asyncIterator]() {
-        const iterator = source[Symbol.asyncIterator]();
+        const iterator = guardOperation(state, () => source[Symbol.asyncIterator]());
         let finished = false;
         const close = () => {
           if (finished) return;
           finished = true;
           try {
-            const returned = iterator.return && iterator.return();
+            const returned = iterator.return && guardOperation(state, () => iterator.return());
             if (returned && typeof returned.then === "function") returned.then(undefined, () => {});
           } catch {}
         };
@@ -2968,17 +3018,17 @@ function enterGuard(value, state) {
         const step = () => finished ? Promise.resolve({
           done: true,
           value: undefined
-        }) : iterator.next().then(step => {
+        }) : guardOperation(state, () => iterator.next()).then(step => {
           if (step.done) {
             finished = true;
             return step;
           }
           return {
             done: false,
-            value: guardFailures(step.value, state)
+            value: guardOperation(state, () => guardFailures(step.value, state))
           };
         }, error => {
-          throw sanitizeServerError(error);
+          throw guardOperation(state, () => sanitizeServerError(error));
         });
         return {
           next: () => finished || !gate || gate.wantsMore() ? step() : gate.awaitDemand().then(step),
@@ -2995,6 +3045,11 @@ function enterGuard(value, state) {
     state.seen.set(value, guardedIterable);
     return guardedIterable;
   }
+  if (state.scope && typeof value[Symbol.iterator] === "function" && !Array.isArray(value) && !(value instanceof Map) && !(value instanceof Set) && !ArrayBuffer.isView(value)) {
+    const scopedIterable = scopeDeferredResult(value, state.scope);
+    state.seen.set(value, scopedIterable);
+    return scopedIterable;
+  }
   if (Array.isArray(value)) {
     const next = value.slice();
     state.seen.set(value, next);
@@ -3018,9 +3073,13 @@ function enterGuard(value, state) {
     return value;
   }
   const descriptors = Object.getOwnPropertyDescriptors(value);
+  for (const key of Object.keys(descriptors)) {
+    descriptors[key].configurable = true;
+    if ("value" in descriptors[key]) descriptors[key].writable = true;
+  }
   const next = Object.create(prototype, descriptors);
   state.seen.set(value, next);
-  return new Frame(OBJECT, value, next, Object.keys(descriptors), descriptors);
+  return new Frame(OBJECT, value, next, Object.keys(value), descriptors);
 }
 function keepGuarded(value, next, changed, state) {
   if (changed || state.cyclic.has(value)) return next;
@@ -3032,6 +3091,12 @@ function sanitizeServerError(value) {
   if (isSafeError(value)) return value;
   return new Error(GENERIC_SERVER_ERROR_MESSAGE);
 }
+function nativePromise(value) {
+  if (value instanceof Promise) return value;
+  try {
+    if (Object.prototype.toString.call(value) === "[object Promise]") return Promise.prototype.then.call(value, value => value);
+  } catch {}
+}
 
 const FRAME_STREAM_HEADER = "X-Frame-Stream";
 function isFrameStreamResponse(response) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@solidjs/web",
   "description": "Solid's web runtime: client rendering, hydration, SSR, and DOM-specific control flow (Portal, Dynamic).",
-  "version": "2.0.0-rc.5",
+  "version": "2.0.0-rc.6",
   "author": "Ryan Carniato",
   "license": "MIT",
   "homepage": "https://solidjs.com",
@@ -398,7 +398,7 @@
     "seroval-plugins": "~1.5.4"
   },
   "peerDependencies": {
-    "solid-js": "^2.0.0-rc.5"
+    "solid-js": "^2.0.0-rc.6"
   },
   "devDependencies": {
     "@codspeed/vitest-plugin": "^5.4.0",

package/server-functions/dist/client.cjs

@@ -635,10 +635,19 @@ async function createRequest(base, id, instance, options, meta) {
     headers
   };
   if (config.prepareRequest) {
-    init = (await config.prepareRequest(init, {
+    const prepared = await config.prepareRequest(init, {
       id,
       meta
-    })) || init;
+    });
+    if (prepared && prepared !== init) {
+      if (typeof prepared !== "object") {
+        throw new Error("prepareRequest must return (or mutate and return) the RequestInit it received; " + `it returned a ${typeof prepared}. Spread the init: ` + "init => ({ ...init, headers: { ...init.headers, ... } })");
+      }
+      if (!new Headers(prepared.headers).has(INSTANCE_HEADER)) {
+        throw new Error("prepareRequest returned an init without the transport headers " + `(${INSTANCE_HEADER}), which would send the call without its payload or ` + "protocol. Spread the init it received: " + "init => ({ ...init, headers: { ...init.headers, ... } })");
+      }
+    }
+    init = prepared || init;
   }
   const send = config.fetch || fetch;
   if (CALL_OBSERVERS.size === 0) return send(base, init);
@@ -755,6 +764,9 @@ async function fetchServerFunction(base, id, options, args, meta, callArgs = arg
   if (response.headers.has(REDIRECT_HEADER) || response.headers.has(REVALIDATE_HEADER) || response.headers.has(SINGLE_FLIGHT_HEADER) || response.status >= 300 && response.status < 400 && response.status !== 304) {
     return response;
   }
+  if (response.status < 300 && !response.headers.has(BODY_FORMAT_HEADER) && !response.headers.has("X-Content-Raw")) {
+    throw serverFunctionFailure(response, new Error(`Server function response carries no recognized encoding (status ${response.status}` + `${response.headers.get("Content-Type") ? `, content-type ${response.headers.get("Content-Type")}` : ""}): answered by something other than the server function runtime`));
+  }
   const result = await decodeResponse(response.clone());
   if (failed) {
     throw serverFunctionFailure(response, result);

package/server-functions/dist/client.js

@@ -633,10 +633,19 @@ async function createRequest(base, id, instance, options, meta) {
     headers
   };
   if (config.prepareRequest) {
-    init = (await config.prepareRequest(init, {
+    const prepared = await config.prepareRequest(init, {
       id,
       meta
-    })) || init;
+    });
+    if (prepared && prepared !== init) {
+      if (typeof prepared !== "object") {
+        throw new Error("prepareRequest must return (or mutate and return) the RequestInit it received; " + `it returned a ${typeof prepared}. Spread the init: ` + "init => ({ ...init, headers: { ...init.headers, ... } })");
+      }
+      if (!new Headers(prepared.headers).has(INSTANCE_HEADER)) {
+        throw new Error("prepareRequest returned an init without the transport headers " + `(${INSTANCE_HEADER}), which would send the call without its payload or ` + "protocol. Spread the init it received: " + "init => ({ ...init, headers: { ...init.headers, ... } })");
+      }
+    }
+    init = prepared || init;
   }
   const send = config.fetch || fetch;
   if (CALL_OBSERVERS.size === 0) return send(base, init);
@@ -753,6 +762,9 @@ async function fetchServerFunction(base, id, options, args, meta, callArgs = arg
   if (response.headers.has(REDIRECT_HEADER) || response.headers.has(REVALIDATE_HEADER) || response.headers.has(SINGLE_FLIGHT_HEADER) || response.status >= 300 && response.status < 400 && response.status !== 304) {
     return response;
   }
+  if (response.status < 300 && !response.headers.has(BODY_FORMAT_HEADER) && !response.headers.has("X-Content-Raw")) {
+    throw serverFunctionFailure(response, new Error(`Server function response carries no recognized encoding (status ${response.status}` + `${response.headers.get("Content-Type") ? `, content-type ${response.headers.get("Content-Type")}` : ""}): answered by something other than the server function runtime`));
+  }
   const result = await decodeResponse(response.clone());
   if (failed) {
     throw serverFunctionFailure(response, result);