@sveltejs/kit 1.0.0-next.47 → 1.0.0-next.470

package/src/exports/index.js

@@ -0,0 +1,45 @@
+import { HttpError, Redirect } from '../runtime/control.js';
+
+/**
+ * Creates an `HttpError` object with an HTTP status code and an optional message.
+ * This object, if thrown during request handling, will cause SvelteKit to
+ * return an error response without invoking `handleError`
+ * @param {number} status
+ * @param {string | undefined} [message]
+ */
+export function error(status, message) {
+	return new HttpError(status, message);
+}
+
+/**
+ * Creates a `Redirect` object. If thrown during request handling, SvelteKit will
+ * return a redirect response.
+ * @param {number} status
+ * @param {string} location
+ */
+export function redirect(status, location) {
+	if (isNaN(status) || status < 300 || status > 399) {
+		throw new Error('Invalid status code');
+	}
+
+	return new Redirect(status, location);
+}
+
+/**
+ * Generates a JSON `Response` object from the supplied data.
+ * @param {any} data
+ * @param {ResponseInit} [init]
+ */
+export function json(data, init) {
+	// TODO deprecate this in favour of `Response.json` when it's
+	// more widely supported
+	const headers = new Headers(init?.headers);
+	if (!headers.has('content-type')) {
+		headers.set('content-type', 'application/json');
+	}
+
+	return new Response(JSON.stringify(data), {
+		...init,
+		headers
+	});
+}

package/src/exports/node/index.js

@@ -0,0 +1,145 @@
+import * as set_cookie_parser from 'set-cookie-parser';
+
+/** @param {import('http').IncomingMessage} req */
+function get_raw_body(req) {
+	const h = req.headers;
+
+	if (!h['content-type']) {
+		return null;
+	}
+
+	const length = Number(h['content-length']);
+
+	// check if no request body
+	// https://github.com/jshttp/type-is/blob/c1f4388c71c8a01f79934e68f630ca4a15fffcd6/index.js#L81-L95
+	if (isNaN(length) && h['transfer-encoding'] == null) {
+		return null;
+	}
+
+	if (req.destroyed) {
+		const readable = new ReadableStream();
+		readable.cancel();
+		return readable;
+	}
+
+	let size = 0;
+	let cancelled = false;
+
+	return new ReadableStream({
+		start(controller) {
+			req.on('error', (error) => {
+				controller.error(error);
+			});
+
+			req.on('end', () => {
+				if (cancelled) return;
+				controller.close();
+			});
+
+			req.on('data', (chunk) => {
+				if (cancelled) return;
+
+				size += chunk.length;
+				if (size > length) {
+					controller.error(new Error('content-length exceeded'));
+					return;
+				}
+
+				controller.enqueue(chunk);
+
+				if (controller.desiredSize === null || controller.desiredSize <= 0) {
+					req.pause();
+				}
+			});
+		},
+
+		pull() {
+			req.resume();
+		},
+
+		cancel(reason) {
+			cancelled = true;
+			req.destroy(reason);
+		}
+	});
+}
+
+/** @type {import('@sveltejs/kit/node').getRequest} */
+export async function getRequest(base, req) {
+	let headers = /** @type {Record<string, string>} */ (req.headers);
+	if (req.httpVersionMajor === 2) {
+		// we need to strip out the HTTP/2 pseudo-headers because node-fetch's
+		// Request implementation doesn't like them
+		// TODO is this still true with Node 18
+		headers = Object.assign({}, headers);
+		delete headers[':method'];
+		delete headers[':path'];
+		delete headers[':authority'];
+		delete headers[':scheme'];
+	}
+
+	return new Request(base + req.url, {
+		method: req.method,
+		headers,
+		body: get_raw_body(req)
+	});
+}
+
+/** @type {import('@sveltejs/kit/node').setResponse} */
+export async function setResponse(res, response) {
+	const headers = Object.fromEntries(response.headers);
+
+	if (response.headers.has('set-cookie')) {
+		const header = /** @type {string} */ (response.headers.get('set-cookie'));
+		const split = set_cookie_parser.splitCookiesString(header);
+
+		// @ts-expect-error
+		headers['set-cookie'] = split;
+	}
+
+	res.writeHead(response.status, headers);
+
+	if (!response.body) {
+		res.end();
+		return;
+	}
+
+	const reader = response.body.getReader();
+
+	if (res.destroyed) {
+		reader.cancel();
+		return;
+	}
+
+	const cancel = (/** @type {Error|undefined} */ error) => {
+		res.off('close', cancel);
+		res.off('error', cancel);
+
+		// If the reader has already been interrupted with an error earlier,
+		// then it will appear here, it is useless, but it needs to be catch.
+		reader.cancel(error).catch(() => {});
+		if (error) res.destroy(error);
+	};
+
+	res.on('close', cancel);
+	res.on('error', cancel);
+
+	next();
+	async function next() {
+		try {
+			for (;;) {
+				const { done, value } = await reader.read();
+
+				if (done) break;
+
+				if (!res.write(value)) {
+					res.once('drain', next);
+					return;
+				}
+			}
+			res.end();
+		} catch (error) {
+			cancel(error instanceof Error ? error : new Error(String(error)));
+		}
+	}
+}

