@vigla/kit 0.0.0-stage → 0.1.0

package/src/entries/app/forms/server.ts

@@ -0,0 +1,21 @@
+import type { ActionResult, Enhancement, SubmitFunction } from '../../../types/forms.ts';
+import { deserialize as decode } from '../../../shared/serialization.ts';
+import { findRequest } from '../../../server/scope.ts';
+import { appTransport } from '../../../server/transport.ts';
+import { server_api_unavailable } from '../../../server/errors.ts';
+
+export function deserialize(result: string): ActionResult {
+	const parsed = JSON.parse(result);
+	if ((parsed.type === 'success' || parsed.type === 'failure') && parsed.data)
+		parsed.data = decode(parsed.data, findRequest()?.hooks.transport ?? appTransport());
+	return parsed;
+}
+export function enhance<
+	Success extends Record<string, unknown> | undefined,
+	Failure extends Record<string, unknown> | undefined
+>(_form: HTMLFormElement, _submit?: SubmitFunction<Success, Failure>): Enhancement {
+	return { destroy() {} };
+}
+export function applyAction(_result: ActionResult): never {
+	return server_api_unavailable({ name: 'applyAction(...)' });
+}

package/src/entries/app/navigation/client.ts

@@ -0,0 +1,21 @@
+export {
+	afterNavigate,
+	beforeNavigate,
+	onNavigate,
+	goto,
+	invalidate,
+	invalidateAll,
+	refreshAll,
+	preloadCode,
+	preloadData,
+	disableScrollHandling,
+	snapshot
+} from '../../../client/navigation.ts';
+export type {
+	AfterNavigate,
+	BeforeNavigate,
+	Navigation,
+	NavigationTarget,
+	NavigationType,
+	OnNavigate
+} from '../../../types/navigation.ts';

package/src/entries/app/navigation/server.ts

@@ -0,0 +1,35 @@
+import type {
+	AfterNavigate,
+	BeforeNavigate,
+	GotoOptions,
+	Invalidation,
+	NavigationCallback,
+	SnapshotOptions
+} from '../../../types/navigation.ts';
+import { server_api_unavailable } from '../../../server/errors.ts';
+
+export function afterNavigate(_callback: (navigation: AfterNavigate) => void): void {}
+export function beforeNavigate(_callback: (navigation: BeforeNavigate) => void): void {}
+export function onNavigate(_callback: NavigationCallback): void {}
+export function snapshot<T>(_options: SnapshotOptions<T>): void {}
+export function disableScrollHandling(): never {
+	return server_api_unavailable({ name: 'disableScrollHandling()' });
+}
+export function goto(_url: string | URL, _options?: GotoOptions): never {
+	return server_api_unavailable({ name: 'goto(...)' });
+}
+export function invalidate(_resource: Invalidation, _keepState?: boolean): never {
+	return server_api_unavailable({ name: 'invalidate(...)' });
+}
+export function invalidateAll(): never {
+	return server_api_unavailable({ name: 'invalidateAll()' });
+}
+export function refreshAll(): never {
+	return server_api_unavailable({ name: 'refreshAll()' });
+}
+export function preloadCode(_id: string): never {
+	return server_api_unavailable({ name: 'preloadCode(...)' });
+}
+export function preloadData(_href: string): never {
+	return server_api_unavailable({ name: 'preloadData(...)' });
+}

package/src/entries/app/paths/client.ts

@@ -0,0 +1 @@
+export { asset, resolve, match, base, assets, app_dir } from '../../../client/paths.ts';

package/src/entries/app/paths/server.ts

@@ -0,0 +1 @@
+export { asset, resolve, match, base, assets, app_dir } from '../../../server/paths.ts';

package/src/entries/app/server/server.ts

