@sveltejs/kit 3.0.0-next.10 → 3.0.0-next.12

package/src/core/sync/write_tsconfig/utils.js

@@ -0,0 +1,162 @@
+import path from 'node:path';
+import { normalize_import_value, read_package_imports } from '../../../utils/imports.js';
+import { posixify } from '../../../utils/os.js';
+
+/**
+ * Without these, compilation will fail
+ * @type {Record<string, any>}
+ */
+export const ESSENTIAL_OPTIONS = {
+	// svelte-preprocess cannot figure out whether you have a value or a type, so tell TypeScript
+	// to enforce using \`import type\` instead of \`import\` for Types.
+	// Also, TypeScript doesn't know about import usages in the template because it only sees the
+	// script of a Svelte file. Therefore preserve all value imports.
+	verbatimModuleSyntax: true,
+	// Vite compiles modules one at a time
+	isolatedModules: true
+};
+
+/**
+ * Options that are strongly recommended, either because not having them is silly or
+ * because the align TypeScript's behaviour with Vite's, but which can be overwritten
+ * @type {Record<string, any>}
+ */
+export const RECOMMENDED_OPTIONS = {
+	allowJs: true,
+	checkJs: true,
+	forceConsistentCasingInFileNames: true,
+	resolveJsonModule: true,
+	moduleDetection: 'force',
+	moduleResolution: 'bundler',
+	allowImportingTsExtensions: true,
+	module: 'esnext',
+	target: 'esnext',
+	skipLibCheck: true,
+	esModuleInterop: true,
+	noEmit: true // prevent tsconfig error "overwriting input files" - Vite handles the build and ignores this
+};
+
+/**
+ * Validates that a tsconfig contains `"extends": "<id>"`
+ * @param {any} options
+ * @param {string} id
+ */
+export function extends_id(options, id) {
+	const o = options.extends;
+	return Array.isArray(o) ? o.includes(id) : o === id;
+}
+
+/**
+ * Makes paths relative to the output file
+ * @param {string} out
+ * @param {any} config
+ * @param {(input: any) => any} [transform] TODO get rid of this option
+ */
+export function normalize_config(out, config, transform) {
+	const dir = path.dirname(out);
+	const relative = (/** @type {string} */ file) => posixify(path.relative(dir, file));
+
+	const paths =
+		config.compilerOptions?.paths &&
+		Object.fromEntries(
+			Object.entries(config.compilerOptions?.paths).map(([k, v]) => [k, v.map(relative)])
+		);
+
+	const normalized = {
+		...config,
+		compilerOptions: {
+			...config.compilerOptions,
+			paths,
+			rootDirs: config.compilerOptions?.rootDirs?.map(relative)
+		},
+		include: config.include?.map(relative),
+		exclude: config.exclude?.map(relative)
+	};
+
+	return transform?.(normalized) ?? normalized;
+}
+
+/**
+ * @param {any} resolved
+ * @param {any} options
+ */
+export function validate_resolved_config(resolved, options) {
+	const warnings = [];
+
+	const join = (/** @type {string[]} */ array) =>
+		array
+			.map((v) => JSON.stringify(v))
+			.join(', ')
+			.replace(/, ([^,]*)$/, ' and $1');
+
+	const missing_types = options.types?.filter(
+		(/** @type {string} */ type) => !resolved.types?.includes(type)
+	);
+
+	if (missing_types.length > 0) {
+		warnings.push(`"types" was overwritten. It must include ${join(missing_types)}`);
+	}
+
+	if (options.paths) {
+		/** @type {Set<string>} */
+		const mismatch = new Set();
+
+		for (const [k, expected] of Object.entries(options.paths)) {
+			const actual = resolved.paths?.[k]?.map((/** @type {string} */ x) =>
+				path.resolve(/** @type {string} */ (resolved.pathsBasePath), x)
+			);
+
+			if (JSON.stringify(expected) !== JSON.stringify(actual)) {
+				mismatch.add(remove_trailing_slashstar(k));
+			}
+		}
+
+		if (mismatch.size > 0) {
+			const joined = join([...mismatch]);
+
+			warnings.push(`"paths" was overwritten. Imports from ${joined} may not typecheck`);
+		}
+	}
+
+	for (const key in ESSENTIAL_OPTIONS) {
+		if (resolved[key] !== options[key]) {
+			warnings.push(`"${key}" was overwritten. It should be ${JSON.stringify(options[key])}`);
+		}
+	}
+
+	return warnings;
+}
+
+/**
+ * @param {string} file
+ */
+export function remove_trailing_slashstar(file) {
+	if (file.endsWith('/*')) {
+		return file.slice(0, -2);
+	} else {
+		return file;
+	}
+}
+
+/**
+ * @param {string} root
+ */
+export function get_subpath_imports(root) {
+	// Add all `#`-prefixed imports from package.json as path aliases
+	const imports = read_package_imports(root);
+
+	/** @type {Record<string, string>} */
+	const alias = {};
+
+	if (imports) {
+		for (const [key, raw_value] of Object.entries(imports)) {
+			if (!key.startsWith('#')) continue;
+			const value = normalize_import_value(raw_value);
+			if (value) {
+				alias[key] = value;
+			}
+		}
+	}
+
+	return alias;
+}

