@vigla/kit 0.0.0-stage → 0.1.0

package/src/server/errors.ts

@@ -0,0 +1,318 @@
+import { runtime, throwDiagnostic } from '../shared/diagnostics.ts';
+import { identity } from '../shared/identity.ts';
+
+export function request_event_unavailable(): never {
+	return throwDiagnostic(
+		'request_event_unavailable',
+		'Can only read the current request event inside functions invoked during `handle`, such as server `load` functions, actions, endpoints, and other server hooks.',
+		request_event_unavailable
+	);
+}
+export function request_event_after_await(): never {
+	return throwDiagnostic(
+		'request_event_after_await',
+		'Can only read the current request event inside functions invoked during `handle`, such as server `load` functions, actions, endpoints, and other server hooks. In environments without `AsyncLocalStorage`, the event must be read synchronously, not after an `await`.',
+		request_event_after_await
+	);
+}
+export function request_store_after_await(): never {
+	return throwDiagnostic(
+		'request_store_after_await',
+		'Could not get the request store. In environments without `AsyncLocalStorage`, the request store (used by e.g. remote functions) must be accessed synchronously, not after an `await`. If it was accessed synchronously then this is an internal error.',
+		request_store_after_await
+	);
+}
+export function ssr_fetch_relative_url({ url }: { url: string }): never {
+	return throwDiagnostic(
+		'ssr_fetch_relative_url',
+		`Cannot call \`fetch\` eagerly during server-side rendering with relative URL (\`${url}\`) — put your \`fetch\` calls inside \`onMount\` or a \`load\` function instead`,
+		ssr_fetch_relative_url
+	);
+}
+export function fetch_response_decoded({ encoding }: { encoding: string }): never {
+	return throwDiagnostic(
+		'fetch_response_decoded',
+		`Cannot return \`fetch(...)\` directly from a handler if the response has a \`Content-Encoding: ${encoding}\` header. The body has already been decoded`,
+		fetch_response_decoded
+	);
+}
+export function client_address_unsupported({ adapter }: { adapter: string }): never {
+	return throwDiagnostic(
+		'client_address_unsupported',
+		`\`${adapter}\` does not specify \`getClientAddress\`. Please raise an issue`,
+		client_address_unsupported
+	);
+}
+export function set_headers_cookie(): never {
+	return throwDiagnostic(
+		'set_headers_cookie',
+		'Use `event.cookies.set(name, value, options)` instead of `event.setHeaders` to set cookies',
+		set_headers_cookie
+	);
+}
+export function header_already_set({ name }: { name: string }): never {
+	return throwDiagnostic(
+		'header_already_set',
+		`\`${name}\` header is already set`,
+		header_already_set
+	);
+}
+export function cookies_set_after_response(): never {
+	return throwDiagnostic(
+		'cookies_set_after_response',
+		'Cannot use `cookies.set(...)` after the response has been generated',
+		cookies_set_after_response
+	);
+}
+export function set_headers_after_response(): never {
+	return throwDiagnostic(
+		'set_headers_after_response',
+		'Cannot use `setHeaders(...)` after the response has been generated',
+		set_headers_after_response
+	);
+}
+export function cookies_serialize_before_route(): never {
+	return throwDiagnostic(
+		'cookies_serialize_before_route',
+		'Cannot serialize cookies until after the route is determined',
+		cookies_serialize_before_route
+	);
+}
+export function cookie_too_large({ name }: { name: string }): never {
+	return throwDiagnostic(
+		'cookie_too_large',
+		`Cookie \`${name}\` is too large, and will be discarded by the browser`,
+		cookie_too_large
+	);
+}
+export function endpoint_invalid_response({ path }: { path: string }): never {
+	return throwDiagnostic(
+		'endpoint_invalid_response',
+		`Invalid response from route \`${path}\`: handler should return a \`Response\` object`,
+		endpoint_invalid_response
+	);
+}
+export function action_throw_fail(): never {
+	return throwDiagnostic(
+		'action_throw_fail',
+		'Cannot `throw fail()`. Use `return fail()`',
+		action_throw_fail
+	);
+}
+export function action_default_with_named(): never {
+	return throwDiagnostic(
+		'action_default_with_named',
+		`When using named actions, the default action cannot be used.${runtime.docs('namedActions', (url) => ` See the docs for more info: ${url}`)}`,
+		action_default_with_named
+	);
+}
+export function action_name_reserved(): never {
+	return throwDiagnostic(
+		'action_name_reserved',
+		'Cannot use reserved action name `default`',
+		action_name_reserved
+	);
+}
+export function action_return_redirect(): never {
+	return throwDiagnostic(
+		'action_return_redirect',
+		'Cannot `return redirect(...)` — use `redirect(...)` instead',
+		action_return_redirect
+	);
+}
+export function action_return_error(): never {
+	return throwDiagnostic(
+		'action_return_error',
+		'Cannot `return error(...)` — use `error(...)` or `return fail(...)` instead',
+		action_return_error
+	);
+}
+export function action_response_not_serializable({ id }: { id: string }): never {
+	return throwDiagnostic(
+		'action_response_not_serializable',
+		`Data returned from action inside \`${id}\` is not serializable. Form actions need to return plain objects or \`fail()\`. E.g. \`return { success: true }\` or \`return fail(400, { message: "invalid" });\``,
+		action_response_not_serializable
+	);
+}
+export function action_data_not_serializable({
+	id,
+	message,
+	path = ''
+}: {
+	id: string;
+	message: string;
+	path?: string;
+}): never {
+	return throwDiagnostic(
+		'action_data_not_serializable',
+		`Data returned from action inside \`${id}\` is not serializable: ${message}${path ? ` (\`${path}\`)` : ''}`,
+		action_data_not_serializable
+	);
+}
+export function load_not_serializable(
+	{
+		id,
+		message,
+		path
+	}: {
+		id: string;
+		message: string;
+		path: string;
+	},
+	options?: ErrorOptions
+): never {
+	try {
+		throwDiagnostic(
+			'load_not_serializable',
+			`Data returned from \`load\` while rendering \`${id}\` is not serializable: ${message} (\`${path}\`). If you need to serialize/deserialize custom types, use transport hooks${runtime.docs('transport', (url) => `: ${url}`)}.`,
+			load_not_serializable
+		);
+	} catch (error) {
+		if (error instanceof Error) error.cause = options?.cause;
+		throw error;
+	}
+}
+export function load_not_plain_object({ id }: { id: string }): never {
+	return throwDiagnostic(
+		'load_not_plain_object',
+		`Data returned from \`load\` while rendering \`${id}\` is not a plain object`,
+		load_not_plain_object
+	);
+}
+export function load_promise_not_serializable(
+	{ id }: { id: string },
+	options?: ErrorOptions
+): never {
+	try {
+		throwDiagnostic(
+			'load_promise_not_serializable',
+			`Failed to serialize promise while rendering \`${id}\``,
+			load_promise_not_serializable
+		);
+	} catch (error) {
+		if (error instanceof Error) error.cause = options?.cause;
+		throw error;
+	}
+}
+export function load_response_header_not_serialized({
+	name,
+	id
+}: {
+	name: string;
+	id: string;
+}): never {
+	return throwDiagnostic(
+		'load_response_header_not_serialized',
+		`Failed to get response header \`${name}\` — it must be included by the \`filterSerializedResponseHeaders\` option${runtime.docs('handle', (url) => `: ${url}`)} (at \`${id}\`)`,
+		load_response_header_not_serialized
+	);
+}
+export function load_fetch_cors({ reason }: { reason: string }): never {
+	return throwDiagnostic(
+		'load_fetch_cors',
+		`CORS error: ${reason} \`Access-Control-Allow-Origin\` header is present on the requested resource`,
+		load_fetch_cors
+	);
+}
+export function prerender_actions(): never {
+	return throwDiagnostic(
+		'prerender_actions',
+		'Cannot prerender pages with actions',
+		prerender_actions
+	);
+}
+export function prerender_endpoint_methods({
+	methods,
+	id
+}: {
+	methods: string;
+	id: string;
+}): never {
+	return throwDiagnostic(
+		'prerender_endpoint_methods',
+		`Cannot prerender a \`+server\` file with ${methods} or fallback handlers (\`${id}\`)`,
+		prerender_endpoint_methods
+	);
+}
+export function prerender_endpoint_not_prerenderable({ id }: { id: string }): never {
+	return throwDiagnostic(
+		'prerender_endpoint_not_prerenderable',
+		`\`${id}\` is not prerenderable`,
+		prerender_endpoint_not_prerenderable
+	);
+}
+export function prerender_nonce(): never {
+	return throwDiagnostic(
+		'prerender_nonce',
+		"Cannot use prerendering if `config.csp.mode === 'nonce'`",
+		prerender_nonce
+	);
+}
+export function prerender_template_nonce({ tag }: { tag: string }): never {
+	return throwDiagnostic(
+		'prerender_template_nonce',
+		`Cannot use prerendering if page template contains \`${tag}\``,
+		prerender_template_nonce
+	);
+}
+export function csp_report_only_missing_report(): never {
+	return throwDiagnostic(
+		'csp_report_only_missing_report',
+		'`content-security-policy-report-only` must be specified with either the `report-to` or `report-uri` directives, or both',
+		csp_report_only_missing_report
+	);
+}
+export function server_api_unavailable({ name }: { name: string }): never {
+	return throwDiagnostic(
+		'server_api_unavailable',
+		`Cannot call \`${name}\` on the server`,
+		server_api_unavailable
+	);
+}
+export function state_read_outside_render({ name }: { name: string }): never {
+	return throwDiagnostic(
+		'state_read_outside_render',
+		`Can only read \`${name}\` on the server during rendering (not in e.g. \`load\` functions), as it is bound to the current request via component context. This prevents state from leaking between users.`,
+		state_read_outside_render
+	);
+}
+export function read_implementation_missing(): never {
+	return throwDiagnostic(
+		'read_implementation_missing',
+		'No `read` implementation was provided. Please ensure that your adapter is up to date and supports this feature',
+		read_implementation_missing
+	);
+}
+export function read_asset_missing({ file }: { file: string }): never {
+	return throwDiagnostic(
+		'read_asset_missing',
+		`Asset does not exist: \`${file}\``,
+		read_asset_missing
+	);
+}
+export function url_search_unavailable_prerender({ property }: { property: string }): never {
+	return throwDiagnostic(
+		'url_search_unavailable_prerender',
+		`Cannot access \`url.${property}\` on a page with prerendering enabled`,
+		url_search_unavailable_prerender
+	);
+}
+export function handle_error_hook_failed(options?: ErrorOptions): never {
+	try {
+		throwDiagnostic(
+			'handle_error_hook_failed',
+			'The `handleError` hook failed',
+			handle_error_hook_failed
+		);
+	} catch (error) {
+		if (error instanceof Error) error.cause = options?.cause;
+		throw error;
+	}
+}
+export function tracing_api_missing(): never {
+	return throwDiagnostic(
+		'tracing_api_missing',
+		`Tracing is enabled (see the ${identity.product} plugin \`tracing.server\` option in your \`vite.config.js\`), but \`@opentelemetry/api\` is not available. This error will likely resolve itself when you set up your tracing instrumentation in \`instrumentation.server.js\`.${runtime.docs('observability', (url) => ` For more information, see ${url}`)}`,
+		tracing_api_missing
+	);
+}