package/src/exports/node/polyfills.js

@@ -0,0 +1,40 @@
+import { fetch, Response, Request, Headers } from 'undici';
+import { ReadableStream, TransformStream, WritableStream } from 'stream/web';
+import { Readable } from 'stream';
+import { Request as NodeFetchRequest } from 'node-fetch';
+import { webcrypto as crypto } from 'crypto';
+
+/** @type {Record<string, any>} */
+const globals = {
+	crypto,
+	fetch,
+	Response,
+	// TODO remove the superclass as soon as Undici supports formData
+	// https://github.com/nodejs/undici/issues/974
+	Request: class extends Request {
+		// @ts-expect-error
+		formData() {
+			return new NodeFetchRequest(this.url, {
+				method: this.method,
+				headers: this.headers,
+				body: this.body && Readable.from(this.body)
+			}).formData();
+		}
+	},
+	Headers,
+	ReadableStream,
+	TransformStream,
+	WritableStream
+};
+
+// exported for dev/preview and node environments
+export function installPolyfills() {
+	for (const name in globals) {
+		Object.defineProperty(globalThis, name, {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: globals[name]
+		});
+	}
+}

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

@@ -0,0 +1,358 @@
+import fs from 'fs';
+import path from 'path';
+import { mkdirp, posixify } from '../../../utils/filesystem.js';
+import { get_vite_config, merge_vite_configs, resolve_entry } 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, get_default_build_config, is_http_method } from './utils.js';
+import { s } from '../../../utils/misc.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_prerendering } 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\.message%/g, '" + message + "')};
+
+let read = null;
+
+set_paths(${s(config.kit.paths)});
+
+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_prerendering(settings.prerendering);
+	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,
+			get_stack: error => String(error), // for security
+			handle_error: (error, event) => {
+				this.options.hooks.handleError({
+					error,
+					event,
+
+					// TODO remove for 1.0
+					// @ts-expect-error
+					get request() {
+						throw new Error('request in handleError has been replaced with event. See https://github.com/sveltejs/kit/pull/3384 for details');
+					}
+				});
+				error.stack = this.options.get_stack(error);
+			},
+			hooks: null,
+			manifest,
+			method_override: ${s(config.kit.methodOverride)},
+			paths: { base, assets },
+			public_env: {},
+			read,
+			root,
+			service_worker: ${has_service_worker ? "base + '/service-worker.js'" : 'null'},
+			app_template,
+			app_template_contains_nonce: ${template.includes('%sveltekit.nonce%')},
+			error_template,
+			trailing_slash: ${s(config.kit.trailingSlash)}
+		};
+	}
+
+	/**
+	 * 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)});
+
+			// TODO remove this for 1.0
+			if (module.externalFetch) {
+				throw new Error('externalFetch has been removed — use handleFetch instead. See https://github.com/sveltejs/kit/pull/6565 for details');
+			}
+
+			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);
+	if (!hooks_file || !fs.existsSync(hooks_file)) {
+		hooks_file = path.join(config.kit.outDir, 'build/hooks.js');
+		fs.writeFileSync(hooks_file, '');
+	}
+
+	/** @type {Record<string, string>} */
+	const input = {
+		index: `${build_dir}/index.js`
+	};
+
+	// add entry points for every endpoint...
+	manifest_data.routes.forEach((route) => {
+		if (route.endpoint) {
+			const resolved = path.resolve(cwd, 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;
+		}
+	});
+
+	// ...and every component used by pages...
+	manifest_data.nodes.forEach((node) => {
+		for (const file of [node.component, node.shared, node.server]) {
+			if (file) {
+				const resolved = path.resolve(cwd, file);
+				const relative = decodeURIComponent(path.relative(config.kit.files.routes, resolved));
+
+				const name = relative.startsWith('..')
+					? posixify(path.join('entries/fallbacks', path.basename(file)))
+					: posixify(path.join('entries/pages', relative.replace(/\.js$/, '')));
+				input[name] = resolved;
+			}
+		}
+	});
+
+	// ...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);
+	});
+
+	/** @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 = merge_vite_configs(
+		get_default_build_config({ config, input, ssr: true, outDir: `${output_dir}/server` }),
+		await get_vite_config(vite_config, vite_config_env)
+	);
+
+	const { chunks } = await create_build(merged_config);
+
+	/** @type {import('vite').Manifest} */
+	const vite_manifest = JSON.parse(
+		fs.readFileSync(`${output_dir}/server/${vite_config.build.manifest}`, 'utf-8')
+	);
+
+	mkdirp(`${output_dir}/server/nodes`);
+	mkdirp(`${output_dir}/server/stylesheets`);
+
+	const stylesheet_lookup = new Map();
+
+	client.assets.forEach((asset) => {
+		if (asset.fileName.endsWith('.css')) {
+			if (asset.source.length < config.kit.inlineStyleThreshold) {
+				const index = stylesheet_lookup.size;
+				const file = `${output_dir}/server/stylesheets/${index}.js`;
+
+				fs.writeFileSync(file, `// ${asset.fileName}\nexport default ${s(asset.source)};`);
+				stylesheet_lookup.set(asset.fileName, index);
+			}
+		}
+	});
+
+	manifest_data.nodes.forEach((node, i) => {
+		/** @type {string[]} */
+		const imports = [];
+
+		// String representation of
+		/** @type {import('types').SSRNode} */
+		/** @type {string[]} */
+		const exports = [`export const index = ${i};`];
+
+		/** @type {string[]} */
+		const imported = [];
+
+		/** @type {string[]} */
+		const stylesheets = [];
+
+		if (node.component) {
+			const entry = find_deps(client.vite_manifest, node.component, true);
+
+			imported.push(...entry.imports);
+			stylesheets.push(...entry.stylesheets);
+
+			exports.push(
+				`export const component = async () => (await import('../${
+					vite_manifest[node.component].file
+				}')).default;`,
+				`export const file = '${entry.file}';` // TODO what is this?
+			);
+		}
+
+		if (node.shared) {
+			const entry = find_deps(client.vite_manifest, node.shared, true);
+
+			imported.push(...entry.imports);
+			stylesheets.push(...entry.stylesheets);
+
+			imports.push(`import * as shared from '../${vite_manifest[node.shared].file}';`);
+			exports.push(`export { shared };`);
+		}
+
+		if (node.server) {
+			imports.push(`import * as server from '../${vite_manifest[node.server].file}';`);
+			exports.push(`export { server };`);
+		}
+
+		exports.push(
+			`export const imports = ${s(imported)};`,
+			`export const stylesheets = ${s(stylesheets)};`
+		);
+
+		/** @type {string[]} */
+		const styles = [];
+
+		stylesheets.forEach((file) => {
+			if (stylesheet_lookup.has(file)) {
+				const index = stylesheet_lookup.get(file);
+				const name = `stylesheet_${index}`;
+				imports.push(`import ${name} from '../stylesheets/${index}.js';`);
+				styles.push(`\t${s(file)}: ${name}`);
+			}
+		});
+
+		if (styles.length > 0) {
+			exports.push(`export const inline_styles = () => ({\n${styles.join(',\n')}\n});`);
+		}
+
+		const out = `${output_dir}/server/nodes/${i}.js`;
+		fs.writeFileSync(out, `${imports.join('\n')}\n\n${exports.join('\n')}\n`);
+	});
+
+	return {
+		chunks,
+		vite_manifest,
+		methods: get_methods(cwd, chunks, manifest_data)
+	};
+}
+
+/**
+ * @param {string} cwd
+ * @param {import('rollup').OutputChunk[]} output
+ * @param {import('types').ManifestData} manifest_data
+ */
+function get_methods(cwd, output, manifest_data) {
+	/** @type {Record<string, string[]>} */
+	const lookup = {};
+	output.forEach((chunk) => {
+		if (!chunk.facadeModuleId) return;
+		const id = chunk.facadeModuleId.slice(cwd.length + 1);
+		lookup[id] = chunk.exports;
+	});
+
+	/** @type {Record<string, import('types').HttpMethod[]>} */
+	const methods = {};
+	manifest_data.routes.forEach((route) => {
+		if (route.endpoint) {
+			if (lookup[route.endpoint.file]) {
+				methods[route.endpoint.file] = lookup[route.endpoint.file].filter(is_http_method);
+			}
+		}
+
+		if (route.leaf?.server) {
+			if (lookup[route.leaf.server]) {
+				methods[route.leaf.server] = lookup[route.leaf.server].filter(is_http_method);
+			}
+		}
+	});
+
+	return methods;
+}

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

