@sveltejs/kit 3.0.0-next.23 → 3.0.0-next.25

package/src/runtime/server/remote-functions.js

@@ -1,9 +1,8 @@
 /** @import { RequestEvent, SSRManifest } from '@sveltejs/kit' */
 /** @import { RemoteForm } from '$app/server' */
-/** @import { ActionResult } from '$app/forms' */
-/** @import { RemoteFormInternals, RemoteFunctionData, RemoteFunctionResponse, RemoteInternals, RequestState, SSROptions } from 'types' */
+/** @import { RemoteFormInternals, RemoteFunctionData, RemoteFunctionResponse, RemoteInternals, RequestState, ServerActionResult } from 'types' */
 
-import { json, error } from '@sveltejs/kit';
+import { error } from '@sveltejs/kit';
 import { Redirect, SvelteKitError } from '@sveltejs/kit/internal';
 import { with_request_store, merge_tracing, record_span } from '@sveltejs/kit/internal/server';
 import { app_dir, base } from '#app/paths';
@@ -11,10 +10,13 @@ import { is_form_content_type } from '../../utils/http.js';
 import { create_remote_key, parse_remote_arg, split_remote_key } from '../shared.js';
 import { stringify } from '#app/internal/transport';
 import { handle_error_and_jsonify } from './errors.js';
-import { normalize_error } from '../../utils/error.js';
-import { check_incorrect_fail_use, get_action_location } from './page/actions.js';
-import { DEV } from 'esm-env';
+import {
+	action_error_result,
+	get_action_location,
+	method_not_allowed_result
+} from './page/actions.js';
 import { deserialize_binary_form } from '../form-utils.js';
+import { text_encoder } from '../utils.js';
 import { with_version_header } from './utils.js';
 
 /**
@@ -24,8 +26,121 @@ import { with_version_header } from './utils.js';
  */
 const KEEP_ALIVE_INTERVAL = 30_000;
 
+/**
+ * @param {RequestEvent} event
+ * @param {RequestState} state
+ * @param {import('types').RemoteQueryLiveInternals} internals
+ * @param {any} arg
+ */
+export function create_live_query_response(event, state, internals, arg) {
+	const cancellation = new AbortController();
+	const live_event = {
+		...event,
+		request: new Request(event.request, {
+			signal: AbortSignal.any([event.request.signal, cancellation.signal])
+		})
+	};
+
+	const generator = internals.run(live_event, state, arg);
+
+	let open = true;
+	let pulling = false;
+	/** @type {ReadableStreamDefaultController<Uint8Array>} */
+	let stream_controller;
+	/** @type {ReturnType<typeof setTimeout> | undefined} */
+	let keep_alive;
+	/** @type {string | undefined} */
+	let result;
+
+	function schedule_keep_alive() {
+		clearTimeout(keep_alive);
+		keep_alive = setTimeout(() => {
+			if (!open) return;
+			if ((stream_controller.desiredSize ?? 0) > 0) {
+				stream_controller.enqueue(text_encoder.encode(': keep-alive\n\n'));
+			}
+			schedule_keep_alive();
+		}, KEEP_ALIVE_INTERVAL);
+	}
+
+	/** @param {any} data */
+	function send(data) {
+		if (!open) return;
+		stream_controller.enqueue(text_encoder.encode('data: ' + JSON.stringify(data) + '\n\n'));
+		schedule_keep_alive();
+	}
+
+	/** @param {boolean} cancelled */
+	function teardown(cancelled) {
+		if (!open) return;
+		open = false;
+		clearTimeout(keep_alive);
+		cancellation.abort();
+		if (!cancelled) stream_controller.close();
+		// AsyncGenerator.return() cannot interrupt a pending next(). Cleanup is
+		// cooperative via request.signal, so stream cancellation must not await it.
+		void generator.return(undefined).catch(() => {});
+	}
+
+	event.request.signal.addEventListener('abort', () => teardown(true), { once: true });
+
+	return new Response(
+		new ReadableStream({
+			start(controller) {
+				stream_controller = controller;
+				schedule_keep_alive();
+			},
+			async pull() {
+				if (!open || pulling) return;
+				pulling = true;
+
+				try {
+					while (open) {
+						const { value, done } = await generator.next();
+
+						if (!open) return;
+
+						if (done) {
+							teardown(false);
+							return;
+						}
+
+						if (result !== (result = stringify(value))) {
+							send({ type: 'result', result });
+							return;
+						}
+					}
+				} catch (error) {
+					if (!open) return;
+
+					if (error instanceof Redirect) {
+						send({ type: 'redirect', location: error.location });
+					} else {
+						const transformed = await handle_error_and_jsonify(event, state, error);
+
+						send({ type: 'error', error: transformed });
+					}
+
+					teardown(false);
+				} finally {
+					pulling = false;
+				}
+			},
+			cancel() {
+				teardown(true);
+			}
+		}),
+		{
+			headers: {
+				'cache-control': 'private, no-store',
+				'content-type': 'text/event-stream'
+			}
+		}
+	);
+}
+
 /** @type {typeof handle_remote_call_internal} */
