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

package/src/runtime/server/errors.js

@@ -1,4 +1,4 @@
-import { json, text } from '@sveltejs/kit';
+import { text } from '@sveltejs/kit';
 import {
 	HandledHttpError,
 	HttpError,
@@ -8,17 +8,16 @@ import {
 import { with_request_store } from '@sveltejs/kit/internal/server';
 import { add_deprecated_handle_error_properties, coalesce_to_error } from '../../utils/error.js';
 import { negotiate } from '../../utils/http.js';
-import { fix_stack_trace } from './internal.js';
+import { fix_stack_trace, hooks, options } from './internal.js';
 import { escape_html } from '../../utils/escape.js';
 
 /**
  * @param {import('@sveltejs/kit').RequestEvent} event
  * @param {import('types').RequestState} state
- * @param {import('types').SSROptions} options
  * @param {unknown} error
  */
-export async function handle_fatal_error(event, state, options, error) {
-	const body = await handle_error_and_jsonify(event, state, options, error);
+export async function handle_fatal_error(event, state, error) {
+	const body = await handle_error_and_jsonify(event, state, error);
 	const status = body.status;
 
 	// sec-fetch-dest would be nicer, but non-browser clients and plain HTTP hosts don't send it
@@ -28,22 +27,21 @@ export async function handle_fatal_error(event, state, options, error) {
 	]);
 
 	if (event.isDataRequest || type === 'application/json') {
-		return json(body, {
+		return Response.json(body, {
 			status
 		});
 	}
 
-	return static_error_page(options, status, body.message);
+	return static_error_page(status, body.message);
 }
 
 /**
  * @param {import('@sveltejs/kit').RequestEvent} event
  * @param {import('types').RequestState} state
- * @param {import('types').SSROptions} options
  * @param {any} error
  * @returns {App.Error | Promise<App.Error>}
  */
-export function handle_error_and_jsonify(event, state, options, error) {
+export function handle_error_and_jsonify(event, state, error) {
 	if (error instanceof HandledHttpError) {
 		return error.body;
 	}
@@ -90,7 +88,7 @@ export function handle_error_and_jsonify(event, state, options, error) {
 		const input = { ...caught, event };
 		if (__SVELTEKIT_DEV__) add_deprecated_handle_error_properties(input, fallback);
 
-		result = with_request_store({ event, state }, () => options.hooks.handleError(input));
+		result = with_request_store({ event, state }, () => hooks.handleError(input));
 	} catch (hook_error) {
 		log_handle_error_hook_failure(error, hook_error);
 		return { status: fallback.status, message: 'Internal Error' };
@@ -141,11 +139,10 @@ function log_handle_error_hook_failure(error, hook_error) {
 /**
  * Return as a response that renders the error.html
  *
- * @param {import('types').SSROptions} options
  * @param {number} status
  * @param {string} message
  */
-export function static_error_page(options, status, message) {
+export function static_error_page(status, message) {
 	let page = options.templates.error({ status, message: escape_html(message) });
 
 	if (__SVELTEKIT_DEV__) {

package/src/runtime/server/fetch.js

@@ -2,14 +2,13 @@ import { parseSetCookie } from 'cookie';
 import { noop } from '../../utils/functions.js';
 import { respond } from './respond.js';
 import * as paths from '#app/paths';
-import { read_implementation } from './internal.js';
+import { hooks, read_implementation } from './internal.js';
 import { has_prerendered_path } from './utils.js';
 import { fork_state_for_subrequest } from './state.js';
 
 /**
  * @param {{
  *   event: import('@sveltejs/kit').RequestEvent;
- *   options: import('types').SSROptions;
  *   manifest: import('@sveltejs/kit').SSRManifest;
  *   state: import('types').RequestState;
  *   get_cookie_header: (url: URL, header: string | null) => string;
@@ -17,7 +16,7 @@ import { fork_state_for_subrequest } from './state.js';
  * }} opts
  * @returns {typeof fetch}
  */
-export function create_fetch({ event, options, manifest, state, get_cookie_header, set_internal }) {
+export function create_fetch({ event, manifest, state, get_cookie_header, set_internal }) {
 	/**
 	 * @type {typeof fetch}
 	 */
@@ -30,7 +29,7 @@ export function create_fetch({ event, options, manifest, state, get_cookie_heade
 		let credentials =
 			(info instanceof Request ? info.credentials : init?.credentials) ?? 'same-origin';
 
-		return options.hooks.handleFetch({
+		return hooks.handleFetch({
 			event,
 			request: original_request,
 			fetch: async (info, init) => {
@@ -148,18 +147,19 @@ export function create_fetch({ event, options, manifest, state, get_cookie_heade
 					request.headers.set('accept-language', accept_language);
 				}
 
-				const response = await internal_fetch(request, options, manifest, state);
+				const response = await internal_fetch(request, manifest, state);
 
 				for (const str of response.headers.getSetCookie()) {
-					const { name, value, ...options } = parseSetCookie(str, { decode: (v) => v });
+					const { name, value, ...cookie_options } = parseSetCookie(str, { decode: (v) => v });
 
-					const path = options.path ?? (url.pathname.split('/').slice(0, -1).join('/') || '/');
+					const path =
+						cookie_options.path ?? (url.pathname.split('/').slice(0, -1).join('/') || '/');
 
-					// options.sameSite is string, something more specific is required - type cast is safe
+					// sameSite is string, something more specific is required - type cast is safe
 					set_internal(name, /** @type {string} */ (value), {
 						path,
 						encode: (value) => value,
-						.../** @type {import('cookie').SerializeOptions} */ (options)
+						.../** @type {import('cookie').SerializeOptions} */ (cookie_options)
 					});
 				}
 
@@ -193,12 +193,11 @@ function normalize_fetch_input(info, init, url) {
 
 /**
  * @param {Request} request
- * @param {import('types').SSROptions} options
  * @param {import('@sveltejs/kit').SSRManifest} manifest
  * @param {import('types').RequestState} state
  * @returns {Promise<Response>}
  */
-async function internal_fetch(request, options, manifest, state) {
+async function internal_fetch(request, manifest, state) {
 	if (request.signal?.aborted) {
 		throw new DOMException('The operation was aborted.', 'AbortError');
 	}
@@ -206,7 +205,7 @@ async function internal_fetch(request, options, manifest, state) {
 	const subrequest_state = fork_state_for_subrequest(state);
 
 	if (!request.signal) {
-		return await respond(request, options, manifest, subrequest_state);
+		return await respond(request, manifest, subrequest_state);
 	}
 
 	let remove_abort_listener = noop;
@@ -219,8 +218,7 @@ async function internal_fetch(request, options, manifest, state) {
 		remove_abort_listener = () => request.signal.removeEventListener('abort', on_abort);
 	});
 
-	return Promise.race([
-		respond(request, options, manifest, subrequest_state),
-		abort_promise
-	]).finally(remove_abort_listener);
+	return Promise.race([respond(request, manifest, subrequest_state), abort_promise]).finally(
+		remove_abort_listener
+	);
 }

package/src/runtime/server/index.js

@@ -1,14 +1,24 @@
 import { noop } from '../../utils/functions.js';
-import { IN_WEBCONTAINER } from '../../constants.js';
+import { stream_from_iterable } from '../utils.js';
+import { IN_WEBCONTAINER, REROUTED_URL_HEADER } from '../../constants.js';
 import { respond } from './respond.js';
 import { create_request_state } from './state.js';
-import { options, get_hooks } from '__SERVER__/internal.js';
-import { set_read_implementation, set_manifest, fix_stack_trace } from './internal.js';
-import { set_env } from '__sveltekit/env';
+import { options, get_hooks } from '<sveltekit:generated>/server.js';
+import {
+	set_read_implementation,
+	set_manifest,
+	set_options,
+	set_hooks,
+	fix_stack_trace
+} from './internal.js';
+import { set_env } from '<sveltekit:generated>/env/config.js';
 import { init_tracing } from '@sveltejs/kit/internal/server';
 import { DEV } from 'esm-env';
 import { init_transport } from '#app/internal/transport';
 
+// set at module scope because prerendering evaluates user modules before constructing a `Server`
+set_options(options);
+
 /** @type {Promise<any>} */
 let init_promise;
 
@@ -48,16 +58,11 @@ if (DEV) {
 }
 
 export class Server {
-	/** @type {import('types').SSROptions} */
-	#options;
-
 	/** @type {import('@sveltejs/kit').SSRManifest} */
 	#manifest;
 
 	/** @param {import('@sveltejs/kit').SSRManifest} manifest */
 	constructor(manifest) {
-		/** @type {import('types').SSROptions} */
-		this.#options = options;
 		this.#manifest = manifest;
 
 		// Since AsyncLocalStorage is not working in webcontainers, we don't reset `sync_store`
@@ -105,14 +110,11 @@ export class Server {
 					return result;
 				}
 
-				// TODO remove the cast once TypeScript's lib includes `ReadableStream.from`
-				return /** @type {ReadableStream} */ (
-					/** @type {any} */ (ReadableStream).from(
-						(async function* () {
-							const stream = await result;
-							if (stream) yield* stream;
-						})()
-					)
+				return stream_from_iterable(
+					(async function* () {
+						const stream = await result;
+						if (stream) yield* stream;
+					})()
 				);
 			};
 
@@ -125,7 +127,7 @@ export class Server {
 			try {
 				const module = await get_hooks();
 
-				this.#options.hooks = {
+				set_hooks({
 					handle: module.handle || (({ event, resolve }) => resolve(event)),
 					handleError:
 						module.handleError ||
@@ -154,7 +156,7 @@ export class Server {
 						}),
 					handleFetch: module.handleFetch || (({ request, fetch }) => fetch(request)),
 					reroute: module.reroute || noop
-				};
+				});
 
 				init_transport(module.transport ?? {});
 
@@ -163,14 +165,14 @@ export class Server {
 				}
 			} catch (e) {
 				if (__SVELTEKIT_DEV__) {
-					this.#options.hooks = {
+					set_hooks({
 						handle: () => {
 							throw e;
 						},
 						handleError: ({ error }) => console.error(error),
 						handleFetch: ({ request, fetch }) => fetch(request),
 						reroute: noop
-					};
+					});
 				} else {
 					throw e;
 				}
@@ -183,18 +185,19 @@ export class Server {
 	 * @param {import('types').InternalRequestOptions} options
 	 */
 	async respond(request, options) {
-		const response = await respond(
-			request,
-			this.#options,
-			this.#manifest,
-			create_request_state(options)
-		);
+		const request_state = create_request_state(options);
+
+		const response = await respond(request, this.#manifest, request_state);
 
 		if (DEV) {
 			const error = decoded_responses.get(response);
 			if (error) console.error(fix_stack_trace(error));
 		}
 
+		if (request_state.rerouted_url) {
+			response.headers.set(REROUTED_URL_HEADER, request_state.rerouted_url);
+		}
+
 		return response;
 	}
 }

package/src/runtime/server/internal.js

@@ -1,4 +1,5 @@
 /** @import { SSRManifest } from '@sveltejs/kit'; */
+/** @import { ServerHooks, SSROptions } from 'types'; */
 import { restore, save } from './dev.js';
 import {
 	has_data_suffix,
@@ -16,6 +17,8 @@ const styleText =
 
 const read_implementation_key = Symbol.for('sveltekit.read_implementation');
 const manifest_key = Symbol.for('sveltekit.manifest');
+const options_key = Symbol.for('sveltekit.options');
+const hooks_key = Symbol.for('sveltekit.hooks');
 
 export let read_implementation = /** @type {((path: string) => ReadableStream<any>) | null} */ (
 	(__SVELTEKIT_DEV__ && restore(read_implementation_key)) ?? null
@@ -25,6 +28,12 @@ export let manifest = /** @type {SSRManifest} */ (
 	(__SVELTEKIT_DEV__ && restore(manifest_key)) ?? null
 );
 
+export let options = /** @type {SSROptions} */ (
+	(__SVELTEKIT_DEV__ && restore(options_key)) ?? null
+);
+
+export let hooks = /** @type {ServerHooks} */ ((__SVELTEKIT_DEV__ && restore(hooks_key)) ?? null);
+
 /**
  * @param {(path: string) => ReadableStream<any>} fn
  */
@@ -42,11 +51,28 @@ export function set_manifest(value) {
 	if (__SVELTEKIT_DEV__) save(manifest_key, value);
 }
 
+/**
+ * @param {SSROptions} value
+ */
+export function set_options(value) {
+	options = value;
+	if (__SVELTEKIT_DEV__) save(options_key, value);
+}
+
+/**
+ * @param {ServerHooks} value
+ */
+export function set_hooks(value) {
+	hooks = value;
+	if (__SVELTEKIT_DEV__) save(hooks_key, value);
+}
+
 /**
  * @param {number} status
  * @param {Request} request
+ * @returns {string}
  */
-export function log_response(status, request) {
+export function format_response(status, request) {
 	const url = new URL(request.url);
 	const requested = url.href.replace(url.origin, '');
 
@@ -59,13 +85,17 @@ export function log_response(status, request) {
 		const pathname = strip_resolution_suffix(url.pathname) || '/';
 		log += pathname + styleText('dim', requested.slice(pathname.length));
 	} else if (has_remote_prefix(url)) {
-		const id = /** @type {string} */ (strip_remote_prefix(url).split('/').pop());
-		log += styleText('dim', url.pathname.slice(0, -id.length)) + id + styleText('dim', url.search);
+		const id = /** @type {string} */ (strip_remote_prefix(url));
+		const [file_hash, name, arg_hash] = id.split('/');
+
+		log += styleText('dim', `${url.pathname.slice(0, -id.length)}${file_hash}/`) + name;
+		if (arg_hash) log += styleText('dim', `/${arg_hash}`);
+		if (url.search) log += styleText('dim', url.search);
 	} else {
 		log += requested;
 	}
 
-	console.log(log);
+	return log;
 }
 
 export { fix_stack_trace, set_fix_stack_trace } from './sourcemaps.js';

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

@@ -1,8 +1,7 @@
 /** @import { RequestEvent, Actions } from '@sveltejs/kit' */
 /** @import { ActionResult } from '$app/forms' */
-/** @import { SSROptions, SSRNode, ServerNode } from 'types' */
+/** @import { SSRNode, ServerNode, ServerActionResult } 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, record_span } from '@sveltejs/kit/internal/server';
 import { normalize_error } from '../../../utils/error.js';
@@ -24,102 +23,46 @@ export function is_action_json_request(event) {
 /**
  * @param {RequestEvent} event
  * @param {import('types').RequestState} state
- * @param {SSROptions} options
  * @param {SSRNode['server'] | undefined} server
  */
-export async function handle_action_json_request(event, state, options, server) {
-	const actions = server?.actions;
-	const location = get_action_location(event.url);
-
-	if (!actions) {
-		const no_actions_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'}`
-		);
+export async function handle_action_json_request(event, state, server) {
+	const result = await handle_action_request(event, state, server);
+	return action_result_json(event, state, result);
+}
 
-		const error = await handle_error_and_jsonify(event, state, options, no_actions_error);
+/**
+ * @param {RequestEvent} event
+ * @param {import('types').RequestState} state
+ * @param {ServerActionResult} result
+ * @returns {Promise<Response>}
+ */
+async function action_result_json(event, state, result) {
+	if (result.type === 'redirect') {
+		return action_json(result);
+	}
 
-		return action_json(
-			{
-				type: 'error',
-				error,
-				location
-			},
-			{
-				status: error.status,
-				headers: {
-					// 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'
-				}
-			}
-		);
+	if (result.type === 'error') {
+		const error = await handle_error_and_jsonify(event, state, result.error);
+		return action_json({ ...result, error }, { status: error.status });
 	}
 
-	check_named_default_separate(actions);
+	if (result.type === 'success' && !result.data) {
+		return action_json({ ...result, status: 204, data: undefined });
+	}
 
 	try {
-		const data = await call_action(event, state, actions);
-
-		if (DEV) {
-			validate_action_return(data);
-		}
-
-		if (data instanceof ActionFailure) {
-			return action_json(
-				{
-					type: 'failure',
-					status: data.status,
-					location,
-					// @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: try_serialize(data.data, stringify, /** @type {string} */ (event.route.id))
-				},
-				{
-					status: data.status
-				}
-			);
-		} else if (data) {
-			return action_json({
-				type: 'success',
-				status: 200,
-				location,
-				// @ts-expect-error see comment above
-				data: try_serialize(data, stringify, /** @type {string} */ (event.route.id))
-			});
-		} else {
-			return action_json({
-				type: 'success',
-				status: 204,
-				location
-			});
-		}
-	} catch (e) {
-		const err = normalize_error(e);
-
-		if (err instanceof Redirect) {
-			return action_json_redirect(err);
-		}
-
-		const transformed = await handle_error_and_jsonify(
-			event,
-			state,
-			options,
-			check_incorrect_fail_use(err)
-		);
-
 		return action_json(
 			{
-				type: 'error',
-				error: transformed,
-				location
+				...result,
+				// @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: try_serialize(result.data, stringify, /** @type {string} */ (event.route.id))
 			},
-			{
-				status: transformed.status
-			}
+			{ status: result.status }
 		);
+	} catch (e) {
+		return action_result_json(event, state, action_error_result(e, result.location));
 	}
 }
 
@@ -140,12 +83,48 @@ export function get_action_location(url) {
 }
 
 /**
- * @param {HttpError | Error} error
+ * @param {RequestEvent} event
+ * @param {string} location
+ * @returns {Extract<ServerActionResult, { type: 'error' }>}
+ */
+export function method_not_allowed_result(event, location) {
+	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,
+		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'}`
+		)
+	};
+}
+
+/**
+ * @param {unknown} e
+ * @param {string} location
+ * @returns {Extract<ServerActionResult, { type: 'redirect' | 'error' }>}
  */
-export function check_incorrect_fail_use(error) {
-	return error instanceof ActionFailure
-		? new Error('Cannot "throw fail()". Use "return fail()"')
-		: error;
+export function action_error_result(e, location) {
+	const err = normalize_error(e);
+
+	if (err instanceof Redirect) {
+		return {
+			type: 'redirect',
+			status: err.status,
+			location: err.location
+		};
+	}
+
+	return {
+		type: 'error',
+		location,
+		error: err
+	};
 }
 
 /**
@@ -164,7 +143,7 @@ export function action_json_redirect(redirect) {
  * @param {ResponseInit} [init]
  */
 function action_json(data, init) {
-	return with_version_header(json(data, init));
+	return with_version_header(Response.json(data, init));
 }
 
 /**
@@ -178,7 +157,7 @@ export function is_action_request(event) {
  * @param {RequestEvent} event
  * @param {import('types').RequestState} state
  * @param {SSRNode['server'] | undefined} server
- * @returns {Promise<ActionResult>}
+ * @returns {Promise<ServerActionResult>}
  */
 export async function handle_action_request(event, state, server) {
 	const actions = server?.actions;
@@ -186,21 +165,7 @@ export async function handle_action_request(event, state, server) {
 
 	if (!actions) {
 		// TODO should this be a different error altogether?
-		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);
 	}
 
 	check_named_default_separate(actions);
@@ -229,22 +194,10 @@ export async function handle_action_request(event, state, server) {
 			};
 		}
 	} 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 instanceof ActionFailure ? new Error('Cannot "throw fail()". Use "return fail()"') : e,
+			location
+		);
 	}
 }