@@ -0,0 +1,90 @@
+import fs from 'fs';
+import * as vite from 'vite';
+import { s } from '../../../utils/misc.js';
+import { assets_base } from './utils.js';
+
+/**
+ * @param {{
+ *   config: import('types').ValidatedConfig;
+ *   vite_config: import('vite').ResolvedConfig;
+ *   vite_config_env: import('vite').ConfigEnv;
+ *   manifest_data: import('types').ManifestData;
+ *   output_dir: string;
+ *   service_worker_entry_file: string | null;
+ * }} options
+ * @param {import('types').Prerendered} prerendered
+ * @param {import('vite').Manifest} client_manifest
+ */
+export async function build_service_worker(
+	{ config, manifest_data, output_dir, service_worker_entry_file },
+	prerendered,
+	client_manifest
+) {
+	const build = new Set();
+	for (const key in client_manifest) {
+		const { file, css = [], assets = [] } = client_manifest[key];
+		build.add(file);
+		css.forEach((file) => build.add(file));
+		assets.forEach((file) => build.add(file));
+	}
+
+	const service_worker = `${config.kit.outDir}/generated/service-worker.js`;
+
+	fs.writeFileSync(
+		service_worker,
+		`
+			// TODO remove for 1.0
+			export const timestamp = {
+				toString: () => {
+					throw new Error('\`timestamp\` has been removed from $service-worker. Use \`version\` instead');
+				}
+			};
+
+			export const build = [
+				${Array.from(build)
+					.map((file) => `${s(`${config.kit.paths.base}/${file}`)}`)
+					.join(',\n\t\t\t\t')}
+			];
+
+			export const files = [
+				${manifest_data.assets
+					.filter((asset) => config.kit.serviceWorker.files(asset.file))
+					.map((asset) => `${s(`${config.kit.paths.base}/${asset.file}`)}`)
+					.join(',\n\t\t\t\t')}
+			];
+
+			export const prerendered = [
+				${prerendered.paths.map((path) => s(path)).join(',\n\t\t\t\t')}
+			];
+
+			export const version = ${s(config.kit.version.name)};
+		`
+			.replace(/^\t{3}/gm, '')
+			.trim()
+	);
+
+	await vite.build({
+		base: assets_base(config.kit),
+		build: {
+			lib: {
+				entry: /** @type {string} */ (service_worker_entry_file),
+				name: 'app',
+				formats: ['es']
+			},
+			rollupOptions: {
+				output: {
+					entryFileNames: 'service-worker.js'
+				}
+			},
+			outDir: `${output_dir}/client`,
+			emptyOutDir: false
+		},
+		configFile: false,
+		resolve: {
+			alias: {
+				'$service-worker': service_worker,
+				$lib: config.kit.files.lib
+			}
+		}
+	});
+}