@sveltejs/kit 1.0.0-next.220 → 1.0.0-next.224

package/dist/ssr.js

@@ -94,13 +94,14 @@ async function render_endpoint(request, route, match) {
 	const response = await handler(request);
 	const preface = `Invalid response from route ${request.url.pathname}`;
 
-	if (!response) {
-		return;
-	}
 	if (typeof response !== 'object') {
 		return error(`${preface}: expected an object, got ${typeof response}`);
 	}
 
+	if (response.fallthrough) {
+		return;
+	}
+
 	let { status = 200, body, headers = {} } = response;
 
 	headers = lowercase_keys(headers);
@@ -512,11 +513,13 @@ function escape(str, dict, unicode_encoder) {
  *   branch: Array<import('./types').Loaded>;
  *   options: import('types/internal').SSRRenderOptions;
  *   $session: any;
- *   page_config: { hydrate: boolean, router: boolean, ssr: boolean };
+ *   page_config: { hydrate: boolean, router: boolean };
  *   status: number;
- *   error?: Error,
+ *   error?: Error;
  *   url: URL;
- *   params: Record<string, string>
+ *   params: Record<string, string>;
+ *   ssr: boolean;
+ *   stuff: Record<string, any>;
  * }} opts
  */
 async function render_response({
@@ -527,7 +530,9 @@ async function render_response({
 	status,
 	error,
 	url,
-	params
+	params,
+	ssr,
+	stuff
 }) {
 	const css = new Set(options.manifest._.entry.css);
 	const js = new Set(options.manifest._.entry.js);
@@ -545,7 +550,7 @@ async function render_response({
 		error.stack = options.get_stack(error);
 	}
 
-	if (page_config.ssr) {
+	if (ssr) {
 		branch.forEach(({ node, loaded, fetched, uses_credentials }) => {
 			if (node.css) node.css.forEach((url) => css.add(url));
 			if (node.js) node.js.forEach((url) => js.add(url));
@@ -568,7 +573,7 @@ async function render_response({
 				navigating: writable(null),
 				session
 			},
-			page: { url, params, status, error },
+			page: { url, params, status, error, stuff },
 			components: branch.map(({ node }) => node.module.default)
 		};
 
@@ -648,9 +653,9 @@ async function render_response({
 					throw new Error(`Failed to serialize session data: ${error.message}`);
 				})},
 				route: ${!!page_config.router},
-				spa: ${!page_config.ssr},
+				spa: ${!ssr},
 				trailing_slash: ${s(options.trailing_slash)},
-				hydrate: ${page_config.ssr && page_config.hydrate ? `{
+				hydrate: ${ssr && page_config.hydrate ? `{
 					status: ${status},
 					error: ${serialize_error(error)},
 					nodes: [
@@ -834,7 +839,6 @@ function normalize(loaded) {
  *   $session: any;
  *   stuff: Record<string, any>;
  *   prerender_enabled: boolean;
- *   is_leaf: boolean;
  *   is_error: boolean;
  *   status?: number;
  *   error?: Error;
@@ -852,7 +856,6 @@ async function load_node({
 	$session,
 	stuff,
 	prerender_enabled,
-	is_leaf,
 	is_error,
 	status,
 	error
@@ -1112,16 +1115,16 @@ async function load_node({
 		}
 
 		loaded = await module.load.call(null, load_input);
+
+		if (!loaded) {
+			throw new Error(`load function must return a value${options.dev ? ` (${node.entry})` : ''}`);
+		}
 	} else {
 		loaded = {};
 	}
 
-	// if leaf node (i.e. page component) has a load function
-	// that returns nothing, we fall through to the next one
-	if (!loaded && is_leaf && !is_error) return;
-
-	if (!loaded) {
-		throw new Error(`${node.entry} - load must return a value except for page fall through`);
+	if (loaded.fallthrough && !is_error) {
+		return;
 	}
 
 	return {
@@ -1149,9 +1152,18 @@ async function load_node({
  *   $session: any;
  *   status: number;
  *   error: Error;
+ *   ssr: boolean;
  * }} opts
  */
-async function respond_with_error({ request, options, state, $session, status, error }) {
+async function respond_with_error({
+	request,
+	options,
+	state,
+	$session,
+	status,
+	error,
+	ssr
+}) {
 	try {
 		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
@@ -1159,8 +1171,7 @@ async function respond_with_error({ request, options, state, $session, status, e
 		/** @type {Record<string, string>} */
 		const params = {}; // error page has no params
 
-		// error pages don't fall through, so we know it's not undefined
-		const loaded = /** @type {Loaded} */ (
+		const layout_loaded = /** @type {Loaded} */ (
 			await load_node({
 				request,
 				options,
@@ -1172,46 +1183,42 @@ async function respond_with_error({ request, options, state, $session, status, e
 				$session,
 				stuff: {},
 				prerender_enabled: is_prerender_enabled(options, default_error, state),
-				is_leaf: false,
 				is_error: false
 			})
 		);
 
-		const branch = [
-			loaded,
-			/** @type {Loaded} */ (
-				await load_node({
-					request,
-					options,
-					state,
-					route: null,
-					url: request.url,
-					params,
-					node: default_error,
-					$session,
-					stuff: loaded ? loaded.stuff : {},
-					prerender_enabled: is_prerender_enabled(options, default_error, state),
-					is_leaf: false,
-					is_error: true,
-					status,
-					error
-				})
-			)
-		];
+		const error_loaded = /** @type {Loaded} */ (
+			await load_node({
+				request,
+				options,
+				state,
+				route: null,
+				url: request.url,
+				params,
+				node: default_error,
+				$session,
+				stuff: layout_loaded ? layout_loaded.stuff : {},
+				prerender_enabled: is_prerender_enabled(options, default_error, state),
+				is_error: true,
+				status,
+				error
+			})
+		);
 
 		return await render_response({
 			options,
 			$session,
 			page_config: {
 				hydrate: options.hydrate,
-				router: options.router,
-				ssr: options.ssr
+				router: options.router
 			},
+			stuff: error_loaded.stuff,
 			status,
 			error,
-			branch,
+			branch: [layout_loaded, error_loaded],
 			url: request.url,
-			params
+			params,
+			ssr
 		});
 	} catch (err) {
 		const error = coalesce_to_error(err);
@@ -1253,15 +1260,30 @@ function is_prerender_enabled(options, node, state) {
  *   $session: any;
  *   route: import('types/internal').SSRPage;
  *   params: Record<string, string>;
+ *   ssr: boolean;
  * }} opts
  * @returns {Promise<ServerResponse | undefined>}
  */
 async function respond$1(opts) {
-	const { request, options, state, $session, route } = opts;
+	const { request, options, state, $session, route, ssr } = opts;
 
 	/** @type {Array<SSRNode | undefined>} */
 	let nodes;
 
+	if (!ssr) {
+		return await render_response({
+			...opts,
+			branch: [],
+			page_config: {
+				hydrate: true,
+				router: true
+			},
+			status: 200,
+			url: request.url,
+			stuff: {}
+		});
+	}
+
 	try {
 		nodes = await Promise.all(
 			route.a.map((n) => options.manifest._.nodes[n] && options.manifest._.nodes[n]())
@@ -1277,7 +1299,8 @@ async function respond$1(opts) {
 			state,
 			$session,
 			status: 500,
-			error
+			error,
+			ssr
 		});
 	}
 
@@ -1307,9 +1330,9 @@ async function respond$1(opts) {
 	/** @type {string[]} */
 	let set_cookie_headers = [];
 
-	ssr: if (page_config.ssr) {
-		let stuff = {};
+	let stuff = {};
 
+	ssr: if (ssr) {
 		for (let i = 0; i < nodes.length; i += 1) {
 			const node = nodes[i];
 
@@ -1324,7 +1347,6 @@ async function respond$1(opts) {
 						node,
 						stuff,
 						prerender_enabled: is_prerender_enabled(options, node, state),
-						is_leaf: i === nodes.length - 1,
 						is_error: false
 					});
 
@@ -1373,7 +1395,6 @@ async function respond$1(opts) {
 							}
 
 							try {
-								// there's no fallthough on an error page, so we know it's not undefined
 								const error_loaded = /** @type {import('./types').Loaded} */ (
 									await load_node({
 										...opts,
@@ -1381,7 +1402,6 @@ async function respond$1(opts) {
 										node: error_node,
 										stuff: node_loaded.stuff,
 										prerender_enabled: is_prerender_enabled(options, error_node, state),
-										is_leaf: false,
 										is_error: true,
 										status,
 										error
@@ -1394,6 +1414,7 @@ async function respond$1(opts) {
 
 								page_config = get_page_config(error_node.module, options);
 								branch = branch.slice(0, j + 1).concat(error_loaded);
+								stuff = { ...node_loaded.stuff, ...error_loaded.stuff };
 								break ssr;
 							} catch (err) {
 								const e = coalesce_to_error(err);
@@ -1415,7 +1436,8 @@ async function respond$1(opts) {
 							state,
 							$session,
 							status,
-							error
+							error,
+							ssr
 						}),
 						set_cookie_headers
 					);
@@ -1435,6 +1457,7 @@ async function respond$1(opts) {
 		return with_cookies(
 			await render_response({
 				...opts,
+				stuff,
 				url: request.url,
 				page_config,
 				status,
@@ -1464,8 +1487,14 @@ async function respond$1(opts) {
  * @param {SSRRenderOptions} options
  */
 function get_page_config(leaf, options) {
+	// TODO remove for 1.0
+	if ('ssr' in leaf) {
+		throw new Error(
+			'`export const ssr` has been removed — use the handle hook instead: https://kit.svelte.dev/docs#hooks-handle'
+		);
+	}
+
 	return {
-		ssr: 'ssr' in leaf ? !!leaf.ssr : options.ssr,
 		router: 'router' in leaf ? !!leaf.router : options.router,
 		hydrate: 'hydrate' in leaf ? !!leaf.hydrate : options.hydrate
 	};
@@ -1488,9 +1517,10 @@ function with_cookies(response, set_cookie_headers) {
  * @param {RegExpExecArray} match
  * @param {import('types/internal').SSRRenderOptions} options
  * @param {import('types/internal').SSRRenderState} state
+ * @param {boolean} ssr
  * @returns {Promise<import('types/hooks').ServerResponse | undefined>}
  */
-async function render_page(request, route, match, options, state) {
+async function render_page(request, route, match, options, state, ssr) {
 	if (state.initiator === route) {
 		// infinite request cycle detected
 		return {
@@ -1510,7 +1540,8 @@ async function render_page(request, route, match, options, state) {
 		state,
 		$session,
 		route,
-		params
+		params,
+		ssr
 	});
 
 	if (response) {
@@ -1748,6 +1779,28 @@ async function respond(incoming, options, state = {}) {
 		locals: {}
 	};
 
+	const { parameter, allowed } = options.method_override;
+	const method_override = incoming.url.searchParams.get(parameter)?.toUpperCase();
+
+	if (method_override) {
+		if (request.method.toUpperCase() === 'POST') {
+			if (allowed.includes(method_override)) {
+				request.method = method_override;
+			} else {
+				const verb = allowed.length === 0 ? 'enabled' : 'allowed';
+				const body = `${parameter}=${method_override} is not ${verb}. See https://kit.svelte.dev/docs#configuration-methodoverride`;
+
+				return {
+					status: 400,
+					headers: {},
+					body
+				};
+			}
+		} else {
+			throw new Error(`${parameter}=${method_override} is only allowed with POST requests`);
+		}
+	}
+
 	// TODO remove this for 1.0
 	/**
 	 * @param {string} property
@@ -1765,19 +1818,25 @@ async function respond(incoming, options, state = {}) {
 	print_error('path', 'pathname');
 	print_error('query', 'searchParams');
 
+	let ssr = true;
+
 	try {
 		return await options.hooks.handle({
 			request,
-			resolve: async (request) => {
+			resolve: async (request, opts) => {
+				if (opts && 'ssr' in opts) ssr = /** @type {boolean} */ (opts.ssr);
+
 				if (state.prerender && state.prerender.fallback) {
 					return await render_response({
 						url: request.url,
 						params: request.params,
 						options,
 						$session: await options.hooks.getSession(request),
-						page_config: { ssr: false, router: true, hydrate: true },
+						page_config: { router: true, hydrate: true },
+						stuff: {},
 						status: 200,
-						branch: []
+						branch: [],
+						ssr: false
 					});
 				}
 
@@ -1790,7 +1849,7 @@ async function respond(incoming, options, state = {}) {
 					const response =
 						route.type === 'endpoint'
 							? await render_endpoint(request, route, match)
-							: await render_page(request, route, match, options, state);
+							: await render_page(request, route, match, options, state, ssr);
 
 					if (response) {
 						// inject ETags for 200 responses
@@ -1830,7 +1889,8 @@ async function respond(incoming, options, state = {}) {
 						state,
 						$session,
 						status: 404,
-						error: new Error(`Not found: ${request.url.pathname}`)
+						error: new Error(`Not found: ${request.url.pathname}`),
+						ssr
 					});
 				}
 			}
@@ -1848,7 +1908,8 @@ async function respond(incoming, options, state = {}) {
 				state,
 				$session,
 				status: 500,
-				error
+				error,
+				ssr
 			});
 		} catch (/** @type {unknown} */ e) {
 			const error = coalesce_to_error(e);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.0.0-next.220",
+  "version": "1.0.0-next.224",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",
@@ -35,7 +35,7 @@
     "node-fetch": "^3.1.0",
     "port-authority": "^1.1.2",
     "rollup": "^2.60.2",
-    "selfsigned": "^1.10.11",
+    "selfsigned": "^2.0.0",
     "sirv": "^2.0.0",
     "svelte": "^3.44.2",
     "svelte-check": "^2.2.10",

package/types/ambient-modules.d.ts

@@ -110,6 +110,7 @@ declare module '$app/stores' {
 	export const page: Readable<{
 		url: URL;
 		params: Record<string, string>;
+		stuff: Record<string, any>;
 		status: number;
 		error: Error | null;
 	}>;

package/types/config.d.ts

@@ -131,6 +131,10 @@ export interface Config {
 		};
 		host?: string;
 		hydrate?: boolean;
+		methodOverride?: {
+			parameter?: string;
+			allowed?: string[];
+		};
 		package?: {
 			dir?: string;
 			emitTypes?: boolean;
@@ -154,7 +158,6 @@ export interface Config {
 			register?: boolean;
 			files?: (filepath: string) => boolean;
 		};
-		ssr?: boolean;
 		target?: string;
 		trailingSlash?: TrailingSlash;
 		vite?: ViteConfig | (() => ViteConfig);

package/types/endpoint.d.ts

@@ -1,5 +1,5 @@
 import { ServerRequest } from './hooks';
-import { JSONString, MaybePromise, ResponseHeaders } from './helper';
+import { JSONString, MaybePromise, ResponseHeaders, Either, Fallthrough } from './helper';
 
 type DefaultBody = JSONString | Uint8Array;
 
@@ -14,5 +14,7 @@ export interface RequestHandler<
 	Input = unknown,
 	Output extends DefaultBody = DefaultBody
 > {
-	(request: ServerRequest<Locals, Input>): MaybePromise<void | EndpointOutput<Output>>;
+	(request: ServerRequest<Locals, Input>): MaybePromise<
+		Either<EndpointOutput<Output>, Fallthrough>
+	>;
 }

package/types/helper.d.ts

@@ -39,3 +39,15 @@ export type RecursiveRequired<T> = {
 		? Extract<T[K], Function> // only take the Function type.
 		: T[K]; // Use the exact type for everything else
 };
+
+type Only<T, U> = {
+	[P in keyof T]: T[P];
+} & {
+	[P in keyof U]?: never;
+};
+
+export type Either<T, U> = Only<T, U> | Only<U, T>;
+
+export interface Fallthrough {
+	fallthrough: true;
+}

package/types/hooks.d.ts

@@ -23,10 +23,14 @@ export interface GetSession<Locals = Record<string, any>, Body = unknown, Sessio
 	(request: ServerRequest<Locals, Body>): MaybePromise<Session>;
 }
 
+export interface ResolveOpts {
+	ssr?: boolean;
+}
+
 export interface Handle<Locals = Record<string, any>, Body = unknown> {
 	(input: {
 		request: ServerRequest<Locals, Body>;
-		resolve(request: ServerRequest<Locals, Body>): MaybePromise<ServerResponse>;
+		resolve(request: ServerRequest<Locals, Body>, opts?: ResolveOpts): MaybePromise<ServerResponse>;
 	}): MaybePromise<ServerResponse>;
 }
 
@@ -35,7 +39,10 @@ export interface Handle<Locals = Record<string, any>, Body = unknown> {
 export interface InternalHandle<Locals = Record<string, any>, Body = unknown> {
 	(input: {
 		request: ServerRequest<Locals, Body>;
-		resolve(request: ServerRequest<Locals, Body>): MaybePromise<ServerResponse | undefined>;
+		resolve(
+			request: ServerRequest<Locals, Body>,
+			opts?: ResolveOpts
+		): MaybePromise<ServerResponse | undefined>;
 	}): MaybePromise<ServerResponse | undefined>;
 }
 

package/types/index.d.ts

@@ -13,5 +13,6 @@ export {
 	Handle,
 	HandleError,
 	ServerRequest as Request,
-	ServerResponse as Response
+	ServerResponse as Response,
+	ResolveOpts
 } from './hooks';

package/types/internal.d.ts

@@ -10,6 +10,7 @@ import {
 	ServerResponse
 } from './hooks';
 import { Load } from './page';
+import { Either, Fallthrough } from './helper';
 
 type PageId = string;
 
@@ -43,11 +44,9 @@ export interface Logger {
 }
 
 export interface SSRComponent {
-	ssr?: boolean;
 	router?: boolean;
 	hydrate?: boolean;
 	prerender?: boolean;
-	preload?: any; // TODO remove for 1.0
 	load: Load;
 	default: {
 		render(props: Record<string, any>): {
@@ -132,6 +131,7 @@ export interface SSRRenderOptions {
 	hooks: Hooks;
 	hydrate: boolean;
 	manifest: SSRManifest;
+	method_override: MethodOverride;
 	paths: {
 		base: string;
 		assets: string;
@@ -142,7 +142,6 @@ export interface SSRRenderOptions {
 	root: SSRComponent['default'];
 	router: boolean;
 	service_worker?: string;
-	ssr: boolean;
 	target: string;
 	template({ head, body, assets }: { head: string; body: string; assets: string }): string;
 	trailing_slash: TrailingSlash;
@@ -219,13 +218,20 @@ export interface BuildData {
 	entries: string[];
 }
 
-export interface NormalizedLoadOutput {
-	status: number;
-	error?: Error;
-	redirect?: string;
-	props?: Record<string, any> | Promise<Record<string, any>>;
-	stuff?: Record<string, any>;
-	maxage?: number;
-}
+export type NormalizedLoadOutput = Either<
+	{
+		status: number;
+		error?: Error;
+		redirect?: string;
+		props?: Record<string, any> | Promise<Record<string, any>>;
+		stuff?: Record<string, any>;
+		maxage?: number;
+	},
+	Fallthrough
+>;
 
 export type TrailingSlash = 'never' | 'always' | 'ignore';
+export interface MethodOverride {
+	parameter: string;
+	allowed: string[];
+}

package/types/page.d.ts

@@ -1,4 +1,4 @@
-import { InferValue, MaybePromise, Rec } from './helper';
+import { InferValue, MaybePromise, Rec, Either, Fallthrough } from './helper';
 
 export interface LoadInput<
 	PageParams extends Rec<string> = Rec<string>,
@@ -51,10 +51,12 @@ export interface Load<
 			InferValue<Input, 'stuff', Rec>,
 			InferValue<Input, 'session', any>
 		>
-	): MaybePromise<void | LoadOutput<
-		InferValue<Output, 'props', Rec>,
-		InferValue<Output, 'stuff', Rec>
-	>>;
+	): MaybePromise<
+		Either<
+			LoadOutput<InferValue<Output, 'props', Rec>, InferValue<Output, 'stuff', Rec>>,
+			Fallthrough
+		>
+	>;
 }
 
 export interface ErrorLoad<