@sveltejs/kit 1.0.0-next.98 → 1.0.0

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

@@ -0,0 +1,326 @@
+import { compact } from '../../../utils/array.js';
+import { normalize_error } from '../../../utils/error.js';
+import { add_data_suffix } from '../../../utils/url.js';
+import { HttpError, Redirect } from '../../control.js';
+import {
+	get_option,
+	redirect_response,
+	static_error_page,
+	handle_error_and_jsonify,
+	serialize_data_node
+} from '../utils.js';
+import {
+	handle_action_json_request,
+	handle_action_request,
+	is_action_json_request,
+	is_action_request
+} from './actions.js';
+import { load_data, load_server_data } from './load_data.js';
+import { render_response } from './render.js';
+import { respond_with_error } from './respond_with_error.js';
+
+/**
+ * @param {import('types').RequestEvent} event
+ * @param {import('types').SSRRoute} route
+ * @param {import('types').PageNodeIndexes} page
+ * @param {import('types').SSROptions} options
+ * @param {import('types').SSRState} state
+ * @param {import('types').RequiredResolveOptions} resolve_opts
+ * @returns {Promise<Response>}
+ */
+export async function render_page(event, route, page, options, state, resolve_opts) {
+	if (state.initiator === route) {
+		// infinite request cycle detected
+		return new Response(`Not found: ${event.url.pathname}`, {
+			status: 404
+		});
+	}
+
+	state.initiator = route;
+
+	if (is_action_json_request(event)) {
+		const node = await options.manifest._.nodes[page.leaf]();
+		return handle_action_json_request(event, options, node?.server);
+	}
+
+	try {
+		const nodes = await Promise.all([
+			// we use == here rather than === because [undefined] serializes as "[null]"
+			...page.layouts.map((n) => (n == undefined ? n : options.manifest._.nodes[n]())),
+			options.manifest._.nodes[page.leaf]()
+		]);
+
+		const leaf_node = /** @type {import('types').SSRNode} */ (nodes.at(-1));
+
+		let status = 200;
+
+		/** @type {import('types').ActionResult | undefined} */
+		let action_result = undefined;
+
+		if (is_action_request(event, leaf_node)) {
+			// for action requests, first call handler in +page.server.js
+			// (this also determines status code)
+			action_result = await handle_action_request(event, leaf_node.server);
+			if (action_result?.type === 'redirect') {
+				return redirect_response(303, action_result.location);
+			}
+			if (action_result?.type === 'error') {
+				const error = action_result.error;
+				status = error instanceof HttpError ? error.status : 500;
+			}
+			if (action_result?.type === 'failure') {
+				status = action_result.status;
+			}
+		}
+
+		const should_prerender_data = nodes.some((node) => node?.server);
+		const data_pathname = add_data_suffix(event.url.pathname);
+
+		// it's crucial that we do this before returning the non-SSR response, otherwise
+		// SvelteKit will erroneously believe that the path has been prerendered,
+		// causing functions to be omitted from the manifesst generated later
+		const should_prerender = get_option(nodes, 'prerender');
+
+		if (should_prerender) {
+			const mod = leaf_node.server;
+			if (mod && mod.actions) {
+				throw new Error('Cannot prerender pages with actions');
+			}
+		} else if (state.prerendering) {
+			// Try to render the shell when ssr is false and prerendering not explicitly disabled.
+			// People can opt out of this behavior by explicitly setting prerender to false.
+			if (
+				should_prerender !== false &&
+				get_option(nodes, 'ssr') === false &&
+				!leaf_node.server?.actions
+			) {
+				return await render_response({
+					branch: [],
+					fetched: [],
+					page_config: {
+						ssr: false,
+						csr: get_option(nodes, 'csr') ?? true
+					},
+					status,
+					error: null,
+					event,
+					options,
+					state,
+					resolve_opts
+				});
+			}
+
+			// if the page isn't marked as prerenderable, then bail out at this point
+			return new Response(undefined, {
+				status: 204
+			});
+		}
+
+		// if we fetch any endpoints while loading data for this page, they should
+		// inherit the prerender option of the page
+		state.prerender_default = should_prerender;
+
+		/** @type {import('./types').Fetched[]} */
+		const fetched = [];
+
+		if (get_option(nodes, 'ssr') === false) {
+			return await render_response({
+				branch: [],
+				fetched,
+				page_config: {
+					ssr: false,
+					csr: get_option(nodes, 'csr') ?? true
+				},
+				status,
+				error: null,
+				event,
+				options,
+				state,
+				resolve_opts
+			});
+		}
+
+		/** @type {Array<import('./types.js').Loaded | null>} */
+		let branch = [];
+
+		/** @type {Error | null} */
+		let load_error = null;
+
+		/** @type {Array<Promise<import('types').ServerDataNode | null>>} */
+		const server_promises = nodes.map((node, i) => {
+			if (load_error) {
+				// if an error happens immediately, don't bother with the rest of the nodes
+				throw load_error;
+			}
+
+			return Promise.resolve().then(async () => {
+				try {
+					if (node === leaf_node && action_result?.type === 'error') {
+						// we wait until here to throw the error so that we can use
+						// any nested +error.svelte components that were defined
+						throw action_result.error;
+					}
+
+					return await load_server_data({
+						event,
+						options,
+						state,
+						node,
+						parent: async () => {
+							/** @type {Record<string, any>} */
+							const data = {};
+							for (let j = 0; j < i; j += 1) {
+								const parent = await server_promises[j];
+								if (parent) Object.assign(data, await parent.data);
+							}
+							return data;
+						}
+					});
+				} catch (e) {
+					load_error = /** @type {Error} */ (e);
+					throw load_error;
+				}
+			});
+		});
+
+		const csr = get_option(nodes, 'csr') ?? true;
+
+		/** @type {Array<Promise<Record<string, any> | null>>} */
+		const load_promises = nodes.map((node, i) => {
+			if (load_error) throw load_error;
+			return Promise.resolve().then(async () => {
+				try {
+					return await load_data({
+						event,
+						fetched,
+						node,
+						parent: async () => {
+							const data = {};
+							for (let j = 0; j < i; j += 1) {
+								Object.assign(data, await load_promises[j]);
+							}
+							return data;
+						},
+						resolve_opts,
+						server_data_promise: server_promises[i],
+						state,
+						csr
+					});
+				} catch (e) {
+					load_error = /** @type {Error} */ (e);
+					throw load_error;
+				}
+			});
+		});
+
+		// if we don't do this, rejections will be unhandled
+		for (const p of server_promises) p.catch(() => {});
+		for (const p of load_promises) p.catch(() => {});
+
+		for (let i = 0; i < nodes.length; i += 1) {
+			const node = nodes[i];
+
+			if (node) {
+				try {
+					const server_data = await server_promises[i];
+					const data = await load_promises[i];
+
+					branch.push({ node, server_data, data });
+				} catch (e) {
+					const err = normalize_error(e);
+
+					if (err instanceof Redirect) {
+						if (state.prerendering && should_prerender_data) {
+							const body = JSON.stringify({
+								type: 'redirect',
+								location: err.location
+							});
+
+							state.prerendering.dependencies.set(data_pathname, {
+								response: new Response(body),
+								body
+							});
+						}
+
+						return redirect_response(err.status, err.location);
+					}
+
+					const status = err instanceof HttpError ? err.status : 500;
+					const error = await handle_error_and_jsonify(event, options, err);
+
+					while (i--) {
+						if (page.errors[i]) {
+							const index = /** @type {number} */ (page.errors[i]);
+							const node = await options.manifest._.nodes[index]();
+
+							let j = i;
+							while (!branch[j]) j -= 1;
+
+							return await render_response({
+								event,
+								options,
+								state,
+								resolve_opts,
+								page_config: { ssr: true, csr: true },
+								status,
+								error,
+								branch: compact(branch.slice(0, j + 1)).concat({
+									node,
+									data: null,
+									server_data: null
+								}),
+								fetched
+							});
+						}
+					}
+
+					// if we're still here, it means the error happened in the root layout,
+					// which means we have to fall back to error.html
+					return static_error_page(options, status, error.message);
+				}
+			} else {
+				// push an empty slot so we can rewind past gaps to the
+				// layout that corresponds with an +error.svelte page
+				branch.push(null);
+			}
+		}
+
+		if (state.prerendering && should_prerender_data) {
+			const body = `{"type":"data","nodes":[${branch
+				.map((node) => serialize_data_node(node?.server_data))
+				.join(',')}]}`;
+
+			state.prerendering.dependencies.set(data_pathname, {
+				response: new Response(body),
+				body
+			});
+		}
+
+		return await render_response({
+			event,
+			options,
+			state,
+			resolve_opts,
+			page_config: {
+				csr: get_option(nodes, 'csr') ?? true,
+				ssr: true
+			},
+			status,
+			error: null,
+			branch: compact(branch),
+			action_result,
+			fetched
+		});
+	} catch (error) {
+		// if we end up here, it means the data loaded successfull
+		// but the page failed to render, or that a prerendering error occurred
+		return await respond_with_error({
+			event,
+			options,
+			state,
+			status: 500,
+			error,
+			resolve_opts
+		});
+	}
+}

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

