@kaito-http/core 3.0.1 → 3.0.3

package/src/handler.ts

@@ -1,96 +0,0 @@
-import type {KaitoError} from './error.ts';
-import type {KaitoRequest} from './request.ts';
-import type {Router} from './router/router.ts';
-import type {GetContext} from './util.ts';
-
-export type HandlerConfig<ContextFrom> = {
-	/**
-	 * The root router to mount on this handler.
-	 */
-	router: Router<ContextFrom, unknown, any>;
-
-	/**
-	 * 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.
-	 */
-	getContext: GetContext<ContextFrom>;
-
-	/**
-	 * A function that is called when an error occurs inside a route handler.
-	 *
-	 * The result of this function is used to determine the response status and message, and is
-	 * always sent to the client. You could include logic to check for production vs development
-	 * environments here, and this would also be a good place to include error tracking
-	 * like Sentry or Rollbar.
-	 *
-	 * @param arg - The error thrown, and the KaitoRequest instance
-	 * @returns A KaitoError or an object with a status and message
-	 */
-	onError: (arg: {error: Error; req: KaitoRequest}) => Promise<KaitoError | {status: number; message: string}>;
-
-	/**
-	 * A function that is called before every request. Most useful for bailing out early in the case of an OPTIONS request.
-	 *
-	 * @example
-	 * ```ts
-	 * before: async req => {
-	 * 	if (req.method === 'OPTIONS') {
-	 * 		return new Response(null, {status: 204});
-	 * 	}
-	 * }
-	 * ```
-	 */
-	before?: (req: Request) => Promise<Response | void | undefined>;
-
-	/**
-	 * Transforms the response before it is sent to the client. Very useful for settings headers like CORS.
-	 *
-	 * You can also return a new response in this function, or just mutate the current one.
-	 *
-	 * This function WILL receive the result of `.before()` if you return a response from it. This means
-	 *  you only need to define headers in a single place.
-	 *
-	 * @example
-	 * ```ts
-	 * transform: async (req, res) => {
-	 * 	res.headers.set('Access-Control-Allow-Origin', 'http://localhost:3000');
-	 * 	res.headers.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
-	 * 	res.headers.set('Access-Control-Allow-Headers', 'Content-Type, Authorization');
-	 * 	res.headers.set('Access-Control-Max-Age', '86400');
-	 * 	res.headers.set('Access-Control-Allow-Credentials', 'true');
-	 * }
-	 * ```
-	 */
-	transform?: (req: Request, res: Response) => Promise<Response | void | undefined>;
-};
-
-export function createKaitoHandler<Context>(config: HandlerConfig<Context>) {
-	const handle = config.router.freeze(config);
-
-	return async (request: Request): Promise<Response> => {
-		if (config.before) {
-			const result = await config.before(request);
-
-			if (result instanceof Response) {
-				if (config.transform) {
-					const result2 = await config.transform(request, result);
-					if (result2 instanceof Response) return result;
-				}
-
-				return result;
-			}
-		}
-
-		const response = await handle(request);
-
-		if (config.transform) {
-			const result = await config.transform(request, response);
-			if (result instanceof Response) return result;
-		}
-
-		return response;
-	};
-}

package/src/head.ts

