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

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

@@ -1,6 +1,6 @@
 /** @import { RequestEvent, SSRManifest } from '@sveltejs/kit' */
 /** @import { RemoteForm } from '$app/server' */
-/** @import { RemoteFormInternals, RemoteFunctionData, RemoteFunctionResponse, RemoteInternals, RequestState, ServerActionResult, SSROptions } from 'types' */
+/** @import { RemoteFormInternals, RemoteFunctionData, RemoteFunctionResponse, RemoteInternals, RequestState, ServerActionResult } from 'types' */
 
 import { error } from '@sveltejs/kit';
 import { Redirect, SvelteKitError } from '@sveltejs/kit/internal';
@@ -16,6 +16,7 @@ import {
 	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';
 
 /**
@@ -25,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: {
@@ -35,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);
 		}
@@ -45,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;
 
@@ -89,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': {
@@ -218,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;
 			}
@@ -309,7 +310,7 @@ 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 Response.json(
 			/** @type {RemoteFunctionResponse} */ ({
@@ -320,7 +321,7 @@ 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 Response.json(
 				/** @type {RemoteFunctionResponse} */ ({
@@ -331,7 +332,7 @@ 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 Response.json(
 			/** @type {RemoteFunctionResponse} */ ({
@@ -356,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
@@ -366,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>[]} */

package/src/runtime/server/respond.js

@@ -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 (
@@ -113,7 +113,7 @@ export async function internal_respond(request, options, manifest, state) {
 				const message = 'Cross-site remote requests are forbidden';
 				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,
@@ -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
@@ -765,7 +769,6 @@ export async function internal_respond(request, options, manifest, state) {
 						event,
 						state,
 						{ page: { layouts: [], leaf: 0 } },
-						options,
 						manifest,
 						invalidated_data_nodes,
 						// there is no route to take a trailing slash option from, and the
@@ -784,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
@@ -806,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');
@@ -853,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()
 	};
 }

package/src/runtime/server/utils.js

@@ -29,13 +29,6 @@ export function allowed_methods(mod) {
 	return allowed;
 }
 
-/**
- * @param {import('types').SSROptions} options
- */
-export function get_global_name(options) {
-	return __SVELTEKIT_DEV__ ? '__sveltekit_dev' : `__sveltekit_${options.version_hash}`;
-}
-
 /**
  * @param {number} status
  * @param {string} location

package/src/runtime/utils.js

@@ -1,6 +1,47 @@
 import { BROWSER } from 'esm-env';
 
 export const text_encoder = new TextEncoder();
+
+/**
+ * `ReadableStream.from`, for runtimes that don't support it (as of writing, every Bun release)
+ * @template T
+ * @param {AsyncIterable<T>} iterable
+ * @returns {ReadableStream<T>}
+ */
+export function stream_from_iterable(iterable) {
+	// TODO remove the casts once TypeScript's lib includes `ReadableStream.from`
+	if (/** @type {any} */ (ReadableStream).from) {
+		return /** @type {any} */ (ReadableStream).from(iterable);
+	}
+
+	const iterator = iterable[Symbol.asyncIterator]();
+	return new ReadableStream({
+		async pull(controller) {
+			const { value, done } = await iterator.next();
+			if (done) controller.close();
+			else controller.enqueue(value);
+		},
+		async cancel(reason) {
+			await iterator.return?.(reason);
+		}
+	});
+}
+
+/**
+ * @param {string} head
+ * @param {AsyncIterable<string>} chunks
+ * @returns {ReadableStream<Uint8Array>} `head` followed by each non-empty chunk, encoded
+ */
+export function stream_text(head, chunks) {
+	return stream_from_iterable(
+		(async function* () {
+			yield text_encoder.encode(head);
+			for await (const chunk of chunks) {
+				if (chunk) yield text_encoder.encode(chunk);
+			}
+		})()
+	);
+}
 export const text_decoder = new TextDecoder();
 
 /**

package/src/types/global-private.d.ts

@@ -13,7 +13,15 @@ declare global {
 	 * it is influenced by `NODE_ENV` which can still be true during `vite preview`
 	 */
 	const __SVELTEKIT_DEV__: boolean;
+	const __SVELTEKIT_CSRF_CHECK_ORIGIN__: boolean;
 	const __SVELTEKIT_EMBEDDED__: boolean;
+	/** True if `config.output.linkHeaderPreload` is `true` */
+	const __SVELTEKIT_LINK_HEADER_PRELOAD__: boolean;
+	const __SVELTEKIT_PATHS_ORIGIN__: string | undefined;
+	/** True if the app has a service worker and `config.serviceWorker.register` is `true` */
+	const __SVELTEKIT_SERVICE_WORKER__: boolean;
+	/** The `__sveltekit_xxx` name the payload object is attached to, without `globalThis.` */
+	const __SVELTEKIT_GLOBAL_NAME__: string;
 	const __SVELTEKIT_PATHS_ASSETS__: string;
 	const __SVELTEKIT_PATHS_BASE__: string;
 	const __SVELTEKIT_PATHS_RELATIVE__: boolean;