@kaito-http/core 2.5.0 → 2.7.0

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

@@ -1,6 +1,6 @@
 /// <reference types="node" />
-import { HTTPMethod } from 'find-my-way';
-import { IncomingMessage } from 'node:http';
+import type { HTTPMethod } from 'find-my-way';
+import type { IncomingMessage } from 'node:http';
 export declare class KaitoRequest {
     readonly raw: IncomingMessage;
     private _url;

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

@@ -1,18 +1,18 @@
 /// <reference types="node" />
-import { ServerResponse } from 'node:http';
-import { CookieSerializeOptions } from 'cookie';
-export declare type ErroredAPIResponse = {
+import type { ServerResponse } from 'node:http';
+import type { CookieSerializeOptions } from 'cookie';
+export type ErroredAPIResponse = {
     success: false;
     data: null;
     message: string;
 };
-export declare type SuccessfulAPIResponse<T> = {
+export type SuccessfulAPIResponse<T> = {
     success: true;
     data: T;
     message: 'OK';
 };
-export declare type APIResponse<T> = ErroredAPIResponse | SuccessfulAPIResponse<T>;
-export declare type AnyResponse = APIResponse<unknown>;
+export type APIResponse<T> = ErroredAPIResponse | SuccessfulAPIResponse<T>;
+export type AnyResponse = APIResponse<unknown>;
 export declare class KaitoResponse<T = unknown> {
     readonly raw: ServerResponse;
     constructor(raw: ServerResponse);

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

@@ -1,14 +1,17 @@
-import { z } from 'zod';
-import { ExtractRouteParams, KaitoMethod } from './util';
-export declare type RouteArgument<Path extends string, Context, InputOutput> = {
+import type { z } from 'zod';
+import type { ExtractRouteParams, KaitoMethod } from './util';
+export type RouteArgument<Path extends string, Context, QueryOutput, BodyOutput> = {
     ctx: Context;
-    input: InputOutput;
+    body: BodyOutput;
+    query: QueryOutput;
     params: ExtractRouteParams<Path>;
 };
-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>;
+export type AnyQueryDefinition = Record<string, z.ZodTypeAny>;
+export 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, InputOutput>): Promise<Result>;
+    run(args: RouteArgument<Path, Context, z.infer<z.ZodObject<Query>>, BodyOutput>): Promise<Result> | Result;
 };
-export declare type AnyRoute<Context = any> = Route<Context, any, any, any, any, z.ZodTypeDef, any>;
+export type AnyRoute<Context = any> = Route<Context, any, any, any, AnyQueryDefinition, any, any, any>;

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

@@ -1,20 +1,34 @@
 import fmw from 'find-my-way';
 import { z } from 'zod';
-import { AnyRoute, Route } from './route';
-import { ServerConfig } from './server';
-import { 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 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>[]>>
+import type { AnyQueryDefinition, AnyRoute, Route } from './route';
+import type { ServerConfig } from './server';
+import type { KaitoMethod } from './util';
+type Routes = readonly AnyRoute[];
+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;
+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;
-    constructor(routes: R);
-    private static handle;
     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>]>;
+    private static handle;
+    constructor(routes: R);
+    /**
+     * Adds a new route to the router
+     * @param route The route specification to add to this router
+     * @returns A new router with this route added
+     * @deprecated Use `Router#add` instead
+     */
+    old_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>]>;
+    /**
+     * Adds a new route to the router
+     * @param method The HTTP method to add a route for
+     * @param path The path to add a route for
+     * @param route The route specification to add to this router
+     * @returns A new router with this route added
+     */
+    add: <Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(method: Method, path: Path, route: ((args: import("./route").RouteArgument<Path, Context, z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }> extends infer T extends object ? { [k in keyof T]: z.objectUtil.addQuestionMarks<{ [k_1 in keyof Query]: Query[k_1]["_output"]; }>[k]; } : never, BodyOutput>) => Result | Promise<Result>) | (Method extends "GET" ? Omit<Route<Context, Result, Path, Method, Query, BodyOutput, BodyDef, BodyInput>, "path" | "body" | "method"> : Omit<Route<Context, Result, Path, Method, Query, BodyOutput, BodyDef, BodyInput>, "path" | "method">)) => 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>;
 }

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