@@ -0,0 +1,9 @@
+export { getRequestEvent, getRequestOwner } from '../../../server/scope.ts';
+export { read } from '../../../server/read.ts';
+export { command } from '../../../server/remote/command.ts';
+export { form } from '../../../server/remote/form.ts';
+export { prerender } from '../../../server/remote/prerender.ts';
+export { query } from '../../../server/remote/query.ts';
+export { requested } from '../../../server/remote/requested.ts';
+export type * from '../../../types/remote.ts';
+export type * from '../../../types/remote-form.ts';

package/src/entries/app/service-worker/client.ts

@@ -0,0 +1,7 @@
+import { DEV } from 'esm-env';
+import { service_worker_module_outside_worker } from '../../../shared/errors.ts';
+
+export const self = globalThis.self;
+const scope: unknown = Reflect.get(globalThis, 'ServiceWorkerGlobalScope');
+if (DEV && (typeof scope !== 'function' || !(self instanceof scope)))
+	service_worker_module_outside_worker();

package/src/entries/app/state/client.ts

@@ -0,0 +1,2 @@
+export { page, navigating, updated } from '../../../client/state.ts';
+export type { Page } from '../../../types/state.ts';

package/src/entries/app/state/server.ts

@@ -0,0 +1 @@
+export { page, navigating, updated } from '../../../server/state.ts';

package/src/entries/define-params.ts

@@ -0,0 +1,40 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { Identity } from '../types/identity.ts';
+import type { DefinedParams, ParamDefinition, ParamMatcher } from '../types/params.ts';
+import { diagnostics } from '../shared/diagnostics.ts';
+import { param_definition_invalid } from '../shared/errors.ts';
+
+export type DefineParams = <T extends Record<string, ParamDefinition>>(
+	definitions: T
+) => DefinedParams<T>;
+
+export function paramsDefiner(identity: Identity): DefineParams {
+	const d = diagnostics(identity);
+	const matcher = (definition: ParamDefinition): ParamMatcher => {
+		if (
+			definition &&
+			(typeof definition === 'object' || typeof definition === 'function') &&
+			'~standard' in definition
+		)
+			return definition;
+		if (typeof definition !== 'function') param_definition_invalid(d);
+		const schema: StandardSchemaV1<string, any> = {
+			'~standard': {
+				version: 1,
+				vendor: 'vigla',
+				validate(value) {
+					const output = definition(value as string);
+					if (output === undefined) return { issues: [{ message: 'Invalid param' }] };
+					if ((output as unknown) instanceof Promise)
+						return output as unknown as Promise<StandardSchemaV1.Result<any>>;
+					return { value: output };
+				}
+			}
+		};
+		return schema;
+	};
+	return <T extends Record<string, ParamDefinition>>(definitions: T) =>
+		Object.fromEntries(
+			Object.entries(definitions).map(([name, definition]) => [name, matcher(definition)])
+		) as DefinedParams<T>;
+}

package/src/entries/env/dynamic/private/server.ts

@@ -0,0 +1 @@
+export { privateEnv as env } from '../../../../server/environment.ts';

package/src/entries/env/dynamic/public/client.ts

@@ -0,0 +1 @@
+export { env } from '../../../../client/payload.ts';

package/src/entries/env/dynamic/public/server.ts

@@ -0,0 +1 @@
+export { publicEnv as env } from '../../../../server/environment.ts';

package/src/entries/env.ts

@@ -0,0 +1,39 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { DefinedEnvVars, EnvVarConfig } from '../types/env.ts';
+
+export type { DefinedEnvVars, EnvVarConfig } from '../types/env.ts';
+
+type Validator = (value: string | undefined) => any;
+
+function schema(validate: Validator): StandardSchemaV1<string | undefined, any> {
+	return {
+		'~standard': {
+			version: 1,
+			vendor: 'vigla',
+			validate(value) {
+				try {
+					const output = validate(value as string | undefined);
+					return output instanceof Promise ? output : { value: output };
+				} catch (error) {
+					return {
+						issues: [
+							{ message: error instanceof Error ? error.message || 'Invalid value' : String(error) }
+						]
+					};
+				}
+			}
+		}
+	};
+}
+
+export function defineEnvVars<T extends Record<string, EnvVarConfig<any>>>(
+	variables: T
+): DefinedEnvVars<T> {
+	const entries = Object.entries(variables).map(([name, config]) => [
+		name,
+		typeof config.schema === 'function' && !('~standard' in config.schema)
+			? { ...config, schema: schema(config.schema) }
+			: config
+	]);
+	return Object.fromEntries(entries) as DefinedEnvVars<T>;
+}

