@kaito-http/core 2.4.0 → 2.5.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 { 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 { ServerResponse } from 'node:http';
+import { 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,14 @@
 import { z } from 'zod';
 import { ExtractRouteParams, KaitoMethod } from './util';
-export declare type RouteArgument<Path extends string, Context, Input extends z.ZodSchema> = {
+export declare type RouteArgument<Path extends string, Context, InputOutput> = {
     ctx: Context;
-    input: z.infer<Input>;
+    input: InputOutput;
     params: ExtractRouteParams<Path>;
 };
-export declare type Route<Context, Result, Path extends string, Method extends KaitoMethod, Input extends z.ZodSchema> = {
-    input?: Input;
+export declare type Route<Context, Result, Path extends string, Method extends KaitoMethod, InputOutput = never, InputDef extends z.ZodTypeDef = z.ZodTypeDef, InputInput = InputOutput> = {
+    input?: z.ZodType<InputOutput, InputDef, InputInput>;
     path: Path;
     method: Method;
-    run(args: RouteArgument<Path, Context, Input>): Promise<Result>;
+    run(args: RouteArgument<Path, Context, InputOutput>): Promise<Result>;
 };
+export declare type AnyRoute<Context = any> = Route<Context, any, any, any, any, z.ZodTypeDef, 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 { AnyRoute, 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, []>;
+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 InputOutput, infer InputDef, infer InputInput> ? Route<Context, Result, `${Prefix}${Path}`, Method, InputOutput, InputDef, InputInput> : never;
+declare type PrefixRoutesPath<Prefix extends `/${string}`, R extends Routes> = R extends [infer First, ...infer Rest] ? [
+    RemapRoutePrefix<Extract<First, AnyRoute<any>>, Prefix>,
+    ...PrefixRoutesPath<Prefix, Extract<Rest, readonly AnyRoute<any>[]>>
+] : [];
+export declare class Router<Context, R extends Routes> {
+    readonly routes: R;
+    constructor(routes: R);
     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;
+    static create: <Context_1>() => Router<Context_1, []>;
+    add: <Result, Path extends string, Method extends KaitoMethod, InputOutput = never, InputDef extends z.ZodTypeDef = z.ZodTypeDef, InputInput = InputOutput>(route: Route<Context, Result, Path, Method, InputOutput, InputDef, InputInput>) => Router<Context, [...R, Route<Context, Result, Path, Method, InputOutput, InputDef, InputInput>]>;
+    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 * as http from 'node:http';
+import { KaitoError } from './error';
 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 { Router } from './router';
+import { 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, {
+        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>;