@sveltejs/kit 1.0.0-next.296 → 1.0.0-next.297

package/assets/client/start.js

@@ -795,7 +795,7 @@ function create_client({ target, session, base, trailing_slash }) {
 	 * @param {import('./types').NavigationIntent} intent
 	 * @param {boolean} no_cache
 	 */
-	async function load_route(route, { id, url, path }, no_cache) {
+	async function load_route(route, { id, url, path, routes }, no_cache) {
 		if (!no_cache) {
 			const cached = cache.get(id);
 			if (cached) return cached;
@@ -804,7 +804,7 @@ function create_client({ target, session, base, trailing_slash }) {
 		const [pattern, a, b, get_params, shadow_key] = route;
 		const params = get_params
 			? // the pattern is for the route which we've already matched to this path
-			  get_params(/** @type {RegExpExecArray}  */ (pattern.exec(path)))
+			  get_params(/** @type {RegExpExecArray} */ (pattern.exec(path)))
 			: {};
 
 		const changed = current.url && {
@@ -876,10 +876,14 @@ function create_client({ target, session, base, trailing_slash }) {
 							}
 
 							if (res.status === 204) {
-								// fallthrough
-								return;
+								if (route !== routes[routes.length - 1]) {
+									// fallthrough
+									return;
+								}
+								props = {};
+							} else {
+								props = await res.json();
 							}
-							props = await res.json();
 						} else {
 							status = res.status;
 							error = new Error('Failed to load data');

package/assets/server/index.js

@@ -1720,7 +1720,9 @@ async function load_node({
 
 					response = await respond(new Request(new URL(requested, event.url).href, opts), options, {
 						fetched: requested,
-						initiator: route
+						getClientAddress: state.getClientAddress,
+						initiator: route,
+						prerender: state.prerender
 					});
 
 					if (state.prerender) {
@@ -2503,7 +2505,7 @@ const DATA_SUFFIX = '/__data.json';
 const default_transform = ({ html }) => html;
 
 /** @type {import('types').Respond} */
-async function respond(request, options, state = {}) {
+async function respond(request, options, state) {
 	const url = new URL(request.url);
 
 	const normalized = normalize_path(url.pathname, options.trailing_slash);
@@ -2544,11 +2546,26 @@ async function respond(request, options, state = {}) {
 
 	/** @type {import('types').RequestEvent} */
 	const event = {
-		request,
-		url,
-		params: {},
+		get clientAddress() {
+			if (!state.getClientAddress) {
+				throw new Error(
+					`${
+						import.meta.env.VITE_SVELTEKIT_ADAPTER_NAME
+					} does not specify getClientAddress. Please raise an issue`
+				);
+			}
+
+			Object.defineProperty(event, 'clientAddress', {
+				value: state.getClientAddress()
+			});
+
+			return event.clientAddress;
+		},
 		locals: {},
-		platform: state.platform
+		params: {},
+		platform: state.platform,
+		request,
+		url
 	};
 
 	// TODO remove this for 1.0
@@ -2750,6 +2767,10 @@ async function respond(request, options, state = {}) {
 					});
 				}
 
+				if (state.prerender) {
+					return new Response('not found', { status: 404 });
+				}
+
 				// we can't load the endpoint from our own manifest,
 				// so we need to make an actual HTTP request
 				return await fetch(request);

package/dist/chunks/index.js

@@ -271,62 +271,72 @@ async function create_plugin(config, cwd) {
 
 						const template = load_template(cwd, config);
 
-						const rendered = await respond(request, {
-							amp: config.kit.amp,
-							csp: config.kit.csp,
-							dev: true,
-							floc: config.kit.floc,
-							get_stack: (error) => {
-								return fix_stack_trace(error);
-							},
-							handle_error: (error, event) => {
-								hooks.handleError({
-									error: new Proxy(error, {
-										get: (target, property) => {
-											if (property === 'stack') {
-												return fix_stack_trace(error);
+						const rendered = await respond(
+							request,
+							{
+								amp: config.kit.amp,
+								csp: config.kit.csp,
+								dev: true,
+								floc: config.kit.floc,
+								get_stack: (error) => {
+									return fix_stack_trace(error);
+								},
+								handle_error: (error, event) => {
+									hooks.handleError({
+										error: new Proxy(error, {
+											get: (target, property) => {
+												if (property === 'stack') {
+													return fix_stack_trace(error);
+												}
+
+												return Reflect.get(target, property, target);
 											}
-
-											return Reflect.get(target, property, target);
+										}),
+										event,
+
+										// TODO remove for 1.0
+										// @ts-expect-error
+										get request() {
+											throw new Error(
+												'request in handleError has been replaced with event. See https://github.com/sveltejs/kit/pull/3384 for details'
+											);
 										}
-									}),
-									event,
-
-									// TODO remove for 1.0
-									// @ts-expect-error
-									get request() {
-										throw new Error(
-											'request in handleError has been replaced with event. See https://github.com/sveltejs/kit/pull/3384 for details'
-										);
-									}
-								});
-							},
-							hooks,
-							hydrate: config.kit.browser.hydrate,
-							manifest,
-							method_override: config.kit.methodOverride,
-							paths: {
-								base: config.kit.paths.base,
-								assets
-							},
-							prefix: '',
-							prerender: config.kit.prerender.enabled,
-							read: (file) => fs__default.readFileSync(path__default.join(config.kit.files.assets, file)),
-							root,
-							router: config.kit.browser.router,
-							template: ({ head, body, assets, nonce }) => {
-								return (
-									template
-										.replace(/%svelte\.assets%/g, assets)
-										.replace(/%svelte\.nonce%/g, nonce)
-										// head and body must be replaced last, in case someone tries to sneak in %svelte.assets% etc
-										.replace('%svelte.head%', () => head)
-										.replace('%svelte.body%', () => body)
-								);
+									});
+								},
+								hooks,
+								hydrate: config.kit.browser.hydrate,
+								manifest,
+								method_override: config.kit.methodOverride,
+								paths: {
+									base: config.kit.paths.base,
+									assets
+								},
+								prefix: '',
+								prerender: config.kit.prerender.enabled,
+								read: (file) => fs__default.readFileSync(path__default.join(config.kit.files.assets, file)),
+								root,
+								router: config.kit.browser.router,
+								template: ({ head, body, assets, nonce }) => {
+									return (
+										template
+											.replace(/%svelte\.assets%/g, assets)
+											.replace(/%svelte\.nonce%/g, nonce)
+											// head and body must be replaced last, in case someone tries to sneak in %svelte.assets% etc
+											.replace('%svelte.head%', () => head)
+											.replace('%svelte.body%', () => body)
+									);
+								},
+								template_contains_nonce: template.includes('%svelte.nonce%'),
+								trailing_slash: config.kit.trailingSlash
 							},
-							template_contains_nonce: template.includes('%svelte.nonce%'),
-							trailing_slash: config.kit.trailingSlash
-						});
+							{
+								getClientAddress: () => {
+									const { remoteAddress } = req.socket;
+									if (remoteAddress) return remoteAddress;
+									throw new Error('Could not determine clientAddress');
+								}
+							}
+						);
 
 						if (rendered) {
 							setResponse(res, rendered);

package/dist/chunks/index2.js

@@ -500,6 +500,8 @@ async function build_server(
 
 	print_config_conflicts(conflicts, 'kit.vite.', 'build_server');
 
+	process.env.VITE_SVELTEKIT_ADAPTER_NAME = config.kit.adapter?.name;
+
 	const { chunks } = await create_build(merged_config);
 
 	/** @type {import('vite').Manifest} */
@@ -1073,6 +1075,7 @@ async function prerender({ config, entries, files, log }) {
 		const dependencies = new Map();
 
 		const response = await server.respond(new Request(`http://sveltekit-prerender${encoded}`), {
+			getClientAddress,
 			prerender: {
 				default: config.kit.prerender.default,
 				dependencies
@@ -1209,6 +1212,7 @@ async function prerender({ config, entries, files, log }) {
 	}
 
 	const rendered = await server.respond(new Request('http://sveltekit-prerender/[fallback]'), {
+		getClientAddress,
 		prerender: {
 			fallback: true,
 			default: false,
@@ -1223,6 +1227,11 @@ async function prerender({ config, entries, files, log }) {
 	return prerendered;
 }
 
+/** @return {string} */
+function getClientAddress() {
+	throw new Error('Cannot read clientAddress during prerendering');
+}
+
 /**
  * @param {import('types').ValidatedConfig} config
  * @param {{ log: import('types').Logger }} opts

package/dist/chunks/index5.js

@@ -145,7 +145,16 @@ async function preview({ port, host, config, https: use_https = false }) {
 				return res.end(err.reason || 'Invalid request body');
 			}
 
-			setResponse(res, await server.respond(request));
+			setResponse(
+				res,
+				await server.respond(request, {
+					getClientAddress: () => {
+						const { remoteAddress } = req.socket;
+						if (remoteAddress) return remoteAddress;
+						throw new Error('Could not determine clientAddress');
+					}
+				})
+			);
 		}
 	]);
 

package/dist/chunks/sync.js

@@ -895,6 +895,22 @@ function validate(config, out, user_file) {
 	}
 }
 
+/** @param {string} imports */
+const header = (imports) => `
+// this file is auto-generated
+import type { ${imports} } from '@sveltejs/kit';`;
+
+/** @param {string} arg */
+const endpoint = (arg) => `
+export type RequestHandler<Output extends ResponseBody = ResponseBody> = GenericRequestHandler<${arg}, Output>;`;
+
+/** @param {string} arg */
+const page = (arg) => `
+export type Load<
+	InputProps extends Record<string, any> = Record<string, any>,
+	OutputProps extends Record<string, any> = InputProps
+> = GenericLoad<${arg}, InputProps, OutputProps>;`;
+
 /**
  * @param {import('types').ValidatedConfig} config
  * @param {import('types').ManifestData} manifest_data
@@ -948,25 +964,25 @@ function write_types(config, manifest_data) {
 		const arg =
 			params.length > 0 ? `{ ${params.map((param) => `${param}: string`).join('; ')} }` : '{}';
 
-		const imports = [
-			type !== 'page' && 'RequestHandler as GenericRequestHandler',
-			type !== 'endpoint' && 'Load as GenericLoad'
-		]
-			.filter(Boolean)
-			.join(', ');
-
-		const file = `${config.kit.outDir}/types/${key || 'index'}.d.ts`;
-		const content = [
-			'// this file is auto-generated',
-			`import type { ${imports} } from '@sveltejs/kit';`,
-			type !== 'page' && `export type RequestHandler = GenericRequestHandler<${arg}>;`,
-			type !== 'endpoint' &&
-				`export type Load<Props = Record<string, any>> = GenericLoad<${arg}, Props>;`
-		]
-			.filter(Boolean)
-			.join('\n');
+		const imports = [];
+		const content = [];
+
+		if (type !== 'page') {
+			imports.push('RequestHandler as GenericRequestHandler, ResponseBody');
+			content.push(endpoint(arg));
+		}
 
-		write_if_changed(file, content);
+		if (type !== 'endpoint') {
+			imports.push('Load as GenericLoad');
+			content.push(page(arg));
+		}
+
+		content.unshift(header(imports.join(', ')));
+
+		write_if_changed(
+			`${config.kit.outDir}/types/${key || 'index'}.d.ts`,
+			content.join('\n').trim()
+		);
 	});
 }
 

package/dist/cli.js

@@ -870,7 +870,7 @@ async function launch(port, https) {
 	exec(`${cmd} ${https ? 'https' : 'http'}://localhost:${port}`);
 }
 
-const prog = sade('svelte-kit').version('1.0.0-next.296');
+const prog = sade('svelte-kit').version('1.0.0-next.297');
 
 prog
 	.command('dev')
@@ -1043,7 +1043,7 @@ async function check_port(port) {
 function welcome({ port, host, https, open, loose, allow, cwd }) {
 	if (open) launch(port, https);
 
-	console.log($.bold().cyan(`\n  SvelteKit v${'1.0.0-next.296'}\n`));
+	console.log($.bold().cyan(`\n  SvelteKit v${'1.0.0-next.297'}\n`));
 
 	const protocol = https ? 'https:' : 'http:';
 	const exposed = typeof host !== 'undefined' && host !== 'localhost' && host !== '127.0.0.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/kit",
-  "version": "1.0.0-next.296",
+  "version": "1.0.0-next.297",
   "repository": {
     "type": "git",
     "url": "https://github.com/sveltejs/kit",

package/types/index.d.ts

@@ -6,11 +6,11 @@ import './ambient';
 import { CompileOptions } from 'svelte/types/compiler/interfaces';
 import {
 	AdapterEntry,
-	Body,
 	CspDirectives,
 	Either,
 	ErrorLoadInput,
 	Fallthrough,
+	JSONValue,
 	LoadInput,
 	LoadOutput,
 	Logger,
@@ -158,7 +158,10 @@ export interface Config {
 	preprocess?: any;
 }
 
-export interface ErrorLoad<Params = Record<string, string>, Props = Record<string, any>> {
+export interface ErrorLoad<
+	Params extends Record<string, string> = Record<string, string>,
+	Props extends Record<string, any> = Record<string, any>
+> {
 	(input: ErrorLoadInput<Params>): MaybePromise<LoadOutput<Props>>;
 }
 
@@ -218,11 +221,14 @@ export interface Page<Params extends Record<string, string> = Record<string, str
  * Note that you can use [generated types](/docs/types#generated-types)
  * instead of manually specifying the `Params` generic argument.
  */
-export interface RequestHandler<Params = Record<string, string>, Output extends Body = Body> {
+export interface RequestHandler<
+	Params extends Record<string, string> = Record<string, string>,
+	Output extends ResponseBody = ResponseBody
+> {
 	(event: RequestEvent<Params>): RequestHandlerOutput<Output>;
 }
 
-export type RequestHandlerOutput<Output extends Body = Body> = MaybePromise<
+export type RequestHandlerOutput<Output extends ResponseBody = ResponseBody> = MaybePromise<
 	Either<
 		{
 			status?: number;
@@ -233,9 +239,11 @@ export type RequestHandlerOutput<Output extends Body = Body> = MaybePromise<
 	>
 >;
 
+export type ResponseBody = JSONValue | Uint8Array | ReadableStream | import('stream').Readable;
+
 export class Server {
 	constructor(manifest: SSRManifest);
-	respond(request: Request, options?: RequestOptions): Promise<Response>;
+	respond(request: Request, options: RequestOptions): Promise<Response>;
 }
 
 export interface SSRManifest {

package/types/internal.d.ts

@@ -92,7 +92,7 @@ export interface Hooks {
 export class InternalServer extends Server {
 	respond(
 		request: Request,
-		options?: RequestOptions & {
+		options: RequestOptions & {
 			prerender?: PrerenderOptions;
 		}
 	): Promise<Response>;
@@ -164,7 +164,7 @@ export type RecursiveRequired<T> = {
 export type RequiredResolveOptions = Required<ResolveOptions>;
 
 export interface Respond {
-	(request: Request, options: SSROptions, state?: SSRState): Promise<Response>;
+	(request: Request, options: SSROptions, state: SSRState): Promise<Response>;
 }
 
 export type RouteData = PageData | EndpointData;
@@ -302,11 +302,12 @@ export interface SSRPagePart {
 export type SSRRoute = SSREndpoint | SSRPage;
 
 export interface SSRState {
+	fallback?: string;
 	fetched?: string;
+	getClientAddress: () => string;
 	initiator?: SSRPage | null;
 	platform?: any;
 	prerender?: PrerenderOptions;
-	fallback?: string;
 }
 
 export type StrictBody = string | Uint8Array;

package/types/private.d.ts

@@ -28,8 +28,6 @@ export interface AdapterEntry {
 	}) => void;
 }
 
-export type Body = JSONValue | Uint8Array | ReadableStream | import('stream').Readable;
-
 // Based on https://github.com/josh-hemphill/csp-typed-directives/blob/latest/src/csp.types.ts
 //
 // MIT License
@@ -140,7 +138,8 @@ export interface CspDirectives {
 
 export type Either<T, U> = Only<T, U> | Only<U, T>;
 
-export interface ErrorLoadInput<Params = Record<string, string>> extends LoadInput<Params> {
+export interface ErrorLoadInput<Params extends Record<string, string> = Record<string, string>>
+	extends LoadInput<Params> {
 	status?: number;
 	error?: Error;
 }
@@ -165,7 +164,10 @@ export type JSONValue =
 	| JSONValue[]
 	| JSONObject;
 
-export interface LoadInput<Params = Record<string, string>, Props = Record<string, any>> {
+export interface LoadInput<
+	Params extends Record<string, string> = Record<string, string>,
+	Props extends Record<string, any> = Record<string, any>
+> {
 	url: URL;
 	params: Params;
 	props: Props;
@@ -174,7 +176,7 @@ export interface LoadInput<Params = Record<string, string>, Props = Record<strin
 	stuff: Partial<App.Stuff>;
 }
 
-export interface LoadOutput<Props = Record<string, any>> {
+export interface LoadOutput<Props extends Record<string, any> = Record<string, any>> {
 	status?: number;
 	error?: string | Error;
 	redirect?: string;
@@ -233,15 +235,17 @@ export interface PrerenderErrorHandler {
 
 export type PrerenderOnErrorValue = 'fail' | 'continue' | PrerenderErrorHandler;
 
-export interface RequestEvent<Params = Record<string, string>> {
-	request: Request;
-	url: URL;
-	params: Params;
+export interface RequestEvent<Params extends Record<string, string> = Record<string, string>> {
+	clientAddress: string;
 	locals: App.Locals;
+	params: Params;
 	platform: Readonly<App.Platform>;
+	request: Request;
+	url: URL;
 }
 
 export interface RequestOptions {
+	getClientAddress: () => string;
 	platform?: App.Platform;
 }