@kaito-http/core 3.0.1 → 3.0.2

package/src/stream/stream.ts

@@ -1,156 +0,0 @@
-export class KaitoSSEResponse<_T> extends Response {
-	constructor(body: ReadableStream<string>, init?: ResponseInit) {
-		const headers = new Headers(init?.headers);
-
-		headers.set('Content-Type', 'text/event-stream');
-		headers.set('Cache-Control', 'no-cache');
-		headers.set('Connection', 'keep-alive');
-
-		super(body, {
-			...init,
-			headers,
-		});
-	}
-
-	async *[Symbol.asyncIterator]() {
-		for await (const chunk of this.body!) {
-			yield chunk;
-		}
-	}
-}
-
-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

@@ -1,83 +0,0 @@
-import type {KaitoHead} from './head.ts';
-import type {KaitoRequest} from './request.ts';
-import {Router} from './router/router.ts';
-
-/**
- * A helper to check if the environment is Node.js-like and the NODE_ENV is development
- */
-export const isNodeLikeDev =
-	typeof process !== 'undefined' && typeof process.env !== 'undefined' && process.env.NODE_ENV === 'development';
-
-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}
-			: {};
-
-/**
- * A function that is called to get the context for a request.
- *
- * This is useful for things like authentication, to pass in a database connection, etc.
- *
- * It's fine for this function to throw; if it does, the error is passed to the `onError` function.
- *
- * @param req - The kaito request object, which contains the request method, url, headers, etc
- * @param head - The kaito head object, which contains getters and setters for headers and status
- * @returns The context for your routes
- */
-export type GetContext<Result> = (req: KaitoRequest, head: KaitoHead) => 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 = createKaitoHandler({
- *   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>;
-}