better-call 0.2.11 → 0.2.13-beta.1

package/dist/index.d.cts

@@ -1,127 +1,350 @@
-import { E as Endpoint, a as EndpointOptions, b as EndpointResponse, P as Prettify, C as Context, I as InferUse, c as ContextTools, H as HasRequiredKeys, M as Method, d as Handler, e as InferBody, f as InferRequest, g as InferHeaders, h as InferUseOptions, R as Router, i as CookiePrefixOptions, j as CookieOptions } from './router-DIrNt-mY.cjs';
-export { A as APIError, u as Cookie, v as CookieConstraint, t as EndpointBody, p as InferMethod, r as InferParam, n as InferParamPath, o as InferParamWildCard, q as InferQuery, S as SignedCookie, k as createRouter, l as getBody, w as parse, x as parseSigned, y as serialize, z as serializeSigned, s as shouldSerialize, m as statusCode } from './router-DIrNt-mY.cjs';
-import { IncomingMessage, ServerResponse } from 'node:http';
-import 'zod';
+import { ZodSchema, ZodError } from 'zod';
+import { BufferSource } from 'stream/web';
 
-interface EndpointConfig {
+type Cookie = Record<string, string>;
+type SignedCookie = Record<string, string | false>;
+type PartitionCookieConstraint = {
+    partition: true;
+    secure: true;
+} | {
+    partition?: boolean;
+    secure?: boolean;
+};
+type SecureCookieConstraint = {
+    secure: true;
+};
+type HostCookieConstraint = {
+    secure: true;
+    path: "/";
+    domain?: undefined;
+};
+type CookieOptions = {
+    domain?: string;
+    expires?: Date;
+    httpOnly?: boolean;
+    maxAge?: number;
+    path?: string;
+    secure?: boolean;
+    signingSecret?: string;
+    sameSite?: "Strict" | "Lax" | "None" | "strict" | "lax" | "none";
+    partitioned?: boolean;
+    prefix?: CookiePrefixOptions;
+} & PartitionCookieConstraint;
+type CookiePrefixOptions = "host" | "secure";
+type CookieConstraint<Name> = Name extends `__Secure-${string}` ? CookieOptions & SecureCookieConstraint : Name extends `__Host-${string}` ? CookieOptions & HostCookieConstraint : CookieOptions;
+declare const parse: (cookie: string, name?: string) => Cookie;
+declare const parseSigned: (cookie: string, secret: string | BufferSource, name?: string) => Promise<SignedCookie>;
+declare const serialize: <Name extends string>(name: Name, value: string, opt?: CookieConstraint<Name>) => string;
+declare const serializeSigned: (name: string, value: string, secret: string | BufferSource, opt?: CookieOptions) => Promise<string>;
+
+/**
+ * Improve this type if possible
+ */
+type Input<T> = Prettify<{
+    [K in keyof T as T[K] extends never ? never : undefined extends T[K] ? never : K]: T[K];
+} & {
+    [K in keyof T as undefined extends T[K] ? K : never]?: T[K];
+}>;
+type RequiredKeysOf<BaseType extends object> = Exclude<{
+    [Key in keyof BaseType]: BaseType extends Record<Key, BaseType[Key]> ? Key : never;
+}[keyof BaseType], undefined>;
+type HasRequiredKeys<BaseType extends object> = RequiredKeysOf<BaseType> extends never ? false : true;
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type IsEmptyObject<T> = keyof T extends never ? true : false;
+type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends (mergedIntersection: infer Intersection) => void ? Intersection & Union : never;
+
+type Method = "GET" | "POST" | "PUT" | "DELETE" | "*";
+interface EndpointOptions {
     /**
-     * Throw when the response isn't in 200 range
+     * Request Method
+     */
+    method: Method | Method[];
+    /**
+     * Body Schema
+     */
+    body?: ZodSchema;
+    /**
+     * Query Schema
+     */
+    query?: ZodSchema;
+    /**
+     * If true headers will be required to be passed in the context
+     */
+    requireHeaders?: boolean;
+    /**
+     * If true request object will be required
+     */
+    requireRequest?: boolean;
+    /**
+     * Endpoint metadata
+     */
+    metadata?: Record<string, any>;
+    /**
+     * Middleware to use
      */
-    throwOnError?: boolean;
-}
-declare function createEndpointCreator<E extends {
     use?: Endpoint[];
-}>(opts?: E): <Path extends string, Opts extends EndpointOptions, R extends EndpointResponse>(path: Path, options: Opts, handler: (ctx: Prettify<Context<Path, Opts> & InferUse<Opts["use"]> & InferUse<E["use"]> & Omit<ContextTools, "_flag">>) => Promise<R>) => {
-    <C extends HasRequiredKeys<Context<Path, Opts>> extends true ? [Context<Path, Opts>] : [(Context<Path, Opts> | undefined)?]>(...ctx: C): Promise<C extends [{
-        asResponse: true;
-    }] ? Response : R extends {
-        _flag: "json";
-    } ? R extends {
-        body: infer B;
-    } ? B : null : Awaited<R>>;
+}
+type InferBody<Options extends EndpointOptions> = Options["body"] extends ZodSchema<infer T> ? T : never;
+type InferQuery<Options extends EndpointOptions> = Options["query"] extends ZodSchema<infer T> ? T : never;
+type InferParamPath<Path> = Path extends `${infer _Start}:${infer Param}/${infer Rest}` ? {
+    [K in Param | keyof InferParamPath<Rest>]: string;
+} : Path extends `${infer _Start}:${infer Param}` ? {
+    [K in Param]: string;
+} : Path extends `${infer _Start}/${infer Rest}` ? InferParamPath<Rest> : {};
+type InferParamWildCard<Path> = Path extends `${infer _Start}/*:${infer Param}/${infer Rest}` | `${infer _Start}/**:${infer Param}/${infer Rest}` ? {
+    [K in Param | keyof InferParamPath<Rest>]: string;
+} : Path extends `${infer _Start}/*` ? {
+    [K in "_"]: string;
+} : Path extends `${infer _Start}/${infer Rest}` ? InferParamPath<Rest> : {};
+type InferParam<Path extends string> = IsEmptyObject<InferParamPath<Path> & InferParamWildCard<Path>> extends true ? never : Prettify<InferParamPath<Path> & InferParamWildCard<Path>>;
+type InferRequest<Option extends EndpointOptions> = Option["requireRequest"] extends true ? Request : Request | undefined;
+type InferHeaders<Option extends EndpointOptions> = Option["requireHeaders"] extends true ? Headers : Headers | undefined;
+type InferUse<Opts extends EndpointOptions["use"]> = Opts extends Endpoint[] ? UnionToIntersection<Awaited<ReturnType<Opts[number]>>> : never;
+type InferMethod<Options extends EndpointOptions> = Options["method"] extends Array<Method> ? Options["method"][number] : Options["method"];
+
+declare class APIError extends Error {
+    message: string;
+    status: number;
+    code: string;
+    headers: {};
+    constructor(message: string, status?: number, code?: string, headers?: {});
+}
+
+interface EndpointContext<Path extends string, Options extends EndpointOptions> {
+    /**
+     * JSON
+     *
+     * a helper function to create a JSON response with the correct headers
+     * and status code. If `asResponse` is set to true in the context then
+     * it will return a Response object instead of the JSON object.
+     *
+     * @param json - The JSON object to return
+     * @param routerResponse - The response object to return if `asResponse` is
+     * true in the context this will take precedence
+     */
+    json: <R extends Record<string, any>>(json: R, routerResponse?: {
+        status?: number;
+        headers?: Record<string, string>;
+        response?: Response;
+    } | Response) => Promise<R>;
+    /**
+     * Body
+     *
+     * The body object will be the parsed JSON from the request and validated
+     * against the body schema if it exists
+     */
+    body: InferBody<Options>;
+    /**
+     * Path
+     *
+     * The path of the endpoint
+     */
     path: Path;
-    options: Opts;
-    method: Method | Method[];
-    headers: Headers;
+    /**
+     * Method
+     */
+    method: InferMethod<Options>;
+    /**
+     * Query
+     *
+     * The query object will be the parsed query string from the request
+     * and validated against the query schema if it exists
+     */
+    query: InferQuery<Options>;
+    /**
+     * Params
+     *
+     * If the path is `/user/:id` and the request is `/user/1` then the params will
+     * be `{ id: "1" }` and if the path includes a wildcard like `/user/*` then the
+     * params will be `{ _: "1" }` where `_` is the wildcard key. If the wildcard
+     * is named like `/user/**:name` then the params will be `{ name: string }`
+     */
+    params: InferParam<Path>;
+    /**
+     * Request object
+     *
+     * If `requireRequest` is set to true in the endpoint options this will be
+     * required
+     */
+    request: InferRequest<Options>;
+    /**
+     * Headers
+     *
+     * If `requireHeaders` is set to true in the endpoint options this will be
+     * required
+     */
+    headers: InferHeaders<Options>;
+    /**
+     * Middleware context
+     */
+    context: InferUse<Options["use"]>;
+    /**
+     * Set header
+     *
+     * If it's called outside of a request it will just be ignored.
+     */
+    setHeader: (key: string, value: string) => void;
+    /**
+     * Get header
+     *
+     * If it's called outside of a request it will just return null
+     *
+     * @param key  - The key of the header
+     * @returns
+     */
+    getHeader: (key: string) => string | null;
+    /**
+     * cookie setter.
+     *
+     * If it's called outside of a request it will just be ignored.
+     */
+    setCookie: (key: string, value: string, options?: CookieOptions) => void;
+    /**
+     * Get cookie value
+     *
+     * If it's called outside of a request it will just be ignored.
+     */
+    getCookie: (key: string, prefix?: CookiePrefixOptions) => string | undefined;
+    /**
+     * Set signed cookie
+     */
+    setSignedCookie: (key: string, value: string, secret: string | BufferSource, options?: CookieOptions) => Promise<void>;
+    /**
+     * Get signed cookie value
+     */
+    getSignedCookie: (key: string, secret: string, prefix?: CookiePrefixOptions) => Promise<string | undefined | false>;
+    /**
+     * Redirect to url
+     */
+    redirect: (url: string) => APIError;
+}
+type Context<Path extends string, Options extends EndpointOptions> = Input<{
+    body: InferBody<Options>;
+    method?: InferMethod<Options>;
+    query: InferQuery<Options>;
+    params: InferParam<Path>;
+    request: InferRequest<Options>;
+    headers: InferHeaders<Options>;
+    asResponse?: boolean;
+}>;
+declare function createSetHeader(headers: Headers): (key: string, value: string) => void;
+declare function createGetHeader(headers: Headers): (key: string) => string | null;
+
+interface JSONResponse<R = any> {
+    /**
+     * Body of the response
+     * It'll be inferred as the response body.
+     * and on the server side this will be returned
+     * as a response of a handler.
+     */
+    body: R;
+    /**
+     * The actual response object
+     */
+    routerResponse: {
+        body?: Record<string, any>;
+        status?: number;
+        headers?: Record<string, string>;
+    };
+    /**
+     * Flag to identify the response type
+     */
+    _flag: "json";
+}
+type EndpointResponse = JSONResponse | Response | void | Record<string, any>;
+type InferResponse<Ctx, R> = Ctx extends {
+    asResponse: true;
+} ? Response : R extends JSONResponse<infer T> ? T : R;
+declare function createJSON({ asResponse, response, }: {
+    asResponse?: boolean;
+    response: Response;
+}): <R extends Record<string, any>>(json: R, routerResponse?: {
+    status?: number;
+    headers?: Record<string, string>;
+    response?: Response;
+}) => Promise<R | {
+    body: R;
+    routerResponse: {
+        status?: number;
+        headers?: Record<string, string>;
+        response?: Response;
+    } | undefined;
+    _flag: string;
+}>;
+type ValidationResponse = {
+    data: {
+        body: any;
+        query: any;
+    };
+    error: null;
+} | {
+    data: null;
+    error: {
+        message: string;
+    };
 };
-declare function createEndpoint<Path extends string, Opts extends EndpointOptions, R extends EndpointResponse>(path: Path, options: Opts, handler: Handler<Path, Opts, R>): {
-    <C extends HasRequiredKeys<Context<Path, Opts>> extends true ? [Context<Path, Opts>] : [Context<Path, Opts>?]>(...ctx: C): Promise<C extends [{
-        asResponse: true;
-    }] ? Response : R extends {
-        _flag: "json";
-    } ? R extends {
-        body: infer B;
-    } ? B : null : Awaited<R>>;
-    path: Path;
-    options: Opts;
-    method: Method | Method[];
-    headers: Headers;
+declare function runValidation(options: EndpointOptions, context: EndpointContext<any, any>): ValidationResponse;
+declare function fromError(error: ZodError): {
+    message: string;
 };
 
-type MiddlewareHandler<Opts extends EndpointOptions, R extends EndpointResponse, Extra extends Record<string, any> = {}> = (ctx: Prettify<InferBody<Opts> & InferRequest<Opts> & InferHeaders<Opts> & {
-    params?: Record<string, string>;
-    query?: Record<string, string>;
-} & ContextTools> & Extra) => Promise<R>;
-declare function createMiddleware<Opts extends EndpointOptions, R extends EndpointResponse>(optionsOrHandler: MiddlewareHandler<Opts, R>): Endpoint<Handler<string, Opts, R>, Opts>;
-declare function createMiddleware<Opts extends Omit<EndpointOptions, "method">, R extends EndpointResponse>(optionsOrHandler: Opts, handler: MiddlewareHandler<Opts & {
-    method: "*";
-}, R>): Endpoint<Handler<string, Opts & {
-    method: "*";
-}, R>, Opts & {
-    method: "*";
-}>;
-declare const createMiddlewareCreator: <E extends {
-    use?: Endpoint[];
-}>(opts?: E) => {
-    <Opts extends EndpointOptions, R extends EndpointResponse>(optionsOrHandler: (ctx: InferBody<Opts, Opts["body"] & (undefined extends InferUseOptions<Opts>["body"] ? {} : InferUseOptions<Opts>["body"])> & InferUse<E["use"]> & InferRequest<Opts, Opts["requireRequest"]> & InferHeaders<Opts, Opts["requireHeaders"]> & {
-        params?: Record<string, string>;
-        query?: Record<string, string>;
-    } & ContextTools extends infer T ? { [key in keyof T]: (InferBody<Opts, Opts["body"] & (undefined extends InferUseOptions<Opts>["body"] ? {} : InferUseOptions<Opts>["body"])> & InferUse<E["use"]> & InferRequest<Opts, Opts["requireRequest"]> & InferHeaders<Opts, Opts["requireHeaders"]> & {
-        params?: Record<string, string>;
-        query?: Record<string, string>;
-    } & ContextTools)[key]; } : never) => Promise<R>): Endpoint<Handler<string, Opts, R>, Opts>;
-    <Opts extends Omit<EndpointOptions, "method">, R_1 extends EndpointResponse>(optionsOrHandler: Opts, handler: (ctx: InferBody<Opts & {
-        method: "*";
-    }, (Opts & {
-        method: "*";
-    })["body"] & (undefined extends InferUseOptions<Opts & {
-        method: "*";
-    }>["body"] ? {} : InferUseOptions<Opts & {
-        method: "*";
-    }>["body"])> & InferUse<E["use"]> & InferRequest<Opts & {
-        method: "*";
-    }, (Opts & {
-        method: "*";
-    })["requireRequest"]> & InferHeaders<Opts & {
-        method: "*";
-    }, (Opts & {
-        method: "*";
-    })["requireHeaders"]> & {
-        params?: Record<string, string>;
-        query?: Record<string, string>;
-    } & ContextTools extends infer T ? { [key in keyof T]: (InferBody<Opts & {
-        method: "*";
-    }, (Opts & {
-        method: "*";
-    })["body"] & (undefined extends InferUseOptions<Opts & {
-        method: "*";
-    }>["body"] ? {} : InferUseOptions<Opts & {
-        method: "*";
-    }>["body"])> & InferUse<E["use"]> & InferRequest<Opts & {
-        method: "*";
-    }, (Opts & {
-        method: "*";
-    })["requireRequest"]> & InferHeaders<Opts & {
-        method: "*";
-    }, (Opts & {
-        method: "*";
-    })["requireHeaders"]> & {
-        params?: Record<string, string>;
-        query?: Record<string, string>;
-    } & ContextTools)[key]; } : never) => Promise<R_1>): Endpoint<Handler<string, Opts & {
-        method: "*";
-    }, R_1>, Opts & {
-        method: "*";
-    }>;
+declare const createEndpoint: <Path extends string, Options extends EndpointOptions, R extends EndpointResponse>(path: Path, options: Options, handler: (context: EndpointContext<Path, Options>) => Promise<R>) => {
+    <Ctx extends Context<Path, Options>>(...inputCtx: HasRequiredKeys<Ctx> extends true ? [Ctx] : [Ctx?]): Promise<Ctx["asResponse"] extends true ? Response : R>;
+    path: Path;
+    options: Options;
 };
-type Middleware<Opts extends EndpointOptions = EndpointOptions, R extends EndpointResponse = EndpointResponse> = (opts: Opts, handler: (ctx: {
-    body?: InferBody<Opts>;
-    params?: Record<string, string>;
-    query?: Record<string, string>;
-}) => Promise<R>) => Endpoint;
+type Endpoint<Handler extends (ctx: any) => Promise<any> = (ctx: any) => Promise<any>, Options extends EndpointOptions = EndpointOptions> = {
+    path: string;
+    options: Options;
+} & Handler;
 
-declare function getRequest({ request, base, bodySizeLimit, }: {
-    base: string;
-    bodySizeLimit?: number;
-    request: IncomingMessage;
-}): Request;
-declare function setResponse(res: ServerResponse, response: Response): Promise<void>;
+interface RouterConfig {
+    /**
+     * Throw error if error occurred other than APIError
+     */
+    throwError?: boolean;
+    /**
+     * Handle error
+     */
+    onError?: (e: unknown) => void | Promise<void> | Response | Promise<Response>;
+    /**
+     * Base path for the router
+     */
+    basePath?: string;
+    /**
+     * Middlewares for the router
+     */
+    routerMiddleware?: {
+        path: string;
+        middleware: Endpoint;
+    }[];
+    /**
+     * On response interceptor
+     */
+    onResponse?: (res: Response) => any | Promise<any>;
+    /**
+     * On request interceptor
+     */
+    onRequest?: (req: Request) => any | Promise<any>;
+    /**
+     * Extra context to pass to the handler
+     */
+    extraContext?: Record<string, any>;
+}
+declare const createRouter: <E extends Record<string, Endpoint>, Config extends RouterConfig>(endpoints: E, config?: Config) => {
+    handler: (request: Request) => Promise<Response>;
+    endpoints: E;
+};
 
-declare function toNodeHandler(handler: Router["handler"]): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+type MiddlewareHandler<Options extends EndpointOptions, R extends EndpointResponse> = (context: EndpointContext<any, Options>) => Promise<R>;
+declare function createMiddleware<Opts extends EndpointOptions, R extends EndpointResponse>(optionsOrHandler: MiddlewareHandler<Opts, R>): Endpoint<MiddlewareHandler<Opts, R>, Opts>;
+declare function createMiddleware<Opts extends EndpointOptions, R extends EndpointResponse>(optionsOrHandler: Opts, handler: MiddlewareHandler<Opts, R>): Endpoint<MiddlewareHandler<Opts, R>, Opts>;
 
 declare const getCookie: (cookie: string, key: string, prefix?: CookiePrefixOptions) => string | undefined;
 declare const setCookie: (header: Headers, name: string, value: string, opt?: CookieOptions) => void;
 declare const setSignedCookie: (header: Headers, name: string, value: string, secret: string | BufferSource, opt?: CookieOptions) => Promise<void>;
 declare const getSignedCookie: (header: Headers, secret: string, key: string, prefix?: CookiePrefixOptions) => Promise<string | false | undefined>;
 
-export { Context, ContextTools, CookieOptions, CookiePrefixOptions, Endpoint, type EndpointConfig, EndpointOptions, EndpointResponse, Handler, InferBody, InferHeaders, InferRequest, InferUse, InferUseOptions, Method, type Middleware, type MiddlewareHandler, Prettify, Router, createEndpoint, createEndpointCreator, createMiddleware, createMiddlewareCreator, getCookie, getRequest, getSignedCookie, setCookie, setResponse, setSignedCookie, toNodeHandler };
+export { type Context, type Cookie, type CookieConstraint, type CookieOptions, type CookiePrefixOptions, type Endpoint, type EndpointContext, type EndpointResponse, type HasRequiredKeys, type InferResponse, type Input, type IsEmptyObject, type JSONResponse, type Prettify, type RequiredKeysOf, type SignedCookie, type UnionToIntersection, createEndpoint, createGetHeader, createJSON, createMiddleware, createRouter, createSetHeader, fromError, getCookie, getSignedCookie, parse, parseSigned, runValidation, serialize, serializeSigned, setCookie, setSignedCookie };