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

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

@@ -1,8 +1,8 @@
 import { Redirect } from '@sveltejs/kit/internal';
 import { render_response } from './render.js';
 import { load_data, load_server_data } from './load_data.js';
-import { handle_error_and_jsonify, static_error_page, redirect_response } from '../utils.js';
-import { get_status } from '../../../utils/error.js';
+import { redirect_response } from '../utils.js';
+import { handle_error_and_jsonify, static_error_page } from '../errors.js';
 import { PageNodes } from '../../../utils/page_nodes.js';
 import { server_data_serializer } from './data_serializer.js';
 
@@ -12,48 +12,38 @@ import { server_data_serializer } from './data_serializer.js';
 
 /**
  * @param {{
- *   event: import('@sveltejs/kit').RequestEvent;
- *   event_state: import('types').RequestState;
+ *   event: import('$app/server').RequestEvent;
+ *   state: import('types').RequestState;
  *   options: import('types').SSROptions;
  *   manifest: import('@sveltejs/kit').SSRManifest;
- *   state: import('types').SSRState;
- *   status: number;
  *   error: unknown;
  *   resolve_opts: import('types').RequiredResolveOptions;
  * }} opts
  */
-export async function respond_with_error({
-	event,
-	event_state,
-	options,
-	manifest,
-	state,
-	status,
-	error,
-	resolve_opts
-}) {
+export async function respond_with_error({ event, state, options, manifest, error, resolve_opts }) {
 	// reroute to the fallback page to prevent an infinite chain of requests.
 	if (event.request.headers.get('x-sveltekit-error')) {
-		return static_error_page(options, status, /** @type {Error} */ (error).message);
+		const transformed = await handle_error_and_jsonify(event, state, options, error);
+		return static_error_page(options, transformed.status, transformed.message);
 	}
 
 	/** @type {import('./types.js').Fetched[]} */
 	const fetched = [];
-
 	try {
 		const branch = [];
 		const default_layout = await manifest._.nodes[0](); // 0 is always the root layout
 		const nodes = new PageNodes([default_layout]);
 		const ssr = nodes.ssr();
 		const csr = nodes.csr();
-		const data_serializer = server_data_serializer(event, event_state, options);
+		const data_serializer = server_data_serializer(event, state, options);
+		// Do this here first in case the awaits below before rendering themselves error
+		const transformed = await handle_error_and_jsonify(event, state, options, error);
 
 		if (ssr) {
 			state.error = true;
 
 			const server_data_promise = load_server_data({
 				event,
-				event_state,
 				state,
 				node: default_layout,
 				// eslint-disable-next-line @typescript-eslint/require-await
@@ -65,14 +55,13 @@ export async function respond_with_error({
 
 			const data = await load_data({
 				event,
-				event_state,
+				state,
 				fetched,
 				node: default_layout,
 				// eslint-disable-next-line @typescript-eslint/require-await
 				parent: async () => ({}),
 				resolve_opts,
 				server_data_promise,
-				state,
 				csr
 			});
 
@@ -93,18 +82,17 @@ export async function respond_with_error({
 		return await render_response({
 			options,
 			manifest,
-			state,
 			page_config: {
 				ssr,
 				csr
 			},
-			status,
-			error: await handle_error_and_jsonify(event, event_state, options, error),
+			status: transformed.status,
+			error: transformed,
 			branch,
 			error_components: [],
 			fetched,
 			event,
-			event_state,
+			state,
 			resolve_opts,
 			data_serializer
 		});
@@ -115,10 +103,8 @@ export async function respond_with_error({
 			return redirect_response(e.status, e.location);
 		}
 
-		return static_error_page(
-			options,
-			get_status(e),
-			(await handle_error_and_jsonify(event, event_state, options, e)).message
-		);
+		const transformed = await handle_error_and_jsonify(event, state, options, e);
+
+		return static_error_page(options, transformed.status, transformed.message);
 	}
 }

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

@@ -1,5 +1,5 @@
 import { escape_html } from '../../../utils/escape.js';
-import { hash } from '../../../utils/hash.js';
+import { hash_request } from '../../../utils/hash.js';
 
 /**
  * Inside a script element, only `</script` and `<!--` hold special meaning to the HTML parser.
@@ -78,18 +78,7 @@ export function serialize_data(fetched, filter, prerendering = false) {
 	}
 
 	if (fetched.request_headers || fetched.request_body) {
-		/** @type {import('types').StrictBody[]} */
-		const values = [];
-
-		if (fetched.request_headers) {
-			values.push([...new Headers(fetched.request_headers)].join(','));
-		}
-
-		if (fetched.request_body) {
-			values.push(fetched.request_body);
-		}
-
-		attrs.push(`data-hash="${hash(...values)}"`);
+		attrs.push(`data-hash="${hash_request(fetched.request_headers, fetched.request_body)}"`);
 	}
 
 	// Compute the time the response should be cached, taking into account max-age and age.

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

@@ -1,4 +1,6 @@
-import { base, assets, relative } from '$app/paths/internal/server';
+/** @import { SSRManifest } from '@sveltejs/kit' */
+import { base, assets } from '#app/paths';
+import { relative } from '$app/paths/internal/server';
 import { text } from '@sveltejs/kit';
 import { s } from '../../../utils/misc.js';
 import { find_route } from '../../../utils/routing.js';
@@ -7,19 +9,19 @@ import { get_relative_path } from '../../utils.js';
 /**
  * @param {import('types').SSRClientRoute} route
  * @param {URL} url
- * @param {import('@sveltejs/kit').SSRManifest} manifest
+ * @param {NonNullable<SSRManifest['_']['client']>} client
  * @returns {string}
  */
-export function generate_route_object(route, url, manifest) {
+export function generate_route_object(route, url, client) {
 	const { errors, layouts, leaf } = route;
 
 	const nodes = [...errors, ...layouts.map((l) => l?.[1]), leaf[1]]
 		.filter((n) => typeof n === 'number')
-		.map((n) => `'${n}': () => ${create_client_import(manifest._.client.nodes?.[n], url)}`)
+		.map((n) => `'${n}': () => ${create_client_import(client.nodes?.[n], url)}`)
 		.join(',\n\t\t');
 
 	// stringified version of
-	/** @type {import('types').CSRRouteServer} */
+	/* @type {import('types').CSRRouteServer} */
 	return [
 		`{\n\tid: ${s(route.id)}`,
 		`errors: ${s(route.errors)}`,
@@ -60,41 +62,98 @@ function create_client_import(import_path, url) {
 /**
  * @param {string} resolved_path
  * @param {URL} url
- * @param {import('@sveltejs/kit').SSRManifest} manifest
+ * @param {SSRManifest} manifest
  * @returns {Promise<Response>}
  */
 export async function resolve_route(resolved_path, url, manifest) {
-	if (!manifest._.client.routes) {
+	if (!manifest._.client?.routes) {
 		return text('Server-side route resolution disabled', { status: 400 });
 	}
 
-	const matchers = await manifest._.matchers();
-	const result = find_route(resolved_path, manifest._.client.routes, matchers);
+	try {
+		const matchers = await manifest._.matchers();
+		const result = find_route(resolved_path, manifest._.client.routes, matchers);
+
+		return create_server_routing_response(
+			result?.route ?? null,
+			result?.params ?? {},
+			url,
+			manifest._.client
+		).response;
+	} catch {
+		return text('Error resolving route', { status: 500 });
+	}
+}
 
-	return create_server_routing_response(result?.route ?? null, result?.params ?? {}, url, manifest)
-		.response;
+/**
+ * Resolve a route-ID resolution request (`/_app/routes/<id>/__route.js`) to a
+ * JS module containing the route's node loaders. Params are always `{}` since
+ * this endpoint exists to support `preloadCode(routeId)`, which doesn't need them.
+ *
+ * The module has one of three shapes, which the client uses to tell three cases apart:
+ *
+ * - `export const route = {...}` — a page route, with loaders to import
+ * - `export const endpoint_only = true` — a real route with no `+page`, so there is
+ *   nothing to preload, but the client can cache that fact and stop asking
+ * - an empty module — no such route
+ *
+ * @param {string} route_id
+ * @param {URL} url
+ * @param {SSRManifest} manifest
+ * @returns {Response}
+ */
+export function resolve_route_by_id(route_id, url, manifest) {
+	if (!manifest._.client?.routes) {
+		return text('Server-side route resolution disabled', { status: 400 });
+	}
+
+	try {
+		const route = manifest._.client.routes.find((r) => r.id === route_id);
+
+		if (route) {
+			return create_server_routing_response(route, null, url, manifest._.client).response;
+		}
+
+		// `client.routes` only contains routes with a `+page`, so a miss above doesn't mean the
+		// route doesn't exist — it might be a `+server.js`-only route. `_.routes` includes those
+		// (with `page: null`), so we can distinguish "exists but has no code" from "unknown".
+		if (manifest._.routes.some((r) => r.id === route_id && !r.page)) {
+			return text('export const endpoint_only = true;', { headers: js_headers() });
+		}
+
+		return create_server_routing_response(null, null, url, manifest._.client).response;
+	} catch {
+		return text('Error resolving route', { status: 500 });
+	}
+}
+
+function js_headers() {
+	return new Headers({
+		'content-type': 'application/javascript; charset=utf-8'
+	});
 }
 
 /**
  * @param {import('types').SSRClientRoute | null} route
- * @param {Partial<Record<string, string>>} params
+ * @param {Partial<Record<string, string>> | null} params
  * @param {URL} url
- * @param {import('@sveltejs/kit').SSRManifest} manifest
+ * @param {NonNullable<SSRManifest['_']['client']>} client
  * @returns {{response: Response, body: string}}
  */
-export function create_server_routing_response(route, params, url, manifest) {
-	const headers = new Headers({
-		'content-type': 'application/javascript; charset=utf-8'
-	});
+export function create_server_routing_response(route, params, url, client) {
+	const headers = js_headers();
+	let body = '';
 
 	if (route) {
-		const csr_route = generate_route_object(route, url, manifest);
-		const body = `${create_css_import(route, url, manifest)}\nexport const route = ${csr_route}; export const params = ${JSON.stringify(params)};`;
+		const csr_route = generate_route_object(route, url, client);
+		body = `${create_css_import(route, url, client)}export const route = ${csr_route};`;
 
-		return { response: text(body, { headers }), body };
-	} else {
-		return { response: text('', { headers }), body: '' };
+		if (params !== null) {
+			body += `\nexport const params = ${JSON.stringify(params)}`;
+		}
 	}
+
+	return { response: text(body, { headers }), body };
 }
 
 /**
@@ -105,17 +164,17 @@ export function create_server_routing_response(route, params, url, manifest) {
  *
  * @param {import('types').SSRClientRoute} route
  * @param {URL} url
- * @param {import('@sveltejs/kit').SSRManifest} manifest
+ * @param {NonNullable<SSRManifest['_']['client']>} client
  * @returns {string}
  */
-function create_css_import(route, url, manifest) {
+function create_css_import(route, url, client) {
 	const { errors, layouts, leaf } = route;
 
 	let css = '';
 
 	for (const node of [...errors, ...layouts.map((l) => l?.[1]), leaf[1]]) {
 		if (typeof node !== 'number') continue;
-		const node_css = manifest._.client.css?.[node];
+		const node_css = client.css?.[node];
 		for (const css_path of node_css ?? []) {
 			css += `'${assets || base}/${css_path}',`;
 		}
@@ -123,5 +182,5 @@ function create_css_import(route, url, manifest) {
 
 	if (!css) return '';
 
-	return `${create_client_import(/** @type {string} */ (manifest._.client.start), url)}.then(x => x.load_css([${css}]));`;
+	return `${create_client_import(client.start, url)}.then(x => x.load_css([${css}]));\n`;
 }