@kaito-http/core 3.0.1 → 3.0.3

package/src/router/router.ts

@@ -1,264 +0,0 @@
-import {KaitoError, WrappedError} from '../error.ts';
-import type {HandlerConfig} from '../handler.ts';
-import {KaitoHead} from '../head.ts';
-import {KaitoRequest} from '../request.ts';
-import type {AnyQueryDefinition, AnyRoute, Route} from '../route.ts';
-import {isNodeLikeDev, type ErroredAPIResponse, type Parsable} from '../util.ts';
-import type {KaitoMethod} from './types.ts';
-
-type PrefixRoutesPathInner<R extends AnyRoute, Prefix extends `/${string}`> =
-	R extends Route<
-		infer ContextFrom,
-		infer ContextTo,
-		infer Result,
-		infer Path,
-		infer Method,
-		infer Query,
-		infer BodyOutput
-	>
-		? Route<ContextFrom, ContextTo, Result, `${Prefix}${Path}`, Method, Query, BodyOutput>
-		: never;
-
-type PrefixRoutesPath<Prefix extends `/${string}`, R extends AnyRoute> = R extends R
-	? PrefixRoutesPathInner<R, Prefix>
-	: never;
-
-export type RouterState<Routes extends AnyRoute, ContextFrom, ContextTo> = {
-	routes: Set<Routes>;
-	through: (context: ContextFrom) => Promise<ContextTo>;
-};
-
-export type InferRoutes<R extends Router<any, any, any>> = R extends Router<any, any, infer R> ? R : never;
-
-export class Router<ContextFrom, ContextTo, R extends AnyRoute> {
-	private readonly state: RouterState<R, ContextFrom, ContextTo>;
-
-	public static create = <Context>(): Router<Context, Context, never> =>
-		new Router<Context, Context, never>({
-			through: async context => context,
-			routes: new Set(),
-		});
-
-	private static parseQuery<T extends AnyQueryDefinition>(schema: T | undefined, url: URL) {
-		if (!schema) {
-			return {};
-		}
-
-		const result: Record<PropertyKey, unknown> = {};
-		for (const key in schema) {
-			if (!schema.hasOwnProperty(key)) continue;
-			const value = url.searchParams.get(key);
-			result[key] = (schema[key] as Parsable).parse(value);
-		}
-
-		return result as {
-			[Key in keyof T]: ReturnType<T[Key]['parse']>;
-		};
-	}
-
-	public constructor(options: RouterState<R, ContextFrom, ContextTo>) {
-		this.state = options;
-	}
-
-	public get routes() {
-		return this.state.routes;
-	}
-
-	public add = <
-		Result,
-		Path extends string,
-		Method extends KaitoMethod,
-		Query extends AnyQueryDefinition = {},
-		Body extends Parsable = never,
-	>(
-		method: Method,
-		path: Path,
-		route:
-			| (Method extends 'GET'
-					? Omit<
-							Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>,
-							'body' | 'path' | 'method' | 'through'
-						>
-					: Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>, 'path' | 'method' | 'through'>)
-			| Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>['run'],
-	): Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body>> => {
-		const merged: Route<ContextFrom, ContextTo, Result, Path, Method, Query, Body> = {
-			// TODO: Ideally fix the typing here, but this will be replaced in Kaito v4 where all routes must return a Response (which we can type)
-			...((typeof route === 'object' ? route : {run: route}) as {run: never}),
-			method,
-			path,
-			through: this.state.through,
-		};
-
-		return new Router({
-			...this.state,
-			routes: new Set([...this.state.routes, merged]),
-		});
-	};
-
-	public readonly merge = <PathPrefix extends `/${string}`, OtherRoutes extends AnyRoute>(
-		pathPrefix: PathPrefix,
-		other: Router<ContextFrom, unknown, OtherRoutes>,
-	): Router<ContextFrom, ContextTo, Extract<R | PrefixRoutesPath<PathPrefix, OtherRoutes>, AnyRoute>> => {
-		const newRoutes = [...other.state.routes].map(route => ({
-			...route,
-			path: `${pathPrefix}${route.path as string}`,
-		}));
-
-		return new Router<ContextFrom, ContextTo, Extract<R | PrefixRoutesPath<PathPrefix, OtherRoutes>, AnyRoute>>({
-			...this.state,
-			routes: new Set([...this.state.routes, ...newRoutes] as never),
-		});
-	};
-
-	public freeze = (server: Omit<HandlerConfig<ContextFrom>, 'router'>) => {
-		const routes = new Map<string, Map<KaitoMethod, AnyRoute>>();
-
-		for (const route of this.state.routes) {
-			if (!routes.has(route.path)) {
-				routes.set(route.path, new Map());
-			}
-
-			routes.get(route.path)!.set(route.method, route);
-		}
-
-		const findRoute = (method: KaitoMethod, path: string): {route?: AnyRoute; params: Record<string, string>} => {
-			const params: Record<string, string> = {};
-			const pathParts = path.split('/').filter(Boolean);
-
-			for (const [routePath, methodHandlers] of routes) {
-				const routeParts = routePath.split('/').filter(Boolean);
-
-				if (routeParts.length !== pathParts.length) continue;
-
-				let matches = true;
-				for (let i = 0; i < routeParts.length; i++) {
-					const routePart = routeParts[i];
-					const pathPart = pathParts[i];
-
-					if (routePart && pathPart && routePart.startsWith(':')) {
-						params[routePart.slice(1)] = pathPart;
-					} else if (routePart !== pathPart) {
-						matches = false;
-						break;
-					}
-				}
-
-				if (matches) {
-					const route = methodHandlers.get(method);
-					if (route) return {route, params};
-				}
-			}
-
-			return {params};
-		};
-
-		return async (req: Request): Promise<Response> => {
-			const url = new URL(req.url);
-			const method = req.method as KaitoMethod;
-
-			const {route, params} = findRoute(method, url.pathname);
-
-			if (!route) {
-				const body: ErroredAPIResponse = {
-					success: false,
-					data: null,
-					message: `Cannot ${method} ${url.pathname}`,
-				};
-
-				return Response.json(body, {status: 404});
-			}
-
-			const request = new KaitoRequest(url, req);
-			const head = new KaitoHead();
-
-			try {
-				const body = route.body ? await route.body.parse(await req.json()) : undefined;
-				const query = Router.parseQuery(route.query, url);
-
-				const rootCtx = await server.getContext(request, head);
-				const ctx = await route.through(rootCtx);
-
-				const result = await route.run({
-					ctx,
-					body,
-					query,
-					params,
-				});
-
-				if (result instanceof Response) {
-					if (isNodeLikeDev) {
-						if (head.touched) {
-							const msg = [
-								'Kaito detected that you used the KaitoHead object to modify the headers or status, but then returned a Response in the route',
-								'This is usually a mistake, as your Response object will override any changes you made to the headers or status code.',
-								'',
-								'This warning was shown because `process.env.NODE_ENV=development`',
-							].join('\n');
-
-							console.warn(msg);
-						}
-					}
-
-					return result;
-				}
-
-				return head.toResponse({
-					success: true,
-					data: result,
-					message: 'OK',
-				});
-			} catch (e) {
-				const error = WrappedError.maybe(e);
-
-				if (error instanceof KaitoError) {
-					return head.status(error.status).toResponse({
-						success: false,
-						data: null,
-						message: error.message,
-					});
-				}
-
-				const {status, message} = await server
-					.onError({error, req: request})
-					.catch(() => ({status: 500, message: 'Internal Server Error'}));
-
-				return head.status(status).toResponse({
-					success: false,
-					data: null,
-					message,
-				});
-			}
-		};
-	};
-
-	private readonly method =
-		<M extends KaitoMethod>(method: M) =>
-		<Result, Path extends string, Query extends AnyQueryDefinition = {}, Body extends Parsable = never>(
-			path: Path,
-			route:
-				| (M extends 'GET'
-						? Omit<Route<ContextFrom, ContextTo, Result, Path, M, Query, Body>, 'body' | 'path' | 'method' | 'through'>
-						: Omit<Route<ContextFrom, ContextTo, Result, Path, M, Query, Body>, 'path' | 'method' | 'through'>)
-				| Route<ContextFrom, ContextTo, Result, Path, M, Query, Body>['run'],
-		) => {
-			return this.add<Result, Path, M, Query, Body>(method, path, route);
-		};
-
-	public get = this.method('GET');
-	public post = this.method('POST');
-	public put = this.method('PUT');
-	public patch = this.method('PATCH');
-	public delete = this.method('DELETE');
-	public head = this.method('HEAD');
-	public options = this.method('OPTIONS');
-
-	public through = <NextContext>(
-		through: (context: ContextTo) => Promise<NextContext>,
-	): Router<ContextFrom, NextContext, R> => {
-		return new Router<ContextFrom, NextContext, R>({
-			...this.state,
-			through: async context => through(await this.state.through(context)),
-		});
-	};
-}

package/src/router/types.ts

@@ -1 +0,0 @@
-export type KaitoMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'CONNECT' | 'TRACE';

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>;
-}