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

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

@@ -11,16 +11,21 @@ import { uneval_action_response } from './actions.js';
 import { SVELTE_KIT_ASSETS } from '../../../constants.js';
 import { SCHEME } from '../../../utils/url.js';
 import { create_server_routing_response, generate_route_object } from './server_routing.js';
-import { add_data_suffix, add_resolution_suffix } from '../../pathname.js';
+import {
+	add_data_suffix,
+	add_resolution_suffix,
+	route_id_resolution_pathname
+} from '../../pathname.js';
 import { try_get_request_store, with_request_store } from '@sveltejs/kit/internal/server';
 import { text_encoder } from '../../utils.js';
-import { count_non_ssi_comments, create_replacer, get_global_name } from '../utils.js';
+import { count_non_ssi_comments, get_global_name } from '../utils.js';
 import { handle_error_and_jsonify } from '../errors.js';
 import * as env from '__sveltekit/env';
 import { collect_remote_data } from '../remote-functions.js';
 import Root from '../../components/root.svelte';
 import { render } from 'svelte/server';
 import { Props, RenderNode } from '../../props.svelte.js';
+import { has_custom_transporters, uneval } from '#app/internal/transport';
 
 // TODO rename this function/module
 
@@ -31,12 +36,11 @@ import { Props, RenderNode } from '../../props.svelte.js';
  *   fetched: Array<import('./types.js').Fetched>;
  *   options: import('types').SSROptions;
  *   manifest: import('@sveltejs/kit').SSRManifest;
- *   state: import('types').SSRState;
  *   page_config: { ssr: boolean; csr: boolean };
  *   status: number;
  *   error: App.Error | null;
  *   event: import('@sveltejs/kit').RequestEvent;
- *   event_state: import('types').RequestState;
+ *   state: import('types').RequestState;
  *   resolve_opts: import('types').RequiredResolveOptions;
  *   action_result?: import('@sveltejs/kit').ActionResult;
  *   data_serializer: import('./types.js').ServerDataSerializer;