@@ -1,83 +0,0 @@
-import type {APIResponse} from './util.ts';
-
-/**
- * This class is merely a wrapper around a `Headers` object and a status code.
- * It's used while the router is executing a route to store any mutations to the status
- * code or headers that the developer may want to make.
- *
- * This exists because there's otherwise no way to indicate back to Kaito that
- * the developer wants to change the status code or headers.
- *
- * @example
- * ```ts
- * const response = new KaitoHead();
- *
- * response.status(200);
- * response.headers.set('Content-Type', 'application/json');
- *
- * console.log(response.headers); // Headers {'content-type': 'application/json'}
- * ```
- */
-export class KaitoHead {
-	private _headers: Headers | null;
-	private _status: number;
-
-	public constructor() {
-		this._headers = null;
-		this._status = 200;
-	}
-
-	public get headers() {
-		if (this._headers === null) {
-			this._headers = new Headers();
-		}
-
-		return this._headers;
-	}
-
-	/**
-	 * Gets the status code of this KaitoHead instance
-	 * @returns The status code
-	 */
-	public status(): number;
-
-	/**
-	 * Sets the status code of this KaitoHead instance
-	 * @param status The status code to set
-	 * @returns This KaitoHead instance
-	 */
-	public status(status: number): this;
-
-	public status(status?: number) {
-		if (status === undefined) {
-			return this._status;
-		}
-
-		this._status = status;
-		return this;
-	}
-
-	/**
-	 * Turn this KaitoHead instance into a Response instance
-	 * @param body The Kaito JSON format to be sent as the response body
-	 * @returns A Response instance, ready to be sent
-	 */
-	public toResponse<T>(body: APIResponse<T>): Response {
-		const init: ResponseInit = {
-			status: this._status,
-		};
-
-		if (this._headers) {
-			init.headers = this._headers;
-		}
-
-		return Response.json(body, init);
-	}
-
-	/**
-	 * Whether this KaitoHead instance has been touched/modified
-	 */
-	public get touched() {
-		return this._status !== 200 || this._headers !== null;
-	}
-}

package/src/index.ts

@@ -1,7 +0,0 @@
-export * from './error.ts';
-export * from './handler.ts';
-export * from './request.ts';
-export * from './route.ts';
-export * from './router/router.ts';
-export type {KaitoMethod} from './router/types.ts';
-export * from './util.ts';

package/src/request.ts

@@ -1,47 +0,0 @@
-export class KaitoRequest {
-	public readonly url: URL;
-
-	private readonly _request: Request;
-
-	public constructor(url: URL, request: Request) {
-		this._request = request;
-		this.url = url;
-	}
-
-	public get headers() {
-		return this._request.headers;
-	}
-
-	public get method() {
-		return this._request.method;
-	}
-
-	public async arrayBuffer(): Promise<ArrayBuffer> {
-		return this._request.arrayBuffer();
-	}
-
-	public async blob(): Promise<Blob> {
-		return this._request.blob();
-	}
-
-	public async formData(): Promise<FormData> {
-		return this._request.formData();
-	}
-
-	public async bytes(): Promise<Uint8Array> {
-		const buffer = await this.arrayBuffer();
-		return new Uint8Array(buffer);
-	}
-
-	public async json(): Promise<unknown> {
-		return this._request.json();
-	}
-
-	public async text(): Promise<string> {
-		return this._request.text();
-	}
-
-	public get request() {
-		return this._request;
-	}
-}

package/src/route.ts

@@ -1,52 +0,0 @@
-import type {KaitoMethod} from './router/types.ts';
-import type {ExtractRouteParams, InferParsable, Parsable} from './util.ts';
-
-export type RouteArgument<Path extends string, Context, QueryOutput, BodyOutput> = {
-	ctx: Context;
-	body: BodyOutput;
-	query: QueryOutput;
-	params: ExtractRouteParams<Path>;
-};
-
-export type AnyQueryDefinition = Record<string, Parsable<any, string | undefined>>;
-
-export type Through<From, To> = (context: From) => Promise<To>;
-
-export type Route<
-	// Router context
-	ContextFrom,
-	ContextTo,
-	// Route information
-	Result,
-	Path extends string,
-	Method extends KaitoMethod,
-	// Schemas
-	Query extends AnyQueryDefinition,
-	Body extends Parsable,
-> = {
-	through: Through<ContextFrom, ContextTo>;
-	body?: Body;
-	query?: Query;
-	path: Path;
-	method: Method;
-	run(
-		arg: RouteArgument<
-			Path,
-			ContextTo,
-			{
-				[Key in keyof Query]: InferParsable<Query[Key]>['output'];
-			},
-			InferParsable<Body>['output']
-		>,
-	): Promise<Result>;
-};
-
-export type AnyRoute<ContextFrom = any, ContextTo = any> = Route<
-	ContextFrom,
-	ContextTo,
-	any,
-	any,
-	any,
-	AnyQueryDefinition,
-	any
->;