package/src/server/failure.ts

@@ -0,0 +1,49 @@
+import type { CaughtError } from '../types/hooks.ts';
+import type { RequestStore } from '../types/internal/server.ts';
+import { HttpError, ValidationError, FrameworkError, HandledError } from '../shared/outcomes.ts';
+export { FrameworkError, HandledError } from '../shared/outcomes.ts';
+import { runRequest } from './scope.ts';
+import { appEvent } from './hooks.ts';
+import * as errors from './errors.ts';
+
+export async function handleError(store: RequestStore, error: unknown): Promise<App.Error> {
+	if (error instanceof HandledError) return error.body;
+	let caught: CaughtError;
+	if (error instanceof HttpError) caught = { kind: 'app', error: error.body };
+	else if (error instanceof FrameworkError)
+		caught = { kind: 'framework', error: { status: error.status, message: error.text } };
+	else if (error instanceof ValidationError)
+		caught = {
+			kind: 'validation',
+			error: { status: 400, message: 'Bad Request' },
+			issues: error.issues
+		};
+	else {
+		caught = { kind: 'unknown', error };
+		let current = error;
+		while (current instanceof Error) {
+			store.options.fixStack?.(current);
+			current = current.cause;
+		}
+	}
+	const fallback =
+		caught.kind === 'unknown' ? { status: 500, message: 'Internal Error' } : caught.error;
+	try {
+		if (!store.hooks.handleError) {
+			if (caught.kind === 'unknown') console.error(error);
+			return fallback as App.Error;
+		}
+		const result = await runRequest(store, () =>
+			store.hooks.handleError!({ ...caught, event: appEvent(store.event) })
+		);
+		return { ...fallback, ...result } as App.Error;
+	} catch (cause) {
+		try {
+			errors.handle_error_hook_failed({ cause });
+		} catch (failure) {
+			console.error(failure);
+		}
+		console.error('Original error:', error);
+		return { status: fallback.status, message: 'Internal Error' } as App.Error;
+	}
+}

