@sveltejs/kit 1.0.0-next.298 → 1.0.0-next.299

package/assets/server/index.js

@@ -88,10 +88,8 @@ function is_pojo(body) {
 
 	return true;
 }
-/**
- * @param {import('types').RequestEvent} event
- * @returns string
- */
+
+/** @param {import('types').RequestEvent} event */
 function normalize_request_method(event) {
 	const method = event.request.method.toLowerCase();
 	return method === 'delete' ? 'del' : method; // 'delete' is a reserved word
@@ -132,7 +130,7 @@ function is_text(content_type) {
 /**
  * @param {import('types').RequestEvent} event
  * @param {{ [method: string]: import('types').RequestHandler }} mod
- * @returns {Promise<Response | undefined>}
+ * @returns {Promise<Response>}
  */
 async function render_endpoint(event, mod) {
 	const method = normalize_request_method(event);
@@ -143,8 +141,17 @@ async function render_endpoint(event, mod) {
 	if (!handler && method === 'head') {
 		handler = mod.get;
 	}
+
 	if (!handler) {
-		return;
+		return event.request.headers.get('x-sveltekit-load')
+			? // TODO would be nice to avoid these requests altogether,
+			  // by noting whether or not page endpoints export `get`
+			  new Response(undefined, {
+					status: 204
+			  })
+			: new Response('Method not allowed', {
+					status: 405
+			  });
 	}
 
 	const response = await handler(event);
@@ -154,8 +161,12 @@ async function render_endpoint(event, mod) {
 		return error(`${preface}: expected an object, got ${typeof response}`);
 	}
 
+	// TODO remove for 1.0
+	// @ts-expect-error
 	if (response.fallthrough) {
-		return;
+		throw new Error(
+			'fallthrough is no longer supported. Use validators instead: https://kit.svelte.dev/docs/routing#advanced-routing-validation'
+		);
 	}
 
 	const { status = 200, body = {} } = response;
@@ -1081,9 +1092,8 @@ const updated = {
  *   $session: any;
  *   page_config: { hydrate: boolean, router: boolean };
  *   status: number;
- *   error?: Error;
- *   url: URL;
- *   params: Record<string, string>;
+ *   error: Error | null;
+ *   event: import('types').RequestEvent;
  *   resolve_opts: import('types').RequiredResolveOptions;
  *   stuff: Record<string, any>;
  * }} opts
@@ -1095,9 +1105,8 @@ async function render_response({
 	$session,
 	page_config,
 	status,
-	error,
-	url,
-	params,
+	error = null,
+	event,
 	resolve_opts,
 	stuff
 }) {
@@ -1155,12 +1164,14 @@ async function render_response({
 				session,
 				updated
 			},
+			/** @type {import('types').Page} */
 			page: {
-				url: state.prerender ? create_prerendering_url_proxy(url) : url,
-				params,
-				status,
 				error,
-				stuff
+				params: event.params,
+				routeId: event.routeId,
+				status,
+				stuff,
+				url: state.prerender ? create_prerendering_url_proxy(event.url) : event.url
 			},
 			components: branch.map(({ node }) => node.module.default)
 		};
@@ -1236,7 +1247,8 @@ async function render_response({
 					.map(({ node }) => `import(${s(options.prefix + node.entry)})`)
 					.join(',\n\t\t\t\t\t\t')}
 				],
-				params: ${devalue(params)}
+				params: ${devalue(event.params)},
+				routeId: ${s(event.routeId)}
 			}` : 'null'}
 		});
 	`;
@@ -1352,7 +1364,7 @@ async function render_response({
 		}
 	}
 
-	const segments = url.pathname.slice(options.paths.base.length).split('/').slice(2);
+	const segments = event.url.pathname.slice(options.paths.base.length).split('/').slice(2);
 	const assets =
 		options.paths.assets || (segments.length > 0 ? segments.map(() => '..').join('/') : '.');
 
@@ -1541,8 +1553,6 @@ function normalize_path(path, trailing_slash) {
  *   options: import('types').SSROptions;
  *   state: import('types').SSRState;
  *   route: import('types').SSRPage | null;
- *   url: URL;
- *   params: Record<string, string>;
  *   node: import('types').SSRNode;
  *   $session: any;
  *   stuff: Record<string, any>;
@@ -1551,15 +1561,13 @@ function normalize_path(path, trailing_slash) {
  *   status?: number;
  *   error?: Error;
  * }} opts
- * @returns {Promise<import('./types').Loaded | undefined>} undefined for fallthrough
+ * @returns {Promise<import('./types').Loaded>}
  */
 async function load_node({
 	event,
 	options,
 	state,
 	route,
-	url,
-	params,
 	node,
 	$session,
 	stuff,
@@ -1580,7 +1588,7 @@ async function load_node({
 	 */
 	let set_cookie_headers = [];
 
-	/** @type {import('types').Either<import('types').Fallthrough, import('types').LoadOutput>} */
+	/** @type {import('types').LoadOutput} */
 	let loaded;
 
 	/** @type {import('types').ShadowData} */
@@ -1593,8 +1601,6 @@ async function load_node({
 		  )
 		: {};
 
-	if (shadow.fallthrough) return;
-
 	if (shadow.cookies) {
 		set_cookie_headers.push(...shadow.cookies);
 	}
@@ -1612,9 +1618,10 @@ async function load_node({
 	} else if (module.load) {
 		/** @type {import('types').LoadInput | import('types').ErrorLoadInput} */
 		const load_input = {
-			url: state.prerender ? create_prerendering_url_proxy(url) : url,
-			params,
+			url: state.prerender ? create_prerendering_url_proxy(event.url) : event.url,
+			params: event.params,
 			props: shadow.body || {},
+			routeId: event.routeId,
 			get session() {
 				uses_credentials = true;
 				return $session;
@@ -1692,7 +1699,10 @@ async function load_node({
 							headers: type ? { 'content-type': type } : {}
 						});
 					} else {
-						response = await fetch(`${url.origin}/${file}`, /** @type {RequestInit} */ (opts));
+						response = await fetch(
+							`${event.url.origin}/${file}`,
+							/** @type {RequestInit} */ (opts)
+						);
 					}
 				} else if (is_root_relative(resolved)) {
 					if (opts.credentials !== 'omit') {
@@ -1719,7 +1729,6 @@ async function load_node({
 					}
 
 					response = await respond(new Request(new URL(requested, event.url).href, opts), options, {
-						fetched: requested,
 						getClientAddress: state.getClientAddress,
 						initiator: route,
 						prerender: state.prerender
@@ -1855,8 +1864,17 @@ async function load_node({
 		loaded = await module.load.call(null, load_input);
 
 		if (!loaded) {
+			// TODO do we still want to enforce this now that there's no fallthrough?
 			throw new Error(`load function must return a value${options.dev ? ` (${node.entry})` : ''}`);
 		}
+
+		// TODO remove for 1.0
+		// @ts-expect-error
+		if (loaded.fallthrough) {
+			throw new Error(
+				'fallthrough is no longer supported. Use validators instead: https://kit.svelte.dev/docs/routing#advanced-routing-validation'
+			);
+		}
 	} else if (shadow.body) {
 		loaded = {
 			props: shadow.body
@@ -1865,10 +1883,6 @@ async function load_node({
 		loaded = {};
 	}
 
-	if (loaded.fallthrough && !is_error) {
-		return;
-	}
-
 	// generate __data.json files when prerendering
 	if (shadow.body && state.prerender) {
 		const pathname = `${event.url.pathname.replace(/\/$/, '')}/__data.json`;
@@ -1931,7 +1945,13 @@ async function load_shadow_data(route, event, options, prerender) {
 		if (!is_get) {
 			const result = await handler(event);
 
-			if (result.fallthrough) return result;
+			// TODO remove for 1.0
+			// @ts-expect-error
+			if (result.fallthrough) {
+				throw new Error(
+					'fallthrough is no longer supported. Use validators instead: https://kit.svelte.dev/docs/routing#advanced-routing-validation'
+				);
+			}
 
 			const { status, headers, body } = validate_shadow_output(result);
 			data.status = status;
@@ -1956,7 +1976,13 @@ async function load_shadow_data(route, event, options, prerender) {
 		if (get) {
 			const result = await get(event);
 
-			if (result.fallthrough) return result;
+			// TODO remove for 1.0
+			// @ts-expect-error
+			if (result.fallthrough) {
+				throw new Error(
+					'fallthrough is no longer supported. Use validators instead: https://kit.svelte.dev/docs/routing#advanced-routing-validation'
+				);
+			}
 
 			const { status, headers, body } = validate_shadow_output(result);
 			add_cookies(/** @type {string[]} */ (data.cookies), headers);
@@ -2058,17 +2084,12 @@ async function respond_with_error({
 		const default_layout = await options.manifest._.nodes[0](); // 0 is always the root layout
 		const default_error = await options.manifest._.nodes[1](); // 1 is always the root error
 
-		/** @type {Record<string, string>} */
-		const params = {}; // error page has no params
-
 		const layout_loaded = /** @type {Loaded} */ (
 			await load_node({
 				event,
 				options,
 				state,
 				route: null,
-				url: event.url, // TODO this is redundant, no?
-				params,
 				node: default_layout,
 				$session,
 				stuff: {},
@@ -2083,8 +2104,6 @@ async function respond_with_error({
 				options,
 				state,
 				route: null,
-				url: event.url,
-				params,
 				node: default_error,
 				$session,
 				stuff: layout_loaded ? layout_loaded.stuff : {},
@@ -2107,8 +2126,7 @@ async function respond_with_error({
 			status,
 			error,
 			branch: [layout_loaded, error_loaded],
-			url: event.url,
-			params,
+			event,
 			resolve_opts
 		});
 	} catch (err) {
@@ -2137,9 +2155,8 @@ async function respond_with_error({
  *   $session: any;
  *   resolve_opts: import('types').RequiredResolveOptions;
  *   route: import('types').SSRPage;
- *   params: Record<string, string>;
  * }} opts
- * @returns {Promise<Response | undefined>}
+ * @returns {Promise<Response>}
  */
 async function respond$1(opts) {
 	const { event, options, state, $session, route, resolve_opts } = opts;
@@ -2156,7 +2173,8 @@ async function respond$1(opts) {
 				router: true
 			},
 			status: 200,
-			url: event.url,
+			error: null,
+			event,
 			stuff: {}
 		});
 	}
@@ -2204,8 +2222,8 @@ async function respond$1(opts) {
 	/** @type {number} */
 	let status = 200;
 
-	/** @type {Error|undefined} */
-	let error;
+	/** @type {Error | null} */
+	let error = null;
 
 	/** @type {string[]} */
 	let set_cookie_headers = [];
@@ -2223,15 +2241,12 @@ async function respond$1(opts) {
 				try {
 					loaded = await load_node({
 						...opts,
-						url: event.url,
 						node,
 						stuff,
 						is_error: false,
 						is_leaf: i === nodes.length - 1
 					});
 
-					if (!loaded) return;
-
 					set_cookie_headers = set_cookie_headers.concat(loaded.set_cookie_headers);
 
 					if (loaded.loaded.redirect) {
@@ -2278,7 +2293,6 @@ async function respond$1(opts) {
 								const error_loaded = /** @type {import('./types').Loaded} */ (
 									await load_node({
 										...opts,
-										url: event.url,
 										node: error_node,
 										stuff: node_loaded.stuff,
 										is_error: true,
@@ -2338,7 +2352,7 @@ async function respond$1(opts) {
 			await render_response({
 				...opts,
 				stuff,
-				url: event.url,
+				event,
 				page_config,
 				status,
 				error,
@@ -2399,7 +2413,7 @@ function with_cookies(response, set_cookie_headers) {
  * @param {import('types').SSROptions} options
  * @param {import('types').SSRState} state
  * @param {import('types').RequiredResolveOptions} resolve_opts
- * @returns {Promise<Response | undefined>}
+ * @returns {Promise<Response>}
  */
 async function render_page(event, route, options, state, resolve_opts) {
 	if (state.initiator === route) {
@@ -2422,29 +2436,14 @@ async function render_page(event, route, options, state, resolve_opts) {
 
 	const $session = await options.hooks.getSession(event);
 
-	const response = await respond$1({
+	return respond$1({
 		event,
 		options,
 		state,
 		$session,
 		resolve_opts,
-		route,
-		params: event.params // TODO this is redundant
+		route
 	});
-
-	if (response) {
-		return response;
-	}
-
-	if (state.fetched) {
-		// we came here because of a bad request in a `load` function.
-		// rather than render the error page — which could lead to an
-		// infinite loop, if the `load` belonged to the root layout,
-		// we respond with a bare-bones 500
-		return new Response(`Bad request in load function: failed to fetch ${state.fetched}`, {
-			status: 500
-		});
-	}
 }
 
 /**
@@ -2499,6 +2498,36 @@ function negotiate(accept, types) {
 	return accepted;
 }
 
+/** @param {string} key */
+
+/**
+ * @param {RegExpMatchArray} match
+ * @param {string[]} names
+ * @param {string[]} types
+ * @param {Record<string, import('types').ParamValidator>} validators
+ */
+function exec(match, names, types, validators) {
+	/** @type {Record<string, string>} */
+	const params = {};
+
+	for (let i = 0; i < names.length; i += 1) {
+		const name = names[i];
+		const type = types[i];
+		const value = match[i + 1] || '';
+
+		if (type) {
+			const validator = validators[type];
+			if (!validator) throw new Error(`Missing "${type}" param validator`); // TODO do this ahead of time?
+
+			if (!validator(value)) return;
+		}
+
+		params[name] = value;
+	}
+
+	return params;
+}
+
 const DATA_SUFFIX = '/__data.json';
 
 /** @param {{ html: string }} opts */
@@ -2506,11 +2535,11 @@ const default_transform = ({ html }) => html;
 
 /** @type {import('types').Respond} */
 async function respond(request, options, state) {
-	const url = new URL(request.url);
+	let url = new URL(request.url);
 
 	const normalized = normalize_path(url.pathname, options.trailing_slash);
 
-	if (normalized !== url.pathname) {
+	if (normalized !== url.pathname && !state.prerender?.fallback) {
 		return new Response(undefined, {
 			status: 301,
 			headers: {
@@ -2544,6 +2573,50 @@ async function respond(request, options, state) {
 		}
 	}
 
+	let decoded = decodeURI(url.pathname);
+
+	/** @type {import('types').SSRRoute | null} */
+	let route = null;
+
+	/** @type {Record<string, string>} */
+	let params = {};
+
+	if (options.paths.base) {
+		if (!decoded.startsWith(options.paths.base)) {
+			return new Response(undefined, { status: 404 });
+		}
+		decoded = decoded.slice(options.paths.base.length) || '/';
+	}
+
+	const is_data_request = decoded.endsWith(DATA_SUFFIX);
+
+	if (is_data_request) {
+		decoded = decoded.slice(0, -DATA_SUFFIX.length) || '/';
+
+		const normalized = normalize_path(
+			url.pathname.slice(0, -DATA_SUFFIX.length),
+			options.trailing_slash
+		);
+
+		url = new URL(url.origin + normalized + url.search);
+	}
+
+	if (!state.prerender || !state.prerender.fallback) {
+		const validators = await options.manifest._.validators();
+
+		for (const candidate of options.manifest._.routes) {
+			const match = candidate.pattern.exec(decoded);
+			if (!match) continue;
+
+			const matched = exec(match, candidate.names, candidate.types, validators);
+			if (matched) {
+				route = candidate;
+				params = decode_params(matched);
+				break;
+			}
+		}
+	}
+
 	/** @type {import('types').RequestEvent} */
 	const event = {
 		get clientAddress() {
@@ -2562,9 +2635,10 @@ async function respond(request, options, state) {
 			return event.clientAddress;
 		},
 		locals: {},
-		params: {},
+		params,
 		platform: state.platform,
 		request,
+		routeId: route && route.id,
 		url
 	};
 
@@ -2607,6 +2681,8 @@ async function respond(request, options, state) {
 		transformPage: default_transform
 	};
 
+	// TODO match route before calling handle?
+
 	try {
 		const response = await options.hooks.handle({
 			event,
@@ -2620,14 +2696,14 @@ async function respond(request, options, state) {
 
 				if (state.prerender && state.prerender.fallback) {
 					return await render_response({
-						url: event.url,
-						params: event.params,
+						event,
 						options,
 						state,
 						$session: await options.hooks.getSession(event),
 						page_config: { router: true, hydrate: true },
 						stuff: {},
 						status: 200,
+						error: null,
 						branch: [],
 						resolve_opts: {
 							...resolve_opts,
@@ -2636,75 +2712,28 @@ async function respond(request, options, state) {
 					});
 				}
 
-				let decoded = decodeURI(event.url.pathname);
-
-				if (options.paths.base) {
-					if (!decoded.startsWith(options.paths.base)) {
-						return new Response(undefined, { status: 404 });
-					}
-					decoded = decoded.slice(options.paths.base.length) || '/';
-				}
-
-				const is_data_request = decoded.endsWith(DATA_SUFFIX);
-
-				if (is_data_request) {
-					decoded = decoded.slice(0, -DATA_SUFFIX.length) || '/';
-
-					const normalized = normalize_path(
-						url.pathname.slice(0, -DATA_SUFFIX.length),
-						options.trailing_slash
-					);
-
-					event.url = new URL(event.url.origin + normalized + event.url.search);
-				}
-
-				// `key` will be set if this request came from a client-side navigation
-				// to a page with a matching endpoint
-				const key = request.headers.get('x-sveltekit-load');
-
-				for (const route of options.manifest._.routes) {
-					if (key) {
-						// client is requesting data for a specific endpoint
-						if (route.type !== 'page') continue;
-						if (route.key !== key) continue;
-					}
-
-					const match = route.pattern.exec(decoded);
-					if (!match) continue;
-
-					event.params = route.params ? decode_params(route.params(match)) : {};
-
-					/** @type {Response | undefined} */
+				if (route) {
+					/** @type {Response} */
 					let response;
 
 					if (is_data_request && route.type === 'page' && route.shadow) {
 						response = await render_endpoint(event, await route.shadow());
 
 						// loading data for a client-side transition is a special case
-						if (key) {
-							if (response) {
-								// since redirects are opaque to the browser, we need to repackage
-								// 3xx responses as 200s with a custom header
-								if (response.status >= 300 && response.status < 400) {
-									const location = response.headers.get('location');
-
-									if (location) {
-										const headers = new Headers(response.headers);
-										headers.set('x-sveltekit-location', location);
-										response = new Response(undefined, {
-											status: 204,
-											headers
-										});
-									}
+						if (request.headers.has('x-sveltekit-load')) {
+							// since redirects are opaque to the browser, we need to repackage
+							// 3xx responses as 200s with a custom header
+							if (response.status >= 300 && response.status < 400) {
+								const location = response.headers.get('location');
+
+								if (location) {
+									const headers = new Headers(response.headers);
+									headers.set('x-sveltekit-location', location);
+									response = new Response(undefined, {
+										status: 204,
+										headers
+									});
 								}
-							} else {
-								// fallthrough
-								response = new Response(undefined, {
-									status: 204,
-									headers: {
-										'content-type': 'application/json'
-									}
-								});
 							}
 						}
 					} else {

package/dist/chunks/index.js

@@ -11,6 +11,7 @@ import { update, init } from './sync.js';
 import { getRequest, setResponse } from '../node.js';
 import { sequence } from '../hooks.js';
 import { p as posixify } from './filesystem.js';
+import { p as parse_route_id } from './routing.js';
 import 'sade';
 import 'child_process';
 import 'net';
@@ -116,12 +117,15 @@ async function create_plugin(config, cwd) {
 							};
 						}),
 						routes: manifest_data.routes.map((route) => {
+							const { pattern, names, types } = parse_route_id(route.id);
+
 							if (route.type === 'page') {
 								return {
 									type: 'page',
-									key: route.key,
-									pattern: route.pattern,
-									params: get_params(route.params),
+									id: route.id,
+									pattern,
+									names,
+									types,
 									shadow: route.shadow
 										? async () => {
 												const url = path__default.resolve(cwd, /** @type {string} */ (route.shadow));
@@ -135,14 +139,34 @@ async function create_plugin(config, cwd) {
 
 							return {
 								type: 'endpoint',
-								pattern: route.pattern,
-								params: get_params(route.params),
+								id: route.id,
+								pattern,
+								names,
+								types,
 								load: async () => {
 									const url = path__default.resolve(cwd, route.file);
 									return await vite.ssrLoadModule(url);
 								}
 							};
-						})
+						}),
+						validators: async () => {
+							/** @type {Record<string, import('types').ParamValidator>} */
+							const validators = {};
+
+							for (const key in manifest_data.validators) {
+								const file = manifest_data.validators[key];
+								const url = path__default.resolve(cwd, file);
+								const module = await vite.ssrLoadModule(url);
+
+								if (module.validate) {
+									validators[key] = module.validate;
+								} else {
+									throw new Error(`${file} does not export a \`validate\` function`);
+								}
+							}
+
+							return validators;
+						}
 					}
 				};
 			}
@@ -355,29 +379,6 @@ async function create_plugin(config, cwd) {
 	};
 }
 
-/** @param {string[]} array */
-function get_params(array) {
-	// given an array of params like `['x', 'y', 'z']` for
-	// src/routes/[x]/[y]/[z]/svelte, create a function
-	// that turns a RegExpExecArray into ({ x, y, z })
-
-	/** @param {RegExpExecArray} match */
-	const fn = (match) => {
-		/** @type {Record<string, string>} */
-		const params = {};
-		array.forEach((key, i) => {
-			if (key.startsWith('...')) {
-				params[key.slice(3)] = match[i + 1] || '';
-			} else {
-				params[key] = match[i + 1];
-			}
-		});
-		return params;
-	};
-
-	return fn;
-}
-
 /** @param {import('http').ServerResponse} res */
 function not_found(res) {
 	res.statusCode = 404;