@sveltejs/kit 2.55.0 → 2.56.1

package/src/runtime/app/paths/server.js

@@ -8,7 +8,7 @@ import { get_hooks } from '__SERVER__/internal.js';
 /** @type {import('./client.js').asset} */
 export function asset(file) {
 	// @ts-expect-error we use the `resolve` mechanism, but with the 'wrong' input
-	return assets ? assets + file : resolve(file);
+	return assets && assets !== base ? assets + file : resolve(file);
 }
 
 /** @type {import('./client.js').resolve} */

package/src/runtime/app/server/index.js

@@ -75,4 +75,4 @@ export function read(asset) {
 
 export { getRequestEvent } from '@sveltejs/kit/internal/server';
 
-export { query, prerender, command, form } from './remote/index.js';
+export { query, prerender, command, form, requested } from './remote/index.js';

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

@@ -1,5 +1,5 @@
 /** @import { RemoteCommand } from '@sveltejs/kit' */
-/** @import { RemoteInfo, MaybePromise } from 'types' */
+/** @import { MaybePromise, RemoteCommandInternals } from 'types' */
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
 import { get_request_store } from '@sveltejs/kit/internal/server';
 import { create_validator, run_remote_function } from './shared.js';
@@ -58,21 +58,26 @@ export function command(validate_or_fn, maybe_fn) {
 	/** @type {(arg?: any) => MaybePromise<Input>} */
 	const validate = create_validator(validate_or_fn, maybe_fn);
 
-	/** @type {RemoteInfo} */
+	/** @type {RemoteCommandInternals} */
 	const __ = { type: 'command', id: '', name: '' };
 
-	/** @type {RemoteCommand<Input, Output> & { __: RemoteInfo }} */
+	/** @type {RemoteCommand<Input, Output> & { __: RemoteCommandInternals }} */
 	const wrapper = (arg) => {
 		const { event, state } = get_request_store();
 
-		if (!state.allows_commands) {
-			const disallowed_method = !MUTATIVE_METHODS.includes(event.request.method);
+		if (!MUTATIVE_METHODS.includes(event.request.method)) {
 			throw new Error(
-				`Cannot call a command (\`${__.name}(${maybe_fn ? '...' : ''})\`) ${disallowed_method ? `from a ${event.request.method} handler or ` : ''}during server-side rendering`
+				`Cannot call a command (\`${__.name}(${maybe_fn ? '...' : ''})\`) from a ${event.request.method} handler`
 			);
 		}
 
-		state.refreshes ??= {};
+		if (state.is_in_render) {
+			throw new Error(
+				`Cannot call a command (\`${__.name}(${maybe_fn ? '...' : ''})\`) during server-side rendering`
+			);
+		}
+
+		state.remote.refreshes ??= {};
 
 		const promise = Promise.resolve(
 			run_remote_function(event, state, true, () => validate(arg), fn)

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

@@ -1,5 +1,5 @@
 /** @import { RemoteFormInput, RemoteForm, InvalidField } from '@sveltejs/kit' */
-/** @import { InternalRemoteFormIssue, MaybePromise, RemoteInfo } from 'types' */
+/** @import { InternalRemoteFormIssue, MaybePromise, RemoteFormInternals } from 'types' */
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
 import { get_request_store } from '@sveltejs/kit/internal/server';
 import { DEV } from 'esm-env';
@@ -84,7 +84,7 @@ export function form(validate_or_fn, maybe_fn) {
 			}
 		});
 
-		/** @type {RemoteInfo} */
+		/** @type {RemoteFormInternals} */
 		const __ = {
 			type: 'form',
 			name: '',
@@ -136,7 +136,7 @@ export function form(validate_or_fn, maybe_fn) {
 						data = validated.value;
 					}
 
-					state.refreshes ??= {};
+					state.remote.refreshes ??= {};
 
 					const issue = create_issues();
 
@@ -160,7 +160,7 @@ export function form(validate_or_fn, maybe_fn) {
 				// We don't need to care about args or deduplicating calls, because uneval results are only relevant in full page reloads
 				// where only one form submission is active at the same time
 				if (!event.isRemoteRequest) {
-					get_cache(__, state)[''] ??= output;
+					get_cache(__, state)[''] ??= { serialize: true, data: output };
 				}
 
 				return output;
@@ -178,26 +178,26 @@ export function form(validate_or_fn, maybe_fn) {
 			get() {
 				return create_field_proxy(
 					{},
-					() => get_cache(__)?.['']?.input ?? {},
+					() => get_cache(__)?.['']?.data?.input ?? {},
 					(path, value) => {
 						const cache = get_cache(__);
-						const data = cache[''];
+						const entry = cache[''];
 
-						if (data?.submission) {
+						if (entry?.data?.submission) {
 							// don't override a submission
 							return;
 						}
 
 						if (path.length === 0) {
-							(cache[''] ??= {}).input = value;
+							(cache[''] ??= { serialize: true, data: {} }).data.input = value;
 							return;
 						}
 
-						const input = data?.input ?? {};
+						const input = entry?.data?.input ?? {};
 						deep_set(input, path.map(String), value);
-						(cache[''] ??= {}).input = input;
+						(cache[''] ??= { serialize: true, data: {} }).data.input = input;
 					},
-					() => flatten_issues(get_cache(__)?.['']?.issues ?? [])
+					() => flatten_issues(get_cache(__)?.['']?.data?.issues ?? [])
 				);
 			}
 		});
@@ -219,7 +219,7 @@ export function form(validate_or_fn, maybe_fn) {
 		Object.defineProperty(instance, 'result', {
 			get() {
 				try {
-					return get_cache(__)?.['']?.result;
+					return get_cache(__)?.['']?.data?.result;
 				} catch {
 					return undefined;
 				}
@@ -248,14 +248,14 @@ export function form(validate_or_fn, maybe_fn) {
 				value: (key) => {
 					const { state } = get_request_store();
 					const cache_key = __.id + '|' + JSON.stringify(key);
-					let instance = (state.form_instances ??= new Map()).get(cache_key);
+					let instance = (state.remote.forms ??= new Map()).get(cache_key);
 
 					if (!instance) {
 						instance = create_instance(key);
 						instance.__.id = `${__.id}/${encodeURIComponent(JSON.stringify(key))}`;
 						instance.__.name = __.name;
 
-						state.form_instances.set(cache_key, instance);
+						state.remote.forms.set(cache_key, instance);
 					}
 
 					return instance;

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

@@ -2,3 +2,4 @@ export { command } from './command.js';
 export { form } from './form.js';
 export { prerender } from './prerender.js';
 export { query } from './query.js';
+export { requested } from './requested.js';

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

@@ -1,5 +1,5 @@
 /** @import { RemoteResource, RemotePrerenderFunction } from '@sveltejs/kit' */
-/** @import { RemotePrerenderInputsGenerator, RemoteInfo, MaybePromise } from 'types' */
+/** @import { RemotePrerenderInputsGenerator, RemotePrerenderInternals, MaybePromise } from 'types' */
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
 import { error, json } from '@sveltejs/kit';
 import { DEV } from 'esm-env';
@@ -76,7 +76,7 @@ export function prerender(validate_or_fn, fn_or_options, maybe_options) {
 	/** @type {(arg?: any) => MaybePromise<Input>} */
 	const validate = create_validator(validate_or_fn, maybe_fn);
 
-	/** @type {RemoteInfo} */
+	/** @type {RemotePrerenderInternals} */
 	const __ = {
 		type: 'prerender',
 		id: '',
@@ -86,7 +86,7 @@ export function prerender(validate_or_fn, fn_or_options, maybe_options) {
 		dynamic: options?.dynamic
 	};
 
-	/** @type {RemotePrerenderFunction<Input, Output> & { __: RemoteInfo }} */
+	/** @type {RemotePrerenderFunction<Input, Output> & { __: RemotePrerenderInternals }} */
 	const wrapper = (arg) => {
 		/** @type {Promise<Output> & Partial<RemoteResource<Output>>} */
 		const promise = (async () => {
@@ -103,8 +103,9 @@ export function prerender(validate_or_fn, fn_or_options, maybe_options) {
 
 						// TODO adapters can provide prerendered data more efficiently than
 						// fetching from the public internet
-						const promise = (cache[key] ??= fetch(new URL(url, event.url.origin).href).then(
-							async (response) => {
+						const promise = (cache[key] ??= {
+							serialize: true,
+							data: fetch(new URL(url, event.url.origin).href).then(async (response) => {
 								if (!response.ok) {
 									throw new Error('Prerendered response not found');
 								}
@@ -116,8 +117,8 @@ export function prerender(validate_or_fn, fn_or_options, maybe_options) {
 								}
 
 								return prerendered.result;
-							}
-						));
+							})
+						}).data;
 
 						return parse_remote_response(await promise, state.transport);
 					});

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

@@ -1,8 +1,8 @@
 /** @import { RemoteQuery, RemoteQueryFunction } from '@sveltejs/kit' */
-/** @import { RemoteInfo, MaybePromise } from 'types' */
+/** @import { RemoteInternals, MaybePromise, RequestState, RemoteQueryBatchInternals, RemoteQueryInternals } from 'types' */
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
 import { get_request_store } from '@sveltejs/kit/internal/server';
-import { create_remote_key, stringify_remote_arg } from '../../../shared.js';
+import { create_remote_key, stringify, stringify_remote_arg } from '../../../shared.js';
 import { prerendering } from '__sveltekit/environment';
 import { create_validator, get_cache, get_response, run_remote_function } from './shared.js';
 import { handle_error_and_jsonify } from '../../../server/utils.js';
@@ -61,10 +61,10 @@ export function query(validate_or_fn, maybe_fn) {
 	/** @type {(arg?: any) => MaybePromise<Input>} */
 	const validate = create_validator(validate_or_fn, maybe_fn);
 
-	/** @type {RemoteInfo} */
-	const __ = { type: 'query', id: '', name: '' };
+	/** @type {RemoteQueryInternals} */
+	const __ = { type: 'query', id: '', name: '', validate };
 
-	/** @type {RemoteQueryFunction<Input, Output> & { __: RemoteInfo }} */
+	/** @type {RemoteQueryFunction<Input, Output> & { __: RemoteQueryInternals }} */
 	const wrapper = (arg) => {
 		if (prerendering) {
 			throw new Error(
@@ -73,34 +73,44 @@ export function query(validate_or_fn, maybe_fn) {
 		}
 
 		const { event, state } = get_request_store();
+		// if the user got this argument from `requested(query)`, it will have already passed validation
+		const is_validated = is_validated_argument(__, state, arg);
 
-		const get_remote_function_result = () =>
-			run_remote_function(event, state, false, () => validate(arg), fn);
-
-		/** @type {Promise<any> & Partial<RemoteQuery<any>>} */
-		const promise = get_response(__, arg, state, get_remote_function_result);
-
-		promise.catch(() => {});
+		return create_query_resource(__, arg, state, () =>
+			run_remote_function(event, state, false, () => (is_validated ? arg : validate(arg)), fn)
+		);
+	};
 
-		promise.set = (value) => update_refresh_value(get_refresh_context(__, 'set', arg), value);
+	Object.defineProperty(wrapper, '__', { value: __ });
 
-		promise.refresh = () => {
-			const refresh_context = get_refresh_context(__, 'refresh', arg);
-			const is_immediate_refresh = !refresh_context.cache[refresh_context.cache_key];
-			const value = is_immediate_refresh ? promise : get_remote_function_result();
-			return update_refresh_value(refresh_context, value, is_immediate_refresh);
-		};
+	return wrapper;
+}
 
-		promise.withOverride = () => {
-			throw new Error(`Cannot call '${__.name}.withOverride()' on the server`);
-		};
+/**
+ * @param {RemoteQueryInternals} __
+ * @param {RequestState} state
+ * @param {any} arg
+ */
+function is_validated_argument(__, state, arg) {
+	return state.remote.validated?.get(__.id)?.has(arg) ?? false;
+}
 
-		return /** @type {RemoteQuery<Output>} */ (promise);
-	};
+/**
+ * @param {RemoteQueryInternals} __
+ * @param {RequestState} state
+ * @param {any} arg
+ */
+export function mark_argument_validated(__, state, arg) {
+	const validated = (state.remote.validated ??= new Map());
+	let validated_args = validated.get(__.id);
 
-	Object.defineProperty(wrapper, '__', { value: __ });
+	if (!validated_args) {
+		validated_args = new Set();
+		validated.set(__.id, validated_args);
+	}
 
-	return wrapper;
+	validated_args.add(arg);
+	return arg;
 }
 
 /**
@@ -145,7 +155,7 @@ function batch(validate_or_fn, maybe_fn) {
 	/** @type {(arg?: any) => MaybePromise<Input>} */
 	const validate = create_validator(validate_or_fn, maybe_fn);
 
-	/** @type {RemoteInfo & { type: 'query_batch' }} */
+	/** @type {RemoteQueryBatchInternals} */
 	const __ = {
 		type: 'query_batch',
 		id: '',
@@ -164,7 +174,8 @@ function batch(validate_or_fn, maybe_fn) {
 					return Promise.all(
 						input.map(async (arg, i) => {
 							try {
-								return { type: 'result', data: get_result(arg, i) };
+								const data = get_result(arg, i);
+								return { type: 'result', data: stringify(data, state.transport) };
 							} catch (error) {
 								return {
 									type: 'error',
@@ -182,10 +193,10 @@ function batch(validate_or_fn, maybe_fn) {
 		}
 	};
 
-	/** @type {{ args: any[], resolvers: Array<{resolve: (value: any) => void, reject: (error: any) => void}> }} */
-	let batching = { args: [], resolvers: [] };
+	/** @type {Map<string, { arg: any, resolvers: Array<{resolve: (value: any) => void, reject: (error: any) => void}> }>} */
+	let batching = new Map();
 
-	/** @type {RemoteQueryFunction<Input, Output> & { __: RemoteInfo }} */
+	/** @type {RemoteQueryFunction<Input, Output> & { __: RemoteQueryBatchInternals }} */
 	const wrapper = (arg) => {
 		if (prerendering) {
 			throw new Error(
@@ -195,85 +206,146 @@ function batch(validate_or_fn, maybe_fn) {
 
 		const { event, state } = get_request_store();
 
-		const get_remote_function_result = () => {
+		return create_query_resource(__, arg, state, () => {
 			// Collect all the calls to the same query in the same macrotask,
 			// then execute them as one backend request.
 			return new Promise((resolve, reject) => {
-				// We don't need to deduplicate args here, because get_response already caches/reuses identical calls
-				batching.args.push(arg);
-				batching.resolvers.push({ resolve, reject });
+				const key = stringify_remote_arg(arg, state.transport);
+				const entry = batching.get(key);
 
-				if (batching.args.length > 1) return;
+				if (entry) {
+					entry.resolvers.push({ resolve, reject });
+					return;
+				}
+
+				batching.set(key, {
+					arg,
+					resolvers: [{ resolve, reject }]
+				});
+
+				if (batching.size > 1) return;
 
 				setTimeout(async () => {
 					const batched = batching;
-					batching = { args: [], resolvers: [] };
+					batching = new Map();
+					const entries = Array.from(batched.values());
+					const args = entries.map((entry) => entry.arg);
 
 					try {
 						return await run_remote_function(
 							event,
 							state,
 							false,
-							async () => Promise.all(batched.args.map(validate)),
+							async () => Promise.all(args.map(validate)),
 							async (input) => {
 								const get_result = await fn(input);
 
-								for (let i = 0; i < batched.resolvers.length; i++) {
+								for (let i = 0; i < entries.length; i++) {
 									try {
-										batched.resolvers[i].resolve(get_result(input[i], i));
+										const result = get_result(input[i], i);
+
+										for (const resolver of entries[i].resolvers) {
+											resolver.resolve(result);
+										}
 									} catch (error) {
-										batched.resolvers[i].reject(error);
+										for (const resolver of entries[i].resolvers) {
+											resolver.reject(error);
+										}
 									}
 								}
 							}
 						);
 					} catch (error) {
-						for (const resolver of batched.resolvers) {
-							resolver.reject(error);
+						for (const entry of batched.values()) {
+							for (const resolver of entry.resolvers) {
+								resolver.reject(error);
+							}
 						}
 					}
 				}, 0);
 			});
-		};
+		});
+	};
+
+	Object.defineProperty(wrapper, '__', { value: __ });
 
-		/** @type {Promise<any> & Partial<RemoteQuery<any>>} */
-		const promise = get_response(__, arg, state, get_remote_function_result);
+	return wrapper;
+}
 
-		promise.catch(() => {});
+/**
+ * @param {RemoteInternals} __
+ * @param {any} arg
+ * @param {RequestState} state
+ * @param {() => Promise<any>} fn
+ * @returns {RemoteQuery<any>}
+ */
+function create_query_resource(__, arg, state, fn) {
+	/** @type {Promise<any> | null} */
+	let promise = null;
 
-		promise.set = (value) => update_refresh_value(get_refresh_context(__, 'set', arg), value);
+	const get_promise = () => {
+		return (promise ??= get_response(__, arg, state, fn));
+	};
 
-		promise.refresh = () => {
+	return {
+		/** @type {Promise<any>['catch']} */
+		catch(onrejected) {
+			return get_promise().catch(onrejected);
+		},
+		current: undefined,
+		error: undefined,
+		/** @type {Promise<any>['finally']} */
+		finally(onfinally) {
+			return get_promise().finally(onfinally);
+		},
+		loading: true,
+		ready: false,
+		refresh() {
 			const refresh_context = get_refresh_context(__, 'refresh', arg);
 			const is_immediate_refresh = !refresh_context.cache[refresh_context.cache_key];
-			const value = is_immediate_refresh ? promise : get_remote_function_result();
+			const value = is_immediate_refresh ? get_promise() : fn();
 			return update_refresh_value(refresh_context, value, is_immediate_refresh);
-		};
-
-		promise.withOverride = () => {
+		},
+		run() {
+			// potential TODO: if we want to be able to run queries at the top level of modules / outside of the request context, we could technically remove
+			// the requirement that `state` is defined, but that's kind of an annoying change to make, so we're going to wait on that until we have any sort of
+			// concrete use case.
+			if (!state.is_in_universal_load) {
+				throw new Error(
+					'On the server, .run() can only be called in universal `load` functions. Anywhere else, just await the query directly'
+				);
+			}
+			return get_response(__, arg, state, fn);
+		},
+		/** @param {any} value */
+		set(value) {
+			return update_refresh_value(get_refresh_context(__, 'set', arg), value);
+		},
+		/** @type {Promise<any>['then']} */
+		then(onfulfilled, onrejected) {
+			return get_promise().then(onfulfilled, onrejected);
+		},
+		withOverride() {
 			throw new Error(`Cannot call '${__.name}.withOverride()' on the server`);
-		};
-
-		return /** @type {RemoteQuery<Output>} */ (promise);
+		},
+		get [Symbol.toStringTag]() {
+			return 'QueryResource';
+		}
 	};
-
-	Object.defineProperty(wrapper, '__', { value: __ });
-
-	return wrapper;
 }
 
 // Add batch as a property to the query function
 Object.defineProperty(query, 'batch', { value: batch, enumerable: true });
 
 /**
- * @param {RemoteInfo} __
+ * @param {RemoteInternals} __
  * @param {'set' | 'refresh'} action
  * @param {any} [arg]
- * @returns {{ __: RemoteInfo; state: any; refreshes: Record<string, Promise<any>>; cache: Record<string, Promise<any>>; refreshes_key: string; cache_key: string }}
+ * @returns {{ __: RemoteInternals; state: any; refreshes: Record<string, Promise<any>>; cache: Record<string, { serialize: boolean; data: any }>; refreshes_key: string; cache_key: string }}
  */
 function get_refresh_context(__, action, arg) {
 	const { state } = get_request_store();
-	const { refreshes } = state;
+	const { refreshes } = state.remote;
 
 	if (!refreshes) {
 		const name = __.type === 'query_batch' ? `query.batch '${__.name}'` : `query '${__.name}'`;
@@ -290,7 +362,7 @@ function get_refresh_context(__, action, arg) {
 }
 
 /**
- * @param {{ __: RemoteInfo; refreshes: Record<string, Promise<any>>; cache: Record<string, Promise<any>>; refreshes_key: string; cache_key: string }} context
+ * @param {{ __: RemoteInternals; refreshes: Record<string, Promise<any>>; cache: Record<string, { serialize: boolean; data: any }>; refreshes_key: string; cache_key: string }} context
  * @param {any} value
  * @param {boolean} [is_immediate_refresh=false]
  * @returns {Promise<void>}
@@ -303,12 +375,15 @@ function update_refresh_value(
 	const promise = Promise.resolve(value);
 
 	if (!is_immediate_refresh) {
-		cache[cache_key] = promise;
+		cache[cache_key] = { serialize: true, data: promise };
 	}
 
 	if (__.id) {
 		refreshes[refreshes_key] = promise;
 	}
 
-	return promise.then(() => {});
+	return promise.then(
+		() => {},
+		() => {}
+	);
 }