@kaito-http/core 2.4.0 → 2.6.0

package/dist/declarations/src/index.d.ts

@@ -1,8 +1,8 @@
 export type { HTTPMethod } from 'find-my-way';
-export * from './server';
-export * from './router';
-export * from './route';
-export * from './util';
+export * from './error';
 export * from './req';
 export * from './res';
-export * from './error';
+export * from './route';
+export * from './router';
+export * from './server';
+export * from './util';

package/dist/declarations/src/req.d.ts

@@ -1,14 +1,33 @@
 /// <reference types="node" />
-import { HTTPMethod } from 'find-my-way';
-import { IncomingMessage } from 'http';
+import type { HTTPMethod } from 'find-my-way';
+import type { IncomingMessage } from 'node:http';
 export declare class KaitoRequest {
     readonly raw: IncomingMessage;
     private _url;
     constructor(raw: IncomingMessage);
+    /**
+     * The full URL of the request, including the protocol, hostname, and path.
+     * Note: does not include the query string or hash
+     */
     get fullURL(): string;
+    /**
+     * A new URL instance for the full URL of the request.
+     */
     get url(): URL;
+    /**
+     * The HTTP method of the request.
+     */
     get method(): HTTPMethod;
+    /**
+     * The protocol of the request, either `http` or `https`.
+     */
     get protocol(): 'http' | 'https';
+    /**
+     * The request headers
+     */
     get headers(): import("http").IncomingHttpHeaders;
+    /**
+     * The hostname of the request.
+     */
     get hostname(): string;
 }

package/dist/declarations/src/res.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
-import { ServerResponse } from 'http';
+import type { ServerResponse } from 'node:http';
+import type { CookieSerializeOptions } from 'cookie';
 export declare type ErroredAPIResponse = {
     success: false;
     data: null;
@@ -15,7 +16,31 @@ export declare type AnyResponse = APIResponse<unknown>;
 export declare class KaitoResponse<T = unknown> {
     readonly raw: ServerResponse;
     constructor(raw: ServerResponse);
+    /**
+     * Send a response
+     * @param key The key of the header
+     * @param value The value of the header
+     * @returns The response object
+     */
     header(key: string, value: string | readonly string[]): this;
+    /**
+     * Set the status code of the response
+     * @param code The status code
+     * @returns The response object
+     */
     status(code: number): this;
+    /**
+     * Set a cookie
+     * @param name The name of the cookie
+     * @param value The value of the cookie
+     * @param options The options for the cookie
+     * @returns The response object
+     */
+    cookie(name: string, value: string, options: CookieSerializeOptions): this;
+    /**
+     * Send a JSON APIResponse body
+     * @param data The data to send
+     * @returns The response object
+     */
     json(data: APIResponse<T>): this;
 }

package/dist/declarations/src/route.d.ts

@@ -1,13 +1,17 @@
-import { z } from 'zod';
-import { ExtractRouteParams, KaitoMethod } from './util';
-export declare type RouteArgument<Path extends string, Context, Input extends z.ZodSchema> = {
+import type { z } from 'zod';
+import type { ExtractRouteParams, KaitoMethod } from './util';
+export declare type RouteArgument<Path extends string, Context, QueryOutput, BodyOutput> = {
     ctx: Context;
-    input: z.infer<Input>;
+    body: BodyOutput;
+    query: QueryOutput;
     params: ExtractRouteParams<Path>;
 };
-export declare type Route<Context, Result, Path extends string, Method extends KaitoMethod, Input extends z.ZodSchema> = {
-    input?: Input;
+export declare type AnyQueryDefinition = Record<string, z.ZodTypeAny>;
+export declare type Route<Context, Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition, BodyOutput, BodyDef extends z.ZodTypeDef, BodyInput> = {
+    body?: z.ZodType<BodyOutput, BodyDef, BodyInput>;
+    query?: Query;
     path: Path;
     method: Method;
-    run(args: RouteArgument<Path, Context, Input>): Promise<Result>;
+    run(args: RouteArgument<Path, Context, z.infer<z.ZodObject<Query>>, BodyOutput>): Promise<Result>;
 };
+export declare type AnyRoute<Context = any> = Route<Context, any, any, any, AnyQueryDefinition, any, any, any>;

package/dist/declarations/src/router.d.ts

@@ -1,27 +1,21 @@
-import fmw, { HTTPMethod, Instance } from 'find-my-way';
+import fmw from 'find-my-way';
 import { z } from 'zod';
-import { Route } from './route';
-import { ServerConfig } from './server';
-import { KaitoMethod } from './util';
-export declare type RoutesInit<Context> = Array<Route<Context, unknown, string, KaitoMethod, z.ZodSchema>>;
-export declare type MergePaths<Routes extends RoutesInit<unknown>, Prefix extends string> = Routes extends [
-    infer R,
-    ...infer Rest
-] ? R extends Route<infer Context, infer Result, infer Path, infer Method, infer Input> ? [Route<Context, Result, `${Prefix}${Path}`, Method, Input>, ...MergePaths<Extract<Rest, RoutesInit<any>>, Prefix>] : MergePaths<Extract<Rest, RoutesInit<any>>, Prefix> : [];
-export declare class Router<Context, Routes extends RoutesInit<Context>> {
-    static create<Context = null>(): Router<Context, []>;
+import type { AnyQueryDefinition, AnyRoute, Route } from './route';
+import type { ServerConfig } from './server';
+import type { KaitoMethod } from './util';
+declare type Routes = readonly AnyRoute[];
+declare type RemapRoutePrefix<R extends AnyRoute, Prefix extends `/${string}`> = R extends Route<infer Context, infer Result, infer Path, infer Method, infer Query, infer BodyOutput, infer BodyDef, infer BodyInput> ? Route<Context, Result, `${Prefix}${Path}`, Method, Query, BodyOutput, BodyDef, BodyInput> : never;
+declare type PrefixRoutesPath<Prefix extends `/${string}`, R extends Routes> = R extends [infer First, ...infer Rest] ? [
+    RemapRoutePrefix<Extract<First, AnyRoute>, Prefix>,
+    ...PrefixRoutesPath<Prefix, Extract<Rest, readonly AnyRoute[]>>
+] : [];
+export declare class Router<Context, R extends Routes> {
+    readonly routes: R;
+    static create: <Context_1>() => Router<Context_1, []>;
     private static handle;
-    readonly 'routes': Routes;
-    private constructor();
-    toFindMyWay(server: ServerConfig<Context>): Instance<fmw.HTTPVersion.V1>;
-    add<Method extends HTTPMethod, Path extends string, Result, Input extends z.ZodSchema>(route: Route<Context, Result, Path, Method, Input>): Router<Context, [...Routes, Route<Context, Result, Path, Method, Input>]>;
-    map(): { [Method in Routes[number]["method"]]: { [R in Extract<Routes[number], {
-        method: Method;
-    }> as R["path"]]: R; }; };
-    merge<Prefix extends string, NewRoutes extends RoutesInit<Context>>(prefix: Prefix, router: Router<Context, NewRoutes>): Router<Context, [...Routes, ...MergePaths<NewRoutes, Prefix>]>;
-    private copyContext;
+    constructor(routes: R);
+    add: <Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(route: Method extends "GET" ? Omit<Route<Context, Result, Path, Method, Query, BodyOutput, BodyDef, BodyInput>, "body"> : Route<Context, Result, Path, Method, Query, BodyOutput, BodyDef, BodyInput>) => Router<Context, [...R, Route<Context, Result, Path, Method, Query, BodyOutput, BodyDef, BodyInput>]>;
+    merge: <PathPrefix extends `/${string}`, OtherRoutes extends Routes>(pathPrefix: PathPrefix, other: Router<Context, OtherRoutes>) => Router<Context, [...R, ...PrefixRoutesPath<PathPrefix, OtherRoutes>]>;
+    toFindMyWay: (server: ServerConfig<Context, any>) => fmw.Instance<fmw.HTTPVersion.V1>;
 }
-/**
- * @deprecated Please use Router#create instead
- */
-export declare const createRouter: typeof Router.create;
+export {};

package/dist/declarations/src/server.d.ts

@@ -1,15 +1,35 @@
 /// <reference types="node" />
-import { Router } from './router';
-import * as http from 'http';
-import { KaitoRequest } from './req';
-import { KaitoResponse } from './res';
-import { KaitoError } from './error';
-import { GetContext } from './util';
-export declare type Before = (req: http.IncomingMessage, res: http.ServerResponse) => Promise<void>;
-export interface ServerConfig<Context> {
+import * as http from 'node:http';
+import type { KaitoError } from './error';
+import type { KaitoRequest } from './req';
+import type { KaitoResponse } from './res';
+import type { Router } from './router';
+import type { GetContext, KaitoMethod } from './util';
+export declare type Before<BeforeAfterContext> = (req: http.IncomingMessage, res: http.ServerResponse) => Promise<BeforeAfterContext>;
+export declare type HandlerResult = {
+    success: true;
+    data: unknown;
+} | {
+    success: false;
+    data: {
+        status: number;
+        message: string;
+    };
+};
+export declare type After<BeforeAfterContext> = (ctx: BeforeAfterContext, result: HandlerResult) => Promise<void>;
+export declare type ServerConfigWithBefore<BeforeAfterContext> = {
+    before: Before<BeforeAfterContext>;
+    after?: After<BeforeAfterContext>;
+} | {
+    before?: undefined;
+};
+export declare type ServerConfig<Context, BeforeAfterContext> = ServerConfigWithBefore<BeforeAfterContext> & {
     router: Router<Context, any>;
     getContext: GetContext<Context>;
-    before?: Before[];
+    rawRoutes?: Partial<Record<KaitoMethod, Array<{
+        path: string;
+        handler: (request: http.IncomingMessage, response: http.ServerResponse) => unknown;
+    }>>>;
     onError(arg: {
         error: Error;
         req: KaitoRequest;
@@ -18,9 +38,9 @@ export interface ServerConfig<Context> {
         status: number;
         message: string;
     }>;
-}
-export declare function createFMWServer<Context>(config: ServerConfig<Context>): {
-    server: http.Server;
-    fmw: import("find-my-way").Instance<import("find-my-way").HTTPVersion.V1>;
 };
-export declare function createServer<Context>(config: ServerConfig<Context>): http.Server;
+export declare function createFMWServer<Context, BeforeAfterContext = null>(config: ServerConfig<Context, BeforeAfterContext>): {
+    readonly server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+    readonly fmw: import("find-my-way").Instance<import("find-my-way").HTTPVersion.V1>;
+};
+export declare function createServer<Context, BeforeAfterContext = null>(config: ServerConfig<Context, BeforeAfterContext>): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;

package/dist/declarations/src/util.d.ts

@@ -1,6 +1,6 @@
-import { HTTPMethod } from 'find-my-way';
-import { KaitoRequest } from './req';
-import { KaitoResponse } from './res';
+import type { HTTPMethod } from 'find-my-way';
+import type { KaitoRequest } from './req';
+import type { KaitoResponse } from './res';
 export declare 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}` ? {
@@ -16,5 +16,5 @@ declare type AddStartSlashes<T extends string> = T extends `/${infer U}` ? `/${U
 export declare type NormalizePath<T extends string> = AddStartSlashes<RemoveEndSlashes<T>>;
 export declare type Values<T> = T[keyof T];
 export declare type NoEmpty<T> = [keyof T] extends [never] ? never : T;
-export declare function getInput(req: KaitoRequest): Promise<unknown>;
+export declare function getBody(req: KaitoRequest): Promise<unknown>;
 export {};