package/src/router/router.test.ts

@@ -1,269 +0,0 @@
-import assert from 'node:assert';
-import {describe, it} from 'node:test';
-import {z} from 'zod';
-import {KaitoError} from '../error.ts';
-import {Router} from './router.ts';
-
-type Context = {
-	userId: string;
-};
-
-type AuthContext = Context & {
-	isAdmin: boolean;
-};
-
-describe('Router', () => {
-	describe('create', () => {
-		it('should create an empty router', () => {
-			const router = Router.create<Context>();
-			assert.strictEqual(router.routes.size, 0);
-		});
-	});
-
-	describe('route handling', () => {
-		it('should handle GET requests', async () => {
-			const router = Router.create<Context>().get('/users', {
-				run: async () => ({users: []}),
-			});
-
-			const handler = router.freeze({
-				getContext: async () => ({userId: '123'}),
-				onError: async () => ({status: 500, message: 'Internal Server Error'}),
-			});
-
-			const response = await handler(new Request('http://localhost/users', {method: 'GET'}));
-			const data = await response.json();
-
-			assert.strictEqual(response.status, 200);
-			assert.deepStrictEqual(data, {
-				success: true,
-				data: {users: []},
-				message: 'OK',
-			});
-		});
-
-		it('should handle POST requests with body parsing', async () => {
-			const router = Router.create<Context>().post('/users', {
-				body: z.object({name: z.string()}),
-				run: async ({body}) => ({id: '1', name: body.name}),
-			});
-
-			const handler = router.freeze({
-				getContext: async () => ({userId: '123'}),
-				onError: async () => ({status: 500, message: 'Internal Server Error'}),
-			});
-
-			const response = await handler(
-				new Request('http://localhost/users', {
-					method: 'POST',
-					headers: {'Content-Type': 'application/json'},
-					body: JSON.stringify({name: 'John'}),
-				}),
-			);
-			const data = await response.json();
-
-			assert.strictEqual(response.status, 200);
-			assert.deepStrictEqual(data, {
-				success: true,
-				data: {id: '1', name: 'John'},
-				message: 'OK',
-			});
-		});
-
-		it('should handle URL parameters', async () => {
-			const router = Router.create<Context>().get('/users/:id', {
-				run: async ({params}) => ({id: params.id}),
-			});
-
-			const handler = router.freeze({
-				getContext: async () => ({userId: '123'}),
-				onError: async () => ({status: 500, message: 'Internal Server Error'}),
-			});
-
-			const response = await handler(new Request('http://localhost/users/456', {method: 'GET'}));
-			const data = await response.json();
-
-			assert.strictEqual(response.status, 200);
-			assert.deepStrictEqual(data, {
-				success: true,
-				data: {id: '456'},
-				message: 'OK',
-			});
-		});
-
-		it('should handle query parameters', async () => {
-			const router = Router.create<Context>().get('/search', {
-				query: {
-					q: z.string(),
-					limit: z
-						.string()
-						.transform(value => Number(value))
-						.pipe(z.number()),
-				},
-				run: async ({query}) => ({
-					query: query.q,
-					limit: query.limit,
-				}),
-			});
-
-			const handler = router.freeze({
-				getContext: async () => ({userId: '123'}),
-				onError: async () => ({status: 500, message: 'Internal Server Error'}),
-			});
-
-			const response = await handler(new Request('http://localhost/search?q=test&limit=10', {method: 'GET'}));
-			const data = await response.json();
-
-			assert.strictEqual(response.status, 200);
-			assert.deepStrictEqual(data, {
-				success: true,
-				data: {query: 'test', limit: 10},
-				message: 'OK',
-			});
-		});
-	});
-
-	describe('middleware and context', () => {
-		it('should transform context through middleware', async () => {
-			const router = Router.create<Context>()
-				.through(async ctx => ({
-					...ctx,
-					isAdmin: ctx.userId === 'admin',
-				}))
-				.get('/admin', {
-					run: async ({ctx}) => ({
-						isAdmin: (ctx as AuthContext).isAdmin,
-					}),
-				});
-
-			const handler = router.freeze({
-				getContext: async () => ({userId: 'admin'}),
-				onError: async () => ({status: 500, message: 'Internal Server Error'}),
-			});
-
-			const response = await handler(new Request('http://localhost/admin', {method: 'GET'}));
-			const data = await response.json();
-
-			assert.strictEqual(response.status, 200);
-			assert.deepStrictEqual(data, {
-				success: true,
-				data: {isAdmin: true},
-				message: 'OK',
-			});
-		});
-	});
-
-	describe('error handling', () => {
-		it('should handle KaitoError with custom status', async () => {
-			const router = Router.create<Context>().get('/error', {
-				run: async () => {
-					throw new KaitoError(403, 'Forbidden');
-				},
-			});
-
-			const handler = router.freeze({
-				getContext: async () => ({userId: '123'}),
-				onError: async () => ({status: 500, message: 'Internal Server Error'}),
-			});
-
-			const response = await handler(new Request('http://localhost/error', {method: 'GET'}));
-			const data = await response.json();
-
-			assert.strictEqual(response.status, 403);
-			assert.deepStrictEqual(data, {
-				success: false,
-				data: null,
-				message: 'Forbidden',
-			});
-		});
-
-		it('should handle generic errors with server error handler', async () => {
-			const router = Router.create<Context>().get('/error', {
-				run: async () => {
-					throw new Error('Something went wrong');
-				},
-			});
-
-			const handler = router.freeze({
-				getContext: async () => ({userId: '123'}),
-				onError: async () => ({status: 500, message: 'Custom Error Message'}),
-			});
-
-			const response = await handler(new Request('http://localhost/error', {method: 'GET'}));
-			const data = await response.json();
-
-			assert.strictEqual(response.status, 500);
-			assert.deepStrictEqual(data, {
-				success: false,
-				data: null,
-				message: 'Custom Error Message',
-			});
-		});
-	});
-
-	describe('router merging', () => {
-		it('should merge routers with prefix', async () => {
-			const userRouter = Router.create<Context>().get('/me', {
-				run: async ({ctx}) => ({id: ctx.userId}),
-			});
-
-			const mainRouter = Router.create<Context>().merge('/api', userRouter);
-
-			const handler = mainRouter.freeze({
-				getContext: async () => ({userId: '123'}),
-				onError: async () => ({status: 500, message: 'Internal Server Error'}),
-			});
-
-			const response = await handler(new Request('http://localhost/api/me', {method: 'GET'}));
-			const data = await response.json();
-
-			assert.strictEqual(response.status, 200);
-			assert.deepStrictEqual(data, {
-				success: true,
-				data: {id: '123'},
-				message: 'OK',
-			});
-		});
-	});
-
-	describe('404 handling', () => {
-		it('should return 404 for non-existent routes', async () => {
-			const router = Router.create<Context>();
-			const handler = router.freeze({
-				getContext: async () => ({userId: '123'}),
-				onError: async () => ({status: 500, message: 'Internal Server Error'}),
-			});
-
-			const response = await handler(new Request('http://localhost/not-found', {method: 'GET'}));
-			const data = await response.json();
-
-			assert.strictEqual(response.status, 404);
-			assert.deepStrictEqual(data, {
-				success: false,
-				data: null,
-				message: 'Cannot GET /not-found',
-			});
-		});
-
-		it('should return 404 for wrong method on existing path', async () => {
-			const router = Router.create<Context>().get('/users', {
-				run: async () => ({users: []}),
-			});
-
-			const handler = router.freeze({
-				getContext: async () => ({userId: '123'}),
-				onError: async () => ({status: 500, message: 'Internal Server Error'}),
-			});
-
-			const response = await handler(new Request('http://localhost/users', {method: 'POST'}));
-			const data = await response.json();
-
-			assert.strictEqual(response.status, 404);
-			assert.deepStrictEqual(data, {
-				success: false,
-				data: null,
-				message: 'Cannot POST /users',
-			});
-		});
-	});
-});