@vigla/kit 0.0.0-stage → 0.1.1

package/src/server/index.ts

@@ -0,0 +1,90 @@
+import type { ServerInitOptions } from '../types/request.ts';
+import type {
+	Environment,
+	Read,
+	RequestStore,
+	RespondOptions,
+	ServerHooks,
+	ServerInstance,
+	ServerManifest,
+	ServerOptions
+} from '../types/internal/server.ts';
+import { carryRequests } from './scope.ts';
+import { Tracer } from './telemetry.ts';
+import { respond } from './respond.ts';
+import { configureEnvironment } from './environment.ts';
+import { configurePaths } from './paths.ts';
+import { configureRead } from './read.ts';
+import { reportDecodedResponse, watchDecodedResponses } from './fetch-guard.ts';
+import { configureTransport } from './transport.ts';
+
+export class Server implements ServerInstance {
+	readonly manifest: ServerManifest;
+	readonly options: ServerOptions;
+	readonly tracer = new Tracer();
+	readonly cookiePaths = new Map<string, Set<string>>();
+	environment: Environment = { public: {}, private: {}, rendered: {} };
+	hooks: ServerHooks = {};
+	read?: Read;
+	#configuration: Promise<void> | null = null;
+	#initialization: Promise<void> | null = null;
+
+	constructor(manifest: ServerManifest, options: ServerOptions) {
+		this.manifest = manifest;
+		this.options = options;
+	}
+
+	configure({ env, read, scope }: ServerInitOptions): Promise<void> {
+		return (this.#configuration ??= (async () => {
+			this.read = read;
+			if (scope) carryRequests(scope);
+			if (this.options.dev) watchDecodedResponses();
+			configureEnvironment(this.options, this.environment);
+			configurePaths(this.options.paths, this.manifest.app_dir);
+			configureRead(this.manifest, this.options.paths, read);
+			await this.setEnv(env);
+		})());
+	}
+
+	async setEnv(env: Record<string, string | undefined>): Promise<void> {
+		this.environment = await this.options.env.set(env);
+		configureEnvironment(this.options, this.environment);
+	}
+
+	init(options: ServerInitOptions): Promise<void> {
+		return (this.#initialization ??= (async () => {
+			await this.configure(options);
+			await this.tracer.init(this.options.tracing.server);
+			this.hooks = await this.options.getHooks();
+			configureTransport(this.hooks.transport);
+			await this.hooks.init?.();
+		})());
+	}
+
+	async respond(request: Request, options: RespondOptions): Promise<Response> {
+		if (!this.#initialization)
+			throw new Error('Server.init() must be called before Server.respond()');
+		await this.#initialization;
+		const response = await this.tracer.request(request, () => respond(this, request, options));
+		if (this.options.dev) reportDecodedResponse(response, this.options.fixStack);
+		return response;
+	}
+
+	respondInternal(request: Request, parent: RequestStore): Promise<Response> {
+		return respond(
+			this,
+			request,
+			{
+				getClientAddress: parent.event.getClientAddress,
+				platform: parent.event.platform,
+				emulator: parent.state.emulator,
+				read: parent.state.read,
+				prerendering: parent.state.prerendering
+			},
+			parent
+		);
+	}
+}
+
+export { getRequestEvent, getRequestOwner } from './scope.ts';
+export { read } from './read.ts';

package/src/server/load.ts

@@ -0,0 +1,247 @@
+import type { PageNode, RequestStore, ServerDataNode, Uses } from '../types/internal/server.ts';
+import type { ServerLoadEvent } from '../types/request.ts';
+import type { ParamValue } from '../types/params.ts';
+import type { Server } from './index.ts';
+import { makeTrackable } from '../shared/url.ts';
+import { load_invalid_response } from '../shared/errors.ts';
+import type { ActionResult } from './actions.ts';
+import { runRequest } from './scope.ts';
+import { replayFetch } from './replay.ts';
+import { restrictSearch } from './url.ts';
+import * as warnings from './warnings.ts';
+import { identity } from '../shared/identity.ts';
+
+export interface LoadedNode {
+	depth: number;
+	node: PageNode;
+	server: ServerDataNode | null;
+	data: Record<string, any> | null;
+}
+
+export function validateLoad(
+	value: unknown,
+	location: string
+): asserts value is Record<string, any> | null | undefined {
+	if (value == null || Object.getPrototypeOf(value) === Object.prototype) return;
+	load_invalid_response({
+		location,
+		type:
+			typeof value !== 'object'
+				? `a ${typeof value}`
+				: value instanceof Response
+					? 'a Response object'
+					: Array.isArray(value)
+						? 'an array'
+						: 'a non-plain object'
+	});
+}
+
+function nodeType(id: string | undefined): string {
+	const file = id?.split('/').at(-1);
+	return file ? file.split('.').slice(0, -1).join('.') : 'unknown';
+}
+
+export async function serverLoad(
+	server: Server,
+	store: RequestStore,
+	node: PageNode | undefined,
+	parent: () => Promise<Record<string, any>>
+): Promise<ServerDataNode | null> {
+	if (!node?.server) return null;
+	const uses: Uses = {
+		dependencies: new Set(),
+		params: new Set(),
+		parent: false,
+		route: false,
+		url: false,
+		search_params: new Set()
+	};
+	if (!node.server.load)
+		return { type: 'data', data: null, uses, slash: node.server.trailingSlash };
+	const { event } = store;
+	let tracking = true;
+	let done = false;
+	const track = (usage: string, change: string, fn: () => void): void => {
+		if (!tracking) return;
+		if (done) {
+			if (server.options.dev)
+				warnings.load_tracking_after_return({
+					id: node.server_id ?? event.route.id ?? '',
+					usage,
+					change
+				});
+			return;
+		}
+		fn();
+	};
+	const url = makeTrackable(
+		event.url,
+		() =>
+			track('Accessing URL properties', 'the URL changes', () => {
+				uses.url = true;
+			}),
+		(name) =>
+			track('Accessing URL properties', 'the URL changes', () => uses.search_params.add(name))
+	);
+	restrictSearch(url, store.state, true);
+	const input: ServerLoadEvent<Record<string, ParamValue>> = {
+		...event,
+		params: new Proxy(event.params, {
+			get(target, key, receiver) {
+				if (typeof key === 'string')
+					track(`Accessing \`params.${key}\``, 'the param changes', () => uses.params.add(key));
+				return Reflect.get(target, key, receiver);
+			}
+		}),
+		route: new Proxy(event.route, {
+			get(target, key, receiver) {
+				track('Accessing route properties', 'the route changes', () => {
+					uses.route = true;
+				});
+				return Reflect.get(target, key, receiver);
+			}
+		}),
+		url,
+		parent: () => {
+			track('Calling `parent(...)`', 'parent data changes', () => {
+				uses.parent = true;
+			});
+			return parent();
+		},
+		depends: (...dependencies) => {
+			for (const dependency of dependencies)
+				track('Calling `depends(...)`', 'the dependency is invalidated', () =>
+					uses.dependencies.add(new URL(dependency, event.url).href)
+				);
+		},
+		untrack: (fn) => {
+			const previous = tracking;
+			tracking = false;
+			try {
+				return fn();
+			} finally {
+				tracking = previous;
+			}
+		}
+	};
+	const result: unknown = await server.tracer.span(
+		`${identity.name}.load`,
+		{
+			[`${identity.name}.load.node_id`]: node.server_id || 'unknown',
+			[`${identity.name}.load.node_type`]: nodeType(node.server_id),
+			[`${identity.name}.load.environment`]: 'server',
+			'http.route': event.route.id ?? 'unknown'
+		},
+		async (span) => {
+			const traced = { ...input, tracing: { ...input.tracing, current: span } };
+			return runRequest({ ...store, event: traced }, () => node.server!.load!(traced));
+		}
+	);
+	validateLoad(
+		result,
+		node.server_id ? `in ${node.server_id}` : `related to route '${event.route.id}'`
+	);
+	observePromises(result);
+	done = true;
+	return { type: 'data', data: result ?? null, uses, slash: node.server.trailingSlash };
+}
+
+export async function universalLoad(
+	server: Server,
+	store: RequestStore,
+	node: PageNode,
+	data: Promise<ServerDataNode | null>,
+	parent: () => Promise<Record<string, any>>,
+	csr: boolean
+): Promise<Record<string, any> | null> {
+	const serverData = await data;
+	if (!node.universal?.load) return serverData?.data ?? null;
+	const { event } = store;
+	const result: unknown = await server.tracer.span(
+		`${identity.name}.load`,
+		{
+			[`${identity.name}.load.node_id`]: node.universal_id || 'unknown',
+			[`${identity.name}.load.node_type`]: nodeType(node.universal_id),
+			[`${identity.name}.load.environment`]: 'server',
+			'http.route': event.route.id ?? 'unknown'
+		},
+		async (span) =>
+			runRequest(store, () =>
+				node.universal!.load!({
+					url: event.url,
+					params: event.params,
+					data: serverData?.data ?? null,
+					route: event.route,
+					fetch: replayFetch(store, csr),
+					setHeaders: event.setHeaders,
+					depends() {},
+					parent,
+					untrack: (fn) => fn(),
+					tracing: { ...event.tracing, current: span }
+				})
+			)
+	);
+	validateLoad(
+		result,
+		node.universal_id ? `in ${node.universal_id}` : `related to route '${event.route.id}'`
+	);
+	return result ?? null;
+}
+
+function observePromises(value: unknown, seen = new WeakSet<object>()): void {
+	if (!value || typeof value !== 'object' || seen.has(value)) return;
+	seen.add(value);
+	if ('then' in value && typeof value.then === 'function') {
+		void Promise.resolve(value)
+			.then(
+				(resolved) => observePromises(resolved, seen),
+				() => {}
+			)
+			.catch(() => {});
+	} else if (value instanceof Map) {
+		for (const [key, entry] of value) {
+			observePromises(key, seen);
+			observePromises(entry, seen);
+		}
+	} else if (value instanceof Set) {
+		for (const entry of value) observePromises(entry, seen);
+	} else {
+		for (const entry of Object.values(value)) observePromises(entry, seen);
+	}
+}
+
+export function loadBranch(
+	server: Server,
+	store: RequestStore,
+	nodes: Array<PageNode | undefined>,
+	csr: boolean,
+	action?: ActionResult
+): Array<Promise<LoadedNode | null>> {
+	const serverData: Array<Promise<ServerDataNode | null>> = [];
+	const universalData: Array<Promise<Record<string, any> | null>> = [];
+	for (const [index, node] of nodes.entries()) {
+		const parent = async (
+			promises: Array<Promise<Record<string, any> | null>>
+		): Promise<Record<string, any>> =>
+			Object.assign({}, ...(await Promise.all(promises.slice(0, index))));
+		serverData[index] =
+			index === nodes.length - 1 && action?.type === 'error'
+				? Promise.reject(action.error)
+				: serverLoad(server, store, node, () =>
+						parent(serverData.map((promise) => promise.then((value) => value?.data ?? null)))
+					);
+		serverData[index]!.catch(() => {});
+		universalData[index] = node
+			? universalLoad(server, store, node, serverData[index]!, () => parent(universalData), csr)
+			: Promise.resolve(null);
+		universalData[index]!.catch(() => {});
+	}
+	return nodes.map((node, index) => {
+		if (!node) return Promise.resolve(null);
+		const loaded = Promise.all([serverData[index]!, universalData[index]!]).then(
+			([server, data]) => ({ depth: index, node, server, data })
+		);
+		loaded.catch(() => {});
+		return loaded;
+	});
+}

package/src/server/origin.ts

@@ -0,0 +1,6 @@
+import { findRequest } from './scope.ts';
+
+export function getOrigin(): string | undefined {
+	const url = findRequest()?.event.request.url;
+	return url === undefined ? undefined : new URL(url).origin;
+}

package/src/server/page.ts

@@ -0,0 +1,220 @@
+import type { PageNode, RequestStore, ServerRoute } from '../types/internal/server.ts';
+import type { TrailingSlash } from '../types/internal/data.ts';
+import type { Server } from './index.ts';
+import type { LoadedNode } from './load.ts';
+import { HttpError, Redirect } from '../shared/outcomes.ts';
+import { negotiate } from '../shared/http.ts';
+import { escapeHtml } from '../shared/escape.ts';
+import { renderDocument } from './document.ts';
+import { loadBranch, serverLoad, universalLoad } from './load.ts';
+import { actionResponse, runAction, wantsActionJson, type ActionResult } from './actions.ts';
+import { FrameworkError, handleError } from './failure.ts';
+import * as errors from './errors.ts';
+import * as warnings from './warnings.ts';
+import { identity } from '../shared/identity.ts';
+
+export interface PageSettings {
+	ssr: boolean;
+	csr: boolean;
+	prerender: boolean | 'auto';
+	trailingSlash: TrailingSlash;
+}
+
+export function pageSettings(nodes: Array<PageNode | undefined>): PageSettings {
+	const settings: PageSettings = { ssr: true, csr: true, prerender: false, trailingSlash: 'never' };
+	for (const node of nodes)
+		for (const module of [node?.server, node?.universal]) {
+			if (module?.ssr !== undefined) settings.ssr = module.ssr;
+			if (module?.csr !== undefined) settings.csr = module.csr;
+			if (module?.prerender !== undefined) settings.prerender = module.prerender;
+			if (module?.trailingSlash !== undefined) settings.trailingSlash = module.trailingSlash;
+		}
+	return settings;
+}
+
+export async function pageResponse(
+	server: Server,
+	store: RequestStore,
+	route: ServerRoute,
+	nodes: Array<PageNode | undefined>
+): Promise<Response> {
+	try {
+		return await renderPage(server, store, route, nodes);
+	} catch (error) {
+		return errorResponse(server, store, error);
+	}
+}
+
+async function renderPage(
+	server: Server,
+	store: RequestStore,
+	route: ServerRoute,
+	nodes: Array<PageNode | undefined>
+): Promise<Response> {
+	const settings = pageSettings(nodes);
+	const { event, state } = store;
+	state.prerenderDefault = settings.prerender;
+	const leaf = nodes.at(-1);
+	if (settings.prerender && leaf?.server?.actions) errors.prerender_actions();
+	if (state.prerendering && !state.prerendering.fallback && !settings.prerender)
+		return new Response(null, { status: 204 });
+	if (wantsActionJson(event.request))
+		return actionResponse(server, store, await runAction(server, store, leaf?.server));
+	let form: unknown = null;
+	let status = 200;
+	let action: ActionResult | undefined;
+	if (event.request.method === 'POST') {
+		const result = (action = await runAction(server, store, leaf?.server));
+		if (result.type === 'redirect')
+			return new Response(null, { status: result.status, headers: { location: result.location } });
+		if (result.type === 'error') {
+			if (!settings.ssr && server.options.dev)
+				warnings.form_action_error_without_ssr(server.options.extension);
+			status =
+				result.error instanceof HttpError || result.error instanceof FrameworkError
+					? result.error.status
+					: 500;
+		} else {
+			form = result.data;
+			status = result.status;
+		}
+		if (!settings.ssr && form && server.options.dev) warnings.form_action_data_without_ssr();
+	}
+	const branch: LoadedNode[] = settings.ssr
+		? []
+		: nodes.flatMap((node, depth) => (node ? [{ depth, node, server: null, data: null }] : []));
+	if (settings.ssr) {
+		const pending = loadBranch(server, store, nodes, settings.csr, action);
+		for (const [index, load] of pending.entries()) {
+			try {
+				const result = await load;
+				if (result) branch.push(result);
+			} catch (error) {
+				if (error instanceof Redirect)
+					return new Response(null, {
+						status: error.status,
+						headers: { location: error.location }
+					});
+				return errorResponse(server, store, error, route, branch, index);
+			}
+		}
+	}
+	const errorNodes = await Promise.all(
+		(route.page?.errors ?? []).map((index) =>
+			index == null ? undefined : server.manifest.nodes[index]!()
+		)
+	);
+	try {
+		const response = await renderDocument(server, store, {
+			branch,
+			errors: errorNodes,
+			status,
+			error: null,
+			form,
+			ssr: settings.ssr,
+			csr: settings.csr
+		});
+		if (state.prerendering)
+			response.headers.set(`x-${identity.name}-prerender`, String(settings.prerender));
+		return response;
+	} catch (error) {
+		return errorResponse(server, store, error, route, branch, nodes.length - 1);
+	}
+}
+
+export async function errorResponse(
+	server: Server,
+	store: RequestStore,
+	failure: unknown,
+	route?: ServerRoute,
+	branch: LoadedNode[] = [],
+	failed?: number
+): Promise<Response> {
+	if (failure instanceof Redirect)
+		return new Response(null, { status: failure.status, headers: { location: failure.location } });
+	const body = await handleError(store, failure);
+	const { event, state } = store;
+	if (!state.error && !event.request.headers.has(`x-${identity.name}-error`)) {
+		state.error = true;
+		try {
+			const candidates = route?.page?.errors ?? [1];
+			const boundary = failed === undefined ? 0 : failed - 1;
+			for (let depth = Math.min(boundary, candidates.length - 1); depth >= 0; depth--) {
+				const id = candidates[depth];
+				if (id == null) continue;
+				const node = await server.manifest.nodes[id]!();
+				if (!node.component) continue;
+				let prefix = branch.filter((loaded) => loaded.depth <= depth);
+				if (!prefix.length && server.manifest.nodes[0]) {
+					const root = await server.manifest.nodes[0]();
+					const { ssr, csr } = pageSettings([root]);
+					if (!ssr)
+						return await renderDocument(server, store, {
+							branch: [],
+							errors: [],
+							status: body.status,
+							error: body,
+							form: null,
+							ssr,
+							csr
+						});
+					const data = await serverLoad(server, store, root, async () => ({}));
+					const universal = await universalLoad(
+						server,
+						store,
+						root,
+						Promise.resolve(data),
+						async () => ({}),
+						csr
+					);
+					prefix = [{ depth: 0, node: root, server: data, data: universal }];
+				}
+				const settings = pageSettings(prefix.map((loaded) => loaded.node));
+				const above = await Promise.all(
+					candidates
+						.slice(0, depth)
+						.map((index) => (index == null ? undefined : server.manifest.nodes[index]!()))
+				);
+				return await renderDocument(server, store, {
+					branch: [...prefix, { depth: depth + 1, node, server: null, data: null }],
+					errors: above,
+					status: body.status,
+					error: body,
+					form: null,
+					ssr: settings.ssr,
+					csr: settings.csr
+				});
+			}
+		} catch (error) {
+			if (error instanceof Redirect)
+				return new Response(null, {
+					status: error.status,
+					headers: { location: error.location }
+				});
+			return staticErrorPage(server, await handleError(store, error));
+		}
+	}
+	return staticErrorPage(server, body);
+}
+
+export async function fatalResponse(
+	server: Server,
+	store: RequestStore,
+	failure: unknown
+): Promise<Response> {
+	const body = await handleError(store, failure);
+	const accept = negotiate(store.event.request.headers.get('accept') || 'text/html', [
+		'application/json',
+		'text/html'
+	]);
+	if (store.event.isDataRequest || accept === 'application/json')
+		return Response.json(body, { status: body.status });
+	return staticErrorPage(server, body);
+}
+
+function staticErrorPage(server: Server, body: App.Error): Response {
+	return new Response(
+		server.options.templates.error({ status: body.status, message: escapeHtml(body.message) }),
+		{ status: body.status, headers: { 'content-type': 'text/html; charset=utf-8' } }
+	);
+}

package/src/server/paths.ts

@@ -0,0 +1,89 @@
+import type { ServerPaths } from '../types/internal/server.ts';
+import { findRequest, runRequest } from './scope.ts';
+import { findRoute, resolveRoute } from '../shared/routing/index.ts';
+import { decodePathname } from '../shared/url.ts';
+import { addDataSuffix } from '../shared/pathname.ts';
+import type { RouteMatch } from '../types/paths.ts';
+import { resolve_params_missing } from '../shared/errors.ts';
+import { identity } from '../shared/identity.ts';
+
+let configured: ServerPaths = { base: '', assets: '', relative: true };
+export let base = '';
+export let assets = '';
+export let app_dir = '_app';
+
+export function configurePaths(paths: ServerPaths, appDir: string): void {
+	configured = paths;
+	base = paths.base;
+	assets = paths.assets || paths.base;
+	app_dir = appDir;
+}
+export function paths(): ServerPaths {
+	return findRequest()?.options.paths ?? configured;
+}
+export function appDirectory(): string {
+	return findRequest()?.manifest.app_dir ?? app_dir;
+}
+export function asset(file: string): string {
+	return paths().assets && paths().assets !== paths().base
+		? `${paths().assets}/${file}`
+		: resolve(file);
+}
+export function resolve(route: string, params?: Record<string, any>): string {
+	if (route.startsWith('/') && route.includes('[') && !params)
+		resolve_params_missing({ id: route });
+	const resolved = route.startsWith('/') ? resolveRoute(route, params ?? {}) : `/${route}`;
+	const store = findRequest();
+	if (paths().relative && store && !store.state.prerendering?.fallback) {
+		const path = store.event.isDataRequest
+			? addDataSuffix(store.event.url.pathname)
+			: store.event.url.pathname;
+		return documentPaths(path, paths()).base + resolved;
+	}
+	return paths().base + resolved;
+}
+export async function match(value: URL | string): Promise<RouteMatch | null> {
+	const store = findRequest();
+	if (!store) return null;
+	const url = value instanceof URL ? value : new URL(value, store.event.url);
+	let path: string;
+	try {
+		path = decodePathname(
+			(await runRequest(store, () =>
+				store.hooks.reroute?.({ url: new URL(url), fetch: store.event.fetch })
+			)) ?? url.pathname
+		);
+	} catch {
+		return null;
+	}
+	const base = store.options.paths.base;
+	if (base && path !== base && !path.startsWith(`${base}/`)) return null;
+	const result = findRoute(
+		path.slice(base.length) || '/',
+		store.manifest.routes,
+		await store.manifest.matchers()
+	);
+	return result ? ({ id: result.route.id, params: result.params } as RouteMatch) : null;
+}
+
+export interface DocumentPaths {
+	base: string;
+	assets: string;
+}
+
+export function documentPaths(pathname: string, source: ServerPaths): DocumentPaths {
+	if (!source.relative) return { base: source.base, assets: source.assets || source.base };
+	const depth = pathname.slice(source.base.length).split('/').slice(2).length;
+	const base = Array.from({ length: depth }, () => '..').join('/') || '.';
+	return {
+		base,
+		assets:
+			!source.assets || (source.assets.startsWith('/') && source.assets !== identity.assets)
+				? base
+				: source.assets
+	};
+}
+
+export function clientPath(file: string, paths: DocumentPaths): string {
+	return file.startsWith('/') ? paths.base + file : `${paths.assets}/${file}`;
+}