@vigla/kit 0.0.0-stage → 0.1.1

package/src/node/response.ts

@@ -0,0 +1,108 @@
+import type { ServerResponse } from 'node:http';
+import { setImmediate } from 'node:timers';
+import { drainRequest } from './request.ts';
+
+export function setResponse(response: ServerResponse, result: Response): void {
+	response.once('finish', () => drainRequest(response.req));
+	response.once('close', () => drainRequest(response.req));
+	try {
+		for (const [name, value] of result.headers)
+			response.setHeader(name, name === 'set-cookie' ? result.headers.getSetCookie() : value);
+	} catch (error) {
+		for (const name of response.getHeaderNames()) response.removeHeader(name);
+		response.writeHead(500).end(String(error));
+		return;
+	}
+	if (result.body === null) {
+		response.writeHead(result.status).end();
+		return;
+	}
+	if (result.body.locked) {
+		response
+			.writeHead(result.status)
+			.end(
+				"Fatal error: Response body is locked. This can happen when the response was already read (for example through 'response.json()' or 'response.text()')."
+			);
+		return;
+	}
+
+	const reader = result.body.getReader();
+	if (response.destroyed) {
+		void reader.cancel().catch(() => {});
+		return;
+	}
+	const queue: Uint8Array[] = [];
+	let pending: Promise<ReadableStreamReadResult<Uint8Array>> | undefined;
+	let stopped = false;
+	let complete = false;
+
+	const cancel = (reason?: Error): void => {
+		stopped = true;
+		response.off('close', cancel);
+		response.off('error', cancel);
+		response.off('drain', pump);
+		void reader.cancel(reason).catch(() => {});
+		if (reason) response.destroy(reason);
+	};
+	response.on('close', cancel);
+	response.on('error', cancel);
+
+	function fail(reason: unknown): void {
+		if (!response.headersSent) response.writeHead(result.status);
+		cancel(reason instanceof Error ? reason : new Error(String(reason)));
+	}
+
+	async function pump(): Promise<void> {
+		try {
+			while (!stopped && !response.destroyed) {
+				const chunk = queue.shift();
+				if (chunk !== undefined) {
+					if (!response.write(chunk)) {
+						response.once('drain', pump);
+						return;
+					}
+					continue;
+				}
+				if (complete) {
+					response.end();
+					return;
+				}
+				const next = await (pending ?? reader.read());
+				pending = undefined;
+				if (next.done) complete = true;
+				else queue.push(next.value);
+			}
+		} catch (error) {
+			fail(error);
+		}
+	}
+
+	async function probe(): Promise<void> {
+		try {
+			const deadline = new Promise<undefined>((resolve) => setImmediate(() => resolve(undefined)));
+			while (queue.length < 2) {
+				pending = reader.read();
+				const next = await Promise.race([pending, deadline]);
+				if (next === undefined) break;
+				pending = undefined;
+				if (next.done) {
+					complete = true;
+					if (!response.hasHeader('content-length') && !response.hasHeader('transfer-encoding')) {
+						response.setHeader(
+							'content-length',
+							queue.reduce((total, chunk) => total + chunk.byteLength, 0)
+						);
+					}
+					break;
+				}
+				queue.push(next.value);
+			}
+			if (stopped || response.destroyed) return;
+			response.writeHead(result.status);
+			await pump();
+		} catch (error) {
+			fail(error);
+		}
+	}
+	void probe();
+}

package/src/node/static.ts

@@ -0,0 +1,147 @@
+import { createReadStream, readdirSync, statSync } from 'node:fs';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import path from 'node:path';
+import { pipeline } from 'node:stream';
+import { lookup } from '../shared/mime.ts';
+
+export interface FileRepresentation {
+	file: string;
+	etag: string;
+	type?: string;
+	cacheControl?: string;
+	encoding?: string;
+	vary?: string;
+}
+
+export interface StaticInput {
+	directory: string;
+	pathname: string;
+	request: IncomingMessage;
+	response: ServerResponse;
+	representation?: FileRepresentation;
+}
+
+interface ByteRange {
+	start: number;
+	end: number;
+}
+
+function range(header: string, size: number): ByteRange | false | undefined {
+	const match = /^bytes=(\d*)-(\d*)$/.exec(header.trim());
+	if (!match || (!match[1] && !match[2])) return;
+	if (!match[1]) {
+		const length = Number(match[2]);
+		return length === 0 || size === 0
+			? false
+			: { start: Math.max(0, size - length), end: size - 1 };
+	}
+	const start = Number(match[1]);
+	const end = match[2] ? Number(match[2]) : size - 1;
+	if (match[2] && end < start) return;
+	if (start >= size) return false;
+	return { start, end: Math.min(end, size - 1) };
+}
+
+function tags(header: string): string[] {
+	const value = header.trim();
+	if (value === '*') return ['*'];
+	if (!/^(?:W\/)?"[^"]*"\s*(?:,\s*(?:W\/)?"[^"]*"\s*)*$/.test(value)) return [];
+	return value.match(/(?:W\/)?"[^"]*"/g) ?? [];
+}
+
+function exactCase(file: string, directory: string): boolean {
+	for (let current = file; current !== directory; current = path.dirname(current)) {
+		const parent = path.dirname(current);
+		if (parent === current || !readdirSync(parent).includes(path.basename(current))) return false;
+	}
+	return true;
+}
+
+export function serveFile({
+	directory,
+	pathname,
+	request,
+	response,
+	representation
+}: StaticInput): boolean {
+	if (request.method !== 'GET' && request.method !== 'HEAD') return false;
+	let decoded: string;
+	try {
+		decoded = representation ? '/' + representation.file : decodeURIComponent(pathname);
+	} catch {
+		return false;
+	}
+	if (!decoded.startsWith('/') || decoded.includes('\0')) return false;
+	directory = path.resolve(directory);
+	const file = path.resolve(directory, '.' + decoded);
+	const relative = path.relative(directory, file);
+	if (
+		!relative ||
+		relative === '..' ||
+		relative.startsWith('..' + path.sep) ||
+		path.isAbsolute(relative)
+	)
+		return false;
+	const stat = statSync(file, { throwIfNoEntry: false });
+	if (!stat?.isFile() || !exactCase(file, directory)) return false;
+	const etag = representation?.etag ?? `W/"${stat.size}-${stat.mtimeMs}"`;
+	const modified = Math.min(Math.floor(stat.mtimeMs / 1000), Math.floor(Date.now() / 1000));
+	const lastModified = new Date(modified * 1000).toUTCString();
+	response.setHeader('etag', etag);
+	response.setHeader('last-modified', lastModified);
+	response.setHeader('accept-ranges', 'bytes');
+	if (representation?.cacheControl)
+		response.setHeader('cache-control', representation.cacheControl);
+	else if (!representation && !response.hasHeader('cache-control'))
+		response.setHeader('cache-control', 'no-cache');
+	if (representation?.encoding) response.setHeader('content-encoding', representation.encoding);
+	if (representation?.vary) response.setHeader('vary', representation.vary);
+	const type = representation?.type ?? lookup(file);
+	if (type && !response.hasHeader('content-type'))
+		response.setHeader('content-type', type === 'text/html' ? type + ';charset=utf-8' : type);
+	const match = request.headers['if-match'];
+	const unmodified = request.headers['if-unmodified-since'];
+	if (
+		(match !== undefined &&
+			!tags(match).some((tag) => tag === '*' || (!tag.startsWith('W/') && tag === etag))) ||
+		(match === undefined && unmodified !== undefined && modified > Date.parse(unmodified) / 1000)
+	) {
+		response.writeHead(412);
+		response.end();
+		return true;
+	}
+	const none = request.headers['if-none-match'];
+	const since = request.headers['if-modified-since'];
+	const unchanged =
+		none !== undefined
+			? tags(none).some(
+					(tag) => tag === '*' || tag.replace(/^W\//, '') === etag.replace(/^W\//, '')
+				)
+			: since !== undefined && modified <= Date.parse(since) / 1000;
+	if (unchanged) {
+		response.writeHead(304);
+		response.end();
+		return true;
+	}
+	const ifRange = request.headers['if-range'];
+	const canRange =
+		ifRange === undefined ||
+		(!etag.startsWith('W/') && ifRange === etag) ||
+		(ifRange === lastModified && modified <= Math.floor(Date.now() / 1000) - 60);
+	const selected =
+		request.method === 'GET' && canRange && request.headers.range
+			? range(request.headers.range, stat.size)
+			: undefined;
+	if (selected === false) {
+		response.writeHead(416, { 'content-range': `bytes */${stat.size}`, 'content-length': 0 });
+		response.end();
+		return true;
+	}
+	if (selected)
+		response.setHeader('content-range', `bytes ${selected.start}-${selected.end}/${stat.size}`);
+	response.setHeader('content-length', selected ? selected.end - selected.start + 1 : stat.size);
+	response.writeHead(selected ? 206 : 200);
+	if (request.method === 'HEAD') response.end();
+	else pipeline(createReadStream(file, selected), response, () => {});
+	return true;
+}

package/src/server/actions.ts

@@ -0,0 +1,139 @@
+import type { ServerNode, RequestStore } from '../types/internal/server.ts';
+import { isForm, negotiate } from '../shared/http.ts';
+import { serialize } from '../shared/serialization.ts';
+import { ActionFailure, HttpError, Redirect } from '../shared/outcomes.ts';
+import type { Server } from './index.ts';
+import { FrameworkError, handleError } from './failure.ts';
+import { runRequest } from './scope.ts';
+import { versionHeader } from './headers.ts';
+import * as errors from './errors.ts';
+import { handleFormPost } from './remote/handler.ts';
+import { identity } from '../shared/identity.ts';
+
+export type ActionResult =
+	| { type: 'success' | 'failure'; status: number; location: string; data: unknown }
+	| { type: 'redirect'; status: number; location: string }
+	| { type: 'error'; location: string; error: unknown };
+
+export function actionLocation(url: URL): string {
+	const location = new URL(url);
+	for (const key of location.searchParams.keys())
+		if (key.startsWith('/')) {
+			location.searchParams.delete(key);
+			break;
+		}
+	return (
+		(location.pathname.startsWith('//') ? `/.${location.pathname}` : location.pathname) +
+		location.search
+	);
+}
+
+export function wantsActionJson(request: Request): boolean {
+	return (
+		request.method === 'POST' &&
+		negotiate(request.headers.get('accept') ?? '*/*', ['application/json', 'text/html']) ===
+			'application/json'
+	);
+}
+
+export async function runAction(
+	server: Server,
+	store: RequestStore,
+	node?: ServerNode
+): Promise<ActionResult> {
+	const { event } = store;
+	const location = actionLocation(event.url);
+	const remote = event.url.searchParams.get('/remote');
+	if (remote) return handleFormPost(store, remote);
+	if (!node?.actions) {
+		event.setHeaders({ allow: 'GET' });
+		return { type: 'error', location, error: new FrameworkError(405, 'Method Not Allowed') };
+	}
+	const actions = node.actions;
+	if (actions.default && Object.keys(actions).length > 1) errors.action_default_with_named();
+	try {
+		const selected = [...new URL(event.request.url).searchParams.keys()].find((key) =>
+			key.startsWith('/')
+		);
+		const name = selected ? selected.slice(1) : 'default';
+		if (selected && name === 'default') errors.action_name_reserved();
+		if (!Object.hasOwn(actions, name))
+			throw new FrameworkError(404, 'Not Found', `No action with name '${name}' found`);
+		if (!isForm(event.request))
+			throw new FrameworkError(
+				415,
+				'Unsupported Media Type',
+				`Form actions expect form-encoded data — received ${event.request.headers.get('content-type')}`
+			);
+		const data = await server.tracer.span(
+			`${identity.name}.form_action`,
+			{ [`${identity.name}.form_action.name`]: name, 'http.route': event.route.id ?? 'unknown' },
+			async (span) => {
+				const traced = { ...event, tracing: { ...event.tracing, current: span } };
+				return runRequest({ ...store, event: traced }, () => actions[name]!(traced));
+			}
+		);
+		if (data instanceof Redirect) errors.action_return_redirect();
+		if (data instanceof HttpError) errors.action_return_error();
+		if (data instanceof ActionFailure)
+			return { type: 'failure', status: data.status, location, data: data.data };
+		return { type: 'success', status: 200, location, data };
+	} catch (error) {
+		if (error instanceof Redirect)
+			return { type: 'redirect', status: error.status, location: error.location };
+		if (error instanceof ActionFailure) {
+			try {
+				errors.action_throw_fail();
+			} catch (failure) {
+				error = failure;
+			}
+		}
+		return { type: 'error', error, location };
+	}
+}
+
+export function serializeAction(data: unknown, server: Server, id: string): string {
+	try {
+		return serialize(data, server.hooks.transport);
+	} catch (error) {
+		if (data instanceof Response) errors.action_response_not_serializable({ id });
+		if (error instanceof Error && 'path' in error)
+			errors.action_data_not_serializable({
+				id,
+				message: error.message,
+				path: error.path ? `data${error.path}` : ''
+			});
+		throw error;
+	}
+}
+
+export async function actionResponse(
+	server: Server,
+	store: RequestStore,
+	result: ActionResult
+): Promise<Response> {
+	let payload: unknown;
+	let status = 200;
+	if (result.type === 'error') {
+		const error = await handleError(store, result.error);
+		payload = { ...result, error };
+		status = error.status;
+	} else if (result.type === 'redirect') payload = result;
+	else if (result.type === 'success' && !result.data)
+		payload = { ...result, status: 204, data: undefined };
+	else {
+		try {
+			payload = {
+				...result,
+				data: serializeAction(result.data, server, store.event.route.id ?? '')
+			};
+			status = result.status;
+		} catch (error) {
+			return actionResponse(server, store, { type: 'error', error, location: result.location });
+		}
+	}
+	return Response.json(payload, {
+		status,
+		headers: versionHeader(server.options)
+	});
+}

package/src/server/cookies.ts

@@ -0,0 +1,192 @@
+import { parseCookie, parseSetCookie, stringifySetCookie } from 'cookie';
+import type { ParseOptions, SerializeOptions } from 'cookie';
+import type { Cookies } from '../types/request.ts';
+import type { TrailingSlash } from '../types/internal/data.ts';
+import { addDataSuffix } from '../shared/pathname.ts';
+import * as errors from './errors.ts';
+import * as warnings from './warnings.ts';
+
+interface Cookie {
+	name: string;
+	value: string;
+	options: SerializeOptions & { path: string };
+}
+
+export class CookieJar {
+	readonly cookies: Cookies;
+	readonly #url: URL;
+	readonly #header: string;
+	readonly #raw: Record<string, string | undefined>;
+	readonly #changes = new Map<string, Cookie>();
+	readonly #queue: Array<() => void> = [];
+	readonly #defaults: SerializeOptions;
+	readonly #paths?: Map<string, Set<string>>;
+	readonly #dev: boolean;
+	#parsed?: Record<string, string | undefined>;
+	#normalized: string | null = null;
+	#sealed = false;
+
+	constructor(request: Request, url: URL, dev: boolean, paths?: Map<string, Set<string>>) {
+		this.#url = url;
+		this.#header = request.headers.get('cookie') ?? '';
+		this.#raw = parseCookie(this.#header, { decode: (value) => value });
+		this.#dev = dev;
+		this.#paths = paths;
+		this.#defaults = {
+			path: '/',
+			httpOnly: true,
+			sameSite: 'lax',
+			secure: !dev && !(url.hostname === 'localhost' && url.protocol === 'http:')
+		};
+		this.cookies = {
+			get: (name, options) => {
+				const current = this.#best(name);
+				if (current) return current.options.maxAge === 0 ? undefined : current.value;
+				const value = this.#parse(options)[name];
+				if (dev && value === undefined) {
+					const paths = [...(this.#paths?.get(name) ?? [])].filter(
+						(path) => path !== url.pathname && pathMatches(path, url.pathname)
+					);
+					if (paths.length)
+						warnings.cookie_path_mismatch({
+							name,
+							pathname: url.pathname,
+							paths: paths.join(' and ')
+						});
+				}
+				return value;
+			},
+			getAll: (options) => {
+				const values = { ...this.#parse(options) };
+				for (const name of new Set([...this.#changes.values()].map((cookie) => cookie.name))) {
+					const cookie = this.#best(name);
+					if (cookie) values[name] = cookie.options.maxAge === 0 ? undefined : cookie.value;
+				}
+				return Object.entries(values).flatMap(([name, value]) =>
+					value === undefined ? [] : [{ name, value }]
+				);
+			},
+			set: (name, value, options) => this.set(name, value, { ...this.#defaults, ...options }),
+			delete: (name, options) => this.set(name, '', { ...this.#defaults, ...options, maxAge: 0 }),
+			parse: parseSetCookie,
+			serialize: (name, value, options = {}) => {
+				const path = this.#path(options.path ?? '/', options.domain, true);
+				const { encode, ...attributes } = { ...this.#defaults, ...options, path };
+				return stringifySetCookie({ name, value, ...attributes }, { encode });
+			}
+		};
+	}
+
+	#parse(options?: ParseOptions): Record<string, string | undefined> {
+		if (options?.decode) return parseCookie(this.#header, options);
+		return (this.#parsed ??= parseCookie(this.#header));
+	}
+
+	#best(name: string): Cookie | undefined {
+		let chosen: Cookie | undefined;
+		for (const cookie of this.#changes.values()) {
+			if (
+				cookie.name === name &&
+				domainMatches(this.#url.hostname, cookie.options.domain) &&
+				pathMatches(this.#url.pathname, cookie.options.path) &&
+				(!chosen || cookie.options.path.length > chosen.options.path.length)
+			)
+				chosen = cookie;
+		}
+		return chosen;
+	}
+
+	#path(path: string, domain?: string, serialize = false): string {
+		if (domain && domain !== this.#url.hostname) return path;
+		if (this.#normalized === null) {
+			if (serialize) errors.cookies_serialize_before_route();
+			throw new Error('Cookie path resolved before routing');
+		}
+		return new URL(path, new URL(this.#normalized, this.#url.origin)).pathname;
+	}
+
+	set(name: string, value: string, options: SerializeOptions): void {
+		if (this.#sealed) errors.cookies_set_after_response();
+		if (this.#normalized === null) {
+			this.#queue.push(() => this.set(name, value, options));
+			return;
+		}
+		const path = this.#path(options.path ?? '/', options.domain);
+		if (this.#dev) {
+			const encoder = new TextEncoder();
+			if (
+				encoder.encode(name).byteLength +
+					encoder.encode((options.encode ?? encodeURIComponent)(value)).byteLength >
+				4096
+			)
+				errors.cookie_too_large({ name });
+			if (this.#paths) {
+				const paths = this.#paths.get(name) ?? new Set<string>();
+				if (value) paths.add(path);
+				else paths.delete(path);
+				this.#paths.set(name, paths);
+			}
+		}
+		this.#changes.set(`${options.domain ?? ''}${path}?${encodeURIComponent(name)}`, {
+			name,
+			value,
+			options: { ...options, path }
+		});
+	}
+
+	route(slash: TrailingSlash): void {
+		const path = this.#url.pathname;
+		this.#normalized =
+			slash === 'always' && !path.endsWith('/')
+				? `${path}/`
+				: slash === 'never' && path !== '/'
+					? path.replace(/\/$/, '')
+					: path;
+		for (const apply of this.#queue.splice(0)) apply();
+	}
+
+	header(destination: URL, explicit: string | null): string {
+		const values = { ...this.#raw };
+		for (const { name, value, options } of this.#changes.values()) {
+			if (
+				domainMatches(destination.hostname, options.domain) &&
+				pathMatches(destination.pathname, options.path)
+			)
+				values[name] = (options.encode ?? encodeURIComponent)(value);
+		}
+		if (explicit) Object.assign(values, parseCookie(explicit, { decode: (value) => value }));
+		return Object.entries(values)
+			.map(([name, value]) => `${name}=${value}`)
+			.join('; ');
+	}
+
+	apply(headers: Headers): void {
+		for (const { name, value, options } of this.#changes.values()) {
+			const { encode, ...attributes } = options;
+			headers.append('set-cookie', stringifySetCookie({ name, value, ...attributes }, { encode }));
+			if (options.path.endsWith('.html'))
+				headers.append(
+					'set-cookie',
+					stringifySetCookie(
+						{ name, value, ...attributes, path: addDataSuffix(options.path) },
+						{ encode }
+					)
+				);
+		}
+	}
+
+	seal(): void {
+		this.#sealed = true;
+	}
+}
+
+function domainMatches(host: string, domain?: string): boolean {
+	const constraint = domain?.replace(/^\./, '');
+	return !constraint || host === constraint || host.endsWith(`.${constraint}`);
+}
+
+function pathMatches(path: string, constraint?: string): boolean {
+	if (!constraint) return true;
+	const root = constraint.replace(/\/$/, '');
+	return path === root || path.startsWith(`${root}/`);
+}