-export async function handle_remote_call(event, state, options, manifest, id) {
+export async function handle_remote_call(event, state, manifest, id) {
 	return record_span({
 		name: 'sveltekit.remote.call',
 		attributes: {
@@ -34,7 +149,7 @@ export async function handle_remote_call(event, state, options, manifest, id) {
 		fn: async (current) => {
 			const traced_event = merge_tracing(event, current);
 			const response = await with_request_store({ event: traced_event, state }, () =>
-				handle_remote_call_internal(traced_event, state, options, manifest, id)
+				handle_remote_call_internal(traced_event, state, manifest, id)
 			);
 			return with_version_header(response);
 		}
@@ -44,11 +159,10 @@ export async function handle_remote_call(event, state, options, manifest, id) {
 /**
  * @param {RequestEvent} event
  * @param {RequestState} state
- * @param {SSROptions} options
  * @param {SSRManifest} manifest
  * @param {string} id
  */
-async function handle_remote_call_internal(event, state, options, manifest, id) {
+async function handle_remote_call_internal(event, state, manifest, id) {
 	const [hash, name, additional_args] = id.split('/');
 	const remotes = manifest._.remotes;
 
@@ -88,119 +202,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 					new URL(event.request.url).searchParams.get('payload')
 				);
 
-				const generator = internals.run(event, state, parse_remote_arg(payload));
-
-				const encoder = new TextEncoder();
-
-				let closed = false;
-
-				/** @type {ReturnType<typeof setTimeout> | undefined} */
-				let keep_alive;
-
-				/**
-				 * (Re)schedule the keep-alive comment. Called whenever a message is sent, so
-				 * that a keep-alive is only emitted once `KEEP_ALIVE_INTERVAL` has elapsed
-				 * without any other activity.
-				 * @param {ReadableStreamDefaultController} controller
-				 */
-				function schedule_keep_alive(controller) {
-					clearTimeout(keep_alive);
-					keep_alive = setTimeout(() => {
-						if (closed || event.request.signal.aborted) return;
-						// SSE comments (lines starting with `:`) are ignored by the client
-						controller.enqueue(encoder.encode(': keep-alive\n\n'));
-						schedule_keep_alive(controller);
-					}, KEEP_ALIVE_INTERVAL);
-				}
-
-				/**
-				 * @param {ReadableStreamDefaultController} controller
-				 * @param {any} payload
-				 */
-				function send(controller, payload) {
-					controller.enqueue(encoder.encode('data: ' + JSON.stringify(payload) + '\n\n'));
-					schedule_keep_alive(controller);
-				}
-
-				/** @type {string | undefined} */
-				let result = undefined;
-
-				async function cancel() {
-					if (closed) return;
-					closed = true;
-					clearTimeout(keep_alive);
-					await generator.return(undefined);
-				}
-
-				event.request.signal.addEventListener('abort', cancel, { once: true });
-
-				return new Response(
-					new ReadableStream({
-						start(controller) {
-							schedule_keep_alive(controller);
-						},
-						async pull(controller) {
-							if (event.request.signal.aborted) {
-								await cancel();
-								controller.close();
-								return;
-							}
-
-							try {
-								while (true) {
-									const { value, done } = await generator.next();
-
-									if (done) {
-										await cancel();
-										controller.close();
-										return;
-									}
-
-									// only send changed data
-									if (result !== (result = stringify(value))) {
-										send(controller, {
-											type: 'result',
-											result
-										});
-
-										return;
-									}
-								}
-							} catch (error) {
-								if (!event.request.signal.aborted) {
-									if (error instanceof Redirect) {
-										send(controller, {
-											type: 'redirect',
-											location: error.location
-										});
-									} else {
-										const transformed = await handle_error_and_jsonify(
-											event,
-											state,
-											options,
-											error
-										);
-
-										send(controller, {
-											type: 'error',
-											error: transformed
-										});
-									}
-								}
-
-								await cancel();
-								controller.close();
-							}
-						},
-						cancel
-					}),
-					{
-						headers: {
-							'cache-control': 'private, no-store',
-							'content-type': 'text/event-stream'
-						}
-					}
-				);
+				return create_live_query_response(event, state, internals, parse_remote_arg(payload));
 			}
 
 			case 'query_batch': {
@@ -217,7 +219,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 
 				const args = await Promise.all(payloads.map((payload) => parse_remote_arg(payload)));
 
-				data._ = await with_request_store({ event, state }, () => internals.run(args, options));
+				data._ = await with_request_store({ event, state }, () => internals.run(args));
 
 				break;
 			}
@@ -262,7 +264,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 
 				if (data._.issues) {
 					// special case — don't serialize refreshes/reconnects
-					return json(
+					return Response.json(
 						/** @type {RemoteFunctionResponse} */ ({
 							type: 'result',
 							data: stringify(data)
@@ -308,9 +310,9 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 			}
 		}
 
-		await collect_remote_data(data, event, state, options);
+		await collect_remote_data(data, event, state);
 
-		return json(
+		return Response.json(
 			/** @type {RemoteFunctionResponse} */ ({
 				type: 'result',
 				data: stringify(data)
@@ -319,9 +321,9 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 		);
 	} catch (error) {
 		if (error instanceof Redirect) {
-			const data = await collect_remote_data({ redirect: error.location }, event, state, options);
+			const data = await collect_remote_data({ redirect: error.location }, event, state);
 
-			return json(
+			return Response.json(
 				/** @type {RemoteFunctionResponse} */ ({
 					type: 'result',
 					data: stringify(data)
@@ -330,9 +332,9 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 			);
 		}
 
-		const transformed = await handle_error_and_jsonify(event, state, options, error);
+		const transformed = await handle_error_and_jsonify(event, state, error);
 
-		return json(
+		return Response.json(
 			/** @type {RemoteFunctionResponse} */ ({
 				type: 'error',
 				error: transformed
@@ -355,9 +357,8 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
  * @param {RemoteFunctionData} data
  * @param {RequestEvent} event
  * @param {RequestState} state
- * @param {SSROptions} options
  */
-export async function collect_remote_data(data, event, state, options) {
+export async function collect_remote_data(data, event, state) {
 	/**
 	 *
 	 * @param {unknown} error
@@ -365,7 +366,7 @@ export async function collect_remote_data(data, event, state, options) {
 	 */
 	function convert_error(error) {
 		// TODO 4.0 remove the `Promise.resolve(...)`
-		return Promise.resolve(handle_error_and_jsonify(event, state, options, error));
+		return Promise.resolve(handle_error_and_jsonify(event, state, error));
 	}
 
 	/** @type {Promise<any>[]} */
@@ -531,7 +532,7 @@ export async function handle_remote_form_post(event, state, manifest, id) {
  * @param {RequestState} state
  * @param {SSRManifest} manifest
  * @param {string} id
- * @returns {Promise<ActionResult>}
+ * @returns {Promise<ServerActionResult>}
  */
 async function handle_remote_form_post_internal(event, state, manifest, id) {
 	const location = get_action_location(event.url);
@@ -547,21 +548,7 @@ async function handle_remote_form_post_internal(event, state, manifest, id) {
 	);
 
 	if (!form) {
-		event.setHeaders({
-			// https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/405
-			// "The server must generate an Allow header field in a 405 status code response"
-			allow: 'GET'
-		});
-		return {
-			type: 'error',
-			location,
-			// We're lying a bit with the types here; this will be transformed into a proper App.Error object later
-			error: new SvelteKitError(
-				405,
-				'Method Not Allowed',
-				`POST method not allowed. No form actions exist for ${DEV ? `the page at ${event.route.id}` : 'this page'}`
-			)
-		};
+		return method_not_allowed_result(event, location);
 	}
 
 	if (action_id) {
@@ -591,22 +578,7 @@ async function handle_remote_form_post_internal(event, state, manifest, id) {
 			location
 		};
 	} catch (e) {
-		const err = normalize_error(e);
-
-		if (err instanceof Redirect) {
-			return {
-				type: 'redirect',
-				status: err.status,
-				location: err.location
-			};
-		}
-
-		return {
-			type: 'error',
-			location,
-			// @ts-expect-error We're lying a bit with the types here; this will be transformed into a proper App.Error object later
-			error: check_incorrect_fail_use(err)
-		};
+		return action_error_result(e, location);
 	}
 }
 

package/src/runtime/server/respond.js

@@ -1,6 +1,6 @@
 /** @import { SSRNode } from 'types' */
 import { DEV } from 'esm-env';
-import { json, text } from '@sveltejs/kit';
+import { text } from '@sveltejs/kit';
 import { Redirect, SvelteKitError } from '@sveltejs/kit/internal';
 import {
 	merge_tracing,
@@ -45,6 +45,7 @@ import {
 } from '../pathname.js';
 import { server_data_serializer } from './page/data_serializer.js';
 import { get_remote_id, handle_remote_call } from './remote-functions.js';
+import { hooks, options } from './internal.js';
 
 /** @type {import('types').RequiredResolveOptions['transformPageChunk']} */
 const default_transform = ({ html }) => html;
@@ -85,12 +86,11 @@ export const respond = propagate_context(internal_respond);
 
 /**
  * @param {Request} request
- * @param {import('types').SSROptions} options
  * @param {import('@sveltejs/kit').SSRManifest} manifest
  * @param {import('types').RequestState} state
  * @returns {Promise<Response>}
  */
-export async function internal_respond(request, options, manifest, state) {
+export async function internal_respond(request, manifest, state) {
 	/** URL but stripped from the potential `/__data.json` suffix and its search param  */
 	const url = new URL(request.url);
 
@@ -100,7 +100,7 @@ export async function internal_respond(request, options, manifest, state) {
 
 	if (!__SVELTEKIT_DEV__) {
 		const request_origin = request.headers.get('origin');
-		const self_origin = get_self_origin(options.paths_origin, url.origin);
+		const self_origin = get_self_origin(__SVELTEKIT_PATHS_ORIGIN__, url.origin);
 
 		if (remote_id) {
 			if (
@@ -111,9 +111,9 @@ export async function internal_respond(request, options, manifest, state) {
 				})
 			) {
 				const message = 'Cross-site remote requests are forbidden';
-				return json({ message }, { status: 403 });
+				return Response.json({ message }, { status: 403 });
 			}
-		} else if (options.csrf_check_origin) {
+		} else if (__SVELTEKIT_CSRF_CHECK_ORIGIN__) {
 			const forbidden = is_csrf_forbidden({
 				request,
 				request_origin,
@@ -126,7 +126,7 @@ export async function internal_respond(request, options, manifest, state) {
 				const opts = { status: 403 };
 
 				if (request.headers.get('accept') === 'application/json') {
-					return json({ message }, opts);
+					return Response.json({ message }, opts);
 				}
 
 				return text(message, opts);
@@ -134,7 +134,7 @@ export async function internal_respond(request, options, manifest, state) {
 		}
 	}
 
-	if (options.hash_routing && url.pathname !== base + '/' && url.pathname !== '/[fallback]') {
+	if (__SVELTEKIT_HASH_ROUTING__ && url.pathname !== base + '/' && url.pathname !== '/[fallback]') {
 		return text('Not found', { status: 404 });
 	}
 
@@ -243,7 +243,6 @@ export async function internal_respond(request, options, manifest, state) {
 	// @ts-expect-error this has to be assigned lazily
 	event.fetch = create_fetch({
 		event,
-		options,
 		manifest,
 		state,
 		get_cookie_header,
@@ -263,7 +262,16 @@ export async function internal_respond(request, options, manifest, state) {
 
 			// reroute could alter the given URL, so we pass a copy
 			resolved_path =
-				(await options.hooks.reroute({ url: new URL(url), fetch: event.fetch })) ?? url.pathname;
+				(await hooks.reroute({ url: new URL(url), fetch: event.fetch })) ?? url.pathname;
+
+			if (!manifest._.routes.length && resolved_path !== url.pathname) {
+				state.rerouted_url = denormalise_url({
+					request_url: request.url,
+					resolved_path,
+					is_data_request,
+					is_route_resolution_request
+				}).toString();
+			}
 		} catch {
 			return text('Internal Server Error', {
 				status: 500
@@ -300,12 +308,12 @@ export async function internal_respond(request, options, manifest, state) {
 		!state.prerendering?.fallback &&
 		has_prerendered_path(manifest, resolved_path)
 	) {
-		const url = new URL(request.url);
-		url.pathname = is_data_request
-			? add_data_suffix(resolved_path)
-			: is_route_resolution_request
-				? add_resolution_suffix(resolved_path)
-				: resolved_path;
+		const url = denormalise_url({
+			request_url: request.url,
+			resolved_path,
+			is_data_request,
+			is_route_resolution_request
+		});
 
 		try {
 			// `fetch` automatically decodes the body, so we need to delete the related headers to not break the response
@@ -323,7 +331,7 @@ export async function internal_respond(request, options, manifest, state) {
 				statusText: response.statusText
 			});
 		} catch (error) {
-			return await handle_fatal_error(event, state, options, error);
+			return await handle_fatal_error(event, state, error);
 		}
 	}
 
@@ -369,7 +377,7 @@ export async function internal_respond(request, options, manifest, state) {
 				event.params = result.params;
 			}
 		} catch (e) {
-			return await handle_fatal_error(event, state, options, e);
+			return await handle_fatal_error(event, state, e);
 		}
 	}
 
@@ -452,10 +460,10 @@ export async function internal_respond(request, options, manifest, state) {
 				add_cookies_to_headers(response.headers, new_cookies.values());
 				return response;
 			} catch (err) {
-				return await handle_fatal_error(event, state, options, err);
+				return await handle_fatal_error(event, state, err);
 			}
 		}
-		return await handle_fatal_error(event, state, options, e);
+		return await handle_fatal_error(event, state, e);
 	}
 
 	async function handle() {
@@ -485,7 +493,7 @@ export async function internal_respond(request, options, manifest, state) {
 				};
 
 				return await with_request_store({ event: traced_event, state }, () =>
-					options.hooks.handle({
+					hooks.handle({
 						event: traced_event,
 						resolve: (event, opts) => {
 							return record_span({
@@ -592,7 +600,6 @@ export async function internal_respond(request, options, manifest, state) {
 				return await respond_with_error({
 					event,
 					state,
-					options,
 					manifest,
 					error: new SvelteKitError(
 						400,
@@ -603,11 +610,10 @@ export async function internal_respond(request, options, manifest, state) {
 				});
 			}
 
-			if (options.hash_routing || state.prerendering?.fallback) {
+			if (__SVELTEKIT_HASH_ROUTING__ || state.prerendering?.fallback) {
 				return await render_response({
 					event,
 					state,
-					options,
 					manifest,
 					page_config: { ssr: false, csr: true },
 					status: 200,
@@ -622,12 +628,12 @@ export async function internal_respond(request, options, manifest, state) {
 					],
 					fetched: [],
 					resolve_opts,
-					data_serializer: server_data_serializer(event, state, options)
+					data_serializer: server_data_serializer(event, state)
 				});
 			}
 
 			if (remote_id) {
-				return await handle_remote_call(event, state, options, manifest, remote_id);
+				return await handle_remote_call(event, state, manifest, remote_id);
 			}
 
 			if (route) {
@@ -641,7 +647,6 @@ export async function internal_respond(request, options, manifest, state) {
 						event,
 						state,
 						route,
-						options,
 						manifest,
 						invalidated_data_nodes,
 						trailing_slash
@@ -676,7 +681,6 @@ export async function internal_respond(request, options, manifest, state) {
 								event,
 								state,
 								route.page,
-								options,
 								manifest,
 								page_nodes,
 								resolve_opts
@@ -754,6 +758,25 @@ export async function internal_respond(request, options, manifest, state) {
 			// if this request came direct from the user, rather than
 			// via our own `fetch`, render a 404 page
 			if (state.depth === 0) {
+				// Error-page data requests only invalidate the root layout.
+				if (
+					!state.prerendering &&
+					is_data_request &&
+					invalidated_data_nodes?.length === 1 &&
+					invalidated_data_nodes[0]
+				) {
+					return await render_data(
+						event,
+						state,
+						{ page: { layouts: [], leaf: 0 } },
+						manifest,
+						invalidated_data_nodes,
+						// there is no route to take a trailing slash option from, and the
+						// SSR'd error page sees the pathname as-is
+						'ignore'
+					);
+				}
+
 				if (non_html_fetch_destinations.has(event.request.headers.get('sec-fetch-dest') ?? '')) {
 					return text('Not Found', {
 						status: 404,
@@ -764,7 +787,6 @@ export async function internal_respond(request, options, manifest, state) {
 				return await respond_with_error({
 					event,
 					state,
-					options,
 					manifest,
 					error: new SvelteKitError(404, 'Not Found', `Not found: ${event.url.pathname}`),
 					resolve_opts
@@ -786,7 +808,7 @@ export async function internal_respond(request, options, manifest, state) {
 			// and I don't even know how to describe it. need to investigate at some point
 
 			// HttpError from endpoint can end up here - TODO should it be handled there instead?
-			return await handle_fatal_error(event, state, options, e);
+			return await handle_fatal_error(event, state, e);
 		} finally {
 			event.cookies.set = () => {
 				throw new Error('Cannot use `cookies.set(...)` after the response has been generated');
@@ -833,3 +855,26 @@ function propagate_context(fn) {
 		});
 	};
 }
+
+/**
+ * @param {object} opts
+ * @param {string} opts.request_url - The original request URL
+ * @param {string} opts.resolved_path - The resolved pathname
+ * @param {boolean} opts.is_data_request - Whether the request is a data request
+ * @param {boolean} opts.is_route_resolution_request -
+ * @returns {URL}
+ */
+function denormalise_url({
+	request_url,
+	resolved_path,
+	is_data_request,
+	is_route_resolution_request
+}) {
+	const url = new URL(request_url);
+	url.pathname = is_data_request
+		? add_data_suffix(resolved_path)
+		: is_route_resolution_request
+			? add_resolution_suffix(resolved_path)
+			: resolved_path;
+	return url;
+}

package/src/runtime/server/state.js

@@ -36,6 +36,7 @@ export function create_request_state(options) {
 		prerender_default: undefined,
 		error: false,
 		depth: 0,
+		rerouted_url: null,
 		...transient_fields()
 	};
 }