@vigla/kit 0.0.0-stage → 0.1.0

package/src/server/state.ts

@@ -0,0 +1,56 @@
+import { getContext, getOwner } from 'vigla';
+import type { Page, Updated } from '../types/state.ts';
+import type { ParamValue } from '../types/params.ts';
+import { state_read_outside_render, server_api_unavailable } from './errors.ts';
+
+export const stateKey = Symbol('page state');
+
+export function renderedPage(): Page<Record<string, ParamValue>> {
+	return (
+		(getOwner() ? getContext<Page<Record<string, ParamValue>> | undefined>(stateKey) : undefined) ??
+		state_read_outside_render({ name: 'page' })
+	);
+}
+
+export const page: Page<Record<string, ParamValue>> = {
+	get url() {
+		return renderedPage().url;
+	},
+	get params() {
+		return renderedPage().params;
+	},
+	get route() {
+		return renderedPage().route;
+	},
+	get status() {
+		return renderedPage().status;
+	},
+	get error() {
+		return renderedPage().error;
+	},
+	get data() {
+		return renderedPage().data;
+	},
+	get state() {
+		return renderedPage().state;
+	},
+	get shallow() {
+		return renderedPage().shallow;
+	},
+	get form() {
+		return renderedPage().form;
+	}
+};
+
+export const navigating = {
+	from: null,
+	to: null,
+	type: null,
+	willUnload: null,
+	delta: null,
+	complete: null
+};
+export const updated: Updated = {
+	current: false,
+	check: () => server_api_unavailable({ name: 'updated.check()' })
+};

package/src/server/stream.ts

@@ -0,0 +1,87 @@
+export class Chunks<T> {
+	#pending = 0;
+	#values: T[] = [];
+	#failure: unknown;
+	#hasFailure = false;
+	#wake: (() => void) | null = null;
+	#closed = false;
+	readonly #signal?: AbortSignal;
+
+	constructor(signal?: AbortSignal) {
+		this.#signal = signal;
+		signal?.addEventListener('abort', this.close, { once: true });
+		if (signal?.aborted) this.close();
+	}
+
+	close = (): void => {
+		this.#closed = true;
+		this.#values.length = 0;
+		this.#signal?.removeEventListener('abort', this.close);
+		this.#wake?.();
+		this.#wake = null;
+	};
+
+	add(promise: Promise<T>): void {
+		if (this.#closed) {
+			promise.catch(() => {});
+			return;
+		}
+		this.#pending++;
+		promise
+			.then(
+				(value) => {
+					if (!this.#closed) this.#values.push(value);
+				},
+				(error) => {
+					if (!this.#closed) {
+						this.#hasFailure = true;
+						this.#failure = error;
+					}
+				}
+			)
+			.finally(() => {
+				this.#pending--;
+				this.#wake?.();
+			});
+	}
+
+	async *[Symbol.asyncIterator](): AsyncGenerator<T> {
+		try {
+			while (!this.#closed) {
+				while (this.#values.length) yield this.#values.shift()!;
+				if (this.#hasFailure) throw this.#failure;
+				if (!this.#pending) return;
+				await new Promise<void>((resolve) => {
+					this.#wake = resolve;
+				});
+			}
+		} finally {
+			this.close();
+		}
+	}
+}
+
+export function streamText(
+	first: string,
+	chunks?: AsyncIterable<string> | null
+): ReadableStream<Uint8Array> {
+	const encoder = new TextEncoder();
+	const iterator = (async function* () {
+		yield first;
+		if (chunks) yield* chunks;
+	})()[Symbol.asyncIterator]();
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const next = await iterator.next();
+				if (next.done) controller.close();
+				else controller.enqueue(encoder.encode(next.value));
+			} catch (error) {
+				controller.error(error);
+			}
+		},
+		async cancel() {
+			await iterator.return?.();
+		}
+	});
+}

package/src/server/telemetry.ts

@@ -0,0 +1,107 @@
+import type { Attributes, Span, SpanContext } from '@opentelemetry/api';
+import { HttpError, Redirect } from '../shared/outcomes.ts';
+import type { SpanRecorder } from '../types/internal/server.ts';
+import * as errors from './errors.ts';
+import { identity } from '../shared/identity.ts';
+
+const emptyContext: SpanContext = {
+	traceId: '00000000000000000000000000000000',
+	spanId: '0000000000000000',
+	traceFlags: 0
+};
+export const noopSpan: Span = {
+	spanContext: () => emptyContext,
+	setAttribute() {
+		return this;
+	},
+	setAttributes() {
+		return this;
+	},
+	addEvent() {
+		return this;
+	},
+	addLink() {
+		return this;
+	},
+	addLinks() {
+		return this;
+	},
+	setStatus() {
+		return this;
+	},
+	updateName() {
+		return this;
+	},
+	end() {},
+	isRecording: () => false,
+	recordException() {}
+};
+
+type Api = typeof import('@opentelemetry/api');
+
+export class Tracer implements SpanRecorder {
+	#api: Api | null = null;
+
+	async init(enabled: boolean): Promise<void> {
+		if (!enabled) return;
+		try {
+			this.#api = await import('@opentelemetry/api');
+		} catch {
+			errors.tracing_api_missing();
+		}
+	}
+
+	current(): Span {
+		return this.#api?.trace.getSpan(this.#api.context.active()) ?? noopSpan;
+	}
+
+	request<T>(request: Request, fn: () => Promise<T>): Promise<T> {
+		const api = this.#api;
+		if (!api) return fn();
+		const context = api.propagation.extract(api.context.active(), request.headers, {
+			get: (headers, key) => headers.get(key) ?? undefined,
+			keys: (headers) => [...headers.keys()]
+		});
+		return api.context.with(context, fn);
+	}
+
+	async span<T>(name: string, attributes: Attributes, fn: (span: Span) => Promise<T>): Promise<T> {
+		const api = this.#api;
+		if (!api) return fn(noopSpan);
+		return api.trace
+			.getTracer(identity.name)
+			.startActiveSpan(name, { attributes }, async (span) => {
+				try {
+					return await fn(span);
+				} catch (error) {
+					if (error instanceof Redirect)
+						span.setAttributes({
+							[`${name}.result.type`]: 'redirect',
+							[`${name}.result.status`]: error.status,
+							[`${name}.result.location`]: error.location
+						});
+					else if (error instanceof HttpError) {
+						span.setAttributes({
+							[`${name}.result.type`]: 'known_error',
+							[`${name}.result.status`]: error.status,
+							[`${name}.result.message`]: error.body.message
+						});
+						if (error.status >= 500) {
+							span.recordException({ name: 'HttpError', message: error.body.message });
+							span.setStatus({ code: api.SpanStatusCode.ERROR, message: error.body.message });
+						}
+					} else {
+						span.setAttribute(`${name}.result.type`, 'unknown_error');
+						if (error instanceof Error) span.recordException(error);
+						span.setStatus({
+							code: api.SpanStatusCode.ERROR,
+							...(error instanceof Error ? { message: error.message } : {})
+						});
+					}
+					throw error;
+				} finally {
+					span.end();
+				}
+			});
+	}
+}

package/src/server/transport.ts

@@ -0,0 +1,14 @@
+import type { Transport } from '../types/hooks.ts';
+
+const unset = Symbol();
+let only: Transport | undefined | typeof unset = unset;
+let shared = false;
+
+export function configureTransport(transport: Transport | undefined): void {
+	if (only === unset) only = transport;
+	else if (only !== transport) shared = true;
+}
+
+export function appTransport(): Transport | undefined {
+	return shared || only === unset ? undefined : only;
+}

package/src/server/url.ts

@@ -0,0 +1,34 @@
+import type { RequestState } from '../types/internal/server.ts';
+import { url_search_unavailable_prerender } from './errors.ts';
+
+function descriptorOf(url: URL, property: string): PropertyDescriptor {
+	for (let object: object | null = url; object; object = Object.getPrototypeOf(object)) {
+		const descriptor = Object.getOwnPropertyDescriptor(object, property);
+		if (descriptor) return descriptor;
+	}
+	throw new TypeError(`URL has no ${property} property`);
+}
+
+export function restrictSearch(url: URL, state: RequestState, staticLoad = false): void {
+	const forbidden = (): boolean =>
+		!state.prerendering?.insideReroute &&
+		!state.prerendering?.fallback &&
+		(!!state.prerendering || (staticLoad && state.prerenderDefault === true));
+	for (const property of ['search', 'searchParams'] as const) {
+		const descriptor = descriptorOf(url, property);
+		Object.defineProperty(url, property, {
+			configurable: true,
+			enumerable: descriptor.enumerable,
+			get() {
+				if (forbidden()) url_search_unavailable_prerender({ property });
+				return 'value' in descriptor ? descriptor.value : descriptor.get!.call(url);
+			},
+			set: descriptor.set
+				? (value) => {
+						if (forbidden()) url_search_unavailable_prerender({ property });
+						descriptor.set!.call(url, value);
+					}
+				: undefined
+		});
+	}
+}

package/src/server/warnings.ts

@@ -0,0 +1,87 @@
+import { runtime, warnDiagnostic } from '../shared/diagnostics.ts';
+import { identity } from '../shared/identity.ts';
+
+export function cookie_path_mismatch({
+	name,
+	pathname,
+	paths
+}: {
+	name: string;
+	pathname: string;
+	paths: string;
+}): void {
+	warnDiagnostic(
+		'cookie_path_mismatch',
+		`\`${name}\` cookie does not exist for \`${pathname}\`, but was previously set at ${paths}. Did you mean to set its \`path\` to \`'/'\` instead?`
+	);
+}
+export function cache_control_empty_directive({ value }: { value: string }): void {
+	warnDiagnostic(
+		'cache_control_empty_directive',
+		`\`cache-control\` header contains empty directives. (While parsing \`${value}\`.)`
+	);
+}
+export function cache_control_invalid_directive({
+	directive,
+	directives,
+	value
+}: {
+	directive: string;
+	directives: string;
+	value: string;
+}): void {
+	warnDiagnostic(
+		'cache_control_invalid_directive',
+		`Invalid \`cache-control\` directive \`${directive}\`. Did you mean one of: ${directives}? (While parsing \`${value}\`.)`
+	);
+}
+export function content_type_invalid({ type, value }: { type: string; value: string }): void {
+	warnDiagnostic(
+		'content_type_invalid',
+		`Invalid \`content-type\` value \`${type}\`. (While parsing \`${value}\`.)`
+	);
+}
+export function load_tracking_after_return({
+	id,
+	usage,
+	change
+}: {
+	id: string;
+	usage: string;
+	change: string;
+}): void {
+	warnDiagnostic(
+		'load_tracking_after_return',
+		`\`${id}\`: ${usage} in a promise handler after \`load(...)\` has returned will not cause the function to re-run when ${change}`
+	);
+}
+export function form_action_error_without_ssr(extension: string): void {
+	warnDiagnostic(
+		'form_action_error_without_ssr',
+		`The form action returned an error, but \`+error${extension}\` wasn't rendered because SSR is off. To get the error page with CSR, enhance your form with \`use:enhance\`.${runtime.docs('enhance')}`
+	);
+}
+export function form_action_data_without_ssr(): void {
+	warnDiagnostic(
+		'form_action_data_without_ssr',
+		`The form action returned a value, but it isn't available in \`page.form\`, because SSR is off. To handle the returned value in CSR, enhance your form with \`use:enhance\`.${runtime.docs('enhance')}`
+	);
+}
+export function transform_page_chunk_comments(): void {
+	warnDiagnostic(
+		'transform_page_chunk_comments',
+		`Removing comments in \`transformPageChunk\` can break ${identity.framework ? `${identity.framework}'s ` : ''}hydration`
+	);
+}
+export function ssr_fetch_eager(): void {
+	warnDiagnostic(
+		'ssr_fetch_eager',
+		'Avoid calling `fetch` eagerly during server-side rendering — put your `fetch` calls inside `onMount` or a `load` function instead'
+	);
+}
+export function streaming_without_csr(): void {
+	warnDiagnostic(
+		'streaming_without_csr',
+		'Returning promises from server `load` functions will only work if `csr === true`'
+	);
+}

package/src/shared/diagnostics.ts

@@ -0,0 +1,62 @@
+import type { Identity, Links } from '../types/identity.ts';
+import { identity } from './identity.ts';
+
+export let verbose = false;
+
+export function enableVerboseErrors(): void {
+	verbose = true;
+}
+
+export interface Diagnostics {
+	readonly identity: Identity;
+	link(code: string): string;
+	docs(link: keyof Links, wrap?: (url: string) => string): string;
+	text(code: string, text: string): string;
+	raise(code: string, text: string, caller: Function): never;
+	raiseCode(code: string): never;
+	warn(code: string, text: string): void;
+	warnCode(code: string): void;
+}
+
+export function diagnostics(identity: Identity): Diagnostics {
+	const link = (code: string) => (identity.diagnostics ? identity.diagnostics + code : code);
+	const trailer = (code: string) => (identity.diagnostics ? `\n${link(code)}` : '');
+	const text = (code: string, text: string) => `${code}\n${text}${trailer(code)}`;
+	return {
+		identity,
+		link,
+		docs(name, wrap = (url) => ` See ${url}`) {
+			const url = identity.links?.[name];
+			return url ? wrap(url) : '';
+		},
+		text,
+		raise(code, message, caller) {
+			const error = new Error(text(code, message));
+			error.name = `${identity.product} error`;
+			Error.captureStackTrace?.(error, caller);
+			throw error;
+		},
+		raiseCode(code) {
+			throw new Error(link(code));
+		},
+		warn(code, message) {
+			console.warn(
+				`%c[${identity.name}] ${code}\n%c${message}${trailer(code)}`,
+				'font-weight: bold',
+				'font-weight: normal'
+			);
+		},
+		warnCode(code) {
+			console.warn(link(code));
+		}
+	};
+}
+
+export const runtime: Diagnostics = diagnostics(identity);
+
+export const diagnosticText: Diagnostics['text'] = runtime.text;
+export const throwDiagnostic: Diagnostics['raise'] = runtime.raise;
+export const throwCode: Diagnostics['raiseCode'] = runtime.raiseCode;
+export const warnDiagnostic: Diagnostics['warn'] = runtime.warn;
+export const warnCode: Diagnostics['warnCode'] = runtime.warnCode;
+export const documentationLink: Diagnostics['docs'] = runtime.docs;

package/src/shared/env.ts

@@ -0,0 +1,58 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { EnvVarConfig } from '../types/env.ts';
+import { runtime, type Diagnostics } from './diagnostics.ts';
+
+export type EnvironmentIssues = Record<string, StandardSchemaV1.Issue[]>;
+export type EnvironmentVariables = Record<string, EnvVarConfig<any> | undefined>;
+
+export const MISSING: StandardSchemaV1.Issue = {
+	message: 'Value is missing. If it is optional, add a validator declaring it as such.'
+};
+export const BAD_VALIDATOR: StandardSchemaV1.Issue = {
+	message: 'Variable was configured with a validator that does not implement Standard Schema'
+};
+export const ASYNC_VALIDATOR: StandardSchemaV1.Issue = {
+	message: 'Variable uses an async validator, which is not supported'
+};
+
+export function validate(
+	variables: EnvironmentVariables,
+	value: string | undefined,
+	name: string,
+	issues: EnvironmentIssues
+): any {
+	const schema = variables[name]?.schema;
+	if (!schema) {
+		if (value === undefined) issues[name] = [MISSING];
+		return value;
+	}
+	if (!('~standard' in schema)) {
+		issues[name] = [BAD_VALIDATOR];
+		return undefined;
+	}
+	const result = schema['~standard'].validate(value);
+	if (result instanceof Promise) {
+		result.catch(() => {});
+		issues[name] = [ASYNC_VALIDATOR];
+		return undefined;
+	}
+	if (result.issues) {
+		issues[name] = [...result.issues];
+		return undefined;
+	}
+	return result.value;
+}
+
+export function handleIssues(issues: EnvironmentIssues, d: Diagnostics = runtime): void {
+	const entries = Object.entries(issues);
+	if (!entries.length) return;
+	const list = entries
+		.map(([name, found]) => `${name}\n${found.map((issue) => `  - ${issue.message}`).join('\n')}`)
+		.join('\n\n');
+	try {
+		d.raise('env_invalid', `Invalid environment variables:\n\n${list}\n`, handleIssues);
+	} catch (error) {
+		if (error instanceof Error) error.stack = `${error.name}: ${error.message}`;
+		throw error;
+	}
+}