@sveltejs/kit 3.0.0-next.1 → 3.0.0-next.11

package/src/runtime/app/server/remote/requested.js

@@ -1,12 +1,15 @@
 /** @import { RemoteLiveQuery, RemoteLiveQueryFunction, RemoteQuery, RemoteQueryFunction, RequestedResult, QueryRequestedResult, LiveQueryRequestedResult } from '@sveltejs/kit' */
 /** @import { MaybePromise, RemoteAnyQueryInternals } from 'types' */
+import { HttpError } from '@sveltejs/kit/internal';
 import { get_request_store } from '@sveltejs/kit/internal/server';
-import { create_remote_key, parse_remote_arg } from '../../../shared.js';
+import { parse_remote_arg } from '../../../shared.js';
 import { noop } from '../../../../utils/functions.js';
+import { get_cache } from './shared.js';
+import { refresh } from './query.js';
 
 /**
- * In the context of a remote `command` or `form` request, returns an iterable
- * of `{ arg, query }` entries for the refreshes requested by the client, up to
+ * Inside a remote `command` or `form` callback, returns an iterable
+ * of `{ arg, query }` entries for the query instances the client asked to refresh, up to
  * the supplied `limit`. Each `query` is a `RemoteQuery` bound to the original
  * client-side cache key, so `refresh()` / `set()` propagate correctly even when
  * the query's schema transforms the input. `arg` is the *validated* argument,
@@ -15,6 +18,8 @@ import { noop } from '../../../../utils/functions.js';
  *
  * Arguments that fail validation or exceed `limit` are recorded as failures in
  * the response to the client.
+ * See [Client-requested refreshes](https://svelte.dev/docs/kit/remote-functions#Single-flight-mutations-Client-requested-refreshes)
+ * for usage in a remote `command` or `form`.
  *
  * @example
  * ```ts
@@ -51,14 +56,16 @@ import { noop } from '../../../../utils/functions.js';
  * @returns {QueryRequestedResult<Validated, Output>}
  */
 /**
- * In the context of a remote `command` or `form` request, returns an iterable
- * of `{ arg, query }` entries for the reconnects requested by the client, up to
+ * Inside a remote `command` or `form` callback, returns an iterable
+ * of `{ arg, query }` entries for the live query instances the client asked to reconnect, up to
  * the supplied `limit`. Each `query` is a `RemoteLiveQuery` bound to the original
  * client-side cache key, so `reconnect()` propagates correctly even when
  * the query's schema transforms the input. `arg` is the *validated* argument.
  *
  * Arguments that fail validation or exceed `limit` are recorded as failures in
  * the response to the client.
+ * See [Client-requested refreshes](https://svelte.dev/docs/kit/remote-functions#Single-flight-mutations-Client-requested-refreshes)
+ * for usage in a remote `command` or `form`.
  *
  * @example
  * ```ts
@@ -95,7 +102,7 @@ import { noop } from '../../../../utils/functions.js';
  * @returns {RequestedResult<Validated, Output>}
  */
 export function requested(query, limit) {
-	const { state } = get_request_store();
+	const { event, state } = get_request_store();
 	const internals = /** @type {RemoteAnyQueryInternals | undefined} */ (
 		/** @type {any} */ (query).__
 	);
@@ -115,15 +122,12 @@ export function requested(query, limit) {
 
 	const requested = state.remote.requested;
 	const payloads = requested?.get(__.id) ?? [];
+
 	// note: don't initialize these maps here -- they will be initialized by the
 	// command/form wrapper when we enter them, and if we initialize them here
 	// we will enable requested(...) in contexts where it shouldn't be allowed,
 	// such as load functions or other server functions
-	const refreshes = state.remote.refreshes;
-	const reconnects = state.remote.reconnects;
-	const store = __.type === 'query_live' ? reconnects : refreshes;
-
-	if (!store) {
+	if (!state.is_in_remote_form_or_command) {
 		throw new Error(
 			'requested(...) can only be called in the context of a command/form remote function'
 		);
@@ -131,6 +135,9 @@ export function requested(query, limit) {
 	const [selected, skipped] = split_limit(payloads, limit);
 
 	/**
+	 * Registers the failure exactly like `.set()` registers a value: the error record
+	 * is serialized to the client (putting the query there into a failed state), and
+	 * subsequent server-side calls of the query with the same argument reject with it.
 	 * @param {string} payload
 	 * @param {unknown} error
 	 */
@@ -138,14 +145,15 @@ export function requested(query, limit) {
 		const promise = Promise.reject(error);
 		promise.catch(noop);
 
-		const key = create_remote_key(__.id, payload);
-		store.set(key, promise);
+		get_cache(__, state)[payload] = promise;
+		refresh(event, state, __, payload, () => promise);
 	};
 
 	for (const payload of skipped) {
 		record_failure(
 			payload,
-			new Error(
+			new HttpError(
+				400,
 				`Requested refresh was rejected because it exceeded requested(${__.name}, ${limit}) limit`
 			)
 		);

package/src/runtime/app/server/remote/shared.js

@@ -2,10 +2,7 @@
 /** @import { ServerHooks, MaybePromise, RequestState, RemoteInternals, RequestStore, RemoteLiveQueryUserFunctionReturnType } from 'types' */
 import { parse } from 'devalue';
 import { error } from '@sveltejs/kit';
-import { hydratable } from 'svelte';
 import { with_request_store, get_request_store } from '@sveltejs/kit/internal/server';
-import { create_remote_key, stringify } from '../../../shared.js';
-import { noop } from '../../../../utils/functions.js';
 
 /**
  * @param {any} validate_or_fn
@@ -38,13 +35,11 @@ export function create_validator(validate_or_fn, maybe_fn) {
 
 			// if the `issues` field exists, the validation failed
 			if (result.issues) {
-				error(
-					400,
-					await state.handleValidationError({
-						issues: result.issues,
-						event
-					})
-				);
+				const body = await state.handleValidationError({
+					issues: result.issues,
+					event
+				});
+				error(body.status ?? 400, body);
 			}
 
 			return result.value;
@@ -76,24 +71,13 @@ export async function get_response(internals, payload, state, get_result) {
 	await 0;
 
 	const cache = get_cache(internals, state);
-	const entry = (cache[payload] ??= {
-		serialize: false,
-		data: get_result()
-	});
 
-	entry.serialize ||= !!state.is_in_universal_load;
-
-	if (state.is_in_render && internals.id) {
-		const remote_key = create_remote_key(internals.id, payload);
-
-		void Promise.resolve(entry.data)
-			.then((value) => {
-				void hydratable(remote_key, () => stringify(value, state.transport));
-			})
-			.catch(noop);
+	if (!state.is_in_remote_query) {
+		// if this is a top-level (not nested) `await myQuery()`, include it in the serialized response
+		get_implicit_lookup(internals, state)[payload] = get_result;
 	}
 
-	return entry.data;
+	return (cache[payload] ??= get_result());
 }
 
 /**
@@ -239,10 +223,15 @@ function to_iterator(source, name) {
 }
 
 /**
+ * Note that `state` is deliberately not optional: resources that capture the request
+ * state at creation must pass it explicitly, because reading it from the request store
+ * at call time is only equivalent on runtimes with `AsyncLocalStorage` support.
+ * Callers without a captured state (such as the module-level `form` instance getters)
+ * should pass `get_request_store().state` themselves.
  * @param {RemoteInternals} internals
  * @param {RequestState} state
  */
-export function get_cache(internals, state = get_request_store().state) {
+export function get_cache(internals, state) {
 	let cache = state.remote.data?.get(internals);
 
 	if (cache === undefined) {
@@ -252,3 +241,18 @@ export function get_cache(internals, state = get_request_store().state) {
 
 	return cache;
 }
+
+/**
+ * @param {RemoteInternals} internals
+ * @param {RequestState} state
+ */
+export function get_implicit_lookup(internals, state) {
+	let cache = state.remote.implicit?.get(internals);
+
+	if (cache === undefined) {
+		cache = {};
+		(state.remote.implicit ??= new Map()).set(internals, cache);
+	}
+
+	return cache;
+}

package/src/runtime/app/state/client.js

@@ -3,7 +3,6 @@ import {
 	navigating as _navigating,
 	updated as _updated
 } from '../../client/state.svelte.js';
-import { stores } from '../../client/client.js';
 
 export const page = {
 	get data() {
@@ -57,5 +56,5 @@ export const updated = {
 	get current() {
 		return _updated.current;
 	},
-	check: stores.updated.check
+	check: _updated.check
 };

package/src/runtime/app/stores.js

@@ -1,101 +1,38 @@
-import { getContext } from 'svelte';
-import { BROWSER, DEV } from 'esm-env';
-import { stores as browser_stores } from '../client/client.js';
+// TODO: remove this file when enough people have migrated to Kit 3
+
+/** @returns {never} */
+function removed() {
+	throw new Error(
+		'`$app/stores` has been removed in favour of `$app/state`. See https://svelte.dev/docs/kit/migrating-to-sveltekit-2#SvelteKit-2.12:-$app-stores-deprecated'
+	);
+}
 
 /**
- * A function that returns all of the contextual stores. On the server, this must be called during component initialization.
- * Only use this if you need to defer store subscription until after the component has mounted, for some reason.
- *
  * @deprecated Use `$app/state` instead (requires Svelte 5, [see docs for more info](https://svelte.dev/docs/kit/migrating-to-sveltekit-2#SvelteKit-2.12:-$app-stores-deprecated))
  */
-export const getStores = () => {
-	const stores = BROWSER ? browser_stores : getContext('__svelte__');
-
-	return {
-		/** @type {typeof page} */
-		page: {
-			subscribe: stores.page.subscribe
-		},
-		/** @type {typeof navigating} */
-		navigating: {
-			subscribe: stores.navigating.subscribe
-		},
-		/** @type {typeof updated} */
-		updated: stores.updated
-	};
-};
+export const getStores = removed;
 
 /**
- * A readable store whose value contains page data.
- *
- * On the server, this store can only be subscribed to during component initialization. In the browser, it can be subscribed to at any time.
- *
  * @deprecated Use `page` from `$app/state` instead (requires Svelte 5, [see docs for more info](https://svelte.dev/docs/kit/migrating-to-sveltekit-2#SvelteKit-2.12:-$app-stores-deprecated))
  * @type {import('svelte/store').Readable<import('@sveltejs/kit').Page>}
  */
 export const page = {
-	subscribe(fn) {
-		const store = DEV ? get_store('page') : getStores().page;
-		return store.subscribe(fn);
-	}
+	subscribe: removed
 };
 
 /**
- * A readable store.
- * When navigating starts, its value is a `Navigation` object with `from`, `to`, `type` and (if `type === 'popstate'`) `delta` properties.
- * When navigating finishes, its value reverts to `null`.
- *
- * On the server, this store can only be subscribed to during component initialization. In the browser, it can be subscribed to at any time.
- *
  * @deprecated Use `navigating` from `$app/state` instead (requires Svelte 5, [see docs for more info](https://svelte.dev/docs/kit/migrating-to-sveltekit-2#SvelteKit-2.12:-$app-stores-deprecated))
  * @type {import('svelte/store').Readable<import('@sveltejs/kit').Navigation | null>}
  */
 export const navigating = {
-	subscribe(fn) {
-		const store = DEV ? get_store('navigating') : getStores().navigating;
-		return store.subscribe(fn);
-	}
+	subscribe: removed
 };
 
 /**
- * A readable store whose initial value is `false`. If [`version.pollInterval`](https://svelte.dev/docs/kit/configuration#version) is a non-zero value, SvelteKit will poll for new versions of the app and update the store value to `true` when it detects one. `updated.check()` will force an immediate check, regardless of polling.
- *
- * On the server, this store can only be subscribed to during component initialization. In the browser, it can be subscribed to at any time.
- *
  * @deprecated Use `updated` from `$app/state` instead (requires Svelte 5, [see docs for more info](https://svelte.dev/docs/kit/migrating-to-sveltekit-2#SvelteKit-2.12:-$app-stores-deprecated))
  * @type {import('svelte/store').Readable<boolean> & { check(): Promise<boolean> }}
  */
 export const updated = {
-	subscribe(fn) {
-		const store = DEV ? get_store('updated') : getStores().updated;
-
-		if (BROWSER) {
-			updated.check = store.check;
-		}
-
-		return store.subscribe(fn);
-	},
-	check: () => {
-		throw new Error(
-			BROWSER
-				? 'Cannot check updated store before subscribing'
-				: 'Can only check updated store in browser'
-		);
-	}
+	subscribe: removed,
+	check: removed
 };
-
-/**
- * @template {keyof ReturnType<typeof getStores>} Name
- * @param {Name} name
- * @returns {ReturnType<typeof getStores>[Name]}
- */
-function get_store(name) {
-	try {
-		return getStores()[name];
-	} catch {
-		throw new Error(
-			`Cannot subscribe to '${name}' store on the server outside of a Svelte component, as it is bound to the current request via component context. This prevents state from leaking between users.` +
-				'For more information, see https://svelte.dev/docs/kit/state-management#avoid-shared-state-on-the-server'
-		);
-	}
-}

package/src/runtime/client/bundle.js

@@ -1,6 +1,6 @@
 /* if `bundleStrategy` is 'single' or 'inline', this file is used as the entry point */
 
-import * as kit from './entry.js';
+import * as kit from './client-entry.js';
 
 // @ts-expect-error
 import * as app from '__sveltekit/manifest';

package/src/runtime/client/client-entry.js

@@ -0,0 +1,3 @@
+// we expose this as a separate entry point (rather than treating client.js as the entry point)
+// so that everything other than `start`/`load_css` can be treeshaken
+export { start, load_css } from './client.js';