@@ -1,12 +1,12 @@
 /// <reference types="node" />
 import * as http from 'node:http';
-import { KaitoError } from './error';
-import { KaitoRequest } from './req';
-import { KaitoResponse } from './res';
-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 = {
+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 type Before<BeforeAfterContext> = (req: http.IncomingMessage, res: http.ServerResponse) => Promise<BeforeAfterContext>;
+export type HandlerResult = {
     success: true;
     data: unknown;
 } | {
@@ -16,20 +16,20 @@ export declare type HandlerResult = {
         message: string;
     };
 };
-export declare type After<BeforeAfterContext> = (ctx: BeforeAfterContext, result: HandlerResult) => Promise<void>;
-export declare type ServerConfigWithBefore<BeforeAfterContext> = {
+export type After<BeforeAfterContext> = (ctx: BeforeAfterContext, result: HandlerResult) => Promise<void>;
+export type ServerConfigWithBefore<BeforeAfterContext> = {
     before: Before<BeforeAfterContext>;
     after?: After<BeforeAfterContext>;
 } | {
     before?: undefined;
 };
-export declare type ServerConfig<Context, BeforeAfterContext> = ServerConfigWithBefore<BeforeAfterContext> & {
+export type ServerConfig<Context, BeforeAfterContext> = ServerConfigWithBefore<BeforeAfterContext> & {
     router: Router<Context, any>;
     getContext: GetContext<Context>;
-    rawRoutes?: Partial<Record<KaitoMethod, {
+    rawRoutes?: Partial<Record<KaitoMethod, Array<{
         path: string;
         handler: (request: http.IncomingMessage, response: http.ServerResponse) => unknown;
-    }[]>>;
+    }>>>;
     onError(arg: {
         error: Error;
         req: KaitoRequest;

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

@@ -1,20 +1,20 @@
-import { HTTPMethod } from 'find-my-way';
-import { KaitoRequest } from './req';
-import { KaitoResponse } from './res';
-export declare type ExtractRouteParams<T extends string> = string extends T ? Record<string, string> : T extends `${string}:${infer Param}/${infer Rest}` ? {
+import type { HTTPMethod } from 'find-my-way';
+import type { KaitoRequest } from './req';
+import type { KaitoResponse } from './res';
+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;
 } : {};
-export declare type KaitoMethod = HTTPMethod | '*';
-export declare type GetContext<Result> = (req: KaitoRequest, res: KaitoResponse) => Promise<Result>;
+export type KaitoMethod = HTTPMethod | '*';
+export type GetContext<Result> = (req: KaitoRequest, res: KaitoResponse) => Promise<Result>;
 export declare function createGetContext<Context>(callback: GetContext<Context>): GetContext<Context>;
-export declare type InferContext<T> = T extends (req: KaitoRequest, res: KaitoResponse) => Promise<infer U> ? U : never;
+export type InferContext<T> = T extends (req: KaitoRequest, res: KaitoResponse) => Promise<infer U> ? U : never;
 export declare function getLastEntryInMultiHeaderValue(headerValue: string | string[]): string;
-declare type RemoveEndSlashes<T extends string> = T extends `${infer U}/` ? U : T;
-declare type AddStartSlashes<T extends string> = T extends `/${infer U}` ? `/${U}` : `/${T}`;
-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>;
+type RemoveEndSlashes<T extends string> = T extends `${infer U}/` ? U : T;
+type AddStartSlashes<T extends string> = T extends `/${infer U}` ? `/${U}` : `/${T}`;
+export type NormalizePath<T extends string> = AddStartSlashes<RemoveEndSlashes<T>>;
+export type Values<T> = T[keyof T];
+export type NoEmpty<T> = [keyof T] extends [never] ? never : T;
+export declare function getBody(req: KaitoRequest): Promise<unknown>;
 export {};