@kaito-http/core 3.0.0-beta.16 → 3.0.0-beta.21

package/src/stream/stream.ts

@@ -0,0 +1,159 @@
+export class KaitoStreamResponse<R> extends Response {
+	constructor(body: ReadableStream<R>) {
+		super(body, {
+			headers: {
+				'Content-Type': 'text/event-stream',
+				'Cache-Control': 'no-cache',
+				Connection: 'keep-alive',
+			},
+		});
+	}
+
+	async *[Symbol.asyncIterator]() {
+		for await (const chunk of this.body!) {
+			yield chunk;
+		}
+	}
+}
+
+export class KaitoSSEResponse<_ClientType> extends KaitoStreamResponse<string> {}
+
+export function stream<R>(body: UnderlyingDefaultSource<R>): KaitoStreamResponse<R> {
+	return new KaitoStreamResponse<R>(new ReadableStream(body));
+}
+
+export type SSEEvent<T, E extends string> = (
+	| {
+			data: T;
+			event?: E | undefined;
+	  }
+	| {
+			data?: T | undefined;
+			event: E;
+	  }
+) & {
+	retry?: number;
+	id?: string;
+};
+
+/**
+ * Converts an SSE Event into a string, ready for sending to the client
+ * @param event The SSE Event
+ * @returns A stringified version
+ */
+export function sseEventToString(event: SSEEvent<unknown, string>): string {
+	let result = '';
+
+	if (event.event) {
+		result += `event:${event.event}\n`;
+	}
+
+	if (event.id) {
+		result += `id:${event.id}\n`;
+	}
+
+	if (event.retry) {
+		result += `retry:${event.retry}\n`;
+	}
+
+	if (event.data !== undefined) {
+		result += `data:${JSON.stringify(event.data)}`;
+	}
+
+	return result;
+}
+
+export class SSEController<U, E extends string> implements Disposable {
+	private readonly controller: ReadableStreamDefaultController<string>;
+
+	public constructor(controller: ReadableStreamDefaultController<string>) {
+		this.controller = controller;
+	}
+
+	public enqueue(event: SSEEvent<U, E>): void {
+		this.controller.enqueue(sseEventToString(event) + '\n\n');
+	}
+
+	public close(): void {
+		this.controller.close();
+	}
+
+	[Symbol.dispose](): void {
+		this.close();
+	}
+}
+
+export interface SSESource<U, E extends string> {
+	cancel?: UnderlyingSourceCancelCallback;
+	start?(controller: SSEController<U, E>): Promise<void>;
+	pull?(controller: SSEController<U, E>): Promise<void>;
+}
+
+function sseFromSource<U, E extends string>(source: SSESource<U, E>) {
+	const start = source.start;
+	const pull = source.pull;
+	const cancel = source.cancel;
+
+	const readable = new ReadableStream<string>({
+		...(cancel ? {cancel} : {}),
+
+		...(start
+			? {
+					start: async controller => {
+						await start(new SSEController<U, E>(controller));
+					},
+				}
+			: {}),
+
+		...(pull
+			? {
+					pull: async controller => {
+						await pull(new SSEController<U, E>(controller));
+					},
+				}
+			: {}),
+	});
+
+	return new KaitoSSEResponse<SSEEvent<U, E>>(readable);
+}
+
+export function sse<U, E extends string, T extends SSEEvent<U, E>>(
+	source: SSESource<U, E> | AsyncGenerator<T, unknown, unknown> | (() => AsyncGenerator<T, unknown, unknown>),
+): KaitoSSEResponse<T> {
+	const evaluated = typeof source === 'function' ? source() : source;
+
+	if ('next' in evaluated) {
+		const generator = evaluated;
+		return sseFromSource<U, E>({
+			async start(controller) {
+				// TODO: use `using` once Node.js supports it
+				// // ensures close is called on controller when we're done
+				// using c = controller;
+				try {
+					for await (const event of generator) {
+						controller.enqueue(event);
+					}
+				} finally {
+					controller.close();
+				}
+			},
+		});
+	} else {
+		// if the SSESource interface is used only strings are permitted.
+		// serialization / deserialization for objects is left to the user
+		return sseFromSource<U, E>(evaluated);
+	}
+}
+
+export function sseFromAnyReadable<R, U, E extends string>(
+	stream: ReadableStream<R>,
+	transform: (chunk: R) => SSEEvent<U, E>,
+): KaitoSSEResponse<SSEEvent<U, E>> {
+	const transformer = new TransformStream({
+		transform: (chunk, controller) => {
+			controller.enqueue(transform(chunk));
+		},
+	});
+
+	return sse(stream.pipeThrough(transformer));
+}

package/src/util.ts

@@ -0,0 +1,66 @@
+import type {KaitoRequest} from './request.ts';
+import type {KaitoResponse} from './response.ts';
+import {Router} from './router/router.ts';
+
+export type ErroredAPIResponse = {success: false; data: null; message: string};
+export type SuccessfulAPIResponse<T> = {success: true; data: T; message: 'OK'};
+export type APIResponse<T> = ErroredAPIResponse | SuccessfulAPIResponse<T>;
+export type AnyResponse = APIResponse<unknown>;
+export type MakeOptional<T, K extends keyof T> = T extends T ? Omit<T, K> & Partial<Pick<T, K>> : never;
+
+export type ExtractRouteParams<T extends string> = string extends T
+	? Record<string, string>
+	: T extends `${string}:${infer Param}/${infer Rest}`
+		? {[k in Param | keyof ExtractRouteParams<Rest>]: string}
+		: T extends `${string}:${infer Param}`
+			? {[k in Param]: string}
+			: {};
+
+export type GetContext<Result> = (req: KaitoRequest, res: KaitoResponse) => Promise<Result>;
+
+/**
+ * A helper function to create typed necessary functions
+ *
+ * @example
+ * ```ts
+ * const {router, getContext} = createUtilities(async (req, res) => {
+ *   // Return context here
+ * })
+ *
+ * const app = router().get('/', async () => "hello");
+ *
+ * const server = createServer({
+ *   router: app,
+ *   getContext,
+ *   // ...
+ * });
+ * ```
+ */
+export function createUtilities<Context>(getContext: GetContext<Context>): {
+	getContext: GetContext<Context>;
+	router: () => Router<Context, Context, never>;
+} {
+	return {
+		getContext,
+		router: () => Router.create<Context>(),
+	};
+}
+
+export interface Parsable<Output = any, Input = Output> {
+	_input: Input;
+	parse: (value: unknown) => Output;
+}
+
+export type InferParsable<T> =
+	T extends Parsable<infer Output, infer Input>
+		? {
+				input: Input;
+				output: Output;
+			}
+		: never;
+
+export function parsable<T>(parse: (value: unknown) => T): Parsable<T, T> {
+	return {
+		parse,
+	} as Parsable<T, T>;
+}