package/src/entries/hooks.ts

@@ -0,0 +1,19 @@
+import { identity } from '../shared/identity.ts';
+import { sequencer } from './sequence.ts';
+
+export type {
+	CaughtError,
+	ClientCaughtError,
+	ClientInit,
+	Handle,
+	HandleClientError,
+	HandleFetch,
+	HandleServerError,
+	Reroute,
+	ResolveOptions,
+	ServerInit,
+	Transport,
+	Transporter
+} from '../types/hooks.ts';
+
+export const sequence = sequencer(identity);

package/src/entries/index.ts

@@ -0,0 +1,82 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { ErrorFunction, HttpError as HttpErrorContract } from '../types/outcomes.ts';
+import { HttpError, Redirect, ActionFailure, ValidationError } from '../shared/outcomes.ts';
+import { identity } from '../shared/identity.ts';
+import { outcomes, type RedirectFunction } from './outcomes.ts';
+
+export type {
+	ActionFailure,
+	Adapter,
+	AdapterViteConfig,
+	AwaitedActions,
+	Builder,
+	Cookies,
+	Emulator,
+	HttpError,
+	Load,
+	LoadEvent,
+	LoadProperties,
+	NavigationEvent,
+	PrerenderOption,
+	Redirect,
+	RequestEvent,
+	RequestHandler,
+	RouteDefinition,
+	Server,
+	ServerInitOptions,
+	ServerLoad,
+	ServerLoadEvent,
+	Snapshot,
+	Action,
+	Actions,
+	ValidationError
+} from '../types/index.ts';
+export { normalizeUrl } from '../shared/pathname.ts';
+export const VERSION = '0.1.0';
+
+const bound = outcomes(identity);
+export const error: ErrorFunction = bound.error;
+export const redirect: RedirectFunction = bound.redirect;
+
+export function isHttpError<Status extends number>(
+	value: unknown,
+	status?: Status
+): value is HttpErrorContract & { status: Status extends undefined ? never : Status } {
+	return value instanceof HttpError && (!status || value.status === status);
+}
+export function isRedirect(value: unknown): value is Redirect {
+	return value instanceof Redirect;
+}
+
+const encoder = new TextEncoder();
+export function json(data: any, init?: ResponseInit): Response {
+	const body = JSON.stringify(data);
+	const headers = new Headers(init?.headers);
+	if (!headers.has('content-length'))
+		headers.set('content-length', String(encoder.encode(body).byteLength));
+	if (!headers.has('content-type')) headers.set('content-type', 'application/json');
+	return new Response(body, { ...init, headers });
+}
+export function text(body: string, init?: ResponseInit): Response {
+	const headers = new Headers(init?.headers);
+	if (headers.has('content-length')) return new Response(body, { ...init, headers });
+	const bytes = encoder.encode(body);
+	headers.set('content-length', String(bytes.byteLength));
+	return new Response(bytes, { ...init, headers });
+}
+export function fail(status: number): ActionFailure<undefined>;
+export function fail<T = undefined>(status: number, data: T): ActionFailure<T>;
+export function fail<T>(status: number, data?: T): ActionFailure<T | undefined> {
+	return new ActionFailure(status, data);
+}
+export function isActionFailure(value: unknown): value is ActionFailure<undefined> {
+	return value instanceof ActionFailure;
+}
+export function invalid(...issues: (StandardSchemaV1.Issue | string)[]): never {
+	throw new ValidationError(
+		issues.map((issue) => (typeof issue === 'string' ? { message: issue } : issue))
+	);
+}
+export function isValidationError(value: unknown): value is ValidationError {
+	return value instanceof ValidationError;
+}