@@ -48,12 +52,11 @@ export async function render_response({
 	fetched,
 	options,
 	manifest,
-	state,
 	page_config,
 	status,
 	error = null,
 	event,
-	event_state,
+	state,
 	resolve_opts,
 	action_result,
 	data_serializer,
@@ -179,7 +182,7 @@ export async function render_response({
 
 		props.page.data = data;
 
-		const render_state = { ...event_state, is_in_render: true };
+		const render_state = { ...state, is_in_render: true };
 
 		const render_opts = {
 			context: new Map([
@@ -390,6 +393,20 @@ export async function render_response({
 				pathname,
 				create_server_routing_response(route, event.params, new URL(pathname, event.url), client)
 			);
+
+			// Prerender a route-ID-keyed `/_app/routes/<id>/__route.js` module alongside the
+			// pathname-keyed one above, so that `preloadCode(id)` can resolve a route ID without
+			// hitting the server.
+			if (route && !state.prerendering.resolved_route_ids.has(route.id)) {
+				state.prerendering.resolved_route_ids.add(route.id);
+
+				const id_pathname = paths.base + route_id_resolution_pathname(paths.app_dir, route.id);
+
+				state.prerendering.dependencies.set(
+					id_pathname,
+					create_server_routing_response(route, null, new URL(id_pathname, event.url), client)
+				);
+			}
 		}
 
 		const blocks = [];
@@ -413,7 +430,7 @@ export async function render_response({
 
 			let app_declaration = '';
 
-			if (Object.keys(options.hooks.transport).length > 0) {
+			if (has_custom_transporters) {
 				if (client.inline) {
 					app_declaration = `const app = ${global}.app.app;`;
 				} else if (client.app) {
@@ -464,8 +481,7 @@ export async function render_response({
 			if (form_value) {
 				serialized.form = uneval_action_response(
 					form_value,
-					/** @type {string} */ (event.route.id),
-					options.hooks.transport
+					/** @type {string} */ (event.route.id)
 				);
 			}
 
@@ -500,11 +516,11 @@ export async function render_response({
 			args.push(`{\n${indent}\t${hydrate.join(`,\n${indent}\t`)}\n${indent}}`);
 		}
 
-		const remote_data = await collect_remote_data({}, event, event_state, options);
+		const remote_data = await collect_remote_data({}, event, state, options);
 
 		const serialized_data =
 			Object.keys(remote_data).length > 0
-				? `${global}.data = ${devalue.uneval(remote_data, create_replacer(options.hooks.transport))};\n\n\t\t\t\t\t\t`
+				? `${global}.data = ${uneval(remote_data)};\n\n\t\t\t\t\t\t`
 				: '';
 
 		// `client.app` is a proxy for `bundleStrategy === 'split'`

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

@@ -13,26 +13,17 @@ import { server_data_serializer } from './data_serializer.js';
 /**
  * @param {{
  *   event: import('@sveltejs/kit').RequestEvent;
- *   event_state: import('types').RequestState;
+ *   state: import('types').RequestState;
  *   options: import('types').SSROptions;
  *   manifest: import('@sveltejs/kit').SSRManifest;
- *   state: import('types').SSRState;
  *   error: unknown;
  *   resolve_opts: import('types').RequiredResolveOptions;
  * }} opts
  */
-export async function respond_with_error({
-	event,
-	event_state,
-	options,
-	manifest,
-	state,
-	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')) {
-		const transformed = await handle_error_and_jsonify(event, event_state, options, error);
+		const transformed = await handle_error_and_jsonify(event, state, options, error);
 		return static_error_page(options, transformed.status, transformed.message);
 	}
 
@@ -44,16 +35,15 @@ export async function respond_with_error({
 		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, event_state, options, 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,7 +82,6 @@ export async function respond_with_error({
 		return await render_response({
 			options,
 			manifest,
-			state,
 			page_config: {
 				ssr,
 				csr
@@ -104,7 +92,7 @@ export async function respond_with_error({
 			error_components: [],
 			fetched,
 			event,
-			event_state,
+			state,
 			resolve_opts,
 			data_serializer
 		});
@@ -115,7 +103,7 @@ export async function respond_with_error({
 			return redirect_response(e.status, e.location);
 		}
 
-		const transformed = await handle_error_and_jsonify(event, event_state, options, e);
+		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

@@ -84,26 +84,75 @@ export async function resolve_route(resolved_path, url, manifest) {
 	}
 }
 
+/**
+ * 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 {NonNullable<SSRManifest['_']['client']>} client
  * @returns {{response: Response, body: string}}
  */
 export function create_server_routing_response(route, params, url, client) {
-	const headers = new Headers({
-		'content-type': 'application/javascript; charset=utf-8'
-	});
+	const headers = js_headers();
+	let body = '';
 
 	if (route) {
 		const csr_route = generate_route_object(route, url, client);
-		const body = `${create_css_import(route, url, client)}\nexport const route = ${csr_route}; export const params = ${JSON.stringify(params)};`;
+		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 };
 }
 
 /**
@@ -132,5 +181,5 @@ function create_css_import(route, url, client) {
 
 	if (!css) return '';
 
-	return `${create_client_import(client.start, url)}.then(x => x.load_css([${css}]));`;
+	return `${create_client_import(client.start, url)}.then(x => x.load_css([${css}]));\n`;
 }

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

@@ -6,7 +6,8 @@ import { Redirect, SvelteKitError } from '@sveltejs/kit/internal';
 import { with_request_store, merge_tracing } from '@sveltejs/kit/internal/server';
 import { app_dir, base } from '$app/paths/internal/server';
 import { is_form_content_type } from '../../utils/http.js';
-import { create_remote_key, parse_remote_arg, split_remote_key, stringify } from '../shared.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 } from './page/actions.js';
@@ -59,7 +60,6 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 
 	/** @type {RemoteInternals} */
 	const internals = fn.__;
-	const transport = options.hooks.transport;
 
 	event.tracing.current.setAttributes({
 		'sveltekit.remote.call.type': internals.type,
@@ -87,7 +87,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, transport));
+				const generator = internals.run(event, state, parse_remote_arg(payload));
 
 				const encoder = new TextEncoder();
 
@@ -156,7 +156,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 									}
 
 									// only send changed data
-									if (result !== (result = stringify(value, transport))) {
+									if (result !== (result = stringify(value))) {
 										send(controller, {
 											type: 'result',
 											result
@@ -214,9 +214,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 				/** @type {{ payloads: string[] }} */
 				const { payloads } = await event.request.json();
 
-				const args = await Promise.all(
-					payloads.map((payload) => parse_remote_arg(payload, transport))
-				);
+				const args = await Promise.all(payloads.map((payload) => parse_remote_arg(payload)));
 
 				data._ = await with_request_store({ event, state }, () => internals.run(args, options));
 
@@ -266,7 +264,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 					return json(
 						/** @type {RemoteFunctionResponse} */ ({
 							type: 'result',
-							data: stringify(data, transport)
+							data: stringify(data)
 						}),
 						{ headers }
 					);
@@ -279,7 +277,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 				/** @type {{ payload: string, refreshes?: string[] }} */
 				const { payload, refreshes } = await event.request.json();
 				state.remote.requested = create_requested_map(refreshes);
-				const arg = parse_remote_arg(payload, transport);
+				const arg = parse_remote_arg(payload);
 
 				data._ = await with_request_store(
 					{ event, state: { ...state, is_in_remote_form_or_command: true } },
@@ -291,7 +289,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 
 			case 'prerender': {
 				data._ = await with_request_store({ event, state }, () =>
-					fn(parse_remote_arg(additional_args, transport))
+					fn(parse_remote_arg(additional_args))
 				);
 
 				break;
@@ -303,9 +301,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 					new URL(event.request.url).searchParams.get('payload')
 				);
 
-				data._ = await with_request_store({ event, state }, () =>
-					fn(parse_remote_arg(payload, transport))
-				);
+				data._ = await with_request_store({ event, state }, () => fn(parse_remote_arg(payload)));
 
 				break;
 			}
@@ -316,7 +312,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 		return json(
 			/** @type {RemoteFunctionResponse} */ ({
 				type: 'result',
-				data: stringify(data, transport)
+				data: stringify(data)
 			}),
 			{ headers }
 		);
@@ -327,7 +323,7 @@ async function handle_remote_call_internal(event, state, options, manifest, id)
 			return json(
 				/** @type {RemoteFunctionResponse} */ ({
 					type: 'result',
-					data: stringify(data, transport)
+					data: stringify(data)
 				}),
 				{ headers }
 			);