@vigla/kit 0.0.0-stage → 0.1.1

package/src/server/remote/iteration.ts

@@ -0,0 +1,102 @@
+import type { RemoteIterator } from '../../types/internal/remote.ts';
+
+interface Consumer {
+	pending?: IteratorResult<any>;
+	waiting?: { resolve(value: IteratorResult<any>): void; reject(error: unknown): void };
+	failure?: { error: unknown };
+	ended: boolean;
+}
+
+export class LiveIterator implements RemoteIterator {
+	readonly #source: () => AsyncGenerator<any>;
+	readonly #signal: AbortSignal;
+	readonly #consumers = new Set<Consumer>();
+	#generator?: AsyncGenerator<any>;
+	#ended = false;
+	#failure?: { error: unknown };
+
+	constructor(signal: AbortSignal, source: () => AsyncGenerator<any>) {
+		this.#signal = signal;
+		this.#source = source;
+		signal.addEventListener('abort', this.close, { once: true });
+	}
+
+	close = (): void => {
+		if (this.#ended) return;
+		this.#ended = true;
+		this.#signal.removeEventListener('abort', this.close);
+		void this.#generator?.return(undefined).catch(() => {});
+		for (const consumer of this.#consumers) this.#finish(consumer);
+	};
+
+	#finish(consumer: Consumer): void {
+		consumer.ended = true;
+		consumer.waiting?.resolve({ done: true, value: undefined });
+		consumer.waiting = undefined;
+	}
+
+	async #pump(): Promise<void> {
+		try {
+			while (!this.#ended) {
+				const next = await this.#generator!.next();
+				if (this.#ended) return;
+				if (next.done) {
+					this.close();
+					return;
+				}
+				for (const consumer of this.#consumers) {
+					if (consumer.waiting) consumer.waiting.resolve(next);
+					else consumer.pending = next;
+					consumer.waiting = undefined;
+				}
+			}
+		} catch (error) {
+			if (!this.#ended) this.#failure = { error };
+			if (!this.#ended)
+				for (const consumer of this.#consumers) {
+					consumer.failure = { error };
+					consumer.waiting?.reject(error);
+					consumer.waiting = undefined;
+				}
+			this.close();
+		}
+	}
+
+	subscribe(): AsyncIterableIterator<any> {
+		const consumer: Consumer = {
+			ended: this.#ended || this.#signal.aborted,
+			failure: this.#failure
+		};
+		if (!consumer.ended) this.#consumers.add(consumer);
+		if (!consumer.ended && !this.#generator) {
+			this.#generator = this.#source();
+			void this.#pump();
+		}
+		return {
+			next: () => {
+				if (consumer.failure) {
+					const { error } = consumer.failure;
+					consumer.failure = undefined;
+					consumer.pending = undefined;
+					return Promise.reject(error);
+				}
+				const pending = consumer.pending;
+				consumer.pending = undefined;
+				if (pending) return Promise.resolve(pending);
+				if (consumer.ended) return Promise.resolve({ done: true, value: undefined });
+				return new Promise((resolve, reject) => {
+					consumer.waiting = { resolve, reject };
+				});
+			},
+			return: async () => {
+				this.#finish(consumer);
+				this.#consumers.delete(consumer);
+				if (!this.#consumers.size) this.close();
+				return { done: true, value: undefined };
+			},
+			[Symbol.asyncIterator]() {
+				return this;
+			}
+		};
+	}
+}

package/src/server/remote/prerender.ts

@@ -0,0 +1,77 @@
+import type { Prerender } from '../../types/remote-functions.ts';
+import type { PrerenderOptions } from '../../types/remote.ts';
+import type {
+	RemoteImplementation,
+	RemotePrerenderInternals,
+	RemoteResponse
+} from '../../types/internal/remote.ts';
+import { encodeArgument } from '../../shared/remote.ts';
+import { deserialize, serialize } from '../../shared/serialization.ts';
+import { getRequestStore } from '../scope.ts';
+import { HandledError } from '../failure.ts';
+import { createValidator, execute } from './shared.ts';
+import { resource } from './resource.ts';
+
+export const prerender: Prerender = (
+	validation: any,
+	fnOrOptions?: RemoteImplementation | PrerenderOptions<any>,
+	options?: PrerenderOptions<any>
+): any => {
+	const implementation = typeof fnOrOptions === 'function' ? fnOrOptions : undefined;
+	const fn = implementation ?? validation;
+	const settings =
+		options ?? (implementation ? undefined : (fnOrOptions as PrerenderOptions<any> | undefined));
+	const validate = createValidator(validation, implementation);
+	const internals: RemotePrerenderInternals = {
+		type: 'prerender',
+		id: '',
+		name: '',
+		validate,
+		implementation: fn,
+		has_arg: !!implementation,
+		inputs: settings?.inputs,
+		dynamic: settings?.dynamic
+	};
+	const invoke = (arg: unknown) => {
+		const store = getRequestStore();
+		const payload = encodeArgument(arg, store.hooks.transport);
+		const path = `/${store.manifest.app_path}/remote/${internals.id}${payload ? `/${payload}` : ''}`;
+		return resource(store, internals, payload, async () => {
+			if (
+				!store.state.prerendering &&
+				!store.options.dev &&
+				!store.event.isRemoteRequest &&
+				internals.id
+			) {
+				let response: RemoteResponse | undefined;
+				try {
+					const result = await fetch(new URL(path, store.event.request.url), {
+						redirect: 'manual'
+					});
+					if (result.ok) response = (await result.json()) as RemoteResponse;
+				} catch {}
+				if (response?.type === 'error') throw new HandledError(response.error);
+				if (response?.type === 'result' && typeof response.data === 'string') {
+					return deserialize(response.data, store.hooks.transport)._;
+				}
+			}
+			const prerendering = store.state.prerendering;
+			const responses = prerendering ? (prerendering.remoteResponses ??= new Map()) : undefined;
+			let pending = responses?.get(path);
+			if (!pending) {
+				pending = execute(store, { prerender: true }, false, () => validate(arg), fn);
+				responses?.set(path, pending);
+			}
+			const result = await pending;
+			if (prerendering && internals.id) {
+				const body = { type: 'result', data: serialize({ _: result }, store.hooks.transport) };
+				prerendering.dependencies.set(path, {
+					response: Response.json(body),
+					body: JSON.stringify(body)
+				});
+			}
+			return result;
+		});
+	};
+	return Object.defineProperty(invoke, '__', { value: internals });
+};

package/src/server/remote/query.ts

@@ -0,0 +1,176 @@
+import { root } from 'vigla';
+import type { Query } from '../../types/remote-functions.ts';
+import type {
+	RemoteBatchEntry,
+	RemoteBatchInternals,
+	RemoteImplementation,
+	RemoteLiveInternals,
+	RemoteQueryInternals
+} from '../../types/internal/remote.ts';
+import type { RequestStore } from '../../types/internal/server.ts';
+import { encodeArgument, getRemoteKey } from '../../shared/remote.ts';
+import { getRequestStore } from '../scope.ts';
+import { handleError } from '../failure.ts';
+import { createValidator, execute, generate } from './shared.ts';
+import { resource, liveResource } from './resource.ts';
+import { LiveIterator } from './iteration.ts';
+import * as errors from './errors.ts';
+
+function assertDynamic(store: RequestStore, type: string, name: string): void {
+	if (store.state.prerendering) errors.queryPrerender(type, name);
+}
+
+function single(validation: any, implementation?: RemoteImplementation): any {
+	const fn = implementation ?? validation;
+	const validate = createValidator(validation, implementation);
+	const internals: RemoteQueryInternals = {
+		type: 'query',
+		id: '',
+		name: '',
+		validate,
+		implementation: fn,
+		bind(payload, arg) {
+			const store = getRequestStore();
+			return resource(store, internals, payload, () =>
+				execute(store, { query: true }, false, () => arg, fn)
+			);
+		}
+	};
+	const invoke = (arg: unknown) => {
+		const store = getRequestStore();
+		assertDynamic(store, 'query', internals.name);
+		const payload = encodeArgument(arg, store.hooks.transport);
+		return resource(store, internals, payload, () =>
+			execute(store, { query: true }, false, () => validate(arg), fn)
+		);
+	};
+	return Object.defineProperty(invoke, '__', { value: internals });
+}
+
+function batch(validation: any, implementation?: RemoteImplementation): any {
+	const fn = implementation ?? validation;
+	const validate = createValidator(validation, implementation);
+	const internals: RemoteBatchInternals = {
+		type: 'query_batch',
+		id: '',
+		name: '',
+		validate,
+		implementation: fn,
+		async run(args) {
+			const store = getRequestStore();
+			return execute(
+				store,
+				{ query: true },
+				false,
+				() => Promise.all(args.map(validate)),
+				async (input: any[]) => {
+					const select = await fn(input);
+					return Promise.all(
+						input.map(async (arg, index) => {
+							try {
+								return { type: 'result' as const, data: await select(arg, index) };
+							} catch (error) {
+								return { type: 'error' as const, error: await handleError(store, error) };
+							}
+						})
+					);
+				}
+			);
+		},
+		bind(payload, arg) {
+			const store = getRequestStore();
+			return resource(store, internals, payload, () => enqueue(store, payload, () => arg));
+		}
+	};
+	const enqueue = (
+		store: RequestStore,
+		payload: string,
+		input: RemoteBatchEntry['input']
+	): Promise<any> => {
+		return new Promise((resolve, reject) => {
+			let queue = store.remote.batches.get(internals);
+			if (!queue) {
+				store.remote.batches.set(internals, (queue = new Map()));
+				const entries = queue;
+				setTimeout(() => {
+					store.remote.batches.delete(internals);
+					const batch = [...entries.values()];
+					void execute(
+						store,
+						{ query: true },
+						false,
+						() => Promise.all(batch.map((entry) => entry.input())),
+						async (args: any[]) => {
+							const select = await fn(args);
+							for (const [index, entry] of batch.entries()) {
+								try {
+									const value = await select(args[index], index);
+									for (const resolver of entry.resolvers) resolver.resolve(value);
+								} catch (error) {
+									for (const resolver of entry.resolvers) resolver.reject(error);
+								}
+							}
+						}
+					).catch((error) => {
+						for (const entry of batch)
+							for (const resolver of entry.resolvers) resolver.reject(error);
+					});
+				}, 0);
+			}
+			const existing = queue.get(payload);
+			if (existing) existing.resolvers.push({ resolve, reject });
+			else queue.set(payload, { input, resolvers: [{ resolve, reject }] });
+		});
+	};
+	const invoke = (arg: unknown) => {
+		const store = getRequestStore();
+		assertDynamic(store, 'query.batch', internals.name);
+		const payload = encodeArgument(arg, store.hooks.transport);
+		return resource(store, internals, payload, () => enqueue(store, payload, () => validate(arg)));
+	};
+	return Object.defineProperty(invoke, '__', { value: internals });
+}
+
+function live(validation: any, implementation?: RemoteImplementation): any {
+	const fn = implementation ?? validation;
+	const validate = createValidator(validation, implementation);
+	const bind = (store: RequestStore, payload: string, input: () => any) => {
+		const generator = () => generate(store, input, fn, internals.name);
+		return liveResource(
+			store,
+			internals,
+			payload,
+			async () => {
+				for await (const value of generator()) return value;
+				return errors.liveEmpty(internals.name);
+			},
+			() => {
+				const key = getRemoteKey(internals.id, payload);
+				let stream = store.remote.live.get(key);
+				if (!stream) {
+					const iterator = new LiveIterator(store.event.request.signal, generator);
+					root(() => iterator.close, store.owner);
+					store.remote.live.set(key, (stream = iterator));
+				}
+				return stream.subscribe();
+			}
+		);
+	};
+	const internals: RemoteLiveInternals = {
+		type: 'query_live',
+		id: '',
+		name: '',
+		validate,
+		implementation: fn,
+		run: (store, arg) => generate(store, () => validate(arg), fn, internals.name),
+		bind: (payload, arg) => bind(getRequestStore(), payload, () => arg)
+	};
+	const invoke = (arg: unknown) => {
+		const store = getRequestStore();
+		assertDynamic(store, 'query.live', internals.name);
+		return bind(store, encodeArgument(arg, store.hooks.transport), () => validate(arg));
+	};
+	return Object.defineProperty(invoke, '__', { value: internals });
+}
+
+export const query: Query = Object.assign(single, { batch, live });

package/src/server/remote/requested.ts

@@ -0,0 +1,94 @@
+import type { Requested } from '../../types/remote-functions.ts';
+import type { RemoteExport, RemoteReadInternals } from '../../types/internal/remote.ts';
+import type { RemoteLiveQuery, RemoteQuery } from '../../types/remote.ts';
+import { decodeArgument, getRemoteKey } from '../../shared/remote.ts';
+import { getRequestStore, runRequest } from '../scope.ts';
+import { cache, refresh } from './resource.ts';
+import { thenable } from './shared.ts';
+import * as errors from './errors.ts';
+
+interface RequestedEntry {
+	arg: any;
+	query: RemoteQuery<any> | RemoteLiveQuery<any>;
+	ignore(): void;
+}
+
+export const requested: Requested = (query: unknown, limit: number): any => {
+	const store = getRequestStore();
+	const internals = (query as RemoteExport | undefined)?.__;
+	if (!internals || !['query', 'query_batch', 'query_live'].includes(internals.type))
+		errors.requestedQuery();
+	const read = internals as RemoteReadInternals;
+	if (!store.remote.mutation) errors.requestedContext();
+	if (limit !== Infinity && (!Number.isInteger(limit) || limit < 0)) errors.requestedLimit();
+	const payloads = store.remote.requested.get(read.id) ?? new Set<string>();
+	const values = [...payloads];
+	const selected = values.slice(0, limit);
+	const consume = (payload: string): void => {
+		payloads.delete(payload);
+		if (!payloads.size) store.remote.requested.delete(read.id);
+	};
+	for (const payload of values.slice(limit)) consume(payload);
+	const entry = (payload: string, arg: any): RequestedEntry => ({
+		arg,
+		query: runRequest(store, () => read.bind(payload, arg)),
+		ignore: () => {
+			store.remote.ignored.add(getRemoteKey(read.id, payload));
+		}
+	});
+	const validate = (payload: string) =>
+		runRequest(store, () => read.validate(decodeArgument(payload, store.hooks.transport)));
+	const fail = (payload: string, error: unknown): void => {
+		const pending = Promise.reject(error);
+		void pending.catch(() => {});
+		cache(store, read).set(payload, pending);
+		refresh(store, read, payload, () => pending);
+	};
+	const result = {
+		*[Symbol.iterator](): Generator<RequestedEntry> {
+			for (const payload of selected) {
+				consume(payload);
+				try {
+					const arg = validate(payload);
+					if (thenable(arg)) errors.requestedAsync(read.name, limit);
+					yield entry(payload, arg);
+				} catch (error) {
+					fail(payload, error);
+				}
+			}
+		},
+		async *[Symbol.asyncIterator](): AsyncGenerator<RequestedEntry> {
+			const pending = new Set<Promise<{ task: Promise<any>; value?: RequestedEntry }>>();
+			for (const payload of selected) {
+				consume(payload);
+				const task: Promise<{ task: Promise<any>; value?: RequestedEntry }> =
+					Promise.resolve().then(async () => {
+						try {
+							return { task, value: entry(payload, await validate(payload)) };
+						} catch (error) {
+							fail(payload, error);
+							return { task };
+						}
+					});
+				pending.add(task);
+			}
+			while (pending.size) {
+				const { task, value } = await Promise.race(pending);
+				pending.delete(task);
+				if (value) yield value;
+			}
+		},
+		async refreshAll() {
+			if (read.type === 'query_live') errors.requestedMethod('refreshAll', true);
+			for await (const { query } of result) void (query as RemoteQuery<any>).refresh();
+		},
+		async reconnectAll() {
+			if (read.type !== 'query_live') errors.requestedMethod('reconnectAll', false);
+			for await (const { query } of result) void (query as RemoteLiveQuery<any>).reconnect();
+		},
+		async ignoreAll() {
+			for await (const { ignore } of result) ignore();
+		}
+	};
+	return result;
+};

package/src/server/remote/resource.ts

@@ -0,0 +1,148 @@
+import { hydrated } from 'vigla';
+import type {
+	RemoteInternals,
+	RemoteNode,
+	RemoteReadInternals
+} from '../../types/internal/remote.ts';
+import type { RemoteLiveQuery, RemoteQuery } from '../../types/remote.ts';
+import type { RequestStore } from '../../types/internal/server.ts';
+import { getRemoteKey } from '../../shared/remote.ts';
+import { serialize } from '../../shared/serialization.ts';
+import { Redirect } from '../../shared/outcomes.ts';
+import { handleError } from '../failure.ts';
+import { server_api_unavailable } from '../errors.ts';
+import { thenable } from './shared.ts';
+
+export function cache(store: RequestStore, internals: RemoteInternals): Map<string, Promise<any>> {
+	let values = store.remote.cache.get(internals);
+	if (!values) store.remote.cache.set(internals, (values = new Map()));
+	return values;
+}
+
+export function snapshot(
+	store: RequestStore,
+	key: string,
+	read: () => RemoteNode | Promise<RemoteNode>
+): void {
+	if (store.event.isRemoteRequest || store.remote.hydration.has(key)) return;
+	store.remote.snapshots.set(key, { read });
+}
+
+export function publishSnapshots(store: RequestStore): void {
+	for (const [key, snapshot] of store.remote.snapshots) {
+		if (store.remote.hydration.has(key)) continue;
+		store.owner.run(() =>
+			hydrated(key, () => {
+				const node = snapshot.read();
+				return thenable(node)
+					? Promise.resolve(node).then((value) => serialize(value, store.hooks.transport))
+					: serialize(node, store.hooks.transport);
+			})
+		);
+		store.remote.hydration.add(key);
+	}
+}
+
+export function refresh(
+	store: RequestStore,
+	internals: RemoteInternals,
+	payload: string,
+	read: () => Promise<any>
+): void {
+	if (!internals.id || (!store.event.isRemoteRequest && store.remote.mutation)) return;
+	store.remote.explicit.set(getRemoteKey(internals.id, payload), { internals, read });
+}
+
+export function resource(
+	store: RequestStore,
+	internals: RemoteInternals,
+	payload: string,
+	execute: () => Promise<any>
+): RemoteQuery<any> {
+	let pending: Promise<any> | null = null;
+	const read = (): Promise<any> =>
+		(pending ??= Promise.resolve().then(() => {
+			const values = cache(store, internals);
+			let result = values.get(payload);
+			if (!result) values.set(payload, (result = execute()));
+			if (internals.id && !store.remote.query) {
+				const key = getRemoteKey(internals.id, payload);
+				store.remote.implicit.set(key, { internals, read });
+				if (!store.event.isRemoteRequest)
+					void result
+						.then(
+							(v) => {
+								if (store.state.active && values.get(payload) === result)
+									snapshot(store, key, () => ({ v }));
+							},
+							(error) => {
+								if (
+									error instanceof Redirect ||
+									!store.state.active ||
+									values.get(payload) !== result
+								)
+									return;
+								snapshot(store, key, () => handleError(store, error).then((e) => ({ e })));
+							}
+						)
+						.catch(() => {});
+			}
+			return result;
+		}));
+	const prime = (): void => {
+		if (store.state.isRendering) void read().catch(() => {});
+	};
+	const value = {
+		then: (resolve: any, reject: any) => read().then(resolve, reject),
+		catch: (reject: any) => read().catch(reject),
+		finally: (finish: any) => read().finally(finish),
+		get current() {
+			prime();
+			return undefined;
+		},
+		get error() {
+			prime();
+			return undefined;
+		},
+		get loading() {
+			prime();
+			return true;
+		},
+		get ready() {
+			prime();
+			return false;
+		},
+		refresh() {
+			pending = null;
+			cache(store, internals).delete(payload);
+			store.remote.snapshots.delete(getRemoteKey(internals.id, payload));
+			refresh(store, internals, payload, read);
+			return Promise.resolve();
+		},
+		set(value: any) {
+			const result = (pending = Promise.resolve(value));
+			cache(store, internals).set(payload, result);
+			if (internals.id) snapshot(store, getRemoteKey(internals.id, payload), () => ({ v: value }));
+			refresh(store, internals, payload, () => result);
+		},
+		withOverride: () => server_api_unavailable({ name: `${internals.name}.withOverride()` }),
+		[Symbol.toStringTag]: 'QueryResource'
+	};
+	return value as unknown as RemoteQuery<any>;
+}
+
+export function liveResource(
+	store: RequestStore,
+	internals: RemoteReadInternals,
+	payload: string,
+	first: () => Promise<any>,
+	iterate: () => AsyncIterableIterator<any>
+): RemoteLiveQuery<any> {
+	const value = resource(store, internals, payload, first);
+	return Object.defineProperties(value, {
+		connected: { get: () => false },
+		done: { get: () => false },
+		reconnect: { value: value.refresh },
+		[Symbol.asyncIterator]: { value: iterate }
+	}) as unknown as RemoteLiveQuery<any>;
+}