package/src/core/sync/write_types/index.js

@@ -609,7 +609,7 @@ function generate_params_type(params, outdir, config) {
 			(param) =>
 				`${/^\w+$/.test(param.name) ? param.name : `'${param.name}'`}${param.optional ? '?' : ''}: ${
 					param.matcher
-						? `import('@sveltejs/kit').MatcherParam<(typeof import('${params_import}').params)[${JSON.stringify(param.matcher)}]>`
+						? `Kit.MatcherParam<(typeof import('${params_import}').params)[${JSON.stringify(param.matcher)}]>`
 						: 'string'
 				}${param.optional ? ' | undefined' : ''}`
 		)
@@ -717,6 +717,62 @@ export function tweak_types(content, is_server) {
 			return _modified;
 		}
 
+		/**
+		 * @param {number} name_end position of the identifier the annotation is attached to
+		 * @param {import('typescript').TypeNode} type_node
+		 * @returns {string} the removed annotation's text
+		 */
+		function strip_type_annotation(name_end, type_node) {
+			let a = type_node.pos;
+			const b = type_node.end;
+			while (is_whitespace(content[a])) a += 1;
+
+			const type = content.slice(a, b);
+			code.remove(name_end, type_node.end);
+			modified = true;
+			return type;
+		}
+
+		/**
+		 * Types the first parameter of an untyped arrow/function expression.
+		 * @param {import('typescript').Expression | undefined} rhs
+		 * @param {string} type
+		 * @returns {boolean} `false` if there was nothing to annotate
+		 */
+		function annotate_first_param(rhs, type) {
+			if (
+				!rhs ||
+				!(ts.isArrowFunction(rhs) || ts.isFunctionExpression(rhs)) ||
+				!rhs.parameters.length
+			) {
+				return false;
+			}
+
+			const arg = rhs.parameters[0];
+			const add_parens = content[arg.pos - 1] !== '(';
+
+			if (add_parens) code.prependRight(arg.pos, '(');
+
+			if (arg.type) return false;
+
+			code.appendLeft(arg.name.end, `: ${type}` + (add_parens ? ')' : ''));
+			return true;
+		}
+
+		/**
+		 * @param {import('typescript').Expression | undefined} initializer
+		 * @param {(prop: import('typescript').PropertyAssignment) => void} callback
+		 */
+		function for_each_action(initializer, callback) {
+			if (initializer && ts.isObjectLiteralExpression(initializer)) {
+				for (const prop of initializer.properties) {
+					if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+						callback(prop);
+					}
+				}
+			}
+		}
+
 		ast.forEachChild((node) => {
 			if (ts.isFunctionDeclaration(node) && node.name?.text && node.name?.text === 'load') {
 				// remove JSDoc comment above `export function load ...`
@@ -742,42 +798,13 @@ export function tweak_types(content, is_server) {
 						// edge case — remove JSDoc comment above individual export
 						replace_jsdoc_type_tags(declaration, declaration.initializer);
 
-						// remove type from `export const load: Load ...`
 						if (declaration.type) {
-							let a = declaration.type.pos;
-							const b = declaration.type.end;
-							while (is_whitespace(content[a])) a += 1;
-
-							const type = content.slice(a, b);
-							code.remove(declaration.name.end, declaration.type.end);
+							const type = strip_type_annotation(declaration.name.end, declaration.type);
 
-							const rhs = declaration.initializer;
-
-							if (
-								rhs &&
-								(ts.isArrowFunction(rhs) || ts.isFunctionExpression(rhs)) &&
-								rhs.parameters.length
-							) {
-								const arg = rhs.parameters[0];
-								const add_parens = content[arg.pos - 1] !== '(';
-
-								if (add_parens) code.prependRight(arg.pos, '(');
-
-								if (arg && !arg.type) {
-									code.appendLeft(
-										arg.name.end,
-										`: Parameters<${type}>[0]` + (add_parens ? ')' : '')
-									);
-								} else {
-									// prevent "type X is imported but not used" (isn't silenced by @ts-nocheck) when svelte-check runs
-									code.append(`;null as any as ${type};`);
-								}
-							} else {
+							if (!annotate_first_param(declaration.initializer, `Parameters<${type}>[0]`)) {
 								// prevent "type X is imported but not used" (isn't silenced by @ts-nocheck) when svelte-check runs
 								code.append(`;null as any as ${type};`);
 							}
-
-							modified = true;
 						}
 					} else if (
 						is_server &&
@@ -789,69 +816,34 @@ export function tweak_types(content, is_server) {
 						const removed = replace_jsdoc_type_tags(node, declaration.initializer);
 						// ... and move type to each individual action
 						if (removed) {
-							const rhs = declaration.initializer;
-							if (ts.isObjectLiteralExpression(rhs)) {
-								for (const prop of rhs.properties) {
-									if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
-										const rhs = prop.initializer;
-										const replaced = replace_jsdoc_type_tags(prop, rhs);
-										if (
-											!replaced &&
-											rhs &&
-											(ts.isArrowFunction(rhs) || ts.isFunctionExpression(rhs)) &&
-											rhs.parameters?.[0]
-										) {
-											const name = ts.isIdentifier(rhs.parameters[0].name)
-												? rhs.parameters[0].name.text
-												: 'event';
-											code.prependRight(
-												rhs.pos,
-												`/** @param {import('./$types').RequestEvent} ${name} */ `
-											);
-										}
-									}
+							for_each_action(declaration.initializer, (prop) => {
+								const rhs = prop.initializer;
+								const replaced = replace_jsdoc_type_tags(prop, rhs);
+								if (
+									!replaced &&
+									rhs &&
+									(ts.isArrowFunction(rhs) || ts.isFunctionExpression(rhs)) &&
+									rhs.parameters?.[0]
+								) {
+									const name = ts.isIdentifier(rhs.parameters[0].name)
+										? rhs.parameters[0].name.text
+										: 'event';
+									code.prependRight(
+										rhs.pos,
+										`/** @param {import('./$types').RequestEvent} ${name} */ `
+									);
 								}
-							}
+							});
 						}
 
-						// remove type from `export const actions: Actions ...`
 						if (declaration.type) {
-							let a = declaration.type.pos;
-							const b = declaration.type.end;
-							while (is_whitespace(content[a])) a += 1;
-
-							const type = content.slice(a, b);
-							code.remove(declaration.name.end, declaration.type.end);
+							const type = strip_type_annotation(declaration.name.end, declaration.type);
 							code.append(`;null as any as ${type};`);
-							modified = true;
 
 							// ... and move type to each individual action
-							const rhs = declaration.initializer;
-							if (ts.isObjectLiteralExpression(rhs)) {
-								for (const prop of rhs.properties) {
-									if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
-										const rhs = prop.initializer;
-
-										if (
-											rhs &&
-											(ts.isArrowFunction(rhs) || ts.isFunctionExpression(rhs)) &&
-											rhs.parameters.length
-										) {
-											const arg = rhs.parameters[0];
-											const add_parens = content[arg.pos - 1] !== '(';
-
-											if (add_parens) code.prependRight(arg.pos, '(');
-
-											if (arg && !arg.type) {
-												code.appendLeft(
-													arg.name.end,
-													": import('./$types').RequestEvent" + (add_parens ? ')' : '')
-												);
-											}
-										}
-									}
-								}
-							}
+							for_each_action(declaration.initializer, (prop) => {
+								annotate_first_param(prop.initializer, "import('./$types').RequestEvent");
+							});
 						}
 					}
 				}

package/src/core/utils.js

@@ -30,18 +30,43 @@ export function get_runtime_base(root) {
 }
 
 /** @param {{ verbose: boolean }} opts */
-export function logger({ verbose }) {
+export function logger({ verbose } = { verbose: true }) {
 	/** @type {import('types').Logger} */
-	const log = (msg) => console.log(msg.replace(/^/gm, '  '));
+	const log = (msg) => console.log(msg);
 
 	/** @param {string} msg */
-	const err = (msg) => console.error(msg.replace(/^/gm, '  '));
+	const err = (msg) => console.error(msg);
 
 	log.success = (msg) => log(styleText('green', `✔ ${msg}`));
 	log.error = (msg) => err(styleText(['bold', 'red'], msg));
 	log.warn = (msg) => log(styleText(['bold', 'yellow'], msg));
 	log.minor = verbose ? (msg) => log(styleText('grey', msg)) : noop;
 	log.info = verbose ? log : noop;
+	log.err = err;
+
+	log.prettyError = (error, caller) => {
+		/** @type {unknown} */
+		let e = error;
+
+		while (e instanceof Error) {
+			let stack = e.stack;
+			if (stack) {
+				if (caller) {
+					const i = stack.indexOf(caller);
+					// Cut the stack trace off at the point when our internal one starts
+					stack = stack.slice(0, stack.lastIndexOf('\n', i));
+				}
+
+				err(stack);
+			}
+
+			e = e.cause;
+		}
+
+		if (e) {
+			err(String(e));
+		}
+	};
 
 	return log;
 }

package/src/exports/env/index.js

@@ -1,12 +1,77 @@
-/** @import { EnvVarConfig } from '@sveltejs/kit' */
+/** @import { StandardSchemaV1 } from '@standard-schema/spec' */
+/** @import { DefinedEnvVars, EnvVarConfig } from '@sveltejs/kit' */
 
 /**
  * Utility for defining [environment variables](https://svelte.dev/docs/kit/environment-variables),
  * which are made available via `$app/env/public` and `$app/env/private`.
+ *
+ * @example
+ * ```js
+ * import { defineEnvVars } from '@sveltejs/kit/env';
+ * import * as v from 'valibot';
+ *
+ * export const variables = defineEnvVars({
+ * 	API_URL: {
+ * 		schema: v.pipe(v.string(), v.url())
+ * 	},
+ * 	PORT: {
+ * 		schema: (value) => {
+ * 			if (value === undefined) return 3000;
+ * 			const port = Number(value);
+ * 			if (!Number.isInteger(port)) throw new Error('PORT must be an integer');
+ * 			return port;
+ * 		}
+ * 	}
+ * });
+ * ```
+ *
  * @template {Record<string, EnvVarConfig<any>>} T
  * @param {T} variables
- * @returns {T}
+ * @returns {DefinedEnvVars<T>}
  */
 export function defineEnvVars(variables) {
-	return variables;
+	/** @type {Record<string, EnvVarConfig<any>>} */
+	const normalized = {};
+
+	for (const [name, config] of Object.entries(variables)) {
+		// standard schemas can be callable (e.g. ArkType), so a function is only a validator if it isn't one
+		normalized[name] =
+			typeof config.schema === 'function' && !('~standard' in config.schema)
+				? { ...config, schema: normalize_env_schema(config.schema) }
+				: config;
+	}
+
+	return /** @type {DefinedEnvVars<T>} */ (normalized);
+}
+
+/**
+ * @param {(value: string | undefined) => any} fn
+ * @returns {StandardSchemaV1<string | undefined, any>}
+ */
+function normalize_env_schema(fn) {
+	return /** @type {StandardSchemaV1<string | undefined, any>} */ (
+		/** @type {unknown} */ ({
+			'~standard': {
+				validate(/** @type {unknown} */ value) {
+					let result;
+
+					try {
+						result = fn(/** @type {string | undefined} */ (value));
+					} catch (error) {
+						return {
+							issues: [
+								{
+									message: error instanceof Error ? error.message || 'Invalid value' : String(error)
+								}
+							]
+						};
+					}
+
+					if (result instanceof Promise) return result; // will be rejected upstream
+
+					return { value: result };
+				}
+			}
+		})
+	);
 }

package/src/exports/internal/env.js

@@ -4,7 +4,7 @@
 import { stackless } from '../../utils/error.js';
 
 const MISSING = {
-	message: `Value is missing. If it is optional, add a Standard Schema validator declaring it as such.`
+	message: `Value is missing. If it is optional, add a validator declaring it as such.`
 };
 
 const BAD_VALIDATOR = {
@@ -24,10 +24,13 @@ const ASYNC_VALIDATOR = {
  */
 export function validate(variables, value, name, issues) {
 	const config = variables[name] ?? {};
-	const validator = config.schema;
+	// `defineEnvVars` normalizes function validators to standard schemas
+	const validator = /** @type {StandardSchemaV1<string | undefined, any> | undefined} */ (
+		config.schema
+	);
 
 	if (!validator) {
-		if (!value) issues[name] = [MISSING];
+		if (value === undefined) issues[name] = [MISSING];
 		return value;
 	}
 

package/src/exports/internal/server/index.js

@@ -2,7 +2,9 @@
 import { try_get_request_store } from './event.js';
 
 export function get_origin() {
-	return try_get_request_store()?.event.url.origin;
+	// `request.url` rather than `event.url`, which throws inside queries
+	const request = try_get_request_store()?.event.request;
+	return request && new URL(request.url).origin;
 }
 
 /**

package/src/exports/params.js

@@ -35,6 +35,15 @@ export function defineParams(definitions) {
  * @returns {import('@sveltejs/kit').ParamMatcher}
  */
 export function normalize_param_definition(definition) {
+	// standard schemas can be callable (e.g. ArkType), so this must be checked before the function case
+	if (
+		definition &&
+		(typeof definition === 'object' || typeof definition === 'function') &&
+		'~standard' in definition
+	) {
+		return definition;
+	}
+
 	if (typeof definition === 'function') {
 		return /** @type {import('@sveltejs/kit').ParamMatcher} */ (
 			/** @type {unknown} */ ({
@@ -55,9 +64,5 @@ export function normalize_param_definition(definition) {
 		);
 	}
 
-	if (definition && typeof definition === 'object' && '~standard' in definition) {
-		return definition;
-	}
-
 	throw new Error('Invalid param definition');
 }