fix: prevent unnecessary __data.json requests

.changeset/heavy-poems-retire.md

@@ -0,0 +1,5 @@
+---
+'@sveltejs/kit': patch
+---
+
+fix: only fetch `__data.json` files for routes with a server `load` function

.changeset/young-planes-flash.md

@@ -0,0 +1,5 @@
+---
+'@sveltejs/kit': patch
+---
+
+fix: install polyfills when analysing code

package.json

@@ -4,11 +4,11 @@
 	"description": "monorepo for @sveltejs/kit and friends",
 	"private": true,
 	"scripts": {
-		"test": "turbo run test --filter=./packages/*",
-		"test:cross-platform": "turbo run test:cross-platform --filter=./packages/*",
+		"test": "turbo run test --filter=./packages/* --force",
+		"test:cross-platform": "turbo run test:cross-platform --filter=./packages/* --force",
 		"test:vite-ecosystem-ci": "pnpm test --dir packages/kit",
-		"check": "turbo run check",
-		"lint": "turbo run lint",
+		"check": "turbo run check --force",
+		"lint": "turbo run lint --force",
 		"format": "turbo run format",
 		"precommit": "turbo run precommit",
 		"release": "changeset publish"

packages/kit/src/core/adapt/builder.js

@@ -17,13 +17,14 @@ const pipe = promisify(pipeline);
  * @param {{
  *   config: import('types').ValidatedConfig;
  *   build_data: import('types').BuildData;
+ *   server_metadata: import('types').ServerMetadata;
  *   routes: import('types').RouteData[];
  *   prerendered: import('types').Prerendered;
  *   log: import('types').Logger;
  * }} opts
  * @returns {import('types').Builder}
  */
-export function create_builder({ config, build_data, routes, prerendered, log }) {
+export function create_builder({ config, build_data, server_metadata, routes, prerendered, log }) {
 	return {
 		log,
 		rimraf,
@@ -53,18 +54,9 @@ export function create_builder({ config, build_data, routes, prerendered, log })
 		async createEntries(fn) {
 			/** @type {import('types').RouteDefinition[]} */
 			const facades = routes.map((route) => {
-				/** @type {Set<import('types').HttpMethod>} */
-				const methods = new Set();
-
-				if (route.page) {
-					methods.add('GET');
-				}
-
-				if (route.endpoint) {
-					for (const method of build_data.server.methods[route.endpoint.file]) {
-						methods.add(method);
-					}
-				}
+				const methods =
+					/** @type {import('types').HttpMethod[]} */
+					(server_metadata.routes.get(route.id)?.methods);
 
 				return {
 					id: route.id,
@@ -74,7 +66,7 @@ export function create_builder({ config, build_data, routes, prerendered, log })
 						content: segment
 					})),
 					pattern: route.pattern,
-					methods: Array.from(methods)
+					methods
 				};
 			});
 

packages/kit/src/core/adapt/builder.spec.js

@@ -29,6 +29,8 @@ test('copy files', () => {
 		config: /** @type {import('types').ValidatedConfig} */ (mocked),
 		// @ts-expect-error
 		build_data: {},
+		// @ts-expect-error
+		server_metadata: {},
 		routes: [],
 		// @ts-expect-error
 		prerendered: {

packages/kit/src/core/adapt/index.js

@@ -4,18 +4,20 @@ import { create_builder } from './builder.js';
 /**
  * @param {import('types').ValidatedConfig} config
  * @param {import('types').BuildData} build_data
+ * @param {import('types').ServerMetadata} server_metadata
  * @param {import('types').Prerendered} prerendered
  * @param {import('types').PrerenderMap} prerender_map
- * @param {{ log: import('types').Logger }} opts
+ * @param {import('types').Logger} log
  */
-export async function adapt(config, build_data, prerendered, prerender_map, { log }) {
+export async function adapt(config, build_data, server_metadata, prerendered, prerender_map, log) {
 	const { name, adapt } = config.kit.adapter;
 
 	console.log(colors.bold().cyan(`\n> Using ${name}`));
 
 	const builder = create_builder({
 		config,
 		build_data,
+		server_metadata,
 		routes: build_data.manifest_data.routes.filter((route) => {
 			if (!route.page && !route.endpoint) return false;
 

packages/kit/src/core/generate_manifest/index.js

@@ -86,7 +86,7 @@ export function generate_manifest({ build_data, relative_path, routes }) {
 		assets: new Set(${s(assets)}),
 		mimeTypes: ${s(get_mime_lookup(build_data.manifest_data))},
 		_: {
-			entry: ${s(build_data.client.entry)},
+			entry: ${s(build_data.client_entry)},
 			nodes: [
 				${(node_paths).map(loader).join(',\n\t\t\t\t')}
 			],
@@ -103,7 +103,7 @@ export function generate_manifest({ build_data, relative_path, routes }) {
 					pattern: ${route.pattern},
 					params: ${s(route.params)},
 					page: ${route.page ? `{ layouts: ${get_nodes(route.page.layouts)}, errors: ${get_nodes(route.page.errors)}, leaf: ${reindexed.get(route.page.leaf)} }` : 'null'},
-					endpoint: ${route.endpoint ? loader(join_relative(relative_path, resolve_symlinks(build_data.server.vite_manifest, route.endpoint.file).chunk.file)) : 'null'}
+					endpoint: ${route.endpoint ? loader(join_relative(relative_path, resolve_symlinks(build_data.server_manifest, route.endpoint.file).chunk.file)) : 'null'}
 				}`;
 				}).filter(Boolean).join(',\n\t\t\t\t')}
 			],

packages/kit/src/core/postbuild/analyse.js

@@ -0,0 +1,135 @@
+import { join } from 'path';
+import { pathToFileURL } from 'url';
+import { get_option } from '../../runtime/server/utils.js';
+import {
+	validate_common_exports,
+	validate_page_server_exports,
+	validate_server_exports
+} from '../../utils/exports.js';
+import { load_config } from '../config/index.js';
+import { forked } from '../../utils/fork.js';
+import { should_polyfill } from '../../utils/platform.js';
+import { installPolyfills } from '../../exports/node/polyfills.js';
+
+export default forked(import.meta.url, analyse);
+
+/**
+ * @param {{
+ *   manifest_path: string;
+ *   env: Record<string, string>
+ * }} opts
+ */
+async function analyse({ manifest_path, env }) {
+	/** @type {import('types').SSRManifest} */
+	const manifest = (await import(pathToFileURL(manifest_path).href)).manifest;
+
+	/** @type {import('types').ValidatedKitConfig} */
+	const config = (await load_config()).kit;
+
+	const server_root = join(config.outDir, 'output');
+
+	/** @type {import('types').ServerInternalModule} */
+	const internal = await import(pathToFileURL(`${server_root}/server/internal.js`).href);
+
+	if (should_polyfill) {
+		installPolyfills();
+	}
+
+	// configure `import { building } from '$app/environment'` —
+	// essential we do this before analysing the code
+	internal.set_building(true);
+
+	// set env, in case it's used in initialisation
+	const entries = Object.entries(env);
+	const prefix = config.env.publicPrefix;
+	internal.set_private_env(Object.fromEntries(entries.filter(([k]) => !k.startsWith(prefix))));
+	internal.set_public_env(Object.fromEntries(entries.filter(([k]) => k.startsWith(prefix))));
+
+	/** @type {import('types').ServerMetadata} */
+	const metadata = {
+		nodes: [],
+		routes: new Map()
+	};
+
+	// analyse nodes
+	for (const loader of manifest._.nodes) {
+		const node = await loader();
+
+		metadata.nodes.push({
+			has_server_load: node.server?.load !== undefined
+		});
+	}
+
+	// analyse routes
+	for (const route of manifest._.routes) {
+		/** @type {Set<import('types').HttpMethod>} */
+		const methods = new Set();
+
+		/** @type {import('types').PrerenderOption | undefined} */
+		let prerender = undefined;
+
+		if (route.endpoint) {
+			const mod = await route.endpoint();
+			if (mod.prerender !== undefined) {
+				validate_server_exports(mod, route.id);
+
+				if (mod.prerender && (mod.POST || mod.PATCH || mod.PUT || mod.DELETE)) {
+					throw new Error(
+						`Cannot prerender a +server file with POST, PATCH, PUT, or DELETE (${route.id})`
+					);
+				}
+
+				prerender = mod.prerender;
+			}
+
+			if (mod.GET) methods.add('GET');
+			if (mod.POST) methods.add('POST');
+			if (mod.PUT) methods.add('PUT');
+			if (mod.PATCH) methods.add('PATCH');
+			if (mod.DELETE) methods.add('DELETE');
+		}
+
+		if (route.page) {
+			const nodes = await Promise.all(
+				[...route.page.layouts, route.page.leaf].map((n) => {
+					if (n !== undefined) return manifest._.nodes[n]();
+				})
+			);
+
+			const layouts = nodes.slice(0, -1);
+			const page = nodes.at(-1);
+
+			for (const layout of layouts) {
+				if (layout) {
+					validate_common_exports(layout.server, route.id);
+					validate_common_exports(layout.universal, route.id);
+				}
+			}
+
+			if (page) {
+				methods.add('GET');
+				if (page.server?.actions) methods.add('POST');
+
+				validate_page_server_exports(page.server, route.id);
+				validate_common_exports(page.universal, route.id);
+			}
+
+			const should_prerender = get_option(nodes, 'prerender');
+			prerender =
+				should_prerender === true ||
+				// Try prerendering if ssr is false and no server needed. Set it to 'auto' so that
+				// the route is not removed from the manifest, there could be a server load function.
+				// People can opt out of this behavior by explicitly setting prerender to false
+				(should_prerender !== false && get_option(nodes, 'ssr') === false && !page?.server?.actions
+					? 'auto'
+					: should_prerender ?? false);
+		}
+
+		metadata.routes.set(route.id, {
+			prerender,
+			methods: Array.from(methods)
+		});
+	}
+
+	return metadata;
+}