package/src/entries/internal/client.ts

@@ -0,0 +1,14 @@
+export { init, start, load_css } from '../../client/entry.ts';
+export { query, query_batch, prerender } from '../../client/remote/query.ts';
+export { query_live } from '../../client/remote/live.ts';
+export { command } from '../../client/remote/command.ts';
+export { form } from '../../client/remote/form.ts';
+export type {
+	ClientApp,
+	ClientPayload,
+	HydrationPayload,
+	Hydration,
+	ClientGlobal,
+	ClientNode,
+	NodeLoader
+} from '../../types/internal/client.ts';

package/src/entries/internal/env.ts

@@ -0,0 +1 @@
+export { validate, handleIssues } from '../../shared/env.ts';

package/src/entries/internal/identity.ts

@@ -0,0 +1,3 @@
+export { outcomes, type Outcomes, type RedirectFunction } from '../outcomes.ts';
+export { rerouter, type ApplyReroute } from '../reroute.ts';
+export { paramsDefiner, type DefineParams } from '../define-params.ts';

package/src/entries/internal/payload.ts

@@ -0,0 +1 @@
+export { init } from '../../client/payload.ts';

package/src/entries/internal/restore.ts

@@ -0,0 +1,5 @@
+import type { Restorer } from '../../types/internal/client.ts';
+
+export type { Restorer };
+
+export const restorer: (() => Restorer) | undefined = undefined;

package/src/entries/internal/sequence.ts

@@ -0,0 +1 @@
+export { sequencer, type Sequence } from '../sequence.ts';

package/src/entries/internal/server.ts

@@ -0,0 +1,12 @@
+export { Server, getRequestEvent, getRequestOwner, read } from '../../server/index.ts';
+export { handleRemote, initRemote } from '../../server/remote/handler.ts';
+export type {
+	ClientBuild,
+	Environment,
+	PageNode,
+	RequestStore,
+	RespondOptions,
+	ServerInstance,
+	ServerManifest,
+	ServerOptions
+} from '../../types/internal/server.ts';

package/src/entries/internal/shallow/client.ts

@@ -0,0 +1 @@
+export { shallow } from '../../../client/navigation.ts';

package/src/entries/internal/shallow/server.ts

@@ -0,0 +1,6 @@
+import type { ShallowCaller } from '../../../types/navigation.ts';
+import { server_api_unavailable } from '../../../server/errors.ts';
+
+export function shallow(caller: ShallowCaller, _url: string | URL, _state: App.PageState): never {
+	return server_api_unavailable({ name: `${caller}(...)` });
+}

package/src/entries/outcomes.ts

@@ -0,0 +1,45 @@
+import { BROWSER, DEV } from 'esm-env';
+import { getOrigin } from '#internal/origin';
+import type { Identity } from '../types/identity.ts';
+import type {
+	ErrorFunction,
+	ErrorProperties,
+	RedirectOptions,
+	RedirectStatus
+} from '../types/outcomes.ts';
+import { HttpError, Redirect } from '../shared/outcomes.ts';
+import { diagnostics } from '../shared/diagnostics.ts';
+import { invalid_error_status, invalid_redirect_status } from '../shared/errors.ts';
+import { validateRedirect } from '../shared/redirect.ts';
+
+export type RedirectFunction = (
+	status: number,
+	location: string | URL,
+	options?: RedirectOptions
+) => never;
+
+export interface Outcomes {
+	error: ErrorFunction;
+	redirect: RedirectFunction;
+}
+
+export function outcomes(identity: Identity): Outcomes {
+	const d = diagnostics(identity);
+	const error: ErrorFunction = (
+		status: number,
+		message?: string,
+		properties?: ErrorProperties
+	): never => {
+		if ((!BROWSER || DEV) && (isNaN(status) || status < 400 || status > 599))
+			invalid_error_status({ status: String(status) }, d);
+		throw new HttpError({ ...properties, status, message: message ?? `Error: ${status}` });
+	};
+	const redirect = (status: number, location: string | URL, options?: RedirectOptions): never => {
+		if ((!BROWSER || DEV) && (isNaN(status) || status < 300 || status > 308))
+			invalid_redirect_status({ status: String(status) }, d);
+		const href = location.toString();
+		validateRedirect(d, href, options, getOrigin());
+		throw new Redirect(status as RedirectStatus, href);
+	};
+	return { error, redirect };
+}

