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

package/src/runtime/server/errors.js

@@ -0,0 +1,160 @@
+import { json, text } from '@sveltejs/kit';
+import {
+	HandledHttpError,
+	HttpError,
+	SvelteKitError,
+	ValidationError
+} from '@sveltejs/kit/internal';
+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 { escape_html } from '../../utils/escape.js';
+
+/**
+ * @param {import('$app/server').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);
+	const status = body.status;
+
+	// sec-fetch-dest would be nicer, but non-browser clients and plain HTTP hosts don't send it
+	const type = negotiate(event.request.headers.get('accept') || 'text/html', [
+		'application/json',
+		'text/html'
+	]);
+
+	if (event.isDataRequest || type === 'application/json') {
+		return json(body, {
+			status
+		});
+	}
+
+	return static_error_page(options, status, body.message);
+}
+
+/**
+ * @param {import('$app/server').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) {
+	if (error instanceof HandledHttpError) {
+		return error.body;
+	}
+
+	/** @type {import('@sveltejs/kit/hooks').CaughtError} */
+	let caught;
+
+	if (error instanceof HttpError) {
+		caught = { kind: 'app', error: error.body };
+	} else if (error instanceof SvelteKitError) {
+		caught = { kind: 'framework', error: { status: error.status, message: error.text } };
+	} else if (error instanceof ValidationError) {
+		caught = {
+			kind: 'validation',
+			error: { status: 400, message: 'Bad Request' },
+			issues: error.issues
+		};
+	} else {
+		caught = { kind: 'unknown', error };
+
+		let e = error;
+		while (e instanceof Error) {
+			fix_stack_trace(e);
+			e = e.cause;
+		}
+	}
+
+	const fallback =
+		caught.kind === 'unknown' ? { status: 500, message: 'Internal Error' } : caught.error;
+
+	/**
+	 * The hook returns only the properties it wants to override; anything it omits
+	 * (including by returning nothing at all) is inherited from the caught error.
+	 * @param {Awaited<ReturnType<import('@sveltejs/kit/hooks').HandleServerError>>} body
+	 * @returns {App.Error}
+	 */
+	function merge(body) {
+		return { ...fallback, ...body };
+	}
+
+	// TODO 4.0 await this, rather than handling the non-Promise case
+	let result;
+	try {
+		const input = { ...caught, event };
+		if (__SVELTEKIT_DEV__) add_deprecated_handle_error_properties(input, fallback);
+
+		result = with_request_store({ event, state }, () => options.hooks.handleError(input));
+	} catch (hook_error) {
+		log_handle_error_hook_failure(error, hook_error);
+		return { status: fallback.status, message: 'Internal Error' };
+	}
+
+	if (result instanceof Promise) {
+		if (!__SVELTEKIT_SUPPORTS_ASYNC__ && state.is_in_render) {
+			console.warn(
+				`To use an async \`handleError\` hook to handle errors that occur during rendering, you must enable \`compilerOptions.experimental.async\` in the SvelteKit plugin of your Vite config. The returned error has been replaced with a generic object`
+			);
+
+			// we're discarding the result, but we still need to prevent an unhandled
+			// rejection if the user's async `handleError` hook rejects
+			result.catch((hook_error) => log_handle_error_hook_failure(error, hook_error));
+
+			return {
+				status: fallback.status,
+				message: 'Internal Error'
+			};
+		}
+
+		return result.then(merge, (hook_error) => {
+			log_handle_error_hook_failure(error, hook_error);
+			return { status: fallback.status, message: 'Internal Error' };
+		});
+	}
+
+	return merge(result);
+}
+
+/**
+ * @param {unknown} error
+ * @param {unknown} hook_error
+ */
+function log_handle_error_hook_failure(error, hook_error) {
+	const failure = new Error('The `handleError` hook failed', {
+		cause: coalesce_to_error(hook_error)
+	});
+	failure.stack = failure.message;
+	console.error(failure);
+	if (error instanceof SvelteKitError) {
+		console.error(`Original error: ${error.status} ${error.text}: ${error.message}`);
+	} else {
+		console.error('Original error:', 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) {
+	let page = options.templates.error({ status, message: escape_html(message) });
+
+	if (__SVELTEKIT_DEV__) {
+		// inject Vite HMR client, for easier debugging
+		page = page.replace('</head>', '<script type="module" src="/@vite/client"></script></head>');
+	}
+
+	return text(page, {
+		headers: { 'content-type': 'text/html; charset=utf-8' },
+		status
+	});
+}

package/src/runtime/server/fetch.js

@@ -1,16 +1,17 @@
 import { parseSetCookie } from 'cookie';
 import { noop } from '../../utils/functions.js';
 import { respond } from './respond.js';
-import * as paths from '$app/paths/internal/server';
-import { read_implementation } from '__sveltekit/server';
+import * as paths from '#app/paths';
+import { 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;
+ *   event: import('$app/server').RequestEvent;
  *   options: import('types').SSROptions;
  *   manifest: import('@sveltejs/kit').SSRManifest;
- *   state: import('types').SSRState;
+ *   state: import('types').RequestState;
  *   get_cookie_header: (url: URL, header: string | null) => string;
  *   set_internal: (name: string, value: string, opts: import('./page/types.js').Cookie['options']) => void;
  * }} opts
@@ -117,7 +118,7 @@ export function create_fetch({ event, options, manifest, state, get_cookie_heade
 					return await fetch(request);
 				}
 
-				if (has_prerendered_path(manifest, paths.base + decoded)) {
+				if (has_prerendered_path(manifest, decoded)) {
 					// The path of something prerendered could match a different route
 					// that is still in the manifest, leading to the wrong route being loaded.
 					// We therefore bail early here. The prerendered logic is different for
@@ -142,11 +143,9 @@ export function create_fetch({ event, options, manifest, state, get_cookie_heade
 					request.headers.set('accept', '*/*');
 				}
 
-				if (!request.headers.has('accept-language')) {
-					request.headers.set(
-						'accept-language',
-						/** @type {string} */ (event.request.headers.get('accept-language'))
-					);
+				const accept_language = event.request.headers.get('accept-language');
+				if (accept_language && !request.headers.has('accept-language')) {
+					request.headers.set('accept-language', accept_language);
 				}
 
 				const response = await internal_fetch(request, options, manifest, state);
@@ -196,38 +195,32 @@ function normalize_fetch_input(info, init, url) {
  * @param {Request} request
  * @param {import('types').SSROptions} options
  * @param {import('@sveltejs/kit').SSRManifest} manifest
- * @param {import('types').SSRState} state
+ * @param {import('types').RequestState} state
  * @returns {Promise<Response>}
  */
 async function internal_fetch(request, options, manifest, state) {
-	if (request.signal) {
-		if (request.signal.aborted) {
-			throw new DOMException('The operation was aborted.', 'AbortError');
-		}
-
-		let remove_abort_listener = noop;
-		/** @type {Promise<never>} */
-		const abort_promise = new Promise((_, reject) => {
-			const on_abort = () => {
-				reject(new DOMException('The operation was aborted.', 'AbortError'));
-			};
-			request.signal.addEventListener('abort', on_abort, { once: true });
-			remove_abort_listener = () => request.signal.removeEventListener('abort', on_abort);
-		});
+	if (request.signal?.aborted) {
+		throw new DOMException('The operation was aborted.', 'AbortError');
+	}
 
-		const result = await Promise.race([
-			respond(request, options, manifest, {
-				...state,
-				depth: state.depth + 1
-			}),
-			abort_promise
-		]);
-		remove_abort_listener();
-		return result;
-	} else {
-		return await respond(request, options, manifest, {
-			...state,
-			depth: state.depth + 1
-		});
+	const subrequest_state = fork_state_for_subrequest(state);
+
+	if (!request.signal) {
+		return await respond(request, options, manifest, subrequest_state);
 	}
+
+	let remove_abort_listener = noop;
+	/** @type {Promise<never>} */
+	const abort_promise = new Promise((_, reject) => {
+		const on_abort = () => {
+			reject(new DOMException('The operation was aborted.', 'AbortError'));
+		};
+		request.signal.addEventListener('abort', on_abort, { once: true });
+		remove_abort_listener = () => request.signal.removeEventListener('abort', on_abort);
+	});
+
+	return Promise.race([
+		respond(request, options, manifest, subrequest_state),
+		abort_promise
+	]).finally(remove_abort_listener);
 }

package/src/runtime/server/index.js

@@ -1,11 +1,13 @@
 import { noop } from '../../utils/functions.js';
-import { IN_WEBCONTAINER } from './constants.js';
+import { IN_WEBCONTAINER } from '../../constants.js';
 import { respond } from './respond.js';
+import { create_request_state } from './state.js';
 import { options, get_hooks } from '__SERVER__/internal.js';
-import { format_server_error } from './utils.js';
-import { set_read_implementation, set_manifest } from '__sveltekit/server';
+import { set_read_implementation, set_manifest, fix_stack_trace } from './internal.js';
 import { set_env } from '__sveltekit/env';
-import { set_app } from './app.js';
+import { init_tracing } from '@sveltejs/kit/internal/server';
+import { DEV } from 'esm-env';
+import { init_transport } from '#app/internal/transport';
 
 /** @type {Promise<any>} */
 let init_promise;
@@ -13,6 +15,38 @@ let init_promise;
 /** @type {Promise<void> | null} */
 let current = null;
 
+/**
+ * Responses that were created with our monkey-patched `fetch`, which may need
+ * to have their `content-encoding` and `content-length` headers removed
+ * if returned directly (i.e. `fetch` is being used to proxy a request)
+ * @type {WeakMap<Response, Error>}
+ */
+const decoded_responses = new WeakMap();
+
+if (DEV) {
+	const fetch = globalThis.fetch;
+
+	/**
+	 * @param {RequestInfo | URL} info
+	 * @param {RequestInit} [init]
+	 */
+	globalThis.fetch = async (info, init) => {
+		const response = await fetch(info, init);
+		const encoding = response.headers.get('content-encoding');
+
+		if (encoding) {
+			decoded_responses.set(
+				response,
+				new Error(
+					`Cannot return \`fetch(...)\` directly from a handler if the response has a \`Content-Encoding: ${encoding}\` header. The body has already been decoded`
+				)
+			);
+		}
+
+		return response;
+	};
+}
+
 export class Server {
 	/** @type {import('types').SSROptions} */
 	#options;
@@ -27,7 +61,7 @@ export class Server {
 		this.#manifest = manifest;
 
 		// Since AsyncLocalStorage is not working in webcontainers, we don't reset `sync_store`
-		// in `src/exports/internal/event.js` and handle only one request at a time.
+		// in `src/exports/internal/server/event.js` and handle only one request at a time.
 		if (IN_WEBCONTAINER) {
 			const respond = this.respond.bind(this);
 
@@ -56,6 +90,8 @@ export class Server {
 		// so anything that shouldn't be rerun should be wrapped in an `if` block to make sure it hasn't
 		// been done already.
 
+		if (__SVELTEKIT_SERVER_TRACING_ENABLED__) init_tracing(import('@opentelemetry/api'));
+
 		// set env, in case it's used in initialisation
 		set_env(env);
 
@@ -67,31 +103,17 @@ export class Server {
 				const result = read(file);
 				if (result instanceof ReadableStream) {
 					return result;
-				} else {
-					return new ReadableStream({
-						async start(controller) {
-							try {
-								const stream = await Promise.resolve(result);
-								if (!stream) {
-									controller.close();
-									return;
-								}
-
-								const reader = stream.getReader();
-
-								while (true) {
-									const { done, value } = await reader.read();
-									if (done) break;
-									controller.enqueue(value);
-								}
-
-								controller.close();
-							} catch (error) {
-								controller.error(error);
-							}
-						}
-					});
 				}
+
+				// 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;
+						})()
+					)
+				);
 			};
 
 			set_read_implementation(wrapped_read);
@@ -107,30 +129,34 @@ export class Server {
 					handle: module.handle || (({ event, resolve }) => resolve(event)),
 					handleError:
 						module.handleError ||
-						(({ status, error, event }) => {
-							const error_message = format_server_error(
-								status,
-								/** @type {Error} */ (error),
-								event
-							);
-							console.error(error_message);
+						(({ kind, error, issues }) => {
+							if (kind === 'validation') {
+								console.error('Remote function schema validation failed:', issues);
+								return;
+							}
+
+							if (kind !== 'unknown') {
+								// don't log stack traces for 404s etc, it's all internal gubbins
+								return;
+							}
+
+							let e = error;
+							while (e instanceof Error) {
+								if (e.stack) {
+									console.error(e.stack);
+								}
+								e = e.cause;
+							}
+
+							if (e) {
+								console.error(String(e));
+							}
 						}),
 					handleFetch: module.handleFetch || (({ request, fetch }) => fetch(request)),
-					handleValidationError:
-						module.handleValidationError ||
-						(({ issues }) => {
-							console.error('Remote function schema validation failed:', issues);
-							return { message: 'Bad Request' };
-						}),
-					reroute: module.reroute || noop,
-					transport: module.transport || {}
+					reroute: module.reroute || noop
 				};
 
-				set_app({
-					decoders: module.transport
-						? Object.fromEntries(Object.entries(module.transport).map(([k, v]) => [k, v.decode]))
-						: {}
-				});
+				init_transport(module.transport ?? {});
 
 				if (module.init) {
 					await module.init();
@@ -143,16 +169,8 @@ export class Server {
 						},
 						handleError: ({ error }) => console.error(error),
 						handleFetch: ({ request, fetch }) => fetch(request),
-						handleValidationError: () => {
-							return { message: 'Bad Request' };
-						},
-						reroute: noop,
-						transport: {}
+						reroute: noop
 					};
-
-					set_app({
-						decoders: {}
-					});
 				} else {
 					throw e;
 				}
@@ -162,13 +180,21 @@ export class Server {
 
 	/**
 	 * @param {Request} request
-	 * @param {import('types').RequestOptions} options
+	 * @param {import('types').InternalRequestOptions} options
 	 */
 	async respond(request, options) {
-		return respond(request, this.#options, this.#manifest, {
-			...options,
-			error: false,
-			depth: 0
-		});
+		const response = await respond(
+			request,
+			this.#options,
+			this.#manifest,
+			create_request_state(options)
+		);
+
+		if (DEV) {
+			const error = decoded_responses.get(response);
+			if (error) console.error(fix_stack_trace(error));
+		}
+
+		return response;
 	}
 }

package/src/runtime/server/internal.js

@@ -0,0 +1,71 @@
+/** @import { SSRManifest } from '@sveltejs/kit'; */
+import { restore, save } from './dev.js';
+import {
+	has_data_suffix,
+	has_resolution_suffix,
+	strip_data_suffix,
+	strip_resolution_suffix
+} from '../../pathname.js';
+import { has_remote_prefix, strip_remote_prefix } from '../../runtime/server/remote-functions.js';
+
+// using `getBuiltinModule` rather than `import` makes this safe to run in non-Node-compatible environments
+const styleText =
+	// eslint-disable-next-line n/prefer-global/process
+	globalThis.process?.getBuiltinModule?.('node:util')?.styleText ??
+	/** @type {(format: unknown, text: string) => string} */ ((_format, text) => text);
+
+const read_implementation_key = Symbol.for('sveltekit.read_implementation');
+const manifest_key = Symbol.for('sveltekit.manifest');
+
+export let read_implementation = /** @type {((path: string) => ReadableStream<any>) | null} */ (
+	(__SVELTEKIT_DEV__ && restore(read_implementation_key)) ?? null
+);
+
+export let manifest = /** @type {SSRManifest} */ (
+	(__SVELTEKIT_DEV__ && restore(manifest_key)) ?? null
+);
+
+/**
+ * @param {(path: string) => ReadableStream<any>} fn
+ */
+export function set_read_implementation(fn) {
+	read_implementation = fn;
+	if (__SVELTEKIT_DEV__) save(read_implementation_key, fn);
+}
+
+/**
+ *
+ * @param {SSRManifest} value
+ */
+export function set_manifest(value) {
+	manifest = value;
+	if (__SVELTEKIT_DEV__) save(manifest_key, value);
+}
+
+/**
+ * @param {number} status
+ * @param {Request} request
+ */
+export function log_response(status, request) {
+	const url = new URL(request.url);
+	const requested = url.href.replace(url.origin, '');
+
+	let log = `${styleText(status < 400 ? ['cyan'] : ['bold', 'red'], `${status}`)} ${request.method} `;
+
+	if (has_data_suffix(url.pathname)) {
+		const pathname = strip_data_suffix(url.pathname) || '/';
+		log += pathname + styleText('dim', requested.slice(pathname.length));
+	} else if (has_resolution_suffix(url.pathname)) {
+		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);
+	} else {
+		log += requested;
+	}
+
+	console.log(log);
+}
+
+export { fix_stack_trace, set_fix_stack_trace } from './sourcemaps.js';