@kaito-http/core 2.9.4 → 3.0.0-beta.1

package/README.md

@@ -1,12 +1,9 @@
 # `kaito-http`
 
-[![Vercel](https://github.com/kaito-http/kaito/raw/main/static/powered-by-vercel.svg)](https://vercel.com?utm_source=kaito-http&utm_campaign=oss)
-
 #### An HTTP Framework for TypeScript
 
 View the [documentation here](https://kaito.cloud)
 
 #### Credits
 
-- [Vercel](https://vercel.com?utm_source=kaito-http&utm_campaign=oss), for sponsoring the project and hosting the documentation
-- [Alistair Smith](https://twitter.com/aabbccsmith)
+- [Alistair Smith](https://twitter.com/alistaiir)

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

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

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

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

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

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type { ServerResponse } from 'node:http';
 import type { CookieSerializeOptions } from 'cookie';
 export type ErroredAPIResponse = {

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

@@ -1,18 +1,22 @@
-import type { z } from 'zod';
-import type { ExtractRouteParams, KaitoMethod } from './util';
+import type { ExtractRouteParams, KaitoMethod, Parsable } from "./util.js";
 export type RouteArgument<Path extends string, Context, QueryOutput, BodyOutput> = {
     ctx: Context;
     body: BodyOutput;
     query: QueryOutput;
     params: ExtractRouteParams<Path>;
 };
-export type AnyQueryDefinition = Record<string, z.ZodTypeAny>;
-export type Route<ContextFrom, ContextTo, Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition, BodyOutput, BodyDef extends z.ZodTypeDef, BodyInput> = {
+export type AnyQueryDefinition = Record<string, Parsable<any>>;
+export type InferQuery<T extends AnyQueryDefinition> = {
+    [Key in keyof T]: InferParsable<T[Key]>;
+};
+export type InferParsable<T> = T extends Parsable<infer U> ? U : never;
+export type RouteRunner<Result, Path extends string, Context, QueryOutput, BodyOutput> = (args: RouteArgument<Path, Context, QueryOutput, BodyOutput>) => Promise<Result>;
+export type Route<ContextFrom, ContextTo, Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition, BodyOutput> = {
     through: (context: ContextFrom) => Promise<ContextTo>;
-    body?: z.ZodType<BodyOutput, BodyDef, BodyInput>;
+    body?: Parsable<BodyOutput>;
     query?: Query;
     path: Path;
     method: Method;
-    run(args: RouteArgument<Path, ContextTo, z.infer<z.ZodObject<Query>>, BodyOutput>): Promise<Result>;
+    run(arg: RouteArgument<Path, ContextTo, InferQuery<Query>, BodyOutput>): Promise<Result>;
 };
-export type AnyRoute<FromContext = any, ToContext = any> = Route<FromContext, ToContext, any, any, any, AnyQueryDefinition, any, any, any>;
+export type AnyRoute<FromContext = any, ToContext = any> = Route<FromContext, ToContext, any, any, any, AnyQueryDefinition, any>;

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

@@ -1,41 +1,34 @@
 import fmw from 'find-my-way';
-import { z } from 'zod';
-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 ContextFrom, infer ContextTo, infer Result, infer Path, infer Method, infer Query, infer BodyOutput, infer BodyDef, infer BodyInput> ? Route<ContextFrom, ContextTo, 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[]>>
-] : [];
+import type { AnyQueryDefinition, AnyRoute, Route } from "./route.js";
+import type { ServerConfig } from "./server.js";
+import type { KaitoMethod } from "./util.js";
+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 RouterOptions<ContextFrom, ContextTo> = {
     through: (context: ContextFrom) => Promise<ContextTo>;
 };
-export declare class Router<ContextFrom, ContextTo, R extends Routes> {
+export declare class Router<ContextFrom, ContextTo, R extends AnyRoute> {
     private readonly routerOptions;
-    readonly routes: R;
-    static create: <Context>() => Router<Context, Context, []>;
+    readonly routes: Set<R>;
+    static create: <Context>() => Router<Context, Context, never>;
+    private static parseQuery;
     private static handle;
-    constructor(routes: R, options: RouterOptions<ContextFrom, ContextTo>);
+    constructor(routes: Iterable<R>, options: RouterOptions<ContextFrom, ContextTo>);
     /**
      * 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
+     * @deprecated Use the method-specific methods instead
      */
-    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, ContextTo, 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>) => Promise<Result>) | (Method extends "GET" ? Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, BodyOutput, BodyDef, BodyInput>, "path" | "body" | "method" | "through"> : Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, BodyOutput, BodyDef, BodyInput>, "path" | "method" | "through">)) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, Method, Query, BodyOutput, BodyDef, BodyInput>]>;
-    readonly merge: <PathPrefix extends `/${string}`, OtherRoutes extends Routes>(pathPrefix: PathPrefix, other: Router<ContextFrom, unknown, OtherRoutes>) => Router<ContextFrom, ContextTo, [...R, ...PrefixRoutesPath<PathPrefix, OtherRoutes>]>;
+    add: <Result, Path extends string, Method extends KaitoMethod, Query extends AnyQueryDefinition = {}, BodyOutput = never>(method: Method, path: Path, route: (Method extends "GET" ? Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, BodyOutput>, "body" | "path" | "method" | "through"> : Omit<Route<ContextFrom, ContextTo, Result, Path, Method, Query, BodyOutput>, "path" | "method" | "through">) | Route<ContextFrom, ContextTo, Result, Path, Method, Query, BodyOutput>["run"]) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, Method, Query, BodyOutput>>;
+    readonly merge: <PathPrefix extends `/${string}`, OtherRoutes extends AnyRoute>(pathPrefix: PathPrefix, other: Router<ContextFrom, unknown, OtherRoutes>) => Router<ContextFrom, ContextTo, Extract<R | PrefixRoutesPath<PathPrefix, OtherRoutes>, AnyRoute>>;
     freeze: (server: ServerConfig<ContextFrom, any>) => fmw.Instance<fmw.HTTPVersion.V1>;
     private readonly method;
-    get: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(path: Path, route: ((args: import("./route").RouteArgument<Path, ContextTo, 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>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "GET", Query, BodyOutput, BodyDef, BodyInput>, "path" | "body" | "method" | "through">) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, "GET", Query, BodyOutput, BodyDef, BodyInput>]>;
-    post: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(path: Path, route: ((args: import("./route").RouteArgument<Path, ContextTo, 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>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "POST", Query, BodyOutput, BodyDef, BodyInput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, "POST", Query, BodyOutput, BodyDef, BodyInput>]>;
-    put: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(path: Path, route: ((args: import("./route").RouteArgument<Path, ContextTo, 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>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, BodyOutput, BodyDef, BodyInput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, BodyOutput, BodyDef, BodyInput>]>;
-    patch: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(path: Path, route: ((args: import("./route").RouteArgument<Path, ContextTo, 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>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, BodyOutput, BodyDef, BodyInput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, BodyOutput, BodyDef, BodyInput>]>;
-    delete: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(path: Path, route: ((args: import("./route").RouteArgument<Path, ContextTo, 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>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, BodyOutput, BodyDef, BodyInput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, BodyOutput, BodyDef, BodyInput>]>;
-    head: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(path: Path, route: ((args: import("./route").RouteArgument<Path, ContextTo, 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>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, BodyOutput, BodyDef, BodyInput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, BodyOutput, BodyDef, BodyInput>]>;
-    options: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never, BodyDef extends z.ZodTypeDef = z.ZodTypeDef, BodyInput = BodyOutput>(path: Path, route: ((args: import("./route").RouteArgument<Path, ContextTo, 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>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, BodyOutput, BodyDef, BodyInput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, [...R, Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, BodyOutput, BodyDef, BodyInput>]>;
+    get: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never>(path: Path, route: ((arg: import("./route.js").RouteArgument<Path, ContextTo, import("./route.js").InferQuery<Query>, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, 'GET', Query, BodyOutput>, 'body' | 'path' | 'method' | 'through'>) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, 'GET', Query, BodyOutput>>;
+    post: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never>(path: Path, route: ((arg: import("./route.js").RouteArgument<Path, ContextTo, import("./route.js").InferQuery<Query>, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "POST", Query, BodyOutput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "POST", Query, BodyOutput>>;
+    put: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never>(path: Path, route: ((arg: import("./route.js").RouteArgument<Path, ContextTo, import("./route.js").InferQuery<Query>, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, BodyOutput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "PUT", Query, BodyOutput>>;
+    patch: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never>(path: Path, route: ((arg: import("./route.js").RouteArgument<Path, ContextTo, import("./route.js").InferQuery<Query>, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, BodyOutput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "PATCH", Query, BodyOutput>>;
+    delete: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never>(path: Path, route: ((arg: import("./route.js").RouteArgument<Path, ContextTo, import("./route.js").InferQuery<Query>, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, BodyOutput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "DELETE", Query, BodyOutput>>;
+    head: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never>(path: Path, route: ((arg: import("./route.js").RouteArgument<Path, ContextTo, import("./route.js").InferQuery<Query>, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, BodyOutput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "HEAD", Query, BodyOutput>>;
+    options: <Result, Path extends string, Query extends AnyQueryDefinition = {}, BodyOutput = never>(path: Path, route: ((arg: import("./route.js").RouteArgument<Path, ContextTo, import("./route.js").InferQuery<Query>, BodyOutput>) => Promise<Result>) | Omit<Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, BodyOutput>, "path" | "method" | "through">) => Router<ContextFrom, ContextTo, R | Route<ContextFrom, ContextTo, Result, Path, "OPTIONS", Query, BodyOutput>>;
     through: <NextContext>(transform: (context: ContextTo) => Promise<NextContext>) => Router<ContextFrom, NextContext, R>;
 }
 export {};

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

@@ -1,10 +1,9 @@
-/// <reference types="node" />
 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';
+import type { KaitoError } from "./error.js";
+import type { KaitoRequest } from "./req.js";
+import type { KaitoResponse } from "./res.js";
+import type { Router } from "./router.js";
+import type { GetContext, KaitoMethod } from "./util.js";
 export type Before<BeforeAfterContext> = (req: http.IncomingMessage, res: http.ServerResponse) => Promise<BeforeAfterContext>;
 export type HandlerResult = {
     success: true;
@@ -23,9 +22,9 @@ export type ServerConfigWithBefore<BeforeAfterContext> = {
 } | {
     before?: undefined;
 };
-export type ServerConfig<Context, BeforeAfterContext> = ServerConfigWithBefore<BeforeAfterContext> & {
-    router: Router<Context, any>;
-    getContext: GetContext<Context>;
+export type ServerConfig<ContextFrom, BeforeAfterContext> = ServerConfigWithBefore<BeforeAfterContext> & {
+    router: Router<ContextFrom, unknown, any>;
+    getContext: GetContext<ContextFrom>;
     rawRoutes?: Partial<Record<KaitoMethod, Array<{
         path: string;
         handler: (request: http.IncomingMessage, response: http.ServerResponse) => unknown;
@@ -41,6 +40,6 @@ export type ServerConfig<Context, BeforeAfterContext> = ServerConfigWithBefore<B
 };
 export declare function createFMWServer<Context, BeforeAfterContext = null>(config: ServerConfig<Context, BeforeAfterContext>): {
     readonly server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
-    readonly fmw: any;
+    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,7 +1,7 @@
 import type { HTTPMethod } from 'find-my-way';
-import type { KaitoRequest } from './req';
-import type { KaitoResponse } from './res';
-import { Router } from './router';
+import type { KaitoRequest } from "./req.js";
+import type { KaitoResponse } from "./res.js";
+import { Router } from "./router.js";
 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}` ? {
@@ -33,14 +33,16 @@ export declare function createGetContext<Context>(callback: GetContext<Context>)
  */
 export declare function createUtilities<Context>(getContext: GetContext<Context>): {
     getContext: GetContext<Context>;
-    router: () => Router<Context, Context, []>;
+    router: () => Router<Context, Context, never>;
 };
 export type InferContext<T> = T extends (req: KaitoRequest, res: KaitoResponse) => Promise<infer U> ? U : never;
 export declare function getLastEntryInMultiHeaderValue(headerValue: string | string[]): string;
-type RemoveEndSlashes<T extends string> = T extends `${infer U}/` ? U : T;
-type AddStartSlashes<T extends string> = T extends `/${infer U}` ? `/${U}` : `/${T}`;
+export interface Parsable<T> {
+    parse: (value: unknown) => T;
+}
+export type RemoveEndSlashes<T extends string> = T extends `${infer U}/` ? U : T;
+export 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 {};

package/dist/kaito-http-core.d.ts

@@ -0,0 +1,2 @@
+export * from "./declarations/src/index";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2FpdG8taHR0cC1jb3JlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuL2RlY2xhcmF0aW9ucy9zcmMvaW5kZXguZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSJ9

package/dist/{kaito-http-core.esm.js → kaito-http-core.js}

@@ -4,7 +4,6 @@ import { Readable } from 'node:stream';
 import { json } from 'node:stream/consumers';
 import getRawBody from 'raw-body';
 import fmw from 'find-my-way';
-import { z } from 'zod';
 import { serialize } from 'cookie';
 import * as http from 'node:http';
 
@@ -149,6 +148,7 @@ class KaitoResponse {
   }
 }
 
+var _Router;
 var getSend = res => (status, response) => {
   if (res.raw.headersSent) {
     return;
@@ -156,6 +156,21 @@ var getSend = res => (status, response) => {
   res.status(status).json(response);
 };
 class Router {
+  static parseQuery(schema, url) {
+    if (!schema) {
+      return {};
+    }
+    var result = {};
+    for (var [key, value] of url.searchParams.entries()) {
+      var parsable = schema[key];
+      if (!parsable) {
+        continue;
+      }
+      var parsed = parsable.parse(value);
+      result[key] = parsed;
+    }
+    return result;
+  }
   static handle(
   // Allow for any server to be passed
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -167,7 +182,7 @@ class Router {
         var rootCtx = yield server.getContext(options.req, options.res);
         var ctx = yield route.through(rootCtx);
         var body = (_yield$route$body$par = yield (_route$body = route.body) === null || _route$body === void 0 ? void 0 : _route$body.parse(yield getBody(options.req))) !== null && _yield$route$body$par !== void 0 ? _yield$route$body$par : undefined;
-        var query = route.query ? z.object(route.query).parse(Object.fromEntries(options.req.url.searchParams.entries())) : {};
+        var query = Router.parseQuery(route.query, options.req.url);
         var result = yield route.run({
           ctx,
           body,
@@ -227,6 +242,10 @@ class Router {
   }
   constructor(routes, options) {
     var _this = this;
+    /**
+     * Adds a new route to the router
+     * @deprecated Use the method-specific methods instead
+     */
     _defineProperty(this, "add", (method, path, route) => {
       var merged = _objectSpread2(_objectSpread2({}, typeof route === 'object' ? route : {
         run: route
@@ -238,11 +257,13 @@ class Router {
       return new Router([...this.routes, merged], this.routerOptions);
     });
     _defineProperty(this, "merge", (pathPrefix, other) => {
-      var newRoutes = other.routes.map(route => _objectSpread2(_objectSpread2({}, route), {}, {
+      var newRoutes = [...other.routes].map(route => _objectSpread2(_objectSpread2({}, route), {}, {
         path: "".concat(pathPrefix).concat(route.path)
       }));
       return new Router([...this.routes, ...newRoutes], this.routerOptions);
     });
+    // Allow for any server context to be passed
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     _defineProperty(this, "freeze", server => {
       var instance = fmw({
         ignoreTrailingSlash: true,
@@ -266,12 +287,12 @@ class Router {
           })();
         }
       });
-      var _loop = function _loop(route) {
+      var _loop = function _loop(_route) {
         var handler = /*#__PURE__*/function () {
           var _ref = _asyncToGenerator(function* (incomingMessage, serverResponse, params) {
             var req = new KaitoRequest(incomingMessage);
             var res = new KaitoResponse(serverResponse);
-            return Router.handle(server, route, {
+            return Router.handle(server, _route, {
               params,
               req,
               res
@@ -281,19 +302,20 @@ class Router {
             return _ref.apply(this, arguments);
           };
         }();
-        if (route.method === '*') {
-          instance.all(route.path, handler);
-          return "continue";
+        if (_route.method === '*') {
+          instance.all(_route.path, handler);
+          return 1; // continue
         }
-        instance.on(route.method, route.path, handler);
+        instance.on(_route.method, _route.path, handler);
       };
-      for (var route of this.routes) {
-        var _ret = _loop(route);
-        if (_ret === "continue") continue;
+      for (var _route2 of this.routes) {
+        if (_loop(_route2)) continue;
       }
       return instance;
     });
-    _defineProperty(this, "method", method => (path, route) => this.add(method, path, route));
+    _defineProperty(this, "method", method => (path, route) => {
+      return this.add(method, path, route);
+    });
     _defineProperty(this, "get", this.method('GET'));
     _defineProperty(this, "post", this.method('POST'));
     _defineProperty(this, "put", this.method('PUT'));
@@ -314,18 +336,11 @@ class Router {
       }()
     }));
     this.routerOptions = options;
-    this.routes = routes;
+    this.routes = new Set(routes);
   }
-
-  /**
-   * 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
-   */
 }
-_defineProperty(Router, "create", () => new Router([], {
+_Router = Router;
+_defineProperty(Router, "create", () => new _Router([], {
   through: function () {
     var _through2 = _asyncToGenerator(function* (context) {
       return context;

package/package.json

@@ -1,19 +1,20 @@
 {
   "name": "@kaito-http/core",
-  "version": "2.9.4",
+  "version": "3.0.0-beta.1",
   "description": "Functional HTTP Framework for TypeScript",
+  "exports": {
+    ".": "./dist/kaito-http-core.js",
+    "./package.json": "./package.json"
+  },
   "repository": "https://github.com/kaito-http/kaito",
   "author": "Alistair Smith <hi@alistair.sh>",
   "license": "MIT",
-  "main": "dist/kaito-http-core.cjs.js",
-  "module": "dist/kaito-http-core.esm.js",
-  "types": "dist/kaito-http-core.cjs.d.ts",
+  "type": "module",
   "devDependencies": {
     "@types/content-type": "^1.1.5",
     "@types/cookie": "^0.5.1",
     "@types/node": "^18.11.9",
-    "typescript": "4.9",
-    "zod": "^3.19.1"
+    "typescript": "^5.6.2"
   },
   "files": [
     "package.json",
@@ -24,18 +25,15 @@
     "url": "https://github.com/kaito-http/kaito/issues"
   },
   "homepage": "https://github.com/kaito-http/kaito",
-  "peerDependencies": {
-    "zod": "*"
-  },
   "keywords": [
     "typescript",
     "http",
     "framework"
   ],
   "dependencies": {
-    "content-type": "^1.0.4",
-    "cookie": "^0.5.0",
-    "find-my-way": "^7.3.1",
-    "raw-body": "^2.5.1"
+    "content-type": "^1.0.5",
+    "cookie": "^0.6.0",
+    "find-my-way": "^9.1.0",
+    "raw-body": "^3.0.0"
   }
 }

package/dist/kaito-http-core.cjs.d.ts

@@ -1 +0,0 @@
-export * from "./declarations/src/index";