@sveltejs/kit 1.0.0-next.430 → 1.0.0-next.433

package/src/runtime/server/index.js

@@ -10,6 +10,7 @@ import { negotiate } from '../../utils/http.js';
 import { HttpError, Redirect } from '../../index/private.js';
 import { load_server_data } from './page/load_data.js';
 import { json } from '../../index/index.js';
+import { once } from '../../utils/functions.js';
 
 /* global __SVELTEKIT_ADAPTER_NAME__ */
 
@@ -92,7 +93,7 @@ export async function respond(request, options, state) {
 	}
 
 	if (route) {
-		if (route.type === 'page') {
+		if (route.page) {
 			const normalized = normalize_path(url.pathname, options.trailing_slash);
 
 			if (normalized !== url.pathname && !state.prerendering?.fallback) {
@@ -252,21 +253,28 @@ export async function respond(request, options, state) {
 				if (route) {
 					/** @type {Response} */
 					let response;
-					if (is_data_request && route.type === 'page') {
+					if (is_data_request && route.page) {
 						try {
-							/** @type {Redirect | HttpError | Error} */
-							let error;
-
-							// TODO only get the data we need for the navigation
-							const promises = [...route.layouts, route.leaf].map(async (n, i) => {
-								try {
-									if (error) return;
-
-									// == because it could be undefined (in dev) or null (in build, because of JSON.stringify)
-									const node = n == undefined ? n : await options.manifest._.nodes[n]();
-									return {
-										// TODO return `uses`, so we can reuse server data effectively
-										data: await load_server_data({
+							const node_ids = [...route.page.layouts, route.page.leaf];
+
+							const invalidated =
+								request.headers.get('x-sveltekit-invalidated')?.split(',').map(Boolean) ??
+								node_ids.map(() => true);
+
+							let aborted = false;
+
+							const functions = node_ids.map((n, i) => {
+								return once(async () => {
+									try {
+										if (aborted) {
+											return /** @type {import('types').ServerDataSkippedNode} */ ({
+												type: 'skip'
+											});
+										}
+
+										// == because it could be undefined (in dev) or null (in build, because of JSON.stringify)
+										const node = n == undefined ? n : await options.manifest._.nodes[n]();
+										return load_server_data({
 											dev: options.dev,
 											event,
 											node,
@@ -274,56 +282,91 @@ export async function respond(request, options, state) {
 												/** @type {Record<string, any>} */
 												const data = {};
 												for (let j = 0; j < i; j += 1) {
-													const parent = await promises[j];
-													if (!parent || parent instanceof HttpError || 'error' in parent) {
-														return data;
-													}
+													const parent = /** @type {import('types').ServerDataNode} */ (
+														await functions[j]()
+													);
 													Object.assign(data, parent.data);
 												}
 												return data;
 											}
-										})
-									};
-								} catch (e) {
-									error = normalize_error(e);
-
-									if (error instanceof Redirect) {
-										throw error;
-									}
-
-									if (error instanceof HttpError) {
-										return error; // { status, message }
+										});
+									} catch (e) {
+										aborted = true;
+										throw e;
 									}
+								});
+							});
 
-									options.handle_error(error, event);
-
-									return {
-										error: error_to_pojo(error, options.get_stack)
-									};
+							const promises = functions.map(async (fn, i) => {
+								if (!invalidated[i]) {
+									return /** @type {import('types').ServerDataSkippedNode} */ ({
+										type: 'skip'
+									});
 								}
+
+								return fn();
 							});
 
-							response = json({
+							let length = promises.length;
+							const nodes = await Promise.all(
+								promises.map((p, i) =>
+									p.catch((e) => {
+										const error = normalize_error(e);
+
+										if (error instanceof Redirect) {
+											throw error;
+										}
+
+										// Math.min because array isn't guaranteed to resolve in order
+										length = Math.min(length, i + 1);
+
+										if (error instanceof HttpError) {
+											return /** @type {import('types').ServerErrorNode} */ ({
+												type: 'error',
+												httperror: { ...error }
+											});
+										}
+
+										options.handle_error(error, event);
+
+										return /** @type {import('types').ServerErrorNode} */ ({
+											type: 'error',
+											error: error_to_pojo(error, options.get_stack)
+										});
+									})
+								)
+							);
+
+							/** @type {import('types').ServerData} */
+							const server_data = {
 								type: 'data',
-								nodes: await Promise.all(promises)
-							});
+								nodes: nodes.slice(0, length)
+							};
+
+							response = json(server_data);
 						} catch (e) {
 							const error = normalize_error(e);
 
 							if (error instanceof Redirect) {
-								response = json({
+								/** @type {import('types').ServerData} */
+								const server_data = {
 									type: 'redirect',
 									location: error.location
-								});
+								};
+
+								response = json(server_data);
 							} else {
 								response = json(error_to_pojo(error, options.get_stack), { status: 500 });
 							}
 						}
+					} else if (route.page) {
+						response = await render_page(event, route, route.page, options, state, resolve_opts);
+					} else if (route.endpoint) {
+						response = await render_endpoint(event, await route.endpoint());
 					} else {
-						response =
-							route.type === 'endpoint'
-								? await render_endpoint(event, route)
-								: await render_page(event, route, options, state, resolve_opts);
+						// a route will always have a page or an endpoint, but TypeScript
+						// doesn't know that
+						throw new Error('This should never happen');
 					}
 
 					if (!is_data_request) {

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

@@ -9,7 +9,7 @@ import { domain_matches, path_matches } from './cookie.js';
  *   event: import('types').RequestEvent;
  *   options: import('types').SSROptions;
  *   state: import('types').SSRState;
- *   route: import('types').SSRPage | import('types').SSRErrorPage;
+ *   route: import('types').SSRRoute | import('types').SSRErrorPage;
  * }} opts
  */
 export function create_fetch({ event, options, state, route }) {

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

@@ -5,6 +5,7 @@ import { method_not_allowed, error_to_pojo, allowed_methods } from '../utils.js'
 import { create_fetch } from './fetch.js';
 import { HttpError, Redirect } from '../../../index/private.js';
 import { error, json } from '../../../index/index.js';
+import { compact } from '../../../utils/array.js';
 import { normalize_error } from '../../../utils/error.js';
 import { load_data, load_server_data } from './load_data.js';
 
@@ -17,13 +18,14 @@ import { load_data, load_server_data } from './load_data.js';
 
 /**
  * @param {import('types').RequestEvent} event
- * @param {import('types').SSRPage} route
+ * @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, options, state, resolve_opts) {
+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}`, {
@@ -41,7 +43,7 @@ export async function render_page(event, route, options, state, resolve_opts) {
 		event.request.method !== 'GET' &&
 		event.request.method !== 'HEAD'
 	) {
-		const node = await options.manifest._.nodes[route.leaf]();
+		const node = await options.manifest._.nodes[page.leaf]();
 		if (node.server) {
 			return handle_json_request(event, options, node.server);
 		}
@@ -52,8 +54,8 @@ export async function render_page(event, route, options, state, resolve_opts) {
 	try {
 		const nodes = await Promise.all([
 			// we use == here rather than === because [undefined] serializes as "[null]"
-			...route.layouts.map((n) => (n == undefined ? n : options.manifest._.nodes[n]())),
-			options.manifest._.nodes[route.leaf]()
+			...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));
@@ -145,7 +147,7 @@ export async function render_page(event, route, options, state, resolve_opts) {
 		/** @type {Error | null} */
 		let load_error = null;
 
-		/** @type {Array<Promise<Record<string, any> | 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
@@ -168,7 +170,8 @@ export async function render_page(event, route, options, state, resolve_opts) {
 							/** @type {Record<string, any>} */
 							const data = {};
 							for (let j = 0; j < i; j += 1) {
-								Object.assign(data, await server_promises[j]);
+								const parent = await server_promises[j];
+								if (parent) Object.assign(data, await parent.data);
 							}
 							return data;
 						}
@@ -243,8 +246,8 @@ export async function render_page(event, route, options, state, resolve_opts) {
 					const status = error instanceof HttpError ? error.status : 500;
 
 					while (i--) {
-						if (route.errors[i]) {
-							const index = /** @type {number} */ (route.errors[i]);
+						if (page.errors[i]) {
+							const index = /** @type {number} */ (page.errors[i]);
 							const node = await options.manifest._.nodes[index]();
 
 							let j = i;
@@ -291,7 +294,7 @@ export async function render_page(event, route, options, state, resolve_opts) {
 				response: new Response(undefined),
 				body: JSON.stringify({
 					type: 'data',
-					nodes: branch.map((branch_node) => ({ data: branch_node?.server_data }))
+					nodes: branch.map((branch_node) => branch_node?.server_data)
 				})
 			});
 		}
@@ -399,18 +402,3 @@ function redirect_response(status, location) {
 		headers: { location }
 	});
 }
-
-/**
- * @template T
- * @param {Array<T | null>} array
- * @returns {T[]}
- */
-function compact(array) {
-	const compacted = [];
-	for (const item of array) {
-		if (item) {
-			compacted.push(item);
-		}
-	}
-	return compacted;
-}

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

@@ -8,19 +8,46 @@ import { LoadURL, PrerenderingURL } from '../../../utils/url.js';
  *   node: import('types').SSRNode | undefined;
  *   parent: () => Promise<Record<string, any>>;
  * }} opts
+ * @returns {Promise<import('types').ServerDataNode | null>}
  */
 export async function load_server_data({ dev, event, node, parent }) {
 	if (!node?.server) return null;
 
-	const server_data = await node.server.load?.call(null, {
+	const uses = {
+		dependencies: new Set(),
+		params: new Set(),
+		parent: false,
+		url: false
+	};
+
+	/** @param {string[]} deps */
+	function depends(...deps) {
+		for (const dep of deps) {
+			const { href } = new URL(dep, event.url);
+			uses.dependencies.add(href);
+		}
+	}
+
+	const params = new Proxy(event.params, {
+		get: (target, key) => {
+			uses.params.add(key);
+			return target[/** @type {string} */ (key)];
+		}
+	});
+
+	const result = await node.server.load?.call(null, {
 		// can't use destructuring here because it will always
 		// invoke event.clientAddress, which breaks prerendering
 		get clientAddress() {
 			return event.clientAddress;
 		},
+		depends,
 		locals: event.locals,
-		params: event.params,
-		parent,
+		params,
+		parent: async () => {
+			uses.parent = true;
+			return parent();
+		},
 		platform: event.platform,
 		request: event.request,
 		routeId: event.routeId,
@@ -28,13 +55,22 @@ export async function load_server_data({ dev, event, node, parent }) {
 		url: event.url
 	});
 
-	const result = server_data ? await unwrap_promises(server_data) : null;
+	const data = result ? await unwrap_promises(result) : null;
 
 	if (dev) {
-		check_serializability(result, /** @type {string} */ (node.server_id), 'data');
+		check_serializability(data, /** @type {string} */ (node.server_id), 'data');
 	}
 
-	return result;
+	return {
+		type: 'data',
+		data,
+		uses: {
+			dependencies: uses.dependencies.size > 0 ? Array.from(uses.dependencies) : undefined,
+			params: uses.params.size > 0 ? Array.from(uses.params) : undefined,
+			parent: uses.parent ? 1 : undefined,
+			url: uses.url ? 1 : undefined
+		}
+	};
 }
 
 /**
@@ -44,21 +80,22 @@ export async function load_server_data({ dev, event, node, parent }) {
  *   fetcher: typeof fetch;
  *   node: import('types').SSRNode | undefined;
  *   parent: () => Promise<Record<string, any>>;
- *   server_data_promise: Promise<Record<string, any> | null>;
+ *   server_data_promise: Promise<import('types').ServerDataNode | null>;
  *   state: import('types').SSRState;
  * }} opts
+ * @returns {Promise<Record<string, any> | null>}
  */
 export async function load_data({ event, fetcher, node, parent, server_data_promise, state }) {
-	const server_data = await server_data_promise;
+	const server_data_node = await server_data_promise;
 
 	if (!node?.shared?.load) {
-		return server_data;
+		return server_data_node?.data ?? null;
 	}
 
 	const load_input = {
 		url: state.prerendering ? new PrerenderingURL(event.url) : new LoadURL(event.url),
 		params: event.params,
-		data: server_data,
+		data: server_data_node?.data ?? null,
 		routeId: event.routeId,
 		fetch: fetcher,
 		setHeaders: event.setHeaders,

package/src/utils/array.js

@@ -0,0 +1,9 @@
+/**
+ * Removes nullish values from an array.
+ *
+ * @template T
+ * @param {Array<T>} arr
+ */
+export function compact(arr) {
+	return arr.filter(/** @returns {val is NonNullable<T>} */ (val) => val != null);
+}

package/src/utils/functions.js

@@ -0,0 +1,16 @@
+/**
+ * @template T
+ * @param {() => T} fn
+ */
+export function once(fn) {
+	let done = false;
+
+	/** @type T */
+	let result;
+
+	return () => {
+		if (done) return result;
+		done = true;
+		return (result = fn());
+	};
+}

package/src/utils/routing.js

@@ -12,12 +12,21 @@ export function parse_route_id(id) {
 	// const add_trailing_slash = !/\.[a-z]+$/.test(key);
 	let add_trailing_slash = true;
 
+	if (/\]\[/.test(id)) {
+		throw new Error(`Invalid route ${id} — parameters must be separated`);
+	}
+
+	if (count_occurrences('[', id) !== count_occurrences(']', id)) {
+		throw new Error(`Invalid route ${id} — brackets are unbalanced`);
+	}
+
 	const pattern =
 		id === ''
 			? /^\/$/
 			: new RegExp(
 					`^${id
-						.split(/(?:@[a-zA-Z0-9_-]+)?(?:\/|$)/)
+						.split(/(?:\/|$)/)
+						.filter(affects_path)
 						.map((segment, i, segments) => {
 							const decoded_segment = decodeURIComponent(segment);
 							// special case — /[...rest]/ could contain zero segments
@@ -79,6 +88,14 @@ export function parse_route_id(id) {
 	return { pattern, names, types };
 }
 
+/**
+ * Returns `false` for `(group)` segments
+ * @param {string} segment
+ */
+export function affects_path(segment) {
+	return !/^\([^)]+\)$/.test(segment);
+}
+
 /**
  * @param {RegExpMatchArray} match
  * @param {string[]} names
@@ -106,3 +123,15 @@ export function exec(match, names, types, matchers) {
 
 	return params;
 }
+
+/**
+ * @param {string} needle
+ * @param {string} haystack
+ */
+function count_occurrences(needle, haystack) {
+	let count = 0;
+	for (let i = 0; i < haystack.length; i += 1) {
+		if (haystack[i] === needle) count += 1;
+	}
+	return count;
+}

package/src/vite/build/build_server.js

@@ -84,7 +84,12 @@ export class Server {
 		};
 	}
 
-	init({ env }) {
+	/**
+	 * Take care: Some adapters may have to call \`Server.init\` per-request to set env vars,
+	 * so anything that shouldn't be rerun should be wrapped in an \`if\` block to make sure it hasn't
+	 * been done already.
+	 */
+	async init({ env }) {
 		const entries = Object.entries(env);
 
 		const prv = Object.fromEntries(entries.filter(([k]) => !k.startsWith('${
@@ -99,12 +104,6 @@ export class Server {
 		set_public_env(pub);
 
 		this.options.public_env = pub;
-	}
-
-	async respond(request, options = {}) {
-		if (!(request instanceof Request)) {
-			throw new Error('The first argument to server.respond must be a Request object. See https://github.com/sveltejs/kit/pull/3384 for details');
-		}
 
 		if (!this.options.hooks) {
 			const module = await import(${s(hooks)});
@@ -114,6 +113,12 @@ export class Server {
 				externalFetch: module.externalFetch || fetch
 			};
 		}
+	}
+
+	async respond(request, options = {}) {
+		if (!(request instanceof Request)) {
+			throw new Error('The first argument to server.respond must be a Request object. See https://github.com/sveltejs/kit/pull/3384 for details');
+		}
 
 		return respond(request, this.options, options);
 	}
@@ -158,8 +163,8 @@ export async function build_server(options, client) {
 
 	// add entry points for every endpoint...
 	manifest_data.routes.forEach((route) => {
-		if (route.type === 'endpoint') {
-			const resolved = path.resolve(cwd, route.file);
+		if (route.endpoint) {
+			const resolved = path.resolve(cwd, route.endpoint.file);
 			const relative = decodeURIComponent(path.relative(config.kit.files.routes, resolved));
 			const name = posixify(path.join('entries/endpoints', relative.replace(/\.js$/, '')));
 			input[name] = resolved;
@@ -326,10 +331,16 @@ function get_methods(cwd, output, manifest_data) {
 	/** @type {Record<string, import('types').HttpMethod[]>} */
 	const methods = {};
 	manifest_data.routes.forEach((route) => {
-		const file = route.type === 'endpoint' ? route.file : route.leaf.server;
+		if (route.endpoint) {
+			if (lookup[route.endpoint.file]) {
+				methods[route.endpoint.file] = lookup[route.endpoint.file].filter(is_http_method);
+			}
+		}
 
-		if (file && lookup[file]) {
-			methods[file] = lookup[file].filter(is_http_method);
+		if (route.leaf?.server) {
+			if (lookup[route.leaf.server]) {
+				methods[route.leaf.server] = lookup[route.leaf.server].filter(is_http_method);
+			}
 		}
 	});
 

package/src/vite/dev/index.js

@@ -7,12 +7,12 @@ import { getRequest, setResponse } from '../../node/index.js';
 import { installPolyfills } from '../../node/polyfills.js';
 import { coalesce_to_error } from '../../utils/error.js';
 import { posixify } from '../../utils/filesystem.js';
-import { parse_route_id } from '../../utils/routing.js';
 import { load_template } from '../../core/config/index.js';
 import { SVELTE_KIT_ASSETS } from '../../core/constants.js';
 import * as sync from '../../core/sync/sync.js';
 import { get_mime_lookup, runtime_base, runtime_prefix } from '../../core/utils.js';
 import { get_env, prevent_illegal_vite_imports, resolve_entry } from '../utils.js';
+import { compact } from '../../utils/array.js';
 
 // Vite doesn't expose this so we just copy the list for now
 // https://github.com/vitejs/vite/blob/3edd1af56e980aef56641a5a51cf2932bb580d41/packages/vite/src/node/plugins/css.ts#L96
@@ -149,36 +149,27 @@ export async function dev(vite, vite_config, svelte_config, illegal_imports) {
 						return result;
 					};
 				}),
-				routes: manifest_data.routes.map((route) => {
-					const { pattern, names, types } = parse_route_id(route.id);
+				routes: compact(
+					manifest_data.routes.map((route) => {
+						if (!route.page && !route.endpoint) return null;
+
+						const endpoint = route.endpoint;
 
-					if (route.type === 'page') {
 						return {
-							type: 'page',
 							id: route.id,
-							pattern,
-							names,
-							types,
-							errors: route.errors.map((id) => (id ? manifest_data.nodes.indexOf(id) : undefined)),
-							layouts: route.layouts.map((id) =>
-								id ? manifest_data.nodes.indexOf(id) : undefined
-							),
-							leaf: manifest_data.nodes.indexOf(route.leaf)
+							pattern: route.pattern,
+							names: route.names,
+							types: route.types,
+							page: route.page,
+							endpoint: endpoint
+								? async () => {
+										const url = path.resolve(cwd, endpoint.file);
+										return await vite.ssrLoadModule(url);
+								  }
+								: null
 						};
-					}
-
-					return {
-						type: 'endpoint',
-						id: route.id,
-						pattern,
-						names,
-						types,
-						load: async () => {
-							const url = path.resolve(cwd, route.file);
-							return await vite.ssrLoadModule(url);
-						}
-					};
-				}),
+					})
+				),
 				matchers: async () => {
 					/** @type {Record<string, import('types').ParamMatcher>} */
 					const matchers = {};
@@ -229,15 +220,16 @@ export async function dev(vite, vite_config, svelte_config, illegal_imports) {
 			to_run();
 		}, 100);
 	};
+
 	// Debounce add/unlink events because in case of folder deletion or moves
 	// they fire in rapid succession, causing needless invocations.
 	watch('add', () => debounce(update_manifest));
 	watch('unlink', () => debounce(update_manifest));
 	watch('change', (file) => {
 		// Don't run for a single file if the whole manifest is about to get updated
-		if (!timeout) {
-			sync.update(svelte_config, manifest_data, file);
-		}
+		if (timeout) return;
+
+		sync.update(svelte_config, manifest_data, file);
 	});
 
 	const assets = svelte_config.kit.paths.assets ? SVELTE_KIT_ASSETS : svelte_config.kit.paths.base;

package/src/vite/index.js

@@ -411,7 +411,13 @@ function kit() {
 
 				const child = fork(
 					script,
-					[vite_config.build.outDir, results_path, manifest_path, '' + verbose],
+					[
+						vite_config.build.outDir,
+						results_path,
+						manifest_path,
+						'' + verbose,
+						JSON.stringify({ ...env.private, ...env.public })
+					],
 					{
 						stdio: 'inherit'
 					}

package/src/vite/preview/index.js

@@ -45,7 +45,7 @@ export async function preview(vite, vite_config, svelte_config) {
 	});
 
 	const server = new Server(manifest);
-	server.init({
+	await server.init({
 		env: loadEnv(vite_config.mode, process.cwd(), '')
 	});
 

package/types/index.d.ts

@@ -264,7 +264,7 @@ export interface ResolveOptions {
 
 export class Server {
 	constructor(manifest: SSRManifest);
-	init(options: ServerInitOptions): void;
+	init(options: ServerInitOptions): Promise<void>;
 	respond(request: Request, options: RequestOptions): Promise<Response>;
 }