package/src/entries/params.ts

@@ -0,0 +1,12 @@
+import { identity } from '../shared/identity.ts';
+import { paramsDefiner } from './define-params.ts';
+
+export type {
+	DefinedParams,
+	MatcherParam,
+	ParamDefinition,
+	ParamMatcher,
+	ParamValue
+} from '../types/params.ts';
+
+export const defineParams = paramsDefiner(identity);

package/src/entries/reroute.ts

@@ -0,0 +1,13 @@
+import type { RerouteNext } from '../types/adapter.ts';
+import type { Identity } from '../types/identity.ts';
+import type { MaybePromise } from '../types/value.ts';
+
+export type ApplyReroute = (response: Response, next: RerouteNext) => MaybePromise<Response>;
+
+export function rerouter(identity: Identity): ApplyReroute {
+	const header = `x-${identity.name}-rerouted-url`;
+	return (response, next) => {
+		const location = response.headers.get(header);
+		return location ? next(new URL(location)) : response;
+	};
+}

package/src/entries/sequence.ts

@@ -0,0 +1,52 @@
+import type { Handle, ResolveOptions } from '../types/hooks.ts';
+import type { Identity } from '../types/identity.ts';
+import type { RequestEvent } from '../types/request.ts';
+import { findRequest, runRequest } from '../server/scope.ts';
+
+export type Sequence = (...handlers: Handle[]) => Handle;
+
+export function sequencer(identity: Identity): Sequence {
+	const span = `${identity.name}.handle.sequenced.`;
+	return (...handlers) => {
+		if (!handlers.length) return ({ event, resolve }) => resolve(event);
+		return ({ event, resolve }) => {
+			const store = findRequest();
+			const next = (
+				index: number,
+				event: RequestEvent,
+				options?: ResolveOptions
+			): Promise<Response> => {
+				const handler = handlers[index]!;
+				const call = async (event: RequestEvent): Promise<Response> =>
+					handler({
+						event,
+						resolve(event, current) {
+							const combined: ResolveOptions = {
+								preload: options?.preload ?? current?.preload,
+								filterSerializedResponseHeaders:
+									options?.filterSerializedResponseHeaders ??
+									current?.filterSerializedResponseHeaders,
+								async transformPageChunk(chunk) {
+									let html = chunk.html;
+									if (current?.transformPageChunk)
+										html = (await current.transformPageChunk({ ...chunk, html })) ?? '';
+									if (options?.transformPageChunk)
+										html = (await options.transformPageChunk({ ...chunk, html })) ?? '';
+									return html;
+								}
+							};
+							return index < handlers.length - 1
+								? next(index + 1, event, combined)
+								: resolve(event, combined);
+						}
+					});
+				if (!store) return call(event);
+				return store.tracer.span(span + (handler.name || index), {}, async (current) => {
+					const traced = { ...event, tracing: { ...event.tracing, current } };
+					return runRequest({ ...store, event: traced }, () => call(traced));
+				});
+			};
+			return next(0, event);
+		};
+	};
+}

package/src/node/index.ts

@@ -0,0 +1,9 @@
+import { createReadStream } from 'node:fs';
+import { Readable } from 'node:stream';
+
+export { getRequest } from './request.ts';
+export { setResponse } from './response.ts';
+
+export function createReadableStream(file: string): ReadableStream<Uint8Array> {
+	return Readable.toWeb(createReadStream(file)) as ReadableStream<Uint8Array>;
+}

