@sveltejs/kit 3.0.0-next.2 → 3.0.0-next.21

package/src/runtime/server/page/data_serializer.js

@@ -1,22 +1,19 @@
 import * as devalue from 'devalue';
 import { compact } from '../../../utils/array.js';
 import { create_async_iterator } from '../../../utils/streaming.js';
-import {
-	clarify_devalue_error,
-	get_global_name,
-	handle_error_and_jsonify,
-	serialize_uses
-} from '../utils.js';
+import { clarify_devalue_error, get_global_name, serialize_uses } from '../utils.js';
+import { handle_error_and_jsonify } from '../errors.js';
+import { encoders } from '#app/internal/transport';
 
 /**
  * If the serialized data contains promises, `chunks` will be an
  * async iterable containing their resolutions
- * @param {import('@sveltejs/kit').RequestEvent} event
- * @param {import('types').RequestState} event_state
+ * @param {import('$app/server').RequestEvent} event
+ * @param {import('types').RequestState} state
  * @param {import('types').SSROptions} options
  * @returns {import('./types.js').ServerDataSerializer}
  */
-export function server_data_serializer(event, event_state, options) {
+export function server_data_serializer(event, state, options) {
 	let promise_id = 1;
 	let max_nodes = -1;
 
@@ -34,7 +31,7 @@ export function server_data_serializer(event, event_state, options) {
 					.then(/** @param {any} data */ (data) => ({ data }))
 					.catch(
 						/** @param {any} error */ async (error) => ({
-							error: await handle_error_and_jsonify(event, event_state, options, error)
+							error: await handle_error_and_jsonify(event, state, options, error)
 						})
 					)
 					.then(
@@ -45,12 +42,14 @@ export function server_data_serializer(event, event_state, options) {
 							let str;
 							try {
 								str = devalue.uneval(error ? [, error] : [data], replacer);
-							} catch {
+							} catch (e) {
 								error = await handle_error_and_jsonify(
 									event,
-									event_state,
+									state,
 									options,
-									new Error(`Failed to serialize promise while rendering ${event.route.id}`)
+									new Error(`Failed to serialize promise while rendering ${event.route.id}`, {
+										cause: e
+									})
 								);
 								str = devalue.uneval([, error], replacer);
 							}
@@ -66,8 +65,8 @@ export function server_data_serializer(event, event_state, options) {
 
 				return `${global}.defer(${id})`;
 			} else {
-				for (const key in options.hooks.transport) {
-					const encoded = options.hooks.transport[key].encode(thing);
+				for (const key in encoders) {
+					const encoded = encoders[key](thing);
 					if (encoded) {
 						return `app.decode('${key}', ${devalue.uneval(encoded, replacer)})`;
 					}
@@ -126,20 +125,18 @@ export function server_data_serializer(event, event_state, options) {
 /**
  * If the serialized data contains promises, `chunks` will be an
  * async iterable containing their resolutions
- * @param {import('@sveltejs/kit').RequestEvent} event
- * @param {import('types').RequestState} event_state
+ * @param {import('$app/server').RequestEvent} event
+ * @param {import('types').RequestState} state
  * @param {import('types').SSROptions} options
  * @returns {import('./types.js').ServerDataSerializerJson}
  */
-export function server_data_serializer_json(event, event_state, options) {
+export function server_data_serializer_json(event, state, options) {
 	let promise_id = 1;
 
 	const iterator = create_async_iterator();
 
 	const reducers = {
-		...Object.fromEntries(
-			Object.entries(options.hooks.transport).map(([key, value]) => [key, value.encode])
-		),
+		...encoders,
 		/** @param {any} thing */
 		Promise: (thing) => {
 			if (typeof thing?.then !== 'function') {
@@ -155,7 +152,7 @@ export function server_data_serializer_json(event, event_state, options) {
 				.catch(
 					/** @param {any} e */ async (e) => {
 						key = 'error';
-						return handle_error_and_jsonify(event, event_state, options, /** @type {any} */ (e));
+						return handle_error_and_jsonify(event, state, options, /** @type {any} */ (e));
 					}
 				)
 				.then(
@@ -164,12 +161,14 @@ export function server_data_serializer_json(event, event_state, options) {
 						let str;
 						try {
 							str = devalue.stringify(value, reducers);
-						} catch {
+						} catch (e) {
 							const error = await handle_error_and_jsonify(
 								event,
-								event_state,
+								state,
 								options,
-								new Error(`Failed to serialize promise while rendering ${event.route.id}`)
+								new Error(`Failed to serialize promise while rendering ${event.route.id}`, {
+									cause: e
+								})
 							);
 
 							key = 'error';

package/src/runtime/server/page/index.js

@@ -1,12 +1,16 @@
-/** @import { ActionResult, RequestEvent, SSRManifest } from '@sveltejs/kit' */
-/** @import { PageNodeIndexes, RequestState, RequiredResolveOptions, ServerDataNode, SSRComponent, SSRNode, SSROptions, SSRState } from 'types' */
+/** @import { Component } from 'svelte' */
+/** @import { SSRManifest } from '@sveltejs/kit' */
+/** @import { RequestEvent } from '$app/server' */
+/** @import { ActionResult } from '$app/forms' */
+/** @import { PageNodeIndexes, RequestState, RequiredResolveOptions, ServerDataNode, SSRNode, SSROptions } from 'types' */
 import { text } from '@sveltejs/kit';
-import { HttpError, Redirect } from '@sveltejs/kit/internal';
+import { Redirect } from '@sveltejs/kit/internal';
 import { compact } from '../../../utils/array.js';
 import { get_status, normalize_error } from '../../../utils/error.js';
 import { noop } from '../../../utils/functions.js';
 import { add_data_suffix } from '../../pathname.js';
-import { redirect_response, static_error_page, handle_error_and_jsonify } from '../utils.js';
+import { redirect_response } from '../utils.js';
+import { static_error_page, handle_error_and_jsonify } from '../errors.js';
 import {
 	handle_action_json_request,
 	handle_action_request,
@@ -18,7 +22,7 @@ import { load_data, load_server_data } from './load_data.js';
 import { render_response } from './render.js';
 import { respond_with_error } from './respond_with_error.js';
 import { DEV } from 'esm-env';
-import { get_remote_action, handle_remote_form_post } from '../remote.js';
+import { get_remote_action, handle_remote_form_post } from '../remote-functions.js';
 import { PageNodes } from '../../../utils/page_nodes.js';
 
 /**
@@ -28,25 +32,15 @@ const MAX_DEPTH = 10;
 
 /**
  * @param {RequestEvent} event
- * @param {RequestState} event_state
+ * @param {RequestState} state
  * @param {PageNodeIndexes} page
  * @param {SSROptions} options
  * @param {SSRManifest} manifest
- * @param {SSRState} state
  * @param {import('../../../utils/page_nodes.js').PageNodes} nodes
  * @param {RequiredResolveOptions} resolve_opts
  * @returns {Promise<Response>}
  */
-export async function render_page(
-	event,
-	event_state,
-	page,
-	options,
-	manifest,
-	state,
-	nodes,
-	resolve_opts
-) {
+export async function render_page(event, state, page, options, manifest, nodes, resolve_opts) {
 	if (state.depth > MAX_DEPTH) {
 		// infinite request cycle detected
 		return text(`Not found: ${event.url.pathname}`, {
@@ -56,7 +50,7 @@ export async function render_page(
 
 	if (is_action_json_request(event)) {
 		const node = await manifest._.nodes[page.leaf]();
-		return handle_action_json_request(event, event_state, options, node?.server);
+		return handle_action_json_request(event, state, options, node?.server);
 	}
 
 	try {
@@ -70,11 +64,11 @@ export async function render_page(
 		if (is_action_request(event)) {
 			const remote_id = get_remote_action(event.url);
 			if (remote_id) {
-				action_result = await handle_remote_form_post(event, event_state, manifest, remote_id);
+				action_result = await handle_remote_form_post(event, state, manifest, remote_id);
 			} else {
 				// for action requests, first call handler in +page.server.js
 				// (this also determines status code)
-				action_result = await handle_action_request(event, event_state, leaf_node.server);
+				action_result = await handle_action_request(event, state, leaf_node.server);
 			}
 
 			if (action_result?.type === 'redirect') {
@@ -120,7 +114,10 @@ export async function render_page(
 		// renders an empty 'shell' page if SSR is turned off and if there is
 		// no server data to prerender. As a result, the load functions and rendering
 		// only occur client-side.
-		if (ssr === false && !(state.prerendering && should_prerender_data)) {
+		if (
+			ssr === false &&
+			!((state.prerendering || state.prerender_default === true) && should_prerender_data)
+		) {
 			// if the user makes a request through a non-enhanced form, the returned value is lost
 			// because there is no SSR or client-side handling of the response
 			if (DEV && action_result && !event.request.headers.has('x-sveltekit-action')) {
@@ -154,12 +151,11 @@ export async function render_page(
 				status,
 				error: null,
 				event,
-				event_state,
+				state,
 				options,
 				manifest,
-				state,
 				resolve_opts,
-				data_serializer: server_data_serializer(event, event_state, options)
+				data_serializer: server_data_serializer(event, state, options)
 			});
 		}
 
@@ -169,10 +165,10 @@ export async function render_page(
 		/** @type {Error | null} */
 		let load_error = null;
 
-		const data_serializer = server_data_serializer(event, event_state, options);
+		const data_serializer = server_data_serializer(event, state, options);
 		const data_serializer_json =
-			state.prerendering && should_prerender_data
-				? server_data_serializer_json(event, event_state, options)
+			(state.prerendering || state.prerender_default === true) && should_prerender_data
+				? server_data_serializer_json(event, state, options)
 				: null;
 
 		/** @type {Array<Promise<ServerDataNode | null>>} */
@@ -192,7 +188,6 @@ export async function render_page(
 
 					const server_data = await load_server_data({
 						event,
-						event_state,
 						state,
 						node,
 						parent: async () => {
@@ -227,7 +222,7 @@ export async function render_page(
 				try {
 					return await load_data({
 						event,
-						event_state,
+						state,
 						fetched,
 						node,
 						parent: async () => {
@@ -239,7 +234,6 @@ export async function render_page(
 						},
 						resolve_opts,
 						server_data_promise: server_promises[i],
-						state,
 						csr
 					});
 				} catch (e) {
@@ -269,6 +263,7 @@ export async function render_page(
 						if (state.prerendering && should_prerender_data) {
 							const body = JSON.stringify({
 								type: 'redirect',
+								status: err.status,
 								location: err.location
 							});
 
@@ -281,8 +276,8 @@ export async function render_page(
 						return redirect_response(err.status, err.location);
 					}
 
-					const status = get_status(err);
-					const error = await handle_error_and_jsonify(event, event_state, options, err);
+					const error = await handle_error_and_jsonify(event, state, options, err);
+					const status = error.status;
 
 					while (i--) {
 						if (page.errors[i]) {
@@ -304,10 +299,9 @@ export async function render_page(
 
 							return await render_response({
 								event,
-								event_state,
+								state,
 								options,
 								manifest,
-								state,
 								resolve_opts,
 								page_config: {
 									ssr: nodes.ssr(),
@@ -315,13 +309,7 @@ export async function render_page(
 								},
 								status,
 								error,
-								error_components: await load_error_components(
-									options,
-									ssr,
-									error_branch,
-									page,
-									manifest
-								),
+								error_components: await load_error_components(ssr, error_branch, page, manifest),
 								branch: error_branch,
 								fetched,
 								data_serializer
@@ -358,10 +346,9 @@ export async function render_page(
 
 		return await render_response({
 			event,
-			event_state,
+			state,
 			options,
 			manifest,
-			state,
 			resolve_opts,
 			page_config: {
 				csr,
@@ -372,8 +359,8 @@ export async function render_page(
 			branch: compact(branch),
 			action_result,
 			fetched,
-			data_serializer: !ssr ? server_data_serializer(event, event_state, options) : data_serializer,
-			error_components: await load_error_components(options, ssr, branch, page, manifest)
+			data_serializer: !ssr ? server_data_serializer(event, state, options) : data_serializer,
+			error_components: await load_error_components(ssr, branch, page, manifest)
 		});
 	} catch (e) {
 		// a remote function could have thrown a redirect during render
@@ -385,11 +372,9 @@ export async function render_page(
 		// but the page failed to render, or that a prerendering error occurred
 		return await respond_with_error({
 			event,
-			event_state,
+			state,
 			options,
 			manifest,
-			state,
-			status: e instanceof HttpError ? e.status : 500,
 			error: e,
 			resolve_opts
 		});
@@ -397,18 +382,16 @@ export async function render_page(
 }
 
 /**
- *
- * @param {SSROptions} options
  * @param {boolean} ssr
  * @param {Array<import('./types.js').Loaded | null>} branch
  * @param {PageNodeIndexes} page
  * @param {SSRManifest} manifest
  */
-async function load_error_components(options, ssr, branch, page, manifest) {
-	/** @type {Array<SSRComponent | undefined> | undefined} */
+async function load_error_components(ssr, branch, page, manifest) {
+	/** @type {Array<Component | undefined> | undefined} */
 	let error_components;
 
-	if (options.server_error_boundaries && ssr) {
+	if (ssr) {
 		let last_idx = -1;
 		error_components = await Promise.all(
 			// eslint-disable-next-line @typescript-eslint/await-thenable

package/src/runtime/server/page/load_data.js

@@ -2,8 +2,7 @@ import { DEV } from 'esm-env';
 import { noop } from '../../../utils/functions.js';
 import { disable_search, make_trackable } from '../../../utils/url.js';
 import { validate_depends, validate_load_response } from '../../shared.js';
-import { with_request_store, merge_tracing } from '@sveltejs/kit/internal/server';
-import { record_span } from '../../telemetry/record_span.js';
+import { with_request_store, merge_tracing, record_span } from '@sveltejs/kit/internal/server';
 import { base64_encode } from '../../utils.js';
 import { NULL_BODY_STATUS } from '../constants.js';
 import { get_node_type } from '../utils.js';
@@ -11,15 +10,14 @@ import { get_node_type } from '../utils.js';
 /**
  * Calls the user's server `load` function.
  * @param {{
- *   event: import('@sveltejs/kit').RequestEvent;
- *   event_state: import('types').RequestState;
- *   state: import('types').SSRState;
+ *   event: import('$app/server').RequestEvent;
+ *   state: import('types').RequestState;
  *   node: import('types').SSRNode | undefined;
  *   parent: () => Promise<Record<string, any>>;
  * }} opts
  * @returns {Promise<import('types').ServerDataNode | null>}
  */
-export async function load_server_data({ event, event_state, state, node, parent }) {
+export async function load_server_data({ event, state, node, parent }) {
 	if (!node?.server) return null;
 
 	let is_tracking = true;
@@ -67,7 +65,7 @@ export async function load_server_data({ event, event_state, state, node, parent
 		}
 	);
 
-	if (state.prerendering) {
+	if (state.prerendering || state.prerender_default === true) {
 		disable_search(url);
 	}
 
@@ -83,7 +81,7 @@ export async function load_server_data({ event, event_state, state, node, parent
 		},
 		fn: async (current) => {
 			const traced_event = merge_tracing(event, current);
-			const result = await with_request_store({ event: traced_event, state: event_state }, () =>
+			const result = await with_request_store({ event: traced_event, state }, () =>
 				load.call(null, {
 					...traced_event,
 					fetch: (info, init) => {
@@ -193,26 +191,24 @@ export async function load_server_data({ event, event_state, state, node, parent
 /**
  * Calls the user's `load` function.
  * @param {{
- *   event: import('@sveltejs/kit').RequestEvent;
- *   event_state: import('types').RequestState;
+ *   event: import('$app/server').RequestEvent;
+ *   state: import('types').RequestState;
  *   fetched: import('./types.js').Fetched[];
  *   node: import('types').SSRNode | undefined;
  *   parent: () => Promise<Record<string, any>>;
  *   resolve_opts: import('types').RequiredResolveOptions;
  *   server_data_promise: Promise<import('types').ServerDataNode | null>;
- *   state: import('types').SSRState;
  *   csr: boolean;
  * }} opts
  * @returns {Promise<Record<string, any | Promise<any>> | null>}
  */
 export async function load_data({
 	event,
-	event_state,
+	state,
 	fetched,
 	node,
 	parent,
 	server_data_promise,
-	state,
 	resolve_opts,
 	csr
 }) {
@@ -234,15 +230,14 @@ export async function load_data({
 		},
 		fn: async (current) => {
 			const traced_event = merge_tracing(event, current);
-			const child_state = { ...event_state, is_in_universal_load: true };
 
-			return await with_request_store({ event: traced_event, state: child_state }, () =>
+			return await with_request_store({ event: traced_event, state }, () =>
 				load.call(null, {
 					url: event.url,
 					params: event.params,
 					data: server_data_node?.data ?? null,
 					route: event.route,
-					fetch: create_universal_fetch(event, state, fetched, csr, resolve_opts),
+					fetch: create_universal_fetch(event, state.prerendering, fetched, csr, resolve_opts),
 					setHeaders: event.setHeaders,
 					depends: noop,
 					parent,
@@ -261,14 +256,14 @@ export async function load_data({
 }
 
 /**
- * @param {Pick<import('@sveltejs/kit').RequestEvent, 'fetch' | 'url' | 'request' | 'route'>} event
- * @param {import('types').SSRState} state
+ * @param {Pick<import('$app/server').RequestEvent, 'fetch' | 'url' | 'request' | 'route'>} event
+ * @param {import('types').PrerenderOptions | undefined} prerendering
  * @param {import('./types.js').Fetched[]} fetched
  * @param {boolean} csr
- * @param {Pick<Required<import('@sveltejs/kit').ResolveOptions>, 'filterSerializedResponseHeaders'>} resolve_opts
+ * @param {Pick<Required<import('@sveltejs/kit/hooks').ResolveOptions>, 'filterSerializedResponseHeaders'>} resolve_opts
  * @returns {typeof fetch}
  */
-export function create_universal_fetch(event, state, fetched, csr, resolve_opts) {
+export function create_universal_fetch(event, prerendering, fetched, csr, resolve_opts) {
 	/**
 	 * @param {URL | RequestInfo} input
 	 * @param {RequestInit} [init]
@@ -290,9 +285,9 @@ export function create_universal_fetch(event, state, fetched, csr, resolve_opts)
 		let dependency;
 
 		if (same_origin) {
-			if (state.prerendering) {
+			if (prerendering) {
 				dependency = { response, body: null };
-				state.prerendering.dependencies.set(url.pathname, dependency);
+				prerendering.dependencies.set(url.pathname, dependency);
 			}
 		} else if (url.protocol === 'https:' || url.protocol === 'http:') {
 			// simulate CORS errors and "no access to body in no-cors mode" server-side for consistency with client-side behaviour
@@ -334,14 +329,24 @@ export function create_universal_fetch(event, state, fetched, csr, resolve_opts)
 						);
 					}
 
+					const request_body =
+						input instanceof Request && cloned_body
+							? await new Response(cloned_body).text()
+							: init?.body;
+
+					if (
+						request_body &&
+						typeof request_body !== 'string' &&
+						!ArrayBuffer.isView(request_body)
+					) {
+						// requests whose body can't be hashed aren't serialized — the browser repeats the fetch
+						return;
+					}
+
 					fetched.push({
 						url: same_origin ? url.href.slice(event.url.origin.length) : url.href,
 						method: event.request.method,
-						request_body: /** @type {string | ArrayBufferView | undefined} */ (
-							input instanceof Request && cloned_body
-								? await stream_to_string(cloned_body)
-								: init?.body
-						),
+						request_body: /** @type {string | ArrayBufferView | null | undefined} */ (request_body),
 						request_headers: cloned_headers,
 						response_body: body,
 						response,
@@ -361,23 +366,14 @@ export function create_universal_fetch(event, state, fetched, csr, resolve_opts)
 					const [a, b] = response.body.tee();
 
 					void (async () => {
-						let result = new Uint8Array();
-
-						for await (const chunk of a) {
-							const combined = new Uint8Array(result.length + chunk.length);
-
-							combined.set(result, 0);
-							combined.set(chunk, result.length);
-
-							result = combined;
-						}
+						const result = new Uint8Array(await new Response(a).arrayBuffer());
 
 						if (dependency) {
 							dependency.body = new Uint8Array(result);
 						}
 
 						void push_fetched(base64_encode(result), true);
-					})();
+					})().catch(noop); // prevent unhandled rejection potentially crashing the process
 
 					return (teed_body = b);
 				}
@@ -465,13 +461,28 @@ export function create_universal_fetch(event, state, fetched, csr, resolve_opts)
 					const included = resolve_opts.filterSerializedResponseHeaders(lower, value);
 					if (!included) {
 						throw new Error(
-							`Failed to get response header "${lower}" — it must be included by the \`filterSerializedResponseHeaders\` option: https://svelte.dev/docs/kit/hooks#Server-hooks-handle (at ${event.route.id})`
+							`Failed to get response header "${lower}" — it must be included by the \`filterSerializedResponseHeaders\` option: https://svelte.dev/docs/kit/hooks#handle (at ${event.route.id})`
 						);
 					}
 				}
 
 				return value;
 			};
+
+			const get_set_cookie = response.headers.getSetCookie;
+			response.headers.getSetCookie = () => {
+				const values = get_set_cookie.call(response.headers);
+				for (const value of values) {
+					const included = resolve_opts.filterSerializedResponseHeaders('set-cookie', value);
+					if (!included) {
+						throw new Error(
+							`Failed to get response header "set-cookie" — it must be included by the \`filterSerializedResponseHeaders\` option: https://svelte.dev/docs/kit/hooks#handle (at ${event.route.id})`
+						);
+					}
+				}
+
+				return values;
+			};
 		}
 
 		return proxy;
@@ -486,21 +497,3 @@ export function create_universal_fetch(event, state, fetched, csr, resolve_opts)
 		return response;
 	};
 }
-
-/**
- * @param {ReadableStream<Uint8Array>} stream
- */
-async function stream_to_string(stream) {
-	let result = '';
-	const reader = stream.getReader();
-	const decoder = new TextDecoder();
-	while (true) {
-		const { done, value } = await reader.read();
-		if (done) {
-			result += decoder.decode();
-			break;
-		}
-		result += decoder.decode(value, { stream: true });
-	}
-	return result;
-}