@sveltejs/kit 1.0.11 → 1.0.13

package/src/exports/vite/build/build_server.js

@@ -1,10 +1,8 @@
 import fs from 'fs';
 import path from 'path';
 import { mergeConfig } from 'vite';
-import { mkdirp, posixify, resolve_entry } from '../../../utils/filesystem.js';
+import { mkdirp, posixify } from '../../../utils/filesystem.js';
 import { get_vite_config } from '../utils.js';
-import { load_error_page, load_template } from '../../../core/config/index.js';
-import { runtime_directory } from '../../../core/utils.js';
 import {
 	create_build,
 	find_deps,
@@ -13,162 +11,31 @@ import {
 	resolve_symlinks
 } from './utils.js';
 import { s } from '../../../utils/misc.js';
+import { runtime_directory } from '../../../core/utils.js';
 
 /**
  * @param {{
- *   hooks: string;
- *   config: import('types').ValidatedConfig;
- *   has_service_worker: boolean;
- *   runtime: string;
- *   template: string;
- *   error_page: string;
- * }} opts
- */
-const server_template = ({ config, hooks, has_service_worker, runtime, template, error_page }) => `
-import root from '__GENERATED__/root.svelte';
-import { respond } from '${runtime}/server/index.js';
-import { set_paths, assets, base } from '${runtime}/paths.js';
-import { set_building, set_version } from '${runtime}/env.js';
-import { set_private_env } from '${runtime}/env-private.js';
-import { set_public_env } from '${runtime}/env-public.js';
-
-const app_template = ({ head, body, assets, nonce }) => ${s(template)
-	.replace('%sveltekit.head%', '" + head + "')
-	.replace('%sveltekit.body%', '" + body + "')
-	.replace(/%sveltekit\.assets%/g, '" + assets + "')
-	.replace(/%sveltekit\.nonce%/g, '" + nonce + "')};
-
-const error_template = ({ status, message }) => ${s(error_page)
-	.replace(/%sveltekit\.status%/g, '" + status + "')
-	.replace(/%sveltekit\.error\.message%/g, '" + message + "')};
-
-let read = null;
-
-set_paths(${s(config.kit.paths)});
-set_version(${s(config.kit.version.name)});
-
-let default_protocol = 'https';
-
-// allow paths to be globally overridden
-// in svelte-kit preview and in prerendering
-export function override(settings) {
-	default_protocol = settings.protocol || default_protocol;
-	set_paths(settings.paths);
-	set_building(settings.building);
-	read = settings.read;
-}
-
-export class Server {
-	constructor(manifest) {
-		this.options = {
-			csp: ${s(config.kit.csp)},
-			csrf: {
-				check_origin: ${s(config.kit.csrf.checkOrigin)},
-			},
-			dev: false,
-			embedded: ${config.kit.embedded},
-			handle_error: (error, event) => {
-				return this.options.hooks.handleError({ error, event }) ?? {
-					message: event.route.id != null ? 'Internal Error' : 'Not Found'
-				};
-			},
-			hooks: null,
-			manifest,
-			paths: { base, assets },
-			public_env: {},
-			read,
-			root,
-			service_worker: ${has_service_worker},
-			app_template,
-			app_template_contains_nonce: ${template.includes('%sveltekit.nonce%')},
-			error_template,
-			version: ${s(config.kit.version.name)}
-		};
-	}
-
-	/**
-	 * Take care: Some adapters may have to call \`Server.init\` per-request to set env vars,
-	 * so anything that shouldn't be rerun should be wrapped in an \`if\` block to make sure it hasn't
-	 * been done already.
-	 */
-	async init({ env }) {
-		const entries = Object.entries(env);
-
-		const prv = Object.fromEntries(entries.filter(([k]) => !k.startsWith('${
-			config.kit.env.publicPrefix
-		}')));
-
-		const pub = Object.fromEntries(entries.filter(([k]) => k.startsWith('${
-			config.kit.env.publicPrefix
-		}')));
-
-		set_private_env(prv);
-		set_public_env(pub);
-
-		this.options.public_env = pub;
-
-		if (!this.options.hooks) {
-			const module = await import(${s(hooks)});
-
-			this.options.hooks = {
-				handle: module.handle || (({ event, resolve }) => resolve(event)),
-				handleError: module.handleError || (({ error }) => console.error(error.stack)),
-				handleFetch: module.handleFetch || (({ request, fetch }) => fetch(request))
-			};
-		}
-	}
-
-	async respond(request, options = {}) {
-		if (!(request instanceof Request)) {
-			throw new Error('The first argument to server.respond must be a Request object. See https://github.com/sveltejs/kit/pull/3384 for details');
-		}
-
-		return respond(request, this.options, options);
-	}
-}
-`;
-
-/**
- * @param {{
- *   cwd: string;
  *   config: import('types').ValidatedConfig;
  *   vite_config: import('vite').ResolvedConfig;
  *   vite_config_env: import('vite').ConfigEnv;
  *   manifest_data: import('types').ManifestData;
- *   build_dir: string;
  *   output_dir: string;
- *   service_worker_entry_file: string | null;
  * }} options
  * @param {{ vite_manifest: import('vite').Manifest, assets: import('rollup').OutputAsset[] }} client
  */
 export async function build_server(options, client) {
-	const {
-		cwd,
-		config,
-		vite_config,
-		vite_config_env,
-		manifest_data,
-		build_dir,
-		output_dir,
-		service_worker_entry_file
-	} = options;
-
-	let hooks_file = resolve_entry(config.kit.files.hooks.server);
-
-	if (!hooks_file || !fs.existsSync(hooks_file)) {
-		hooks_file = path.join(config.kit.outDir, 'build/hooks.js');
-		fs.writeFileSync(hooks_file, '');
-	}
+	const { config, vite_config, vite_config_env, manifest_data, output_dir } = options;
 
 	/** @type {Record<string, string>} */
 	const input = {
-		index: `${build_dir}/index.js`
+		index: `${runtime_directory}/server/index.js`,
+		internal: `${config.kit.outDir}/generated/server-internal.js`
 	};
 
 	// add entry points for every endpoint...
 	manifest_data.routes.forEach((route) => {
 		if (route.endpoint) {
-			const resolved = path.resolve(cwd, route.endpoint.file);
+			const resolved = path.resolve(route.endpoint.file);
 			const relative = decodeURIComponent(path.relative(config.kit.files.routes, resolved));
 			const name = posixify(path.join('entries/endpoints', relative.replace(/\.js$/, '')));
 			input[name] = resolved;
@@ -179,7 +46,7 @@ export async function build_server(options, client) {
 	manifest_data.nodes.forEach((node) => {
 		for (const file of [node.component, node.universal, node.server]) {
 			if (file) {
-				const resolved = path.resolve(cwd, file);
+				const resolved = path.resolve(file);
 				const relative = decodeURIComponent(path.relative(config.kit.files.routes, resolved));
 
 				const name = relative.startsWith('..')
@@ -193,27 +60,9 @@ export async function build_server(options, client) {
 	// ...and every matcher
 	Object.entries(manifest_data.matchers).forEach(([key, file]) => {
 		const name = posixify(path.join('entries/matchers', key));
-		input[name] = path.resolve(cwd, file);
+		input[name] = path.resolve(file);
 	});
 
-	/** @type {(file: string) => string} */
-	const app_relative = (file) => {
-		const relative_file = path.relative(build_dir, path.resolve(cwd, file));
-		return relative_file[0] === '.' ? relative_file : `./${relative_file}`;
-	};
-
-	fs.writeFileSync(
-		input.index,
-		server_template({
-			config,
-			hooks: app_relative(hooks_file),
-			has_service_worker: config.kit.serviceWorker.register && !!service_worker_entry_file,
-			runtime: posixify(path.relative(build_dir, runtime_directory)),
-			template: load_template(cwd, config),
-			error_page: load_error_page(config)
-		})
-	);
-
 	const merged_config = mergeConfig(
 		get_default_build_config({ config, input, ssr: true, outDir: `${output_dir}/server` }),
 		await get_vite_config(vite_config, vite_config_env)
@@ -321,21 +170,20 @@ export async function build_server(options, client) {
 	return {
 		chunks,
 		vite_manifest,
-		methods: get_methods(cwd, chunks, manifest_data)
+		methods: get_methods(chunks, manifest_data)
 	};
 }
 
 /**
- * @param {string} cwd
  * @param {import('rollup').OutputChunk[]} output
  * @param {import('types').ManifestData} manifest_data
  */
-function get_methods(cwd, output, manifest_data) {
+function get_methods(output, manifest_data) {
 	/** @type {Record<string, string[]>} */
 	const lookup = {};
 	output.forEach((chunk) => {
 		if (!chunk.facadeModuleId) return;
-		const id = posixify(path.relative(cwd, chunk.facadeModuleId));
+		const id = posixify(path.relative('.', chunk.facadeModuleId));
 		lookup[id] = chunk.exports;
 	});
 

package/src/exports/vite/build/build_service_worker.js

@@ -11,13 +11,14 @@ import { assets_base } from './utils.js';
  *   vite_config_env: import('vite').ConfigEnv;
  *   manifest_data: import('types').ManifestData;
  *   output_dir: string;
- *   service_worker_entry_file: string | null;
  * }} options
+ * @param {string} service_worker_entry_file
  * @param {import('types').Prerendered} prerendered
  * @param {import('vite').Manifest} client_manifest
  */
 export async function build_service_worker(
-	{ config, vite_config, manifest_data, output_dir, service_worker_entry_file },
+	{ config, vite_config, manifest_data, output_dir },
+	service_worker_entry_file,
 	prerendered,
 	client_manifest
 ) {

package/src/exports/vite/build/utils.js

@@ -127,6 +127,7 @@ export function get_build_setup_config({ config, ssr }) {
 			__SVELTEKIT_ADAPTER_NAME__: JSON.stringify(config.kit.adapter?.name),
 			__SVELTEKIT_APP_VERSION_FILE__: JSON.stringify(`${config.kit.appDir}/version.json`),
 			__SVELTEKIT_APP_VERSION_POLL_INTERVAL__: JSON.stringify(config.kit.version.pollInterval),
+			__SVELTEKIT_DEV__: 'false',
 			__SVELTEKIT_EMBEDDED__: config.kit.embedded ? 'true' : 'false'
 		},
 		resolve: {

package/src/exports/vite/dev/index.js

@@ -3,16 +3,16 @@ import colors from 'kleur';
 import path from 'path';
 import sirv from 'sirv';
 import { URL } from 'url';
-import { isCSSRequest } from 'vite';
+import { isCSSRequest, loadEnv } from 'vite';
 import { getRequest, setResponse } from '../../../exports/node/index.js';
 import { installPolyfills } from '../../../exports/node/polyfills.js';
 import { coalesce_to_error } from '../../../utils/error.js';
 import { posixify, resolve_entry, to_fs } from '../../../utils/filesystem.js';
 import { should_polyfill } from '../../../utils/platform.js';
-import { load_error_page, load_template } from '../../../core/config/index.js';
+import { load_error_page } from '../../../core/config/index.js';
 import { SVELTE_KIT_ASSETS } from '../../../constants.js';
 import * as sync from '../../../core/sync/sync.js';
-import { get_mime_lookup, runtime_prefix } from '../../../core/utils.js';
+import { get_mime_lookup, runtime_base } from '../../../core/utils.js';
 import { compact } from '../../../utils/array.js';
 import { not_found } from '../utils.js';
 
@@ -42,9 +42,6 @@ export async function dev(vite, vite_config, svelte_config) {
 
 	sync.init(svelte_config, vite_config.mode);
 
-	/** @type {import('types').Respond} */
-	const respond = (await import(`${runtime_prefix}/server/index.js`)).respond;
-
 	/** @type {import('types').ManifestData} */
 	let manifest_data;
 	/** @type {import('types').SSRManifest} */
@@ -96,7 +93,7 @@ export async function dev(vite, vite_config, svelte_config) {
 			mimeTypes: get_mime_lookup(manifest_data),
 			_: {
 				entry: {
-					file: `/@fs${runtime_prefix}/client/start.js`,
+					file: `${runtime_base}/client/start.js`,
 					imports: [],
 					stylesheets: [],
 					fonts: []
@@ -224,9 +221,9 @@ export async function dev(vite, vite_config, svelte_config) {
 		};
 	}
 
-	/** @param {Error} error */
-	function fix_stack_trace(error) {
-		return error.stack ? vite.ssrRewriteStacktrace(error.stack) : error.stack;
+	/** @param {string} stack */
+	function fix_stack_trace(stack) {
+		return stack ? vite.ssrRewriteStacktrace(stack) : stack;
 	}
 
 	await update_manifest();
@@ -273,7 +270,8 @@ export async function dev(vite, vite_config, svelte_config) {
 		sync.update(svelte_config, manifest_data, file);
 	});
 
-	const { appTemplate } = svelte_config.kit.files;
+	const { appTemplate, errorTemplate, serviceWorker, hooks } = svelte_config.kit.files;
+
 	// vite client only executes a full reload if the triggering html file path is index.html
 	// kit defaults to src/app.html, so unless user changed that to index.html
 	// send the vite client a full-reload event without path being set
@@ -285,6 +283,17 @@ export async function dev(vite, vite_config, svelte_config) {
 		});
 	}
 
+	vite.watcher.on('all', (_, file) => {
+		if (
+			file === appTemplate ||
+			file === errorTemplate ||
+			file.startsWith(serviceWorker) ||
+			file.startsWith(hooks.server)
+		) {
+			sync.server(svelte_config);
+		}
+	});
+
 	// changing the svelte config requires restarting the dev server
 	// the config is only read on start and passed on to vite-plugin-svelte
 	// which needs up-to-date values to operate correctly
@@ -307,6 +316,18 @@ export async function dev(vite, vite_config, svelte_config) {
 		}
 	});
 
+	// This shameful hack allows us to load runtime server code via Vite
+	// while apps load `HttpError` and `Redirect` in Node, without
+	// causing `instanceof` checks to fail
+	const control_module_node = await import(`../../../runtime/control.js`);
+	const control_module_vite = await vite.ssrLoadModule(`${runtime_base}/control.js`);
+
+	control_module_node.replace_implementations({
+		ActionFailure: control_module_vite.ActionFailure,
+		HttpError: control_module_vite.HttpError,
+		Redirect: control_module_vite.Redirect
+	});
+
 	vite.middlewares.use(async (req, res, next) => {
 		try {
 			const base = `${vite.config.server.https ? 'https' : 'http'}://${
@@ -332,10 +353,12 @@ export async function dev(vite, vite_config, svelte_config) {
 		} catch (e) {
 			const error = coalesce_to_error(e);
 			res.statusCode = 500;
-			res.end(fix_stack_trace(error));
+			res.end(fix_stack_trace(/** @type {string} */ (error.stack)));
 		}
 	});
 
+	const env = loadEnv(vite_config.mode, svelte_config.kit.env.dir, '');
+
 	return () => {
 		const serve_static_middleware = vite.middlewares.stack.find(
 			(middleware) =>
@@ -385,40 +408,28 @@ export async function dev(vite, vite_config, svelte_config) {
 					return;
 				}
 
-				const hooks_file = svelte_config.kit.files.hooks.server;
-				/** @type {Partial<import('types').ServerHooks>} */
-				const user_hooks = resolve_entry(hooks_file)
-					? await vite.ssrLoadModule(`/${hooks_file}`)
-					: {};
-
-				const handle = user_hooks.handle || (({ event, resolve }) => resolve(event));
-
-				/** @type {import('types').ServerHooks} */
-				const hooks = {
-					handle,
-					handleError:
-						user_hooks.handleError ||
-						(({ error: e }) => {
-							const error = /** @type {Error & { frame?: string }} */ (e);
-							console.error(colors.bold().red(error.message ?? error)); // Could be anything
-							if (error.frame) {
-								console.error(colors.gray(error.frame));
-							}
-							if (error.stack) {
-								console.error(colors.gray(error.stack));
-							}
-						}),
-					handleFetch: user_hooks.handleFetch || (({ request, fetch }) => fetch(request))
-				};
-
-				// TODO the / prefix will probably fail if outDir is outside the cwd (which
-				// could be the case in a monorepo setup), but without it these modules
-				// can get loaded twice via different URLs, which causes failures. Might
-				// require changes to Vite to fix
-				const { default: root } = await vite.ssrLoadModule(
-					`/${posixify(path.relative(cwd, `${svelte_config.kit.outDir}/generated/root.svelte`))}`
+				const { set_paths, set_version, set_fix_stack_trace } =
+					/** @type {import('types').ServerInternalModule} */ (
+						await vite.ssrLoadModule(`${runtime_base}/shared.js`)
+					);
+
+				const { Server } = /** @type {import('types').ServerModule} */ (
+					await vite.ssrLoadModule(`${runtime_base}/server/index.js`)
 				);
 
+				set_paths({
+					base: svelte_config.kit.paths.base,
+					assets
+				});
+
+				set_version(svelte_config.kit.version.name);
+
+				set_fix_stack_trace(fix_stack_trace);
+
+				const server = new Server(manifest);
+
+				await server.init({ env });
+
 				let request;
 
 				try {
@@ -431,20 +442,19 @@ export async function dev(vite, vite_config, svelte_config) {
 					return res.end('Invalid request body');
 				}
 
-				const template = load_template(cwd, svelte_config);
-				const error_page = load_error_page(svelte_config);
-
-				/** @param {{ status: number; message: string }} opts */
-				const error_template = ({ status, message }) => {
-					return error_page
-						.replace(/%sveltekit\.status%/g, String(status))
-						.replace(/%sveltekit\.error\.message%/g, message);
-				};
-
 				if (manifest_error) {
 					console.error(colors.bold().red('Invalid routes'));
 					console.error(manifest_error);
 
+					const error_page = load_error_page(svelte_config);
+
+					/** @param {{ status: number; message: string }} opts */
+					const error_template = ({ status, message }) => {
+						return error_page
+							.replace(/%sveltekit\.status%/g, String(status))
+							.replace(/%sveltekit\.error\.message%/g, message);
+					};
+
 					res.writeHead(500, {
 						'Content-Type': 'text/html; charset=utf-8'
 					});
@@ -455,66 +465,14 @@ export async function dev(vite, vite_config, svelte_config) {
 					return;
 				}
 
-				const rendered = await respond(
-					request,
-					{
-						csp: svelte_config.kit.csp,
-						csrf: {
-							check_origin: svelte_config.kit.csrf.checkOrigin
-						},
-						dev: true,
-						embedded: svelte_config.kit.embedded,
-						handle_error: async (error, event) => {
-							const error_object = await hooks.handleError({
-								error: new Proxy(error, {
-									get: (target, property) => {
-										if (property === 'stack') {
-											return fix_stack_trace(error);
-										}
-
-										return Reflect.get(target, property, target);
-									}
-								}),
-								event
-							});
-							return (
-								error_object ?? { message: event.route.id != null ? 'Internal Error' : 'Not Found' }
-							);
-						},
-						hooks,
-						manifest,
-						paths: {
-							base: svelte_config.kit.paths.base,
-							assets
-						},
-						public_env: {},
-						read: (file) => fs.readFileSync(path.join(svelte_config.kit.files.assets, file)),
-						root,
-						app_template: ({ head, body, assets, nonce }) => {
-							return (
-								template
-									.replace(/%sveltekit\.assets%/g, assets)
-									.replace(/%sveltekit\.nonce%/g, nonce)
-									// head and body must be replaced last, in case someone tries to sneak in %sveltekit.assets% etc
-									.replace('%sveltekit.head%', () => head)
-									.replace('%sveltekit.body%', () => body)
-							);
-						},
-						app_template_contains_nonce: template.includes('%sveltekit.nonce%'),
-						error_template,
-						service_worker:
-							svelte_config.kit.serviceWorker.register &&
-							!!resolve_entry(svelte_config.kit.files.serviceWorker),
-						version: svelte_config.kit.version.name
+				const rendered = await server.respond(request, {
+					getClientAddress: () => {
+						const { remoteAddress } = req.socket;
+						if (remoteAddress) return remoteAddress;
+						throw new Error('Could not determine clientAddress');
 					},
-					{
-						getClientAddress: () => {
-							const { remoteAddress } = req.socket;
-							if (remoteAddress) return remoteAddress;
-							throw new Error('Could not determine clientAddress');
-						}
-					}
-				);
+					read: (file) => fs.readFileSync(path.join(svelte_config.kit.files.assets, file))
+				});
 
 				if (rendered.status === 404) {
 					// @ts-expect-error
@@ -527,7 +485,7 @@ export async function dev(vite, vite_config, svelte_config) {
 			} catch (e) {
 				const error = coalesce_to_error(e);
 				res.statusCode = 500;
-				res.end(fix_stack_trace(error));
+				res.end(fix_stack_trace(/** @type {string} */ (error.stack)));
 			}
 		});
 	};