@@ -0,0 +1,270 @@
+import { disable_search, make_trackable } from '../../../utils/url.js';
+import { unwrap_promises } from '../../../utils/promises.js';
+
+/**
+ * Calls the user's server `load` function.
+ * @param {{
+ *   event: import('types').RequestEvent;
+ *   options: import('types').SSROptions;
+ *   state: import('types').SSRState;
+ *   node: import('types').SSRNode | undefined;
+ *   parent: () => Promise<Record<string, any>>;
+ * }} opts
+ * @returns {Promise<import('types').ServerDataNode | null>}
+ */
+export async function load_server_data({ event, options, state, node, parent }) {
+	if (!node?.server) return null;
+
+	const uses = {
+		dependencies: new Set(),
+		params: new Set(),
+		parent: false,
+		route: false,
+		url: false
+	};
+
+	const url = make_trackable(event.url, () => {
+		uses.url = true;
+	});
+
+	if (state.prerendering) {
+		disable_search(url);
+	}
+
+	const result = await node.server.load?.call(null, {
+		...event,
+		/** @param {string[]} deps */
+		depends: (...deps) => {
+			for (const dep of deps) {
+				const { href } = new URL(dep, event.url);
+				uses.dependencies.add(href);
+			}
+		},
+		params: new Proxy(event.params, {
+			get: (target, key) => {
+				uses.params.add(key);
+				return target[/** @type {string} */ (key)];
+			}
+		}),
+		parent: async () => {
+			uses.parent = true;
+			return parent();
+		},
+		route: {
+			get id() {
+				uses.route = true;
+				return event.route.id;
+			}
+		},
+		url
+	});
+
+	const data = result ? await unwrap_promises(result) : null;
+	if (options.dev) {
+		validate_load_response(data, /** @type {string} */ (event.route.id));
+	}
+
+	return {
+		type: 'data',
+		data,
+		uses,
+		slash: node.server.trailingSlash
+	};
+}
+
+/**
+ * Calls the user's `load` function.
+ * @param {{
+ *   event: import('types').RequestEvent;
+ *   fetched: import('./types').Fetched[];
+ *   node: import('types').SSRNode | undefined;
+ *   parent: () => Promise<Record<string, any>>;
+ *   resolve_opts: import('types').RequiredResolveOptions;
+ *   server_data_promise: Promise<import('types').ServerDataNode | null>;
+ *   state: import('types').SSRState;
+ *   csr: boolean;
+ * }} opts
+ * @returns {Promise<Record<string, any> | null>}
+ */
+export async function load_data({
+	event,
+	fetched,
+	node,
+	parent,
+	server_data_promise,
+	state,
+	resolve_opts,
+	csr
+}) {
+	const server_data_node = await server_data_promise;
+
+	if (!node?.universal?.load) {
+		return server_data_node?.data ?? null;
+	}
+
+	const result = await node.universal.load.call(null, {
+		url: event.url,
+		params: event.params,
+		data: server_data_node?.data ?? null,
+		route: event.route,
+		fetch: async (input, init) => {
+			const cloned_body = input instanceof Request && input.body ? input.clone().body : null;
+			const response = await event.fetch(input, init);
+
+			const url = new URL(input instanceof Request ? input.url : input, event.url);
+			const same_origin = url.origin === event.url.origin;
+
+			/** @type {import('types').PrerenderDependency} */
+			let dependency;
+
+			if (same_origin) {
+				if (state.prerendering) {
+					dependency = { response, body: null };
+					state.prerendering.dependencies.set(url.pathname, dependency);
+				}
+			} else {
+				// simulate CORS errors server-side for consistency with client-side behaviour
+				const mode = input instanceof Request ? input.mode : init?.mode ?? 'cors';
+				if (mode !== 'no-cors') {
+					const acao = response.headers.get('access-control-allow-origin');
+					if (!acao || (acao !== event.url.origin && acao !== '*')) {
+						throw new Error(
+							`CORS error: ${
+								acao ? 'Incorrect' : 'No'
+							} 'Access-Control-Allow-Origin' header is present on the requested resource`
+						);
+					}
+				}
+			}
+
+			const proxy = new Proxy(response, {
+				get(response, key, _receiver) {
+					async function text() {
+						const body = await response.text();
+
+						if (!body || typeof body === 'string') {
+							const status_number = Number(response.status);
+							if (isNaN(status_number)) {
+								throw new Error(
+									`response.status is not a number. value: "${
+										response.status
+									}" type: ${typeof response.status}`
+								);
+							}
+
+							fetched.push({
+								url: same_origin ? url.href.slice(event.url.origin.length) : url.href,
+								method: event.request.method,
+								request_body: /** @type {string | ArrayBufferView | undefined} */ (
+									input instanceof Request && cloned_body
+										? await stream_to_string(cloned_body)
+										: init?.body
+								),
+								response_body: body,
+								response: response
+							});
+						}
+
+						if (dependency) {
+							dependency.body = body;
+						}
+
+						return body;
+					}
+
+					if (key === 'arrayBuffer') {
+						return async () => {
+							const buffer = await response.arrayBuffer();
+
+							if (dependency) {
+								dependency.body = new Uint8Array(buffer);
+							}
+
+							// TODO should buffer be inlined into the page (albeit base64'd)?
+							// any conditions in which it shouldn't be?
+
+							return buffer;
+						};
+					}
+
+					if (key === 'text') {
+						return text;
+					}
+
+					if (key === 'json') {
+						return async () => {
+							return JSON.parse(await text());
+						};
+					}
+
+					return Reflect.get(response, key, response);
+				}
+			});
+
+			if (csr) {
+				// ensure that excluded headers can't be read
+				const get = response.headers.get;
+				response.headers.get = (key) => {
+					const lower = key.toLowerCase();
+					const value = get.call(response.headers, lower);
+					if (value && !lower.startsWith('x-sveltekit-')) {
+						const included = resolve_opts.filterSerializedResponseHeaders(lower, value);
+						if (!included) {
+							throw new Error(
+								`Failed to get response header "${lower}" — it must be included by the \`filterSerializedResponseHeaders\` option: https://kit.svelte.dev/docs/hooks#server-hooks-handle (at ${event.route})`
+							);
+						}
+					}
+
+					return value;
+				};
+			}
+
+			return proxy;
+		},
+		setHeaders: event.setHeaders,
+		depends: () => {},
+		parent
+	});
+
+	const data = result ? await unwrap_promises(result) : null;
+	validate_load_response(data, /** @type {string} */ (event.route.id));
+	return data;
+}
+
+/**
+ * @param {ReadableStream<Uint8Array>} stream
+ */
+async function stream_to_string(stream) {
+	let result = '';
+	const reader = stream.getReader();
+	const decoder = new TextDecoder();
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) {
+			break;
+		}
+		result += decoder.decode(value);
+	}
+	return result;
+}
+
+/**
+ * @param {any} data
+ * @param {string} [routeId]
+ */
+function validate_load_response(data, routeId) {
+	if (data != null && Object.getPrototypeOf(data) !== Object.prototype) {
+		throw new Error(
+			`a load function related to route '${routeId}' returned ${
+				typeof data !== 'object'
+					? `a ${typeof data}`
+					: data instanceof Response
+					? 'a Response object'
+					: Array.isArray(data)
+					? 'an array'
+					: 'a non-plain object'
+			}, but must return a plain object at the top level (i.e. \`return {...}\`)`
+		);
+	}
+}