package/src/server/fetch-guard.ts

@@ -0,0 +1,60 @@
+import { findRequest } from './scope.ts';
+import * as errors from './errors.ts';
+import * as warnings from './warnings.ts';
+import { SCHEME } from '../shared/url.ts';
+
+const decoded = new WeakMap<Response, Error>();
+let watching = false;
+
+function capture(fn: () => never): Error {
+	try {
+		fn();
+	} catch (error) {
+		return error as Error;
+	}
+	throw new Error('unreachable');
+}
+
+export function watchDecodedResponses(): void {
+	if (watching) return;
+	watching = true;
+	const original = globalThis.fetch;
+	globalThis.fetch = async (info, init) => {
+		const response = await original(info, init);
+		const encoding = response.headers.get('content-encoding');
+		if (encoding)
+			decoded.set(
+				response,
+				capture(() => errors.fetch_response_decoded({ encoding }))
+			);
+		return response;
+	};
+}
+
+export function reportDecodedResponse(
+	response: Response,
+	fixStack?: (error: Error) => Error
+): void {
+	const error = decoded.get(response);
+	if (error) console.error(fixStack ? fixStack(error) : error);
+}
+
+export async function guardRenderFetch<T>(render: () => PromiseLike<T>): Promise<T> {
+	const original = globalThis.fetch;
+	let warned = false;
+	globalThis.fetch = (info, init) => {
+		if (typeof info === 'string' && !SCHEME.test(info))
+			errors.ssr_fetch_relative_url({ url: info });
+		const remote = findRequest()?.remote;
+		if (!warned && !remote?.query && !remote?.prerender && !remote?.mutation) {
+			warnings.ssr_fetch_eager();
+			warned = true;
+		}
+		return original(info, init);
+	};
+	try {
+		return await render();
+	} finally {
+		globalThis.fetch = original;
+	}
+}

