@duplojs/http 0.6.1 → 0.7.0

package/dist/client/getBody.cjs

@@ -15,7 +15,7 @@ function getBody(response) {
         return response.formData();
     }
     else {
-        return response.blob();
+        return Promise.resolve(undefined);
     }
 }
 

package/dist/client/getBody.mjs

@@ -13,7 +13,7 @@ function getBody(response) {
         return response.formData();
     }
     else {
-        return response.blob();
+        return Promise.resolve(undefined);
     }
 }
 

package/dist/client/hooks.d.ts

@@ -1,28 +1,4 @@
-import { type MaybePromise } from "@duplojs/utils";
-import { type NotPredictedClientResponse, type ClientResponse } from "./types/clientResponse";
-import { type PromiseRequestParams } from "./promiseRequest";
-export type RequestHook<GenericPromiseRequestParams extends PromiseRequestParams = PromiseRequestParams> = (requestParams: GenericPromiseRequestParams) => MaybePromise<PromiseRequestParams>;
-export type ResponseHook<GenericPromiseRequestParams extends PromiseRequestParams = PromiseRequestParams> = (response: ClientResponse<GenericPromiseRequestParams>) => MaybePromise<ClientResponse<GenericPromiseRequestParams>>;
-export type InformationHook<GenericPromiseRequestParams extends PromiseRequestParams = PromiseRequestParams> = (response: ClientResponse<GenericPromiseRequestParams>) => MaybePromise<void>;
-export type ResponseTypeHook<GenericPromiseRequestParams extends PromiseRequestParams = PromiseRequestParams> = (response: ClientResponse<GenericPromiseRequestParams>) => MaybePromise<void>;
-export type ExpectedResponseHook<GenericPromiseRequestParams extends PromiseRequestParams = PromiseRequestParams> = (response: ClientResponse<GenericPromiseRequestParams>) => MaybePromise<void>;
-export type CodeHook<GenericPromiseRequestParams extends PromiseRequestParams = PromiseRequestParams> = (response: ClientResponse<GenericPromiseRequestParams>) => MaybePromise<void>;
-export type NotPredictedResponseHook<GenericPromiseRequestParams extends PromiseRequestParams = PromiseRequestParams> = (response: NotPredictedClientResponse<GenericPromiseRequestParams>) => MaybePromise<void>;
-export type ErrorHook<GenericPromiseRequestParams extends PromiseRequestParams = PromiseRequestParams> = (error: unknown, requestParams: GenericPromiseRequestParams) => MaybePromise<void>;
-export interface Hooks {
-    request: RequestHook[];
-    response: ResponseHook[];
-    information: Record<string, InformationHook[]>;
-    code: Record<string, CodeHook[]>;
-    informationalResponseType: ResponseTypeHook[];
-    successfulResponseType: ResponseTypeHook[];
-    redirectionResponseType: ResponseTypeHook[];
-    clientErrorResponseType: ResponseTypeHook[];
-    serverErrorResponseType: ResponseTypeHook[];
-    expectedResponse: ExpectedResponseHook[];
-    notPredictedResponse: NotPredictedResponseHook[];
-    error: ErrorHook[];
-}
+import { type CodeHook, type ErrorHook, type InformationHook, type NotPredictedResponseHook, type RequestHook, type ResponseHook, type ResponseTypeHook, type PromiseRequestParams, type NotPredictedClientResponse, type ClientResponse } from "./types";
 export declare function launchRequestHook(clientHook: readonly RequestHook[], promiseRequestHook: readonly RequestHook[], requestParams: PromiseRequestParams): Promise<PromiseRequestParams>;
 export declare function launchResponseHook(clientHook: readonly ResponseHook[], promiseRequestHook: readonly ResponseHook[], response: ClientResponse): Promise<ClientResponse>;
 export declare function launchInformationHook(clientHook: readonly InformationHook[], promiseRequestHook: readonly InformationHook[], response: ClientResponse): Promise<void>;

package/dist/client/httpClient.d.ts

@@ -1,17 +1,19 @@
-import { type Kind, type MayBeGetter, type NeverCoalescing, type SimplifyTopLevel } from "@duplojs/utils";
-import { type ClientRequestInitParams, type ServerRoute, type ServerRouteToClientRequestParams, type ServerRouteToClientResponse, type ClientRequestParams } from "./types";
-import { PromiseRequest, type PromiseRequestParams } from "./promiseRequest";
-import { type Hooks, type RequestHook, type ResponseHook, type InformationHook, type CodeHook, type ResponseTypeHook, type ExpectedResponseHook, type ErrorHook, type NotPredictedResponseHook } from "./hooks";
+import { type Kind, type MayBeGetter, type SimplifyTopLevel, type IsEqual } from "@duplojs/utils";
+import { type ClientRequestInitParams, type ServerRoute, type ServerRouteToClientRequestParams, type ServerRouteToClientResponse, type ClientRequestParams, type ClientResponse, type Hooks, type RequestHook, type ResponseHook, type InformationHook, type CodeHook, type ResponseTypeHook, type ExpectedResponseHook, type NotPredictedResponseHook, type ErrorHook, type GetServerRoutePath } from "./types";
+import { PromiseRequest } from "./promiseRequest";
 export declare const httpClientKind: import("@duplojs/utils").KindHandler<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/http-client", unknown>>;
 type MaybeRequestParams<GenericRequestParams extends object> = {} extends GenericRequestParams ? [params?: GenericRequestParams] : [params: GenericRequestParams];
-type HttpClientRequestMethod<GenericServerRoute extends ServerRoute, GenericHookParams extends Record<string, unknown>, GenericMethod extends string> = <GenericClientRequestParams extends NeverCoalescing<ServerRouteToClientRequestParams<Extract<GenericServerRoute, {
+type HttpClientRequestMethod<GenericServerRoute extends ServerRoute, GenericHookParams extends Record<string, unknown>, GenericMethod extends string> = IsEqual<GenericServerRoute, ServerRoute> extends true ? (path: string, params?: SimplifyTopLevel<Omit<ClientRequestParams<GenericHookParams>, "method" | "path">>) => PromiseRequest<GenericHookParams, ClientResponse<GenericHookParams>> : <GenericPath extends Extract<GenericServerRoute, {
     method: GenericMethod;
-}>, GenericHookParams>, ClientRequestParams<GenericHookParams>>, GenericPath extends GenericClientRequestParams["path"], GenericClientRequestRest extends SimplifyTopLevel<Omit<NeverCoalescing<Extract<GenericClientRequestParams, {
-    path: GenericPath;
-}>, ClientRequestParams<GenericHookParams>>, "method" | "path">>>(path: GenericPath, ...args: MaybeRequestParams<GenericClientRequestRest>) => PromiseRequest<PromiseRequestParams<GenericHookParams>, ServerRouteToClientResponse<NeverCoalescing<Extract<GenericServerRoute, {
+}>["path"], GenericMatchedPath extends GetServerRoutePath<Extract<GenericServerRoute, {
     method: GenericMethod;
-    path: GenericPath;
-}>, ServerRoute>, GenericHookParams>>;
+}>, GenericPath>>(path: GenericPath, ...args: MaybeRequestParams<SimplifyTopLevel<Omit<ServerRouteToClientRequestParams<Extract<GenericServerRoute, {
+    method: GenericMethod;
+    path: GenericMatchedPath | GenericPath;
+}>, GenericHookParams>, "method" | "path">>>) => PromiseRequest<GenericHookParams, ServerRouteToClientResponse<Extract<GenericServerRoute, {
+    method: GenericMethod;
+    path: GenericMatchedPath;
+}>, GenericHookParams>>;
 export interface HttpClientConfig {
     readonly baseUrl: string;
     readonly informationHeaderKey: string;
@@ -26,21 +28,23 @@ export interface HttpClient<GenericServerRoute extends ServerRoute = ServerRoute
     readonly defaultHeaders: Map<string, () => (string | undefined | null)>;
     addDefaultHeader(headerName: string, headerValue: MayBeGetter<string | undefined | null>): void;
     addDefaultHeaders(headers: Record<string, MayBeGetter<string | undefined | null>>): void;
-    addRequestHook(hook: RequestHook<PromiseRequestParams<GenericHookParams>>): void;
-    addResponseHook(hook: ResponseHook<PromiseRequestParams<GenericHookParams>>): void;
-    addInformationHook(information: string, hook: InformationHook<PromiseRequestParams<GenericHookParams>>): void;
-    addCodeHook(code: string, hook: CodeHook<PromiseRequestParams<GenericHookParams>>): void;
-    addInformationalResponseTypeHook(hook: ResponseTypeHook<PromiseRequestParams<GenericHookParams>>): void;
-    addSuccessfulResponseTypeHook(hook: ResponseTypeHook<PromiseRequestParams<GenericHookParams>>): void;
-    addRedirectionResponseTypeHook(hook: ResponseTypeHook<PromiseRequestParams<GenericHookParams>>): void;
-    addClientErrorResponseTypeHook(hook: ResponseTypeHook<PromiseRequestParams<GenericHookParams>>): void;
-    addServerErrorResponseTypeHook(hook: ResponseTypeHook<PromiseRequestParams<GenericHookParams>>): void;
-    addExpectedResponseHook(hook: ExpectedResponseHook<PromiseRequestParams<GenericHookParams>>): void;
-    addNotPredictedResponseHook(hook: NotPredictedResponseHook<PromiseRequestParams<GenericHookParams>>): void;
-    addErrorHook(hook: ErrorHook<PromiseRequestParams<GenericHookParams>>): void;
-    request<GenericClientRequestParams extends ServerRouteToClientRequestParams<GenericServerRoute, GenericHookParams>>(params: GenericClientRequestParams): PromiseRequest<PromiseRequestParams<GenericHookParams>, ServerRouteToClientResponse<Extract<GenericServerRoute, {
+    addRequestHook(hook: RequestHook<GenericHookParams>): void;
+    addResponseHook(hook: ResponseHook<GenericHookParams>): void;
+    addInformationHook(information: string, hook: InformationHook<GenericHookParams>): void;
+    addCodeHook(code: string, hook: CodeHook<GenericHookParams>): void;
+    addInformationalResponseTypeHook(hook: ResponseTypeHook<GenericHookParams>): void;
+    addSuccessfulResponseTypeHook(hook: ResponseTypeHook<GenericHookParams>): void;
+    addRedirectionResponseTypeHook(hook: ResponseTypeHook<GenericHookParams>): void;
+    addClientErrorResponseTypeHook(hook: ResponseTypeHook<GenericHookParams>): void;
+    addServerErrorResponseTypeHook(hook: ResponseTypeHook<GenericHookParams>): void;
+    addExpectedResponseHook(hook: ExpectedResponseHook<GenericHookParams>): void;
+    addNotPredictedResponseHook(hook: NotPredictedResponseHook<GenericHookParams>): void;
+    addErrorHook(hook: ErrorHook<GenericHookParams>): void;
+    request<GenericClientRequestParams extends ServerRouteToClientRequestParams<GenericServerRoute, GenericHookParams>, GenericMatchedPath extends GetServerRoutePath<Extract<GenericServerRoute, {
+        method: GenericClientRequestParams["method"];
+    }>, GenericClientRequestParams["path"]>>(params: GenericClientRequestParams): PromiseRequest<GenericHookParams, ServerRouteToClientResponse<Extract<GenericServerRoute, {
         method: GenericClientRequestParams["method"];
-        path: GenericClientRequestParams["path"];
+        path: GenericMatchedPath;
     }>, GenericHookParams>>;
     get: HttpClientRequestMethod<GenericServerRoute, GenericHookParams, "GET">;
     post: HttpClientRequestMethod<GenericServerRoute, GenericHookParams, "POST">;
@@ -57,5 +61,5 @@ export interface CreateHttpClientParams {
     readonly predictedHeaderKey?: string;
     readonly disabledPredictedMode?: boolean;
 }
-export declare function createHttpClient<GenericServerRoute extends ServerRoute = never, GenericHookParams extends Record<string, unknown> = Record<string, unknown>>(clientParams: CreateHttpClientParams): HttpClient<NeverCoalescing<GenericServerRoute, ServerRoute>, GenericHookParams>;
+export declare function createHttpClient<GenericServerRoute extends ServerRoute = ServerRoute, GenericHookParams extends Record<string, unknown> = Record<string, unknown>>(clientParams: CreateHttpClientParams): HttpClient<GenericServerRoute, GenericHookParams>;
 export {};

package/dist/client/promiseRequest.cjs

@@ -310,6 +310,9 @@ class PromiseRequest extends Promise {
                     headers["content-type"] = "text/plain; charset=utf-8";
                     body = body.toString();
                 }
+                else if (body instanceof utils.TheFormData) {
+                    headers["content-type-options"] = "advanced";
+                }
                 else if ((body
                     && typeof body === "object"
                     && body?.constructor?.name === "Object")

package/dist/client/promiseRequest.d.ts

@@ -1,97 +1,89 @@
 import { type NeverCoalescing, type MaybePromise } from "@duplojs/utils";
-import { type Hooks, type ErrorHook, type NotPredictedResponseHook } from "./hooks";
 import * as EE from "@duplojs/utils/either";
 import { type RequestErrorContent } from "./unexpectedResponseError";
-import { type NotPredictedClientResponse, type ClientRequestParams, type ClientResponse } from "./types";
-type MaybeResponse<GenericClientResponse extends ClientResponse = ClientResponse> = (EE.EitherRight<"response", GenericClientResponse> | EE.EitherLeft<"request-error", RequestErrorContent>);
-type MaybeWantedResponse<GenericWantedClientResponse extends ClientResponse = ClientResponse, GenericUnexpectClientResponse extends ClientResponse = ClientResponse> = (EE.EitherRight<"response", GenericWantedClientResponse> | EE.EitherLeft<"unexpect-response", GenericUnexpectClientResponse> | EE.EitherLeft<"request-error", RequestErrorContent>);
-export interface PromiseRequestParams<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> extends ClientRequestParams<GenericHookParams> {
-    baseUrl: string;
-    hooks: Hooks;
-    informationHeaderKey: string;
-    predictedHeaderKey: string;
-    disabledPredicateMode: boolean;
-}
-export declare class PromiseRequest<GenericPromiseRequestParams extends PromiseRequestParams = PromiseRequestParams, GenericClientResponse extends ClientResponse = ClientResponse> extends Promise<MaybeResponse<GenericClientResponse | NotPredictedClientResponse<GenericPromiseRequestParams>>> {
+import { type NotPredictedClientResponse, type ClientResponse, type PromiseRequestParams, type Hooks, type NotPredictedResponseHook, type ErrorHook } from "./types";
+type MaybeResponse<GenericClientResponse extends ClientResponse = ClientResponse> = (EE.Right<"response", GenericClientResponse> | EE.Left<"request-error", RequestErrorContent>);
+type MaybeWantedResponse<GenericWantedClientResponse extends ClientResponse = ClientResponse, GenericUnexpectClientResponse extends ClientResponse = ClientResponse> = (EE.Right<"response", GenericWantedClientResponse> | EE.Left<"unexpect-response", GenericUnexpectClientResponse> | EE.Left<"request-error", RequestErrorContent>);
+export declare class PromiseRequest<GenericHookParams extends Record<string, unknown> = Record<string, unknown>, GenericClientResponse extends ClientResponse<GenericHookParams> = ClientResponse<GenericHookParams>> extends Promise<MaybeResponse<GenericClientResponse | NotPredictedClientResponse<GenericHookParams>>> {
     params: PromiseRequestParams;
     readonly hooks: Partial<Hooks>;
     constructor(params: PromiseRequestParams);
-    addRequestInterceptor(callback: (requestParams: GenericPromiseRequestParams) => MaybePromise<GenericPromiseRequestParams>): this;
+    addRequestInterceptor(callback: (requestParams: GenericClientResponse["requestParams"]) => MaybePromise<GenericClientResponse["requestParams"]>): this;
     addResponseInterceptor(callback: (response: GenericClientResponse) => MaybePromise<GenericClientResponse>): this;
-    whenNotPredictedResponse(callback: NotPredictedResponseHook<GenericPromiseRequestParams>): this;
+    whenNotPredictedResponse(callback: NotPredictedResponseHook<GenericHookParams>): this;
     whenInformation<GenericInformation extends Extract<GenericClientResponse["information"], string>>(information: GenericInformation | GenericInformation[], callback: (response: NeverCoalescing<Extract<GenericClientResponse, GenericInformation extends any ? {
         information: GenericInformation;
-    } : never>, ClientResponse<GenericPromiseRequestParams>>) => MaybePromise<void>): this;
+    } : never>, ClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
     whenCode<GenericCode extends GenericClientResponse["code"]>(code: GenericCode | GenericCode[], callback: (response: NeverCoalescing<Extract<GenericClientResponse, GenericCode extends any ? {
         code: GenericCode;
-    } : never>, ClientResponse<GenericPromiseRequestParams>>) => MaybePromise<void>): this;
+    } : never>, ClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
     whenInformationalResponse(callback: (response: NeverCoalescing<Extract<GenericClientResponse, {
         code: `1${number}`;
-    }>, ClientResponse<GenericPromiseRequestParams>>) => MaybePromise<void>): this;
+    }>, ClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
     whenSuccessfulResponse(callback: (response: NeverCoalescing<Extract<GenericClientResponse, {
         code: `2${number}`;
-    }>, ClientResponse<GenericPromiseRequestParams>>) => MaybePromise<void>): this;
+    }>, ClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
     whenRedirectionResponse(callback: (response: NeverCoalescing<Extract<GenericClientResponse, {
         code: `3${number}`;
-    }>, ClientResponse<GenericPromiseRequestParams>>) => MaybePromise<void>): this;
+    }>, ClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
     whenClientErrorResponse(callback: (response: NeverCoalescing<Extract<GenericClientResponse, {
         code: `4${number}`;
-    }>, ClientResponse<GenericPromiseRequestParams>>) => MaybePromise<void>): this;
+    }>, ClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
     whenServerErrorResponse(callback: (response: NeverCoalescing<Extract<GenericClientResponse, {
         code: `5${number}`;
-    }>, ClientResponse<GenericPromiseRequestParams>>) => MaybePromise<void>): this;
+    }>, ClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
     whenExpectedResponse(callback: (response: NeverCoalescing<Extract<GenericClientResponse, {
         code: `2${number}` | `4${number}`;
-    }>, ClientResponse<GenericPromiseRequestParams>>) => MaybePromise<void>): this;
-    whenError(callback: ErrorHook<GenericPromiseRequestParams>): this;
+    }>, ClientResponse<GenericHookParams>>) => MaybePromise<void>): this;
+    whenError(callback: ErrorHook<GenericHookParams>): this;
     iWantInformation<GenericInformation extends Extract<GenericClientResponse["information"], string>, GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, GenericInformation extends any ? {
         information: GenericInformation;
-    } : never>, ClientResponse<GenericPromiseRequestParams>>>(information: GenericInformation | GenericInformation[]): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericPromiseRequestParams>>>>;
+    } : never>, ClientResponse<GenericHookParams>>>(information: GenericInformation | GenericInformation[]): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericHookParams>>>>;
     iWantCode<GenericCode extends GenericClientResponse["code"], GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, GenericCode extends any ? {
         code: GenericCode;
-    } : never>, ClientResponse<GenericPromiseRequestParams>>>(code: GenericCode | GenericCode[]): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericPromiseRequestParams>>>>;
+    } : never>, ClientResponse<GenericHookParams>>>(code: GenericCode | GenericCode[]): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericHookParams>>>>;
     iWantInformationalResponse<GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, {
         code: `1${number}`;
-    }>, ClientResponse<GenericPromiseRequestParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericPromiseRequestParams>>>>;
+    }>, ClientResponse<GenericHookParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericHookParams>>>>;
     iWantSuccessfulResponse<GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, {
         code: `2${number}`;
-    }>, ClientResponse<GenericPromiseRequestParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericPromiseRequestParams>>>>;
+    }>, ClientResponse<GenericHookParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericHookParams>>>>;
     iWantRedirectionResponse<GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, {
         code: `3${number}`;
-    }>, ClientResponse<GenericPromiseRequestParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericPromiseRequestParams>>>>;
+    }>, ClientResponse<GenericHookParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericHookParams>>>>;
     iWantClientErrorResponse<GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, {
         code: `4${number}`;
-    }>, ClientResponse<GenericPromiseRequestParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericPromiseRequestParams>>>>;
+    }>, ClientResponse<GenericHookParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericHookParams>>>>;
     iWantServerErrorResponse<GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, {
         code: `5${number}`;
-    }>, ClientResponse<GenericPromiseRequestParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericPromiseRequestParams>>>>;
+    }>, ClientResponse<GenericHookParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericHookParams>>>>;
     iWantExpectedResponse<GenericResponse extends NeverCoalescing<Extract<GenericClientResponse, {
         code: `2${number}` | `4${number}`;
-    }>, ClientResponse<GenericPromiseRequestParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericPromiseRequestParams>>>>;
+    }>, ClientResponse<GenericHookParams>>>(): Promise<MaybeWantedResponse<GenericResponse, NeverCoalescing<Exclude<GenericClientResponse, GenericResponse>, ClientResponse<GenericHookParams>>>>;
     iWantInformationOrThrow<GenericInformation extends Extract<GenericClientResponse["information"], string>>(information: GenericInformation | GenericInformation[]): Promise<NeverCoalescing<Extract<GenericClientResponse, GenericInformation extends any ? {
         information: GenericInformation;
-    } : never>, ClientResponse<GenericPromiseRequestParams>>>;
+    } : never>, ClientResponse<GenericHookParams>>>;
     iWantCodeOrThrow<GenericCode extends GenericClientResponse["code"]>(code: GenericCode | GenericCode[]): Promise<NeverCoalescing<Extract<GenericClientResponse, GenericCode extends any ? {
         code: GenericCode;
-    } : never>, ClientResponse<GenericPromiseRequestParams>>>;
+    } : never>, ClientResponse<GenericHookParams>>>;
     iWantInformationalResponseOrThrow(): Promise<NeverCoalescing<Extract<GenericClientResponse, {
         code: `1${number}`;
-    }>, ClientResponse<GenericPromiseRequestParams>>>;
+    }>, ClientResponse<GenericHookParams>>>;
     iWantSuccessfulResponseOrThrow(): Promise<NeverCoalescing<Extract<GenericClientResponse, {
         code: `2${number}`;
-    }>, ClientResponse<GenericPromiseRequestParams>>>;
+    }>, ClientResponse<GenericHookParams>>>;
     iWantRedirectionResponseOrThrow(): Promise<NeverCoalescing<Extract<GenericClientResponse, {
         code: `3${number}`;
-    }>, ClientResponse<GenericPromiseRequestParams>>>;
+    }>, ClientResponse<GenericHookParams>>>;
     iWantClientErrorResponseOrThrow(): Promise<NeverCoalescing<Extract<GenericClientResponse, {
         code: `4${number}`;
-    }>, ClientResponse<GenericPromiseRequestParams>>>;
+    }>, ClientResponse<GenericHookParams>>>;
     iWantServerErrorResponseOrThrow(): Promise<NeverCoalescing<Extract<GenericClientResponse, {
         code: `5${number}`;
-    }>, ClientResponse<GenericPromiseRequestParams>>>;
+    }>, ClientResponse<GenericHookParams>>>;
     iWantExpectedResponseOrThrow(): Promise<NeverCoalescing<Extract<GenericClientResponse, {
         code: `2${number}` | `4${number}`;
-    }>, ClientResponse<GenericPromiseRequestParams>>>;
+    }>, ClientResponse<GenericHookParams>>>;
     static get [Symbol.species](): PromiseConstructor;
     static fetch<GenericPromiseRequestParams extends PromiseRequestParams>(requestParams: GenericPromiseRequestParams): Promise<MaybeResponse>;
 }

package/dist/client/promiseRequest.mjs

@@ -1,4 +1,4 @@
-import { unwrap } from '@duplojs/utils';
+import { unwrap, TheFormData } from '@duplojs/utils';
 import { getBody } from './getBody.mjs';
 import { insertParamsInPath } from './insertParamsInPath.mjs';
 import { queryToString } from './queryToString.mjs';
@@ -287,6 +287,9 @@ class PromiseRequest extends Promise {
                     headers["content-type"] = "text/plain; charset=utf-8";
                     body = body.toString();
                 }
+                else if (body instanceof TheFormData) {
+                    headers["content-type-options"] = "advanced";
+                }
                 else if ((body
                     && typeof body === "object"
                     && body?.constructor?.name === "Object")

package/dist/client/types/clientResponse.d.ts

@@ -1,9 +1,9 @@
 import type * as SS from "@duplojs/utils/string";
 import { type ServerRouteResponse, type ServerRoute } from "./serverRoute";
 import { type IsEqual, type SimplifyTopLevel } from "@duplojs/utils";
-import { type PromiseRequestParams } from "../promiseRequest";
+import { type PromiseRequestParams } from "./promiseRequestParams";
 export type ClientResponseBody = unknown;
-export interface ClientResponse<GenericPromiseRequestParams extends PromiseRequestParams = PromiseRequestParams> {
+export interface ClientResponse<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> {
     code: SS.Number;
     information: undefined | string;
     body: ClientResponseBody;
@@ -13,16 +13,16 @@ export interface ClientResponse<GenericPromiseRequestParams extends PromiseReque
     url: string;
     redirected: boolean;
     raw: globalThis.Response;
-    requestParams: GenericPromiseRequestParams;
+    requestParams: PromiseRequestParams<GenericHookParams>;
     predicted: boolean;
 }
-export interface NotPredictedClientResponse<GenericPromiseRequestParams extends PromiseRequestParams = PromiseRequestParams> extends ClientResponse<GenericPromiseRequestParams> {
+export interface NotPredictedClientResponse<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> extends ClientResponse<GenericHookParams> {
     predicted: false;
 }
-export type ServerRouteToClientResponse<GenericServerRoute extends ServerRoute = ServerRoute, GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = IsEqual<GenericServerRoute, ServerRoute> extends true ? ClientResponse<PromiseRequestParams<GenericHookParams>> : GenericServerRoute extends any ? GenericServerRoute["responses"] extends infer InferredResponse ? InferredResponse extends ServerRouteResponse ? SimplifyTopLevel<{
+export type ServerRouteToClientResponse<GenericServerRoute extends ServerRoute = ServerRoute, GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = GenericServerRoute extends any ? GenericServerRoute["responses"] extends infer InferredResponse ? InferredResponse extends ServerRouteResponse ? SimplifyTopLevel<{
     code: InferredResponse["code"];
     information: InferredResponse["information"];
-    body: InferredResponse["body"];
+    body: IsEqual<InferredResponse["body"], File> extends true ? undefined : InferredResponse["body"];
     ok: boolean | null;
     headers: Headers;
     type: ResponseType;

package/dist/client/types/hooks.d.ts

@@ -0,0 +1,25 @@
+import { type MaybePromise } from "@duplojs/utils";
+import { type NotPredictedClientResponse, type ClientResponse } from "./clientResponse";
+import { type PromiseRequestParams } from "./promiseRequestParams";
+export type RequestHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (requestParams: PromiseRequestParams<GenericHookParams>) => MaybePromise<PromiseRequestParams<GenericHookParams>>;
+export type ResponseHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: ClientResponse<GenericHookParams>) => MaybePromise<ClientResponse<GenericHookParams>>;
+export type InformationHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: ClientResponse<GenericHookParams>) => MaybePromise<void>;
+export type ResponseTypeHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: ClientResponse<GenericHookParams>) => MaybePromise<void>;
+export type ExpectedResponseHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: ClientResponse<GenericHookParams>) => MaybePromise<void>;
+export type CodeHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: ClientResponse<GenericHookParams>) => MaybePromise<void>;
+export type NotPredictedResponseHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (response: NotPredictedClientResponse<GenericHookParams>) => MaybePromise<void>;
+export type ErrorHook<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> = (error: unknown, requestParams: PromiseRequestParams<GenericHookParams>) => MaybePromise<void>;
+export interface Hooks {
+    request: RequestHook[];
+    response: ResponseHook[];
+    information: Record<string, InformationHook[]>;
+    code: Record<string, CodeHook[]>;
+    informationalResponseType: ResponseTypeHook[];
+    successfulResponseType: ResponseTypeHook[];
+    redirectionResponseType: ResponseTypeHook[];
+    clientErrorResponseType: ResponseTypeHook[];
+    serverErrorResponseType: ResponseTypeHook[];
+    expectedResponse: ExpectedResponseHook[];
+    notPredictedResponse: NotPredictedResponseHook[];
+    error: ErrorHook[];
+}

package/dist/client/types/index.cjs

@@ -4,4 +4,6 @@ require('./clientRequestParams.cjs');
 require('./clientResponse.cjs');
 require('./serverRoute.cjs');
 require('./ObjectCanBeEmpty.cjs');
+require('./promiseRequestParams.cjs');
+require('./hooks.cjs');
 

package/dist/client/types/index.d.ts

@@ -2,3 +2,5 @@ export * from "./clientRequestParams";
 export * from "./clientResponse";
 export * from "./serverRoute";
 export * from "./ObjectCanBeEmpty";
+export * from "./promiseRequestParams";
+export * from "./hooks";

package/dist/client/types/index.mjs

@@ -2,3 +2,5 @@ import './clientRequestParams.mjs';
 import './clientResponse.mjs';
 import './serverRoute.mjs';
 import './ObjectCanBeEmpty.mjs';
+import './promiseRequestParams.mjs';
+import './hooks.mjs';

package/dist/client/types/promiseRequestParams.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/client/types/promiseRequestParams.d.ts

@@ -0,0 +1,9 @@
+import { type ClientRequestParams } from "./clientRequestParams";
+import { type Hooks } from "./hooks";
+export interface PromiseRequestParams<GenericHookParams extends Record<string, unknown> = Record<string, unknown>> extends ClientRequestParams<GenericHookParams> {
+    baseUrl: string;
+    hooks: Hooks;
+    informationHeaderKey: string;
+    predictedHeaderKey: string;
+    disabledPredicateMode: boolean;
+}

package/dist/client/types/promiseRequestParams.mjs

@@ -0,0 +1 @@
+

package/dist/client/types/serverRoute.d.ts

@@ -1,4 +1,4 @@
-import { type MaybeArray } from "@duplojs/utils";
+import { type SimplifyTopLevel, type MaybeArray, type IsEqual } from "@duplojs/utils";
 import type * as SS from "@duplojs/utils/string";
 export type ServerPrimitiveData = string | undefined | number | null | boolean;
 export type ServerRouteHeaders = Record<string, ServerPrimitiveData>;
@@ -20,3 +20,21 @@ export interface ServerRoute {
     body?: ServerRouteBody;
     responses: ServerRouteResponse;
 }
+export type GetServerRoutePath<GenericServerRoute extends ServerRoute, GenericPath extends GenericServerRoute["path"]> = GenericServerRoute extends ServerRoute ? IsEqual<Extract<GenericPath, GenericServerRoute["path"]>, never> extends true ? never : GenericServerRoute["path"] : never;
+export type AddPrefixPathServerRoute<GenericRoute extends ServerRoute, GenericPrefix extends string> = GenericRoute extends ServerRoute ? SimplifyTopLevel<{
+    path: `${GenericPrefix}${GenericRoute["path"]}`;
+} & Omit<GenericRoute, "path">> : never;
+export type RemovePrefixPathServerRoute<GenericRoute extends ServerRoute, GenericPrefix extends string> = GenericRoute extends ServerRoute ? GenericRoute["path"] extends `${GenericPrefix}${infer InferredPathRest}` ? SimplifyTopLevel<{
+    path: InferredPathRest;
+} & Omit<GenericRoute, "path">> : GenericRoute : never;
+export type FindServerRoute<GenericRoute extends ServerRoute, GenericMethod extends GenericRoute["method"], GenericPath extends Extract<GenericRoute, {
+    method: GenericMethod;
+}>["path"] = Extract<GenericRoute, {
+    method: GenericMethod;
+}>["path"]> = Extract<GenericRoute, {
+    method: GenericMethod;
+    path: GenericPath;
+}>;
+export type FindServerRouteResponse<GenericRoute extends ServerRoute, GenericKey extends "code" | "information", GenericValue extends GenericRoute["responses"][GenericKey] = GenericRoute["responses"][GenericKey]> = Extract<GenericRoute["responses"], {
+    [Prop in GenericKey]: GenericValue;
+}>;

package/dist/client/unexpectedResponseError.d.ts

@@ -1,5 +1,4 @@
-import { type ClientResponse } from "./types";
-import { type PromiseRequestParams } from "./promiseRequest";
+import { type PromiseRequestParams, type ClientResponse } from "./types";
 export interface RequestErrorContent {
     error: unknown;
     requestParams: PromiseRequestParams;

package/dist/core/builders/preflight/route.cjs

@@ -18,4 +18,5 @@ builder.preflightBuilder.set("useRouteBuilder", ({ args: [method, paths, options
         ...(options?.metadata ?? []),
         ...accumulator.metadata,
     ],
+    bodyController: options?.bodyController ?? null,
 }));

package/dist/core/builders/preflight/route.d.ts

@@ -1,14 +1,15 @@
 import { type Floor } from "../../floor";
-import { type RequestMethods, type Request } from "../../request";
+import { type RequestMethods, type Request, type BodyController } from "../../request";
 import { type MakeRequestFromHooks, type HookRouteLifeCycle, type RoutePath } from "../../route";
 import { type RouteBuilder } from "../route";
 import { type NeverCoalescing } from "@duplojs/utils";
 import { type Metadata } from "../../metadata";
 declare module "./builder" {
     interface PreflightBuilder<GenericDefinition extends PreflightBuilderDefinition = PreflightBuilderDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> {
-        useRouteBuilder<GenericMethod extends RequestMethods, const GenericPaths extends RoutePath | readonly [RoutePath, ...RoutePath[]], const GenericHooks extends readonly HookRouteLifeCycle[] = readonly [], const GenericMetadata extends readonly Metadata[] = readonly []>(method: GenericMethod, path: GenericPaths, options?: {
+        useRouteBuilder<GenericMethod extends RequestMethods, const GenericPaths extends RoutePath | readonly [RoutePath, ...RoutePath[]], const GenericHooks extends readonly HookRouteLifeCycle[] = readonly [], const GenericMetadata extends readonly Metadata[] = readonly [], const GenericBodyController extends BodyController | null = null>(method: GenericMethod, path: GenericPaths, options?: {
             hooks?: GenericHooks | readonly HookRouteLifeCycle[];
             metadata?: GenericMetadata;
+            bodyController?: GenericBodyController;
         }): RouteBuilder<{
             readonly method: GenericMethod;
             readonly paths: GenericPaths extends string ? readonly [GenericPaths] : GenericPaths;
@@ -22,6 +23,7 @@ declare module "./builder" {
                 ...GenericMetadata,
                 ...GenericDefinition["metadata"]
             ];
+            readonly bodyController: GenericBodyController;
         }, GenericFloor, (GenericRequest & NeverCoalescing<MakeRequestFromHooks<GenericHooks>, Request>)>;
     }
 }

package/dist/core/builders/preflight/route.mjs

@@ -16,4 +16,5 @@ preflightBuilder.set("useRouteBuilder", ({ args: [method, paths, options,], accu
         ...(options?.metadata ?? []),
         ...accumulator.metadata,
     ],
+    bodyController: options?.bodyController ?? null,
 }));

package/dist/core/builders/route/builder.cjs

@@ -12,6 +12,7 @@ function useRouteBuilder(method, path, options) {
         steps: [],
         hooks: options?.hooks ?? [],
         metadata: options?.metadata ?? [],
+        bodyController: options?.bodyController ?? null,
     });
 }
 

package/dist/core/builders/route/builder.d.ts

@@ -1,14 +1,15 @@
 import { type MakeRequestFromHooks, type HookRouteLifeCycle, type RouteDefinition, type RoutePath } from "../../route";
 import { type Floor } from "../../floor";
-import { type RequestMethods, type Request } from "../../request";
+import { type RequestMethods, type Request, type BodyController } from "../../request";
 import { type Builder, type NeverCoalescing } from "@duplojs/utils";
 import { type Metadata } from "../../metadata";
 export interface RouteBuilder<GenericDefinition extends RouteDefinition = RouteDefinition, GenericFloor extends Floor = {}, GenericRequest extends Request = Request> extends Builder<RouteDefinition> {
 }
 export declare const routeBuilderHandler: import("@duplojs/utils").BuilderHandler<RouteBuilder<RouteDefinition, {}, Request>>;
-export declare function useRouteBuilder<GenericMethod extends RequestMethods, const GenericPaths extends RoutePath | readonly [RoutePath, ...RoutePath[]], const GenericHooks extends readonly HookRouteLifeCycle[] = readonly [], const GenericMetadata extends readonly Metadata[] = readonly []>(method: GenericMethod, path: GenericPaths, options?: {
+export declare function useRouteBuilder<GenericMethod extends RequestMethods, const GenericPaths extends RoutePath | readonly [RoutePath, ...RoutePath[]], const GenericHooks extends readonly HookRouteLifeCycle[] = readonly [], const GenericMetadata extends readonly Metadata[] = readonly [], const GenericBodyController extends BodyController | null = null>(method: GenericMethod, path: GenericPaths, options?: {
     hooks?: GenericHooks | readonly HookRouteLifeCycle[];
     metadata?: GenericMetadata;
+    bodyController?: GenericBodyController;
 }): RouteBuilder<{
     readonly method: GenericMethod;
     readonly paths: GenericPaths extends string ? readonly [GenericPaths] : GenericPaths;
@@ -16,4 +17,5 @@ export declare function useRouteBuilder<GenericMethod extends RequestMethods, co
     readonly steps: readonly [];
     readonly hooks: GenericHooks;
     readonly metadata: GenericMetadata;
+    readonly bodyController: GenericBodyController;
 }, {}, NeverCoalescing<MakeRequestFromHooks<GenericHooks>, Request>>;

package/dist/core/builders/route/builder.mjs

@@ -10,6 +10,7 @@ function useRouteBuilder(method, path, options) {
         steps: [],
         hooks: options?.hooks ?? [],
         metadata: options?.metadata ?? [],
+        bodyController: options?.bodyController ?? null,
     });
 }
 

package/dist/core/clean/constraint.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var clean = require('@duplojs/utils/clean');
+
+clean.createConstraint.overrideHandler.setMethod("toExtractParser", (self) => {
+    const dataParserWithCheckers = self
+        .primitiveHandler
+        .dataParser
+        .addChecker(...self.checkers);
+    const valueContainer = clean.constrainedTypeKind.setTo({}, { [self.name]: null });
+    const dataParser = utils.DPE.transform(dataParserWithCheckers, (input) => ({
+        ...valueContainer,
+        [utils.keyWrappedValue]: input,
+    }));
+    return dataParser;
+});
+clean.createConstraint.overrideHandler.setMethod("toEndpointSchema", (self) => {
+    const dataParser = self
+        .primitiveHandler
+        .dataParser
+        .addChecker(...self.checkers);
+    return utils.DPE.lazy(() => dataParser);
+});

package/dist/core/clean/constraint.d.ts

@@ -0,0 +1,8 @@
+import { type DP, DPE } from "@duplojs/utils";
+import { type ConstrainedType, type EligiblePrimitive } from "@duplojs/utils/clean";
+declare module "@duplojs/utils/clean" {
+    interface ConstraintHandler<GenericName extends string = string, GenericPrimitiveValue extends EligiblePrimitive = EligiblePrimitive, GenericCheckers extends readonly DP.DataParserChecker[] = readonly DP.DataParserChecker[]> {
+        toExtractParser(): DPE.ContractExtended<ConstrainedType<GenericName, GenericPrimitiveValue>, unknown>;
+        toEndpointSchema(): DPE.ContractExtended<GenericPrimitiveValue>;
+    }
+}

package/dist/core/clean/constraint.mjs

@@ -0,0 +1,22 @@
+import { DPE, keyWrappedValue } from '@duplojs/utils';
+import { createConstraint, constrainedTypeKind } from '@duplojs/utils/clean';
+
+createConstraint.overrideHandler.setMethod("toExtractParser", (self) => {
+    const dataParserWithCheckers = self
+        .primitiveHandler
+        .dataParser
+        .addChecker(...self.checkers);
+    const valueContainer = constrainedTypeKind.setTo({}, { [self.name]: null });
+    const dataParser = DPE.transform(dataParserWithCheckers, (input) => ({
+        ...valueContainer,
+        [keyWrappedValue]: input,
+    }));
+    return dataParser;
+});
+createConstraint.overrideHandler.setMethod("toEndpointSchema", (self) => {
+    const dataParser = self
+        .primitiveHandler
+        .dataParser
+        .addChecker(...self.checkers);
+    return DPE.lazy(() => dataParser);
+});

package/dist/core/clean/constraintsSet.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var clean = require('@duplojs/utils/clean');
+
+clean.createConstraintsSet.overrideHandler.setMethod("toExtractParser", (self) => {
+    const checkers = utils.A.flatMap(self.constraints, ({ checkers }) => checkers);
+    const dataParserWithCheckers = self
+        .primitiveHandler
+        .dataParser
+        .addChecker(...checkers);
+    const constraintsKindValue = utils.pipe(self.constraints, utils.A.map(({ name }) => utils.O.entry(name, null)), utils.O.fromEntries);
+    const valueContainer = clean.constrainedTypeKind.setTo({}, constraintsKindValue);
+    const dataParser = utils.DPE.transform(dataParserWithCheckers, (input) => ({
+        ...valueContainer,
+        [utils.keyWrappedValue]: input,
+    }));
+    return dataParser;
+});
+clean.createConstraintsSet.overrideHandler.setMethod("toEndpointSchema", (self) => {
+    const checkers = utils.A.flatMap(self.constraints, ({ checkers }) => checkers);
+    const dataParserWithCheckers = self
+        .primitiveHandler
+        .dataParser
+        .addChecker(...checkers);
+    return utils.DPE.lazy(() => dataParserWithCheckers);
+});