@sveltejs/kit 3.0.0-next.13 → 3.0.0-next.16

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

@@ -1,15 +1,15 @@
 /** @import { RequestEvent, ActionResult, Actions } from '@sveltejs/kit' */
-/** @import { SSROptions, SSRNode, ServerNode, ServerHooks } from 'types' */
-import * as devalue from 'devalue';
+/** @import { SSROptions, SSRNode, ServerNode } from 'types' */
 import { DEV } from 'esm-env';
 import { json } from '@sveltejs/kit';
 import { HttpError, Redirect, ActionFailure, SvelteKitError } from '@sveltejs/kit/internal';
 import { with_request_store, merge_tracing } from '@sveltejs/kit/internal/server';
 import { normalize_error } from '../../../utils/error.js';
 import { is_form_content_type, negotiate } from '../../../utils/http.js';
-import { create_replacer, with_version_header } from '../utils.js';
+import { with_version_header } from '../utils.js';
 import { handle_error_and_jsonify } from '../errors.js';
 import { record_span } from '../../telemetry/record_span.js';
+import { stringify, uneval } from '#app/internal/transport';
 
 /** @param {RequestEvent} event */
 export function is_action_json_request(event) {
@@ -23,11 +23,11 @@ export function is_action_json_request(event) {
 
 /**
  * @param {RequestEvent} event
- * @param {import('types').RequestState} event_state
+ * @param {import('types').RequestState} state
  * @param {SSROptions} options
  * @param {SSRNode['server'] | undefined} server
  */
-export async function handle_action_json_request(event, event_state, options, server) {
+export async function handle_action_json_request(event, state, options, server) {
 	const actions = server?.actions;
 
 	if (!actions) {
@@ -37,7 +37,7 @@ export async function handle_action_json_request(event, event_state, options, se
 			`POST method not allowed. No form actions exist for ${DEV ? `the page at ${event.route.id}` : 'this page'}`
 		);
 
-		const error = await handle_error_and_jsonify(event, event_state, options, no_actions_error);
+		const error = await handle_error_and_jsonify(event, state, options, no_actions_error);
 
 		return action_json(
 			{
@@ -58,7 +58,7 @@ export async function handle_action_json_request(event, event_state, options, se
 	check_named_default_separate(actions);
 
 	try {
-		const data = await call_action(event, event_state, actions);
+		const data = await call_action(event, state, actions);
 
 		if (DEV) {
 			validate_action_return(data);
@@ -72,11 +72,7 @@ export async function handle_action_json_request(event, event_state, options, se
 					// @ts-expect-error we assign a string to what is supposed to be an object. That's ok
 					// because we don't use the object outside, and this way we have better code navigation
 					// through knowing where the related interface is used.
-					data: stringify_action_response(
-						data.data,
-						/** @type {string} */ (event.route.id),
-						options.hooks.transport
-					)
+					data: try_serialize(data.data, stringify, /** @type {string} */ (event.route.id))
 				},
 				{
 					status: data.status
@@ -87,11 +83,7 @@ export async function handle_action_json_request(event, event_state, options, se
 				type: 'success',
 				status: 200,
 				// @ts-expect-error see comment above
-				data: stringify_action_response(
-					data,
-					/** @type {string} */ (event.route.id),
-					options.hooks.transport
-				)
+				data: try_serialize(data, stringify, /** @type {string} */ (event.route.id))
 			});
 		} else {
 			// no data returned — use 204 No Content (without a body, per the spec)
@@ -106,7 +98,7 @@ export async function handle_action_json_request(event, event_state, options, se
 
 		const transformed = await handle_error_and_jsonify(
 			event,
-			event_state,
+			state,
 			options,
 			check_incorrect_fail_use(err)
 		);
@@ -160,11 +152,11 @@ export function is_action_request(event) {
 
 /**
  * @param {RequestEvent} event
- * @param {import('types').RequestState} event_state
+ * @param {import('types').RequestState} state
  * @param {SSRNode['server'] | undefined} server
  * @returns {Promise<ActionResult>}
  */
-export async function handle_action_request(event, event_state, server) {
+export async function handle_action_request(event, state, server) {
 	const actions = server?.actions;
 
 	if (!actions) {
@@ -188,7 +180,7 @@ export async function handle_action_request(event, event_state, server) {
 	check_named_default_separate(actions);
 
 	try {
-		const data = await call_action(event, event_state, actions);
+		const data = await call_action(event, state, actions);
 
 		if (DEV) {
 			validate_action_return(data);
@@ -240,11 +232,11 @@ function check_named_default_separate(actions) {
 
 /**
  * @param {RequestEvent} event
- * @param {import('types').RequestState} event_state
+ * @param {import('types').RequestState} state
  * @param {NonNullable<ServerNode['actions']>} actions
  * @throws {Redirect | HttpError | SvelteKitError | Error}
  */
-async function call_action(event, event_state, actions) {
+async function call_action(event, state, actions) {
 	const url = new URL(event.request.url);
 
 	let name = 'default';
@@ -283,7 +275,7 @@ async function call_action(event, event_state, actions) {
 		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 }, () =>
 				action(traced_event)
 			);
 
@@ -314,26 +306,9 @@ function validate_action_return(data) {
  * Try to `devalue.uneval` the data object, and if it fails, return a proper Error with context
  * @param {any} data
  * @param {string} route_id
- * @param {ServerHooks['transport']} transport
  */
-export function uneval_action_response(data, route_id, transport) {
-	const replacer = create_replacer(transport);
-
-	return try_serialize(data, (value) => devalue.uneval(value, replacer), route_id);
-}
-
-/**
- * Try to `devalue.stringify` the data object, and if it fails, return a proper Error with context
- * @param {any} data
- * @param {string} route_id
- * @param {ServerHooks['transport']} transport
- */
-function stringify_action_response(data, route_id, transport) {
-	const encoders = Object.fromEntries(
-		Object.entries(transport).map(([key, value]) => [key, value.encode])
-	);
-
-	return try_serialize(data, (value) => devalue.stringify(value, encoders), route_id);
+export function uneval_action_response(data, route_id) {
+	return try_serialize(data, uneval, route_id);
 }
 
 /**

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

@@ -1,4 +1,4 @@
-import { text_encoder } from '../../utils.js';
+import { base64_encode, text_encoder } from '../../utils.js';
 
 /**
  * SHA-256 hashing function adapted from https://bitwiseshiftleft.github.io/sjcl
@@ -102,7 +102,7 @@ export function sha256(data) {
 	const bytes = new Uint8Array(out.buffer);
 	reverse_endianness(bytes);
 
-	return btoa(String.fromCharCode(...bytes));
+	return base64_encode(bytes);
 }
 
 /** The SHA-256 initialization vector */

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

@@ -1,11 +1,12 @@
 import { escape_html } from '../../../utils/escape.js';
+import { base64_encode } from '../../utils.js';
 import { sha256 } from './crypto.js';
 
 const array = new Uint8Array(16);
 
 function generate_nonce() {
 	crypto.getRandomValues(array);
-	return btoa(String.fromCharCode(...array));
+	return base64_encode(array);
 }
 
 const quoted = new Set([

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

@@ -3,16 +3,17 @@ import { compact } from '../../../utils/array.js';
 import { create_async_iterator } from '../../../utils/streaming.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('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;
 
@@ -30,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(
@@ -44,7 +45,7 @@ export function server_data_serializer(event, event_state, options) {
 							} catch (e) {
 								error = await handle_error_and_jsonify(
 									event,
-									event_state,
+									state,
 									options,
 									new Error(`Failed to serialize promise while rendering ${event.route.id}`, {
 										cause: e
@@ -64,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)})`;
 					}
@@ -125,19 +126,17 @@ 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('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') {
@@ -153,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(
@@ -165,7 +164,7 @@ export function server_data_serializer_json(event, event_state, options) {
 						} 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}`, {
 									cause: e

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

@@ -1,6 +1,6 @@
 /** @import { Component } from 'svelte' */
 /** @import { ActionResult, RequestEvent, SSRManifest } from '@sveltejs/kit' */
-/** @import { PageNodeIndexes, RequestState, RequiredResolveOptions, ServerDataNode, SSRNode, SSROptions, SSRState } from 'types' */
+/** @import { PageNodeIndexes, RequestState, RequiredResolveOptions, ServerDataNode, SSRNode, SSROptions } from 'types' */
 import { text } from '@sveltejs/kit';
 import { Redirect } from '@sveltejs/kit/internal';
 import { compact } from '../../../utils/array.js';
@@ -30,25 +30,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}`, {
@@ -58,7 +48,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 {
@@ -72,11 +62,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') {
@@ -156,12 +146,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)
 			});
 		}
 
@@ -171,10 +160,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)
+				? server_data_serializer_json(event, state, options)
 				: null;
 
 		/** @type {Array<Promise<ServerDataNode | null>>} */
@@ -194,7 +183,6 @@ export async function render_page(
 
 					const server_data = await load_server_data({
 						event,
-						event_state,
 						state,
 						node,
 						parent: async () => {
@@ -229,7 +217,7 @@ export async function render_page(
 				try {
 					return await load_data({
 						event,
-						event_state,
+						state,
 						fetched,
 						node,
 						parent: async () => {
@@ -241,7 +229,6 @@ export async function render_page(
 						},
 						resolve_opts,
 						server_data_promise: server_promises[i],
-						state,
 						csr
 					});
 				} catch (e) {
@@ -284,7 +271,7 @@ export async function render_page(
 						return redirect_response(err.status, err.location);
 					}
 
-					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--) {
@@ -307,10 +294,9 @@ export async function render_page(
 
 							return await render_response({
 								event,
-								event_state,
+								state,
 								options,
 								manifest,
-								state,
 								resolve_opts,
 								page_config: {
 									ssr: nodes.ssr(),
@@ -355,10 +341,9 @@ export async function render_page(
 
 		return await render_response({
 			event,
-			event_state,
+			state,
 			options,
 			manifest,
-			state,
 			resolve_opts,
 			page_config: {
 				csr,
@@ -369,7 +354,7 @@ export async function render_page(
 			branch: compact(branch),
 			action_result,
 			fetched,
-			data_serializer: !ssr ? server_data_serializer(event, event_state, options) : data_serializer,
+			data_serializer: !ssr ? server_data_serializer(event, state, options) : data_serializer,
 			error_components: await load_error_components(ssr, branch, page, manifest)
 		});
 	} catch (e) {
@@ -382,10 +367,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,
 			error: e,
 			resolve_opts
 		});

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

@@ -12,14 +12,13 @@ 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;
+ *   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;
@@ -83,7 +82,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) => {
@@ -194,25 +193,23 @@ 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;
+ *   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 +231,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,
@@ -262,13 +258,13 @@ export async function load_data({
 
 /**
  * @param {Pick<import('@sveltejs/kit').RequestEvent, 'fetch' | 'url' | 'request' | 'route'>} event
- * @param {import('types').SSRState} state
+ * @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
  * @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 +286,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
@@ -336,7 +332,7 @@ export function create_universal_fetch(event, state, fetched, csr, resolve_opts)
 
 					const request_body =
 						input instanceof Request && cloned_body
-							? await stream_to_string(cloned_body)
+							? await new Response(cloned_body).text()
 							: init?.body;
 
 					if (
@@ -371,16 +367,7 @@ 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);
@@ -482,6 +469,21 @@ export function create_universal_fetch(event, state, fetched, csr, resolve_opts)
 
 				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;
@@ -496,21 +498,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;
-}