package/src/node/request.ts

@@ -0,0 +1,114 @@
+import type { IncomingMessage } from 'node:http';
+import type { RequestInput } from '../types/node.ts';
+
+const listeners = new WeakMap<IncomingMessage, (chunk: Uint8Array) => void>();
+
+class BodyLimitError extends Error {
+	readonly status = 413;
+	readonly text = 'Payload Too Large';
+}
+
+function body(request: IncomingMessage, limit?: number): ReadableStream<Uint8Array> | null {
+	const length = Number(request.headers['content-length']);
+	const knownLength = Number.isFinite(length);
+	if (
+		length === 0 ||
+		(request.httpVersionMajor === 1 && !knownLength && request.headers['transfer-encoding'] == null)
+	)
+		return null;
+	if (request.destroyed) return new ReadableStream({ start: (controller) => controller.close() });
+
+	let received = 0;
+	let ended = false;
+	return new ReadableStream<Uint8Array>({
+		start(controller) {
+			if (limit !== undefined && knownLength && length > limit) {
+				ended = true;
+				controller.error(
+					new BodyLimitError(`Content-length of ${length} exceeds limit of ${limit} bytes.`)
+				);
+				return;
+			}
+			const receive = (chunk: Uint8Array): void => {
+				if (ended) return;
+				received += chunk.byteLength;
+				const reason =
+					limit !== undefined && received > limit
+						? `request body size exceeded BODY_SIZE_LIMIT of ${limit}`
+						: knownLength && received > length
+							? `request body size exceeded content-length of ${length}`
+							: undefined;
+				if (reason !== undefined) {
+					ended = true;
+					controller.error(new BodyLimitError(reason));
+					return;
+				}
+				controller.enqueue(chunk);
+				if ((controller.desiredSize ?? 0) <= 0) request.pause();
+			};
+			listeners.set(request, receive);
+			request.on('data', receive);
+			request.on('end', () => {
+				if (!ended) {
+					ended = true;
+					controller.close();
+				}
+			});
+			request.on('error', (error: Error) => {
+				ended = true;
+				controller.error(error);
+			});
+		},
+		pull() {
+			request.resume();
+		},
+		cancel(reason) {
+			ended = true;
+			request.destroy(reason);
+		}
+	});
+}
+
+export function drainRequest(request: IncomingMessage | undefined): void {
+	if (request === undefined || request.readableEnded || request.destroyed) return;
+	const listener = listeners.get(request);
+	if (listener !== undefined) {
+		request.off('data', listener);
+		listeners.delete(request);
+	}
+	request.resume();
+}
+
+interface StreamingRequestInit extends RequestInit {
+	duplex: 'half';
+}
+
+export function getRequest({ request, response, base, bodySizeLimit }: RequestInput): Request {
+	const headers = new Headers();
+	for (const [name, value] of Object.entries(request.headers)) {
+		if (value === undefined || (request.httpVersionMajor >= 2 && name.startsWith(':'))) continue;
+		if (Array.isArray(value)) for (const entry of value) headers.append(name, entry);
+		else headers.set(name, value);
+	}
+	if (request.httpVersionMajor >= 2 && request.headers[':authority'])
+		headers.set('host', String(request.headers[':authority']));
+
+	const signal = new AbortController();
+	request.once('close', () => {
+		if (request.readableAborted) signal.abort();
+	});
+	response?.once('close', () => {
+		if (!response.writableEnded) signal.abort();
+	});
+	const init: StreamingRequestInit = {
+		duplex: 'half',
+		method: request.method,
+		headers,
+		signal: signal.signal,
+		body:
+			request.method === 'GET' || request.method === 'HEAD'
+				? undefined
+				: body(request, bodySizeLimit)
+	};
+	return new Request(base + request.url, init);
+}