package/src/server/fetch.ts

@@ -0,0 +1,119 @@
+import { parseSetCookie } from 'cookie';
+import type { SerializeOptions } from 'cookie';
+import type { RequestStore } from '../types/internal/server.ts';
+import type { Server } from './index.ts';
+import type { CookieJar } from './cookies.ts';
+import { runRequest } from './scope.ts';
+import { appEvent } from './hooks.ts';
+
+function requestInput(input: RequestInfo | URL, init: RequestInit | undefined, base: URL): Request {
+	return input instanceof Request
+		? init
+			? new Request(input, init)
+			: input
+		: new Request(new URL(input, base), init);
+}
+
+export function createFetch(server: Server, store: RequestStore, cookies: CookieJar): typeof fetch {
+	const { event } = store;
+	const internal: typeof fetch = async (input, init) => {
+		const request = requestInput(input, init, event.url);
+		const url = new URL(request.url);
+		const mode = (input instanceof Request ? input.mode : init?.mode) ?? 'cors';
+		const credentials =
+			(input instanceof Request ? input.credentials : init?.credentials) ?? 'same-origin';
+		if (!request.headers.has('origin')) request.headers.set('origin', event.url.origin);
+		if (
+			['GET', 'HEAD'].includes(request.method) &&
+			(url.origin === event.url.origin || mode === 'no-cors')
+		)
+			request.headers.delete('origin');
+		let decoded: string;
+		try {
+			decoded = decodeURIComponent(url.pathname);
+		} catch {
+			return globalThis.fetch(request);
+		}
+		const base = server.options.paths.base;
+		const sameApp =
+			url.origin === event.url.origin &&
+			(!base || decoded === base || decoded.startsWith(`${base}/`));
+		if (!sameApp) {
+			if (`.${url.hostname}`.endsWith(`.${event.url.hostname}`) && credentials !== 'omit') {
+				const header = cookies.header(url, request.headers.get('cookie'));
+				if (header) request.headers.set('cookie', header);
+			}
+			return globalThis.fetch(request);
+		}
+		const assetPrefix = server.options.paths.assets || base;
+		const filename = (
+			decoded.startsWith(`${assetPrefix}/`) ? decoded.slice(assetPrefix.length) : decoded
+		).slice(1);
+		const asset =
+			server.manifest.assets.has(filename) || filename in server.manifest.server_assets
+				? filename
+				: server.manifest.assets.has(`${filename}/index.html`)
+					? `${filename}/index.html`
+					: null;
+		if (asset) {
+			if (store.state.read) {
+				const body = await store.state.read(asset);
+				const type = server.manifest.mime_types[asset.slice(asset.lastIndexOf('.'))];
+				return new Response(body, { headers: type ? { 'content-type': type } : {} });
+			}
+			return globalThis.fetch(request, { redirect: 'manual' });
+		}
+		if (
+			server.manifest.prerendered_routes.has(decoded) ||
+			server.manifest.prerendered_routes.has(decoded.replace(/\/$/, ''))
+		)
+			return globalThis.fetch(request, { redirect: 'manual' });
+		if (credentials !== 'omit') {
+			const header = cookies.header(url, request.headers.get('cookie'));
+			if (header) request.headers.set('cookie', header);
+			const auth = event.request.headers.get('authorization');
+			if (auth && !request.headers.has('authorization')) request.headers.set('authorization', auth);
+		}
+		if (!request.headers.has('accept')) request.headers.set('accept', '*/*');
+		const language = event.request.headers.get('accept-language');
+		if (language && !request.headers.has('accept-language'))
+			request.headers.set('accept-language', language);
+		if (request.signal.aborted) throw new DOMException('The operation was aborted.', 'AbortError');
+		let onAbort: () => void;
+		const aborted = new Promise<never>((_, reject) => {
+			onAbort = () => reject(new DOMException('The operation was aborted.', 'AbortError'));
+			request.signal.addEventListener('abort', onAbort, { once: true });
+		});
+		const response = await Promise.race([server.respondInternal(request, store), aborted]).finally(
+			() => {
+				request.signal.removeEventListener('abort', onAbort);
+			}
+		);
+		for (const value of response.headers.getSetCookie()) {
+			const {
+				name,
+				value: content,
+				...attributes
+			} = parseSetCookie(value, { decode: (value) => value });
+			cookies.set(name, content ?? '', {
+				path: attributes.path ?? (url.pathname.split('/').slice(0, -1).join('/') || '/'),
+				encode: (value) => value,
+				...attributes
+			} as SerializeOptions);
+		}
+		return response;
+	};
+	const execute: typeof fetch = async (input, init) => {
+		const request = requestInput(input, init, event.url);
+		return runRequest(store, () =>
+			server.hooks.handleFetch
+				? server.hooks.handleFetch({ event: appEvent(event), request, fetch: internal })
+				: internal(request)
+		);
+	};
+	return (input, init) => {
+		const promise = execute(input, init);
+		promise.catch(() => {});
+		return promise;
+	};
+}

package/src/server/headers.ts

@@ -0,0 +1,84 @@
+import type { ServerOptions } from '../types/internal/server.ts';
+import * as errors from './errors.ts';
+import * as warnings from './warnings.ts';
+import { identity } from '../shared/identity.ts';
+
+export function versionHeader(options: ServerOptions): Record<string, string> {
+	return options.output.bundleStrategy === 'inline'
+		? {}
+		: { [`x-${identity.name}-version`]: options.version.name };
+}
+
+const directives = new Set([
+	'max-age',
+	'public',
+	'private',
+	'no-cache',
+	'no-store',
+	'must-revalidate',
+	'proxy-revalidate',
+	's-maxage',
+	'immutable',
+	'stale-while-revalidate',
+	'stale-if-error',
+	'no-transform',
+	'only-if-cached',
+	'max-stale',
+	'min-fresh'
+]);
+
+export function validateHeaders(headers: Record<string, string>): void {
+	for (const [name, value] of Object.entries(headers)) {
+		if (name.toLowerCase() === 'cache-control') {
+			const parts = value.split(',').map((part) => part.trim());
+			if (parts.some((part) => !part)) warnings.cache_control_empty_directive({ value });
+			else {
+				const invalid = parts
+					.map((part) => part.split('=')[0]!.toLowerCase())
+					.find((part) => !directives.has(part));
+				if (invalid)
+					warnings.cache_control_invalid_directive({
+						directive: invalid,
+						directives: [...directives].join(', '),
+						value
+					});
+			}
+		} else if (name.toLowerCase() === 'content-type') {
+			const type = value.split(';')[0]!.trim();
+			if (
+				!/^(application|audio|example|font|haptics|image|message|model|multipart|text|video|x-[a-z]+)\/[-+.\w]+$/i.test(
+					type
+				)
+			)
+				warnings.content_type_invalid({ type, value });
+		}
+	}
+}
+
+export class ResponseHeaders {
+	readonly values = new Headers();
+	#sealed = false;
+	readonly #dev: boolean;
+
+	constructor(dev: boolean) {
+		this.#dev = dev;
+	}
+
+	set = (headers: Record<string, string>): void => {
+		if (this.#sealed) errors.set_headers_after_response();
+		if (this.#dev) validateHeaders(headers);
+		for (const [key, value] of Object.entries(headers)) {
+			const name = key.toLowerCase();
+			if (name === 'set-cookie') errors.set_headers_cookie();
+			if (name === 'server-timing') this.values.append(name, value);
+			else {
+				if (this.values.has(name)) errors.header_already_set({ name: key });
+				this.values.set(name, value);
+			}
+		}
+	};
+
+	seal(): void {
+		this.#sealed = true;
+	}
+}

package/src/server/hooks.ts

@@ -0,0 +1,6 @@
+import type { ParamValue } from '../types/params.ts';
+import type { RequestEvent } from '../types/request.ts';
+
+export function appEvent(event: RequestEvent<Record<string, ParamValue>>): RequestEvent {
+	return event as RequestEvent;
+}