@sveltejs/kit 3.0.0-next.2 → 3.0.0-next.21

package/src/exports/internal/server/telemetry.js

@@ -0,0 +1,95 @@
+/** @import { Tracer, SpanStatusCode, PropagationAPI, ContextAPI } from '@opentelemetry/api' */
+/** @import { RecordSpan } from 'types' */
+import { HttpError, Redirect } from '../shared.js';
+import { noop_span } from '../../../telemetry.js';
+
+// Import this module by its bare specifier so bundled and external code share its state.
+
+/** @type {Promise<{ tracer: Tracer, SpanStatusCode: typeof SpanStatusCode, propagation: PropagationAPI, context: ContextAPI }> | null} */
+export let otel = null;
+
+/**
+ * The caller passes in `import('@opentelemetry/api')` so the import lives behind
+ * `__SVELTEKIT_SERVER_TRACING_ENABLED__` in the bundled runtime and is eliminated
+ * from builds with tracing disabled, where the package may not be installed.
+ * @param {Promise<typeof import('@opentelemetry/api')>} api
+ * @returns {void}
+ */
+export function init_tracing(api) {
+	otel ??= api
+		.then((module) => {
+			return {
+				tracer: module.trace.getTracer('sveltekit'),
+				propagation: module.propagation,
+				context: module.context,
+				SpanStatusCode: module.SpanStatusCode
+			};
+		})
+		.catch(() => {
+			throw new Error(
+				'Tracing is enabled (see the SvelteKit plugin `tracing.server` option in your vite.config.js), but `@opentelemetry/api` is not available. This error will likely resolve itself when you set up your tracing instrumentation in `instrumentation.server.js`. For more information, see https://svelte.dev/docs/kit/observability#opentelemetry-api'
+			);
+		});
+}
+
+/** @type {RecordSpan} */
+export async function record_span({ name, attributes, fn }) {
+	if (otel === null) {
+		return fn(noop_span);
+	}
+
+	const { SpanStatusCode, tracer } = await otel;
+
+	return tracer.startActiveSpan(name, { attributes }, async (span) => {
+		try {
+			return await fn(span);
+		} catch (error) {
+			if (error instanceof HttpError) {
+				span.setAttributes({
+					[`${name}.result.type`]: 'known_error',
+					[`${name}.result.status`]: error.status,
+					[`${name}.result.message`]: error.body.message
+				});
+				if (error.status >= 500) {
+					span.recordException({
+						name: 'HttpError',
+						message: error.body.message
+					});
+					span.setStatus({
+						code: SpanStatusCode.ERROR,
+						message: error.body.message
+					});
+				}
+			} else if (error instanceof Redirect) {
+				span.setAttributes({
+					[`${name}.result.type`]: 'redirect',
+					[`${name}.result.status`]: error.status,
+					[`${name}.result.location`]: error.location
+				});
+			} else if (error instanceof Error) {
+				span.setAttributes({
+					[`${name}.result.type`]: 'unknown_error'
+				});
+				span.recordException({
+					name: error.name,
+					message: error.message,
+					// conditional so this compiles under consumers' `exactOptionalPropertyTypes`
+					...(error.stack !== undefined && { stack: error.stack })
+				});
+				span.setStatus({
+					code: SpanStatusCode.ERROR,
+					message: error.message
+				});
+			} else {
+				span.setAttributes({
+					[`${name}.result.type`]: 'unknown_error'
+				});
+				span.setStatus({ code: SpanStatusCode.ERROR });
+			}
+
+			throw error;
+		} finally {
+			span.end();
+		}
+	});
+}

package/src/exports/internal/shared.js

@@ -0,0 +1,90 @@
+/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
+
+export class HttpError {
+	/**
+	 * @param {App.Error} error
+	 */
+	constructor(error) {
+		this.status = error.status;
+		this.body = error;
+	}
+
+	toString() {
+		return JSON.stringify(this.body);
+	}
+}
+
+/**
+ * An `HttpError` whose body is already in its final, user-facing form — either produced by the
+ * `handleError` hook on the server and reconstructed here from the response, or authored directly
+ * by the client runtime. Unlike a plain `HttpError` (which represents a fresh `error(...)` call
+ * that the hook has yet to see), `handleError` must not run on it.
+ * @extends HttpError
+ */
+export class HandledHttpError extends HttpError {}
+
+export class Redirect {
+	/**
+	 * @param {300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308} status
+	 * @param {string} location
+	 */
+	constructor(status, location) {
+		try {
+			new Headers({ location });
+		} catch {
+			throw new Error(
+				`Invalid redirect location ${JSON.stringify(location)}: ` +
+					'this string contains characters that cannot be used in HTTP headers'
+			);
+		}
+
+		this.status = status;
+		this.location = location;
+	}
+}
+
+/**
+ * An error that was thrown from within the SvelteKit runtime that is not fatal and doesn't result in a 500, such as a 404.
+ * `SvelteKitError` goes through `handleError`.
+ * @extends Error
+ */
+export class SvelteKitError extends Error {
+	/**
+	 * @param {number} status
+	 * @param {string} text
+	 * @param {string} message
+	 */
+	constructor(status, text, message) {
+		super(message);
+		this.status = status;
+		this.text = text;
+	}
+}
+
+/**
+ * @template [T=undefined]
+ */
+export class ActionFailure {
+	/**
+	 * @param {number} status
+	 * @param {T} data
+	 */
+	constructor(status, data) {
+		this.status = status;
+		this.data = data;
+	}
+}
+
+/**
+ * Error thrown when form validation fails imperatively
+ */
+export class ValidationError extends Error {
+	/**
+	 * @param {StandardSchemaV1.Issue[]} issues
+	 */
+	constructor(issues) {
+		super('Validation failed');
+		this.name = 'ValidationError';
+		this.issues = issues;
+	}
+}

package/src/exports/node/index.js

@@ -1,8 +1,11 @@
 import { createReadStream } from 'node:fs';
 import { Readable } from 'node:stream';
-import { SvelteKitError } from '../internal/index.js';
+import { SvelteKitError } from '../internal/shared.js';
 import { noop } from '../../utils/functions.js';
 
+/** @type {WeakMap<import('http').IncomingMessage, (chunk: Buffer) => void>} */
+const body_data_listeners = new WeakMap();
+
 /**
  * @param {import('http').IncomingMessage} req
  * @param {number} [body_size_limit]
@@ -47,17 +50,19 @@ function get_raw_body(req, body_size_limit) {
 				return;
 			}
 
-			req.on('error', (error) => {
+			/** @param {Error} error */
+			const on_error = (error) => {
 				cancelled = true;
 				controller.error(error);
-			});
+			};
 
-			req.on('end', () => {
+			const on_end = () => {
 				if (cancelled) return;
 				controller.close();
-			});
+			};
 
-			req.on('data', (chunk) => {
+			/** @param {Buffer} chunk */
+			const on_data = (chunk) => {
 				if (cancelled) return;
 
 				size += chunk.length;
@@ -89,7 +94,12 @@ function get_raw_body(req, body_size_limit) {
 				if (controller.desiredSize === null || controller.desiredSize <= 0) {
 					req.pause();
 				}
-			});
+			};
+
+			req.on('error', on_error);
+			req.on('end', on_end);
+			req.on('data', on_data);
+			body_data_listeners.set(req, on_data);
 		},
 
 		pull() {
@@ -109,11 +119,9 @@ function get_raw_body(req, body_size_limit) {
  *   base: string;
  *   bodySizeLimit?: number;
  * }} options
- * @returns {Promise<Request>}
+ * @returns {Request}
  */
-// TODO 3.0 make the signature synchronous?
-// eslint-disable-next-line @typescript-eslint/require-await
-export async function getRequest({ request, base, bodySizeLimit }) {
+export function getRequest({ request, base, bodySizeLimit }) {
 	let headers = /** @type {Record<string, string>} */ (request.headers);
 	if (request.httpVersionMajor >= 2) {
 		// the Request constructor rejects headers with ':' in the name
@@ -129,14 +137,9 @@ export async function getRequest({ request, base, bodySizeLimit }) {
 	}
 
 	const controller = new AbortController();
-	// TODO: Whenever Node >=22.17 is the minimum supported version, we can do `if (request.readableAborted) controller.abort()` instead
-	// see https://github.com/nodejs/node/blob/5cf3c3e24c7257a0c6192ed8ef71efec8ddac22b/lib/internal/streams/readable.js#L1443-L1453
-	let errored = false;
-	let end_emitted = false;
-	request.once('error', () => (errored = true));
-	request.once('end', () => (end_emitted = true));
+
 	request.once('close', () => {
-		if ((errored || request.destroyed) && !end_emitted) {
+		if (request.readableAborted) {
 			controller.abort();
 		}
 	});
@@ -154,14 +157,53 @@ export async function getRequest({ request, base, bodySizeLimit }) {
 	});
 }
 
+/**
+ * Drains any unconsumed request body once the response has been sent. When a
+ * route doesn't read the request body (for example a page route receiving a
+ * POST), the unread bytes remain buffered in the socket. On keep-alive
+ * connections Node's HTTP parser then reads those leftover bytes as the next
+ * request, fails to parse them, and resets the connection — losing any
+ * pipelined request. Resuming the request discards the bytes so the connection
+ * stays usable.
+ *
+ * Because `get_raw_body` attaches a `data` listener, Node marks the request as
+ * being consumed (`req._consuming`) and skips its own automatic drain, so we
+ * have to do it ourselves. The whole remaining body is read and discarded; this
+ * is the intended trade-off (keeping the connection reusable) over destroying it.
+ * @see https://github.com/sveltejs/kit/issues/14916
+ * @see https://github.com/sveltejs/kit/issues/15526
+ * @param {import('http').ServerResponse} res
+ */
+function drain_request(res) {
+	const req = res.req;
+	if (!req || req.readableEnded || req.destroyed) return;
+
+	// When the body went unread, get_raw_body's `data` listener is still attached
+	// and enqueues into a ReadableStream nobody consumes; it pauses the request at
+	// the high water mark, so one chunk sits in memory and the rest stays buffered
+	// in the socket. Remove only that `data` listener so the resumed stream drops
+	// the remaining bytes instead of re-buffering them. The `end` and `error`
+	// listeners stay attached so the body's ReadableStream is still closed (or
+	// errored) once draining completes, and a consumer that stopped reading
+	// mid-body sees a clean end instead of hanging.
+	const on_data = body_data_listeners.get(req);
+	if (on_data) {
+		req.removeListener('data', on_data);
+		body_data_listeners.delete(req);
+	}
+
+	req.resume();
+}
+
 /**
  * @param {import('http').ServerResponse} res
  * @param {Response} response
- * @returns {Promise<void>}
+ * @returns {void}
  */
-// TODO 3.0 make the signature synchronous?
-// eslint-disable-next-line @typescript-eslint/require-await
-export async function setResponse(res, response) {
+export function setResponse(res, response) {
+	res.once('finish', () => drain_request(res));
+	res.once('close', () => drain_request(res));
+
 	for (const [key, value] of response.headers) {
 		try {
 			res.setHeader(key, key === 'set-cookie' ? response.headers.getSetCookie() : value);

package/src/exports/params/index.js

@@ -0,0 +1,70 @@
+/** @import { ParamDefinition, ParamMatcher } from '@sveltejs/kit/params' */
+
+/**
+ * Define [parameter matchers](https://svelte.dev/docs/kit/advanced-routing#Matching) for your app.
+ *
+ * @example
+ * ```js
+ * import { defineParams } from '@sveltejs/kit/params';
+ * import * as v from 'valibot';
+ *
+ * export const params = defineParams({
+ * 	locale: (param) => {
+ * 		if (param !== 'de' && param !== 'en') return;
+ * 		return param;
+ * 	},
+ * 	number: v.pipe(v.string(), v.toNumber())
+ * });
+ * ```
+ *
+ * @template {Record<string, import('./public.js').ParamDefinition>} T
+ * @param {T} definitions
+ * @returns {import('./public.js').DefinedParams<T>}
+ */
+export function defineParams(definitions) {
+	/** @type {Record<string, import('./public.js').ParamMatcher>} */
+	const matchers = {};
+
+	for (const [key, definition] of Object.entries(definitions)) {
+		matchers[key] = normalize_param_definition(definition);
+	}
+
+	return /** @type {import('./public.js').DefinedParams<T>} */ (matchers);
+}
+
+/**
+ * @param {ParamDefinition} definition
+ * @returns {ParamMatcher}
+ */
+export function normalize_param_definition(definition) {
+	// standard schemas can be callable (e.g. ArkType), so this must be checked before the function case
+	if (
+		definition &&
+		(typeof definition === 'object' || typeof definition === 'function') &&
+		'~standard' in definition
+	) {
+		return definition;
+	}
+
+	if (typeof definition === 'function') {
+		return /** @type {ParamMatcher} */ (
+			/** @type {unknown} */ ({
+				'~standard': {
+					validate(/** @type {unknown} */ value) {
+						const result = definition(/** @type {string} */ (value));
+
+						if (result === undefined) {
+							return { issues: [{ message: 'Invalid param' }] };
+						}
+
+						if (/** @type {any} */ (result) instanceof Promise) return result; // will be validated and rejected upstream
+
+						return { value: result };
+					}
+				}
+			})
+		);
+	}
+
+	throw new Error('Invalid param definition');
+}

package/src/exports/params/public.d.ts

@@ -0,0 +1,63 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+
+/**
+ * The shape of a param matcher. See [matching](https://svelte.dev/docs/kit/advanced-routing#Matching) for more info.
+ */
+export type ParamMatcher<Output = any> = StandardSchemaV1<string, Output>;
+
+/**
+ * A value that can be parsed from a URL param and losslessly encoded with `String(...)`.
+ */
+export type ParamValue = string | number | boolean | bigint;
+
+/**
+ * A param matcher definition passed to [`defineParams`](https://svelte.dev/docs/kit/@sveltejs-kit-params#defineParams).
+ */
+export type ParamDefinition =
+	| ((param: string) => ParamValue | undefined)
+	| StandardSchemaV1<string, ParamValue>;
+
+/**
+ * The return type of [`defineParams`](https://svelte.dev/docs/kit/@sveltejs-kit-params#defineParams).
+ */
+export type DefinedParams<T extends Record<string, ParamDefinition>> = {
+	readonly [K in keyof T]: ParamEntry<T[K]>;
+};
+
+/**
+ * Normalizes a property of defineParams (schema or function) to standard schema.
+ */
+type ParamEntry<M> =
+	M extends StandardSchemaV1<any, any>
+		? StandardSchemaV1.InferOutput<M> extends ParamValue
+			? StandardSchemaV1<any, M>
+			: StandardSchemaV1<any, never>
+		: M extends (param: string) => infer R
+			? Exclude<R, undefined> extends ParamValue
+				? StandardSchemaV1<any, Exclude<R, undefined>>
+				: StandardSchemaV1<any, never>
+			: never;
+
+/**
+ * Extracts the param type from a matcher.
+ */
+export type MatcherParam<M extends StandardSchemaV1<any, any>> =
+	M extends StandardSchemaV1<any, infer Inner>
+		? Inner extends ParamValue
+			? Inner
+			: Inner extends StandardSchemaV1<any, any>
+				? StandardSchemaV1.InferOutput<Inner> extends ParamValue
+					? StandardSchemaV1.InferOutput<Inner>
+					: never
+				: never
+		: never;
+
+/**
+ * Define [parameter matchers](https://svelte.dev/docs/kit/advanced-routing#Matching) for your app.
+ *
+ * @template T
+ * @param definitions
+ */
+export function defineParams<T extends Record<string, ParamDefinition>>(
+	definitions: T
+): DefinedParams<T>;