@vigla/kit 0.0.0-stage → 0.1.1

package/src/server/remote/shared.ts

@@ -0,0 +1,117 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { RemoteImplementation, RemoteValidator } from '../../types/internal/remote.ts';
+import type { RequestStore } from '../../types/internal/server.ts';
+import type { MaybePromise } from '../../types/value.ts';
+import { HttpError, ValidationError } from '../../shared/outcomes.ts';
+import { runRequest } from '../scope.ts';
+import * as errors from './errors.ts';
+
+export interface Execution {
+	query?: boolean;
+	prerender?: boolean;
+	mutation?: boolean;
+}
+
+export function createValidator(
+	validation: any,
+	implementation?: RemoteImplementation
+): RemoteValidator {
+	if (!implementation)
+		return (arg) => {
+			if (arg !== undefined) throw new HttpError({ status: 400, message: 'Bad Request' });
+		};
+	if (validation === 'unchecked') return (arg) => arg;
+	if (!validation || !('~standard' in validation)) return errors.invalidValidator();
+	const schema = validation as StandardSchemaV1;
+	const result = (validated: StandardSchemaV1.Result<unknown>): unknown => {
+		if (validated.issues) throw new ValidationError(validated.issues as StandardSchemaV1.Issue[]);
+		return validated.value;
+	};
+	return (input) => {
+		const validated = schema['~standard'].validate(input);
+		return thenable(validated) ? Promise.resolve(validated).then(result) : result(validated);
+	};
+}
+
+export function thenable(value: unknown): value is PromiseLike<any> {
+	return (
+		value !== null && (typeof value === 'object' || typeof value === 'function') && 'then' in value
+	);
+}
+
+export function remoteStore(
+	store: RequestStore,
+	execution: Execution,
+	allowCookies: boolean
+): RequestStore {
+	const original = store.event;
+	const event = {
+		...original,
+		setHeaders: () => errors.headersForbidden(),
+		cookies: {
+			...original.cookies,
+			set: ((name, value, options) => {
+				if (!allowCookies) errors.cookieForbidden('set');
+				if (options?.path && !options.path.startsWith('/')) errors.cookiePath('set');
+				return original.cookies.set(name, value, options);
+			}) as typeof original.cookies.set,
+			delete: ((name, options) => {
+				if (!allowCookies) errors.cookieForbidden('delete');
+				if (options?.path && !options.path.startsWith('/')) errors.cookiePath('deleted');
+				return original.cookies.delete(name, options);
+			}) as typeof original.cookies.delete
+		}
+	};
+	const remote = { ...store.remote, ...execution };
+	if (remote.query)
+		for (const property of ['url', 'params', 'route']) {
+			Object.defineProperty(event, property, {
+				get: () => errors.requestProperty(property),
+				enumerable: false
+			});
+		}
+	return { ...store, event, remote };
+}
+
+export async function execute<T>(
+	store: RequestStore,
+	execution: Execution,
+	allowCookies: boolean,
+	input: () => MaybePromise<any>,
+	implementation: (arg: any) => MaybePromise<T>
+): Promise<T> {
+	const derived = remoteStore(store, execution, allowCookies);
+	const value = await runRequest(derived, input);
+	return runRequest(derived, () => implementation(value));
+}
+
+export async function* generate(
+	store: RequestStore,
+	input: () => MaybePromise<any>,
+	implementation: RemoteImplementation,
+	name: string
+): AsyncGenerator<any> {
+	const derived = remoteStore(store, { query: true }, false);
+	const arg = await runRequest(derived, input);
+	const source = await runRequest(derived, () => implementation(arg));
+	const iterator: Iterator<any> | AsyncIterator<any> =
+		source && typeof source.next === 'function'
+			? source
+			: (source?.[Symbol.asyncIterator]?.() ??
+				source?.[Symbol.iterator]?.() ??
+				errors.liveInvalid(name));
+	let done = false;
+	try {
+		while (true) {
+			const step = { ...derived, remote: { ...derived.remote, cache: new Map() } };
+			const result = await runRequest(step, () => iterator.next());
+			if (result.done) {
+				done = true;
+				return;
+			}
+			yield result.value;
+		}
+	} finally {
+		if (!done) await runRequest(derived, () => iterator.return?.());
+	}
+}

package/src/server/remote/stream.ts

@@ -0,0 +1,81 @@
+import { root } from 'vigla';
+import type { RemoteLiveInternals, RemoteLiveResponse } from '../../types/internal/remote.ts';
+import type { RequestStore } from '../../types/internal/server.ts';
+import { Redirect } from '../../shared/outcomes.ts';
+import { serialize } from '../../shared/serialization.ts';
+import { handleError } from '../failure.ts';
+
+export function liveResponse(
+	store: RequestStore,
+	internals: RemoteLiveInternals,
+	arg: unknown
+): Response {
+	const cancellation = new AbortController();
+	const signal = AbortSignal.any([store.event.request.signal, cancellation.signal]);
+	const event = { ...store.event, request: new Request(store.event.request, { signal }) };
+	const generator = internals.run({ ...store, event }, arg);
+	const encoder = new TextEncoder();
+	let controller: ReadableStreamDefaultController<Uint8Array>;
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	let open = true;
+	let previous: string | undefined;
+	const close = (cancelled: boolean): void => {
+		if (!open) return;
+		open = false;
+		clearTimeout(timer);
+		store.event.request.signal.removeEventListener('abort', abort);
+		cancellation.abort();
+		if (!cancelled) controller.close();
+		void generator.return(undefined).catch(() => {});
+	};
+	const abort = () => close(true);
+	const keepAlive = (): void => {
+		clearTimeout(timer);
+		timer = setTimeout(() => {
+			if (!open) return;
+			if ((controller.desiredSize ?? 0) > 0) controller.enqueue(encoder.encode(': keep-alive\n\n'));
+			keepAlive();
+		}, 30_000);
+	};
+	const send = (value: RemoteLiveResponse): void => {
+		if (!open) return;
+		controller.enqueue(encoder.encode(`data: ${JSON.stringify(value)}\n\n`));
+		keepAlive();
+	};
+	store.event.request.signal.addEventListener('abort', abort, { once: true });
+	root(() => () => close(true), store.owner);
+	const body = new ReadableStream<Uint8Array>({
+		start(output) {
+			controller = output;
+			keepAlive();
+		},
+		async pull() {
+			try {
+				while (open) {
+					const next = await generator.next();
+					if (!open) return;
+					if (next.done) {
+						close(false);
+						return;
+					}
+					const result = serialize(next.value, store.hooks.transport);
+					if (result === previous) continue;
+					previous = result;
+					send({ type: 'result', result });
+					return;
+				}
+			} catch (error) {
+				if (!open) return;
+				if (error instanceof Redirect) send({ type: 'redirect', location: error.location });
+				else send({ type: 'error', error: await handleError(store, error) });
+				close(false);
+			}
+		},
+		cancel() {
+			close(true);
+		}
+	});
+	return new Response(body, {
+		headers: { 'cache-control': 'private, no-store', 'content-type': 'text/event-stream' }
+	});
+}

package/src/server/replay.ts

@@ -0,0 +1,174 @@
+import type { Fetched, RequestStore } from '../types/internal/server.ts';
+import { base64, hashRequest } from '../shared/hash.ts';
+import { escapeHtml, escapeJson } from '../shared/escape.ts';
+import * as errors from './errors.ts';
+import { identity } from '../shared/identity.ts';
+
+export function replayFetch(store: RequestStore, csr: boolean): typeof fetch {
+	const execute: typeof fetch = async (input, init) => {
+		const { event, state } = store;
+		const url = new URL(input instanceof Request ? input.url : input, event.url);
+		const requestHeaders =
+			input instanceof Request
+				? [...input.headers].length
+					? new Headers(input.headers)
+					: undefined
+				: init?.headers
+					? new Headers(init.headers)
+					: undefined;
+		const requestBody =
+			input instanceof Request && input.body ? input.clone().text() : Promise.resolve(init?.body);
+		let response = await event.fetch(input, init);
+		const sameOrigin = url.origin === event.url.origin;
+		if (!sameOrigin && /^https?:$/.test(url.protocol)) {
+			const mode = input instanceof Request ? input.mode : (init?.mode ?? 'cors');
+			if (mode === 'no-cors')
+				response = new Response(null, {
+					status: response.status,
+					statusText: response.statusText,
+					headers: response.headers
+				});
+			else {
+				const origin = response.headers.get('access-control-allow-origin');
+				if (origin !== '*' && origin !== event.url.origin)
+					errors.load_fetch_cors({ reason: origin ? 'Incorrect' : 'No' });
+			}
+		}
+		const dependency =
+			state.prerendering && sameOrigin
+				? { response, body: null as string | Uint8Array | null }
+				: null;
+		if (dependency) state.prerendering!.dependencies.set(url.pathname, dependency);
+		const wrap = (response: Response): Response => {
+			let recorded = false;
+			let body: ReadableStream<Uint8Array> | null = null;
+			const capture = async (value: string, bytes?: Uint8Array): Promise<void> => {
+				if (recorded) return;
+				recorded = true;
+				if (dependency) dependency.body = bytes ?? value;
+				const request = await requestBody;
+				if (request && typeof request !== 'string' && !ArrayBuffer.isView(request)) return;
+				if (csr)
+					state.fetched.push({
+						url: sameOrigin ? url.href.slice(url.origin.length) : url.href,
+						method: event.request.method,
+						request_headers: requestHeaders,
+						request_body: request as string | ArrayBufferView | undefined,
+						response,
+						response_body: value,
+						is_b64: !!bytes
+					});
+			};
+			const text = async (): Promise<string> => {
+				const value = await response.text();
+				await capture(value);
+				return value;
+			};
+			const headers = new Proxy(response.headers, {
+				get(target, key) {
+					if (csr && key === 'get')
+						return (name: string) => {
+							const value = target.get(name);
+							if (
+								value &&
+								!name.toLowerCase().startsWith(`x-${identity.name}-`) &&
+								!state.resolveOptions.filterSerializedResponseHeaders?.(name.toLowerCase(), value)
+							)
+								errors.load_response_header_not_serialized({
+									name: name.toLowerCase(),
+									id: event.route.id ?? ''
+								});
+							return value;
+						};
+					if (csr && key === 'getSetCookie')
+						return () => {
+							const values = target.getSetCookie();
+							for (const value of values)
+								if (!state.resolveOptions.filterSerializedResponseHeaders?.('set-cookie', value))
+									errors.load_response_header_not_serialized({
+										name: 'set-cookie',
+										id: event.route.id ?? ''
+									});
+							return values;
+						};
+					const value = Reflect.get(target, key, target);
+					return typeof value === 'function' ? value.bind(target) : value;
+				}
+			});
+			return new Proxy(response, {
+				get(target, key) {
+					if (key === 'headers') return headers;
+					if (key === 'text') return text;
+					if (key === 'json')
+						return async () => {
+							const value = await text();
+							return value ? JSON.parse(value) : undefined;
+						};
+					if (key === 'arrayBuffer')
+						return async () => {
+							const value = await target.arrayBuffer();
+							const bytes = new Uint8Array(value);
+							await capture(base64(bytes), bytes);
+							return value;
+						};
+					if (key === 'clone') return () => wrap(target.clone());
+					if (key === 'body') {
+						if (!target.body) return null;
+						if (!body) {
+							const [recording, consuming] = target.body.tee();
+							body = consuming;
+							void new Response(recording)
+								.arrayBuffer()
+								.then((value) => {
+									const bytes = new Uint8Array(value);
+									return capture(base64(bytes), bytes);
+								})
+								.catch(() => {});
+						}
+						return body;
+					}
+					const value = Reflect.get(target, key, target);
+					return typeof value === 'function' ? value.bind(target) : value;
+				}
+			});
+		};
+		return wrap(response);
+	};
+	return (input, init) => {
+		const pending = execute(input, init);
+		pending.catch(() => {});
+		return pending;
+	};
+}
+
+export function serializeFetched(
+	fetched: Fetched,
+	filter: (name: string, value: string) => boolean,
+	prerender: boolean
+): string {
+	const headers = Object.fromEntries(
+		[...fetched.response.headers].filter(([name, value]) => filter(name, value))
+	);
+	const attributes = [
+		'type="application/json"',
+		`data-${identity.name}-fetched`,
+		`data-url="${escapeHtml(fetched.url, true)}"`
+	];
+	if (fetched.is_b64) attributes.push('data-b64');
+	if (fetched.request_headers || fetched.request_body)
+		attributes.push(`data-hash="${hashRequest(fetched.request_headers, fetched.request_body)}"`);
+	const cache = fetched.response.headers.get('cache-control');
+	if (
+		!prerender &&
+		fetched.method === 'GET' &&
+		fetched.response.headers.get('vary')?.trim() !== '*' &&
+		cache
+	) {
+		const maxAge = /s-maxage=(\d+)/.exec(cache) ?? /max-age=(\d+)/.exec(cache);
+		if (maxAge)
+			attributes.push(
+				`data-ttl="${Number(maxAge[1]) - Number(fetched.response.headers.get('age') ?? 0)}"`
+			);
+	}
+	return `<script ${attributes.join(' ')}>${escapeJson({ status: fetched.response.status, statusText: fetched.response.statusText, headers, body: [101, 103, 204, 205, 304].includes(fetched.response.status) ? null : fetched.response_body })}</script>`;
+}