@duplojs/http 0.6.1 → 0.7.0

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

@@ -0,0 +1,8 @@
+import { DPE, type UnionToIntersection } from "@duplojs/utils";
+import { type EligiblePrimitive, type GetConstraint, type Primitive } from "@duplojs/utils/clean";
+declare module "@duplojs/utils/clean" {
+    interface ConstraintsSetHandler<GenericPrimitiveValue extends EligiblePrimitive = EligiblePrimitive, GenericConstraintsHandler extends readonly ConstraintHandler[] = readonly []> {
+        toExtractParser(): DPE.ContractExtended<(Primitive<GenericPrimitiveValue> & UnionToIntersection<GenericConstraintsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>), unknown>;
+        toEndpointSchema(): DPE.ContractExtended<GenericPrimitiveValue>;
+    }
+}

package/dist/core/clean/constraintsSet.mjs

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

package/dist/core/clean/entity.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var clean = require('@duplojs/utils/clean');
+
+function propertiesDefinitionToSchema(definition, method) {
+    return utils.pipe(definition, utils.P.when(clean.newTypeHandlerKind.has, (value) => value[method]()), utils.P.when(utils.isType("array"), utils.innerPipe(utils.A.map((element) => element[method]()), (options) => {
+        utils.asserts(options, utils.A.minElements(1));
+        return utils.DP.union(options);
+    })), utils.P.otherwise((definition) => utils.pipe(definition.type, (subDefinition) => propertiesDefinitionToSchema(subDefinition, method), (dataParser) => {
+        if (definition.inArray) {
+            return utils.pipe(dataParser, utils.DP.array, (dataParser) => typeof definition.inArray === "object"
+                && typeof definition.inArray.min === "number"
+                ? dataParser.addChecker(utils.DP.checkerArrayMin(definition.inArray.min))
+                : dataParser, (dataParser) => typeof definition.inArray === "object"
+                && typeof definition.inArray.max === "number"
+                ? dataParser.addChecker(utils.DP.checkerArrayMax(definition.inArray.max))
+                : dataParser);
+        }
+        return dataParser;
+    }, (dataParser) => definition.nullable === true
+        ? utils.DP.nullable(dataParser)
+        : dataParser)));
+}
+clean.createEntity.overrideHandler.setMethod("toExtractParser", (self, keys) => utils.pipe(self.propertiesDefinition, utils.O.entries, utils.A.filter(([key]) => keys === undefined || utils.A.includes(keys, key)), utils.A.map(([key, value]) => utils.O.entry(key, propertiesDefinitionToSchema(value, "toExtractParser"))), utils.O.fromEntries, utils.DPE.object));
+clean.createEntity.overrideHandler.setMethod("toEndpointSchema", (self, keys, params) => utils.pipe(self.propertiesDefinition, utils.O.entries, utils.A.filter(([key]) => keys === undefined || utils.A.includes(keys, key)), utils.A.map(([key, value]) => utils.O.entry(key, propertiesDefinitionToSchema(value, "toEndpointSchema"))), utils.O.fromEntries, (shape) => typeof params?.addEntityName !== "undefined"
+    ? {
+        ...shape,
+        _entityName: typeof params.addEntityName === "string"
+            ? utils.DP.literal(`${self.name}/${params.addEntityName}`)
+            : utils.DP.literal(self.name),
+    }
+    : shape, utils.DPE.object));

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

@@ -0,0 +1,20 @@
+import { DP, DPE, type IsEqual, type SimplifyTopLevel, type IsExtends } from "@duplojs/utils";
+import { type EntityRawProperties, type EntityProperties, type EntityPropertiesDefinition } from "@duplojs/utils/clean";
+interface ToEndpointSchemaParams {
+    addEntityName?: boolean | string;
+}
+declare module "@duplojs/utils/clean" {
+    interface EntityHandler<GenericName extends string = string, GenericPropertiesDefinition extends EntityPropertiesDefinition = EntityPropertiesDefinition> {
+        toExtractParser<GenericEntityProperties extends EntityProperties<GenericPropertiesDefinition>, const GenericKey extends keyof GenericEntityProperties = keyof GenericEntityProperties>(keys?: GenericKey[]): ReturnType<typeof DPE.object<{
+            [Prop in GenericKey]: DP.Contract<GenericEntityProperties[Prop], unknown>;
+        }>>;
+        toEndpointSchema<GenericEntityRawProperties extends EntityRawProperties<GenericPropertiesDefinition>, const GenericKey extends keyof GenericEntityRawProperties = keyof GenericEntityRawProperties, const GenericParams extends ToEndpointSchemaParams = {}>(keys?: GenericKey[], params?: GenericParams | ToEndpointSchemaParams): ReturnType<typeof DPE.object<SimplifyTopLevel<{
+            [Prop in GenericKey]: DP.Contract<GenericEntityRawProperties[Prop], unknown>;
+        } & (IsEqual<GenericParams["addEntityName"], true> extends true ? {
+            [Prop in "_entityName"]: DP.Contract<GenericName, unknown>;
+        } : {}) & (IsExtends<GenericParams["addEntityName"], string> extends true ? {
+            [Prop in "_entityName"]: DP.Contract<`${GenericName}/${GenericParams["addEntityName"]}`, unknown>;
+        } : {})>>>;
+    }
+}
+export {};

package/dist/core/clean/entity.mjs

@@ -0,0 +1,31 @@
+import { pipe, P, isType, innerPipe, A, asserts, DP, O, DPE } from '@duplojs/utils';
+import { newTypeHandlerKind, createEntity } from '@duplojs/utils/clean';
+
+function propertiesDefinitionToSchema(definition, method) {
+    return pipe(definition, P.when(newTypeHandlerKind.has, (value) => value[method]()), P.when(isType("array"), innerPipe(A.map((element) => element[method]()), (options) => {
+        asserts(options, A.minElements(1));
+        return DP.union(options);
+    })), P.otherwise((definition) => pipe(definition.type, (subDefinition) => propertiesDefinitionToSchema(subDefinition, method), (dataParser) => {
+        if (definition.inArray) {
+            return pipe(dataParser, DP.array, (dataParser) => typeof definition.inArray === "object"
+                && typeof definition.inArray.min === "number"
+                ? dataParser.addChecker(DP.checkerArrayMin(definition.inArray.min))
+                : dataParser, (dataParser) => typeof definition.inArray === "object"
+                && typeof definition.inArray.max === "number"
+                ? dataParser.addChecker(DP.checkerArrayMax(definition.inArray.max))
+                : dataParser);
+        }
+        return dataParser;
+    }, (dataParser) => definition.nullable === true
+        ? DP.nullable(dataParser)
+        : dataParser)));
+}
+createEntity.overrideHandler.setMethod("toExtractParser", (self, keys) => pipe(self.propertiesDefinition, O.entries, A.filter(([key]) => keys === undefined || A.includes(keys, key)), A.map(([key, value]) => O.entry(key, propertiesDefinitionToSchema(value, "toExtractParser"))), O.fromEntries, DPE.object));
+createEntity.overrideHandler.setMethod("toEndpointSchema", (self, keys, params) => pipe(self.propertiesDefinition, O.entries, A.filter(([key]) => keys === undefined || A.includes(keys, key)), A.map(([key, value]) => O.entry(key, propertiesDefinitionToSchema(value, "toEndpointSchema"))), O.fromEntries, (shape) => typeof params?.addEntityName !== "undefined"
+    ? {
+        ...shape,
+        _entityName: typeof params.addEntityName === "string"
+            ? DP.literal(`${self.name}/${params.addEntityName}`)
+            : DP.literal(self.name),
+    }
+    : shape, DPE.object));

package/dist/core/clean/index.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+require('./newType.cjs');
+require('./constraint.cjs');
+require('./constraintsSet.cjs');
+require('./primitive.cjs');
+require('./entity.cjs');
+

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

@@ -0,0 +1,5 @@
+export * from "./newType";
+export * from "./constraint";
+export * from "./constraintsSet";
+export * from "./primitive";
+export * from "./entity";

package/dist/core/clean/index.mjs

@@ -0,0 +1,5 @@
+import './newType.mjs';
+import './constraint.mjs';
+import './constraintsSet.mjs';
+import './primitive.mjs';
+import './entity.mjs';

package/dist/core/clean/newType.cjs

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

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

@@ -0,0 +1,8 @@
+import { DPE } from "@duplojs/utils";
+import { type NewType } from "@duplojs/utils/clean";
+declare module "@duplojs/utils/clean" {
+    interface NewTypeHandler<GenericName extends string = string, GenericValue extends unknown = unknown, GenericConstraintsHandler extends readonly ConstraintHandler[] = readonly ConstraintHandler[], GenericInput extends unknown = unknown> {
+        toExtractParser(): DPE.ContractExtended<NewType<GenericName, GenericValue, GenericConstraintsHandler[number]["name"]>, unknown>;
+        toEndpointSchema(): DPE.ContractExtended<GenericValue>;
+    }
+}

package/dist/core/clean/newType.mjs

@@ -0,0 +1,13 @@
+import { pipe, A, O, DPE, keyWrappedValue } from '@duplojs/utils';
+import { createNewType, newTypeKind, constrainedTypeKind } from '@duplojs/utils/clean';
+
+createNewType.overrideHandler.setMethod("toExtractParser", (self) => {
+    const constraintsKindValue = pipe(self.constraints, A.map(({ name }) => O.entry(name, null)), O.fromEntries);
+    const valueContainer = newTypeKind.setTo(constrainedTypeKind.setTo({}, constraintsKindValue), self.name);
+    const dataParser = DPE.transform(self.dataParser, (input) => ({
+        ...valueContainer,
+        [keyWrappedValue]: input,
+    }));
+    return dataParser;
+});
+createNewType.overrideHandler.setMethod("toEndpointSchema", (self) => DPE.lazy(() => self.dataParser));

package/dist/core/clean/primitive.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var utils = require('@duplojs/utils');
+var clean = require('@duplojs/utils/clean');
+
+clean.createPrimitive.overrideHandler.setMethod("toExtractParser", (self) => {
+    const dataParser = utils.DPE.transform(self.dataParser, (input) => ({
+        [utils.keyWrappedValue]: input,
+    }));
+    return dataParser;
+});
+clean.createPrimitive.overrideHandler.setMethod("toEndpointSchema", (self) => utils.DPE.lazy(() => self.dataParser));

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

@@ -0,0 +1,8 @@
+import { DPE } from "@duplojs/utils";
+import { type EligiblePrimitive, type Primitive } from "@duplojs/utils/clean";
+declare module "@duplojs/utils/clean" {
+    interface PrimitiveHandler<GenericValue extends EligiblePrimitive = EligiblePrimitive> {
+        toExtractParser(): DPE.ContractExtended<Primitive<GenericValue>, unknown>;
+        toEndpointSchema(): DPE.ContractExtended<GenericValue, unknown>;
+    }
+}

package/dist/core/clean/primitive.mjs

@@ -0,0 +1,10 @@
+import { DPE, keyWrappedValue } from '@duplojs/utils';
+import { createPrimitive } from '@duplojs/utils/clean';
+
+createPrimitive.overrideHandler.setMethod("toExtractParser", (self) => {
+    const dataParser = DPE.transform(self.dataParser, (input) => ({
+        [keyWrappedValue]: input,
+    }));
+    return dataParser;
+});
+createPrimitive.overrideHandler.setMethod("toEndpointSchema", (self) => DPE.lazy(() => self.dataParser));

package/dist/core/defaultHooks/index.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+require('../response/index.cjs');
+require('../route/index.cjs');
+var serverUtils = require('@duplojs/server-utils');
+var hooks = require('../route/hooks.cjs');
+var predicted = require('../response/predicted.cjs');
+var hook = require('../response/hook.cjs');
+
+function initDefaultHook(hub, serverParams) {
+    const informationHeaderKey = serverParams.informationHeaderKey;
+    const predictedHeaderKey = serverParams.predictedHeaderKey;
+    const fromHookHeaderKey = serverParams.fromHookHeaderKey;
+    const isDev = hub.config.environment === "DEV";
+    return hooks.createHookRouteLifeCycle({
+        beforeSendResponse({ currentResponse, next }) {
+            if (!currentResponse.headers?.["content-type"]) {
+                const body = currentResponse.body;
+                if (typeof body === "string"
+                    || body instanceof Error) {
+                    currentResponse.setHeader("content-type", "text/plain; charset=utf-8");
+                }
+                else if (serverUtils.SF.isFileInterface(body)) {
+                    const filename = body.getName();
+                    const filenameHeader = filename
+                        ? ` filename="${filename}"`
+                        : "";
+                    currentResponse
+                        .setHeader("content-type", body.getMimeType() ?? "application/octet-stream")
+                        .setHeader("content-disposition", `attachment;${filenameHeader}`);
+                }
+                else if (typeof body === "object"
+                    || typeof body === "number"
+                    || typeof body === "boolean") {
+                    currentResponse.setHeader("content-type", "application/json; charset=utf-8");
+                }
+            }
+            currentResponse.setHeader(informationHeaderKey, currentResponse.information);
+            if (currentResponse instanceof predicted.PredictedResponse) {
+                currentResponse.setHeader(predictedHeaderKey, "1");
+            }
+            else if (currentResponse instanceof hook.HookResponse) {
+                currentResponse.setHeader(fromHookHeaderKey, currentResponse.fromHook);
+            }
+            return next();
+        },
+    });
+}
+
+exports.initDefaultHook = initDefaultHook;

package/dist/core/defaultHooks/index.d.ts

@@ -0,0 +1,5 @@
+import { type Hub } from "../hub";
+import { type HttpServerParams } from "../types";
+export declare function initDefaultHook(hub: Hub, serverParams: HttpServerParams): {
+    beforeSendResponse({ currentResponse, next }: import("../route").RouteHookParamsAfter<import("..").Request>): import("../route").RouteHookNext;
+};

package/dist/core/defaultHooks/index.mjs

@@ -0,0 +1,48 @@
+import '../response/index.mjs';
+import '../route/index.mjs';
+import { SF } from '@duplojs/server-utils';
+import { createHookRouteLifeCycle } from '../route/hooks.mjs';
+import { PredictedResponse } from '../response/predicted.mjs';
+import { HookResponse } from '../response/hook.mjs';
+
+function initDefaultHook(hub, serverParams) {
+    const informationHeaderKey = serverParams.informationHeaderKey;
+    const predictedHeaderKey = serverParams.predictedHeaderKey;
+    const fromHookHeaderKey = serverParams.fromHookHeaderKey;
+    const isDev = hub.config.environment === "DEV";
+    return createHookRouteLifeCycle({
+        beforeSendResponse({ currentResponse, next }) {
+            if (!currentResponse.headers?.["content-type"]) {
+                const body = currentResponse.body;
+                if (typeof body === "string"
+                    || body instanceof Error) {
+                    currentResponse.setHeader("content-type", "text/plain; charset=utf-8");
+                }
+                else if (SF.isFileInterface(body)) {
+                    const filename = body.getName();
+                    const filenameHeader = filename
+                        ? ` filename="${filename}"`
+                        : "";
+                    currentResponse
+                        .setHeader("content-type", body.getMimeType() ?? "application/octet-stream")
+                        .setHeader("content-disposition", `attachment;${filenameHeader}`);
+                }
+                else if (typeof body === "object"
+                    || typeof body === "number"
+                    || typeof body === "boolean") {
+                    currentResponse.setHeader("content-type", "application/json; charset=utf-8");
+                }
+            }
+            currentResponse.setHeader(informationHeaderKey, currentResponse.information);
+            if (currentResponse instanceof PredictedResponse) {
+                currentResponse.setHeader(predictedHeaderKey, "1");
+            }
+            else if (currentResponse instanceof HookResponse) {
+                currentResponse.setHeader(fromHookHeaderKey, currentResponse.fromHook);
+            }
+            return next();
+        },
+    });
+}
+
+export { initDefaultHook };

package/dist/{interfaces/node/error → core/errors}/bodyParseWrongChunkReceived.cjs

@@ -1,12 +1,14 @@
 'use strict';
 
-var utils = require('@duplojs/utils');
 var kind = require('../kind.cjs');
+var utils = require('@duplojs/utils');
 
-class BodyParseWrongChunkReceived extends utils.kindHeritage("body-parse-wrong-chunk-received", kind.createInterfacesNodeLibKind("body-parse-wrong-chunk-received"), Error) {
+class BodyParseWrongChunkReceived extends utils.kindHeritage("body-parse-wrong-chunk-received", kind.createCoreLibKind("body-parse-wrong-chunk-received"), Error) {
+    information;
     wrongChunk;
-    constructor(wrongChunk) {
-        super({}, ["Received chunk is not buffer or string."]);
+    constructor(information, wrongChunk) {
+        super({}, [`Received chunk is not ${information}`]);
+        this.information = information;
         this.wrongChunk = wrongChunk;
     }
 }

package/dist/core/errors/bodyParseWrongChunkReceived.d.ts

@@ -0,0 +1,9 @@
+declare const BodyParseWrongChunkReceived_base: new (params: {
+    "@DuplojsHttpCore/body-parse-wrong-chunk-received"?: unknown;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/body-parse-wrong-chunk-received", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-parse-wrong-chunk-received", unknown>, unknown>;
+export declare class BodyParseWrongChunkReceived extends BodyParseWrongChunkReceived_base {
+    information: string;
+    wrongChunk: unknown;
+    constructor(information: string, wrongChunk: unknown);
+}
+export {};

package/dist/core/errors/bodyParseWrongChunkReceived.mjs

@@ -0,0 +1,14 @@
+import { createCoreLibKind } from '../kind.mjs';
+import { kindHeritage } from '@duplojs/utils';
+
+class BodyParseWrongChunkReceived extends kindHeritage("body-parse-wrong-chunk-received", createCoreLibKind("body-parse-wrong-chunk-received"), Error) {
+    information;
+    wrongChunk;
+    constructor(information, wrongChunk) {
+        super({}, [`Received chunk is not ${information}`]);
+        this.information = information;
+        this.wrongChunk = wrongChunk;
+    }
+}
+
+export { BodyParseWrongChunkReceived };

package/dist/{interfaces/node/error → core/errors}/bodySizeExceedsLimitError.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
-var utils = require('@duplojs/utils');
 var kind = require('../kind.cjs');
+var utils = require('@duplojs/utils');
 
-class BodySizeExceedsLimitError extends utils.kindHeritage("body-size-exceeds-limit-error", kind.createInterfacesNodeLibKind("body-size-exceeds-limit-error"), Error) {
+class BodySizeExceedsLimitError extends utils.kindHeritage("body-size-exceeds-limit-error", kind.createCoreLibKind("body-size-exceeds-limit-error"), Error) {
     bytesInString;
     constructor(bytesInString) {
         super({}, [`Body size is bigger than ${bytesInString}.`]);

package/dist/{interfaces/node/error → core/errors}/bodySizeExceedsLimitError.d.ts

@@ -1,7 +1,7 @@
 import { type BytesInString } from "@duplojs/utils";
 declare const BodySizeExceedsLimitError_base: new (params: {
-    "@DuplojsHttpInterfacesNode/body-size-exceeds-limit-error"?: unknown;
-}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpInterfacesNode/body-size-exceeds-limit-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-size-exceeds-limit-error", unknown>, unknown>;
+    "@DuplojsHttpCore/body-size-exceeds-limit-error"?: unknown;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/body-size-exceeds-limit-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-size-exceeds-limit-error", unknown>, unknown>;
 export declare class BodySizeExceedsLimitError extends BodySizeExceedsLimitError_base {
     bytesInString: BytesInString | number;
     constructor(bytesInString: BytesInString | number);

package/dist/{interfaces/node/error → core/errors}/bodySizeExceedsLimitError.mjs

@@ -1,7 +1,7 @@
+import { createCoreLibKind } from '../kind.mjs';
 import { kindHeritage } from '@duplojs/utils';
-import { createInterfacesNodeLibKind } from '../kind.mjs';
 
-class BodySizeExceedsLimitError extends kindHeritage("body-size-exceeds-limit-error", createInterfacesNodeLibKind("body-size-exceeds-limit-error"), Error) {
+class BodySizeExceedsLimitError extends kindHeritage("body-size-exceeds-limit-error", createCoreLibKind("body-size-exceeds-limit-error"), Error) {
     bytesInString;
     constructor(bytesInString) {
         super({}, [`Body size is bigger than ${bytesInString}.`]);

package/dist/{interfaces/node/error → core/errors}/index.cjs

@@ -1,11 +1,13 @@
 'use strict';
 
-var bodySizeExceedsLimitError = require('./bodySizeExceedsLimitError.cjs');
+var wrongContentTypeError = require('./wrongContentTypeError.cjs');
 var bodyParseWrongChunkReceived = require('./bodyParseWrongChunkReceived.cjs');
-var bodyParseUnknownError = require('./bodyParseUnknownError.cjs');
+var bodySizeExceedsLimitError = require('./bodySizeExceedsLimitError.cjs');
+var parseJsonError = require('./parseJsonError.cjs');
 
 
 
-exports.BodySizeExceedsLimitError = bodySizeExceedsLimitError.BodySizeExceedsLimitError;
+exports.WrongContentTypeError = wrongContentTypeError.WrongContentTypeError;
 exports.BodyParseWrongChunkReceived = bodyParseWrongChunkReceived.BodyParseWrongChunkReceived;
-exports.BodyParseUnknownError = bodyParseUnknownError.BodyParseUnknownError;
+exports.BodySizeExceedsLimitError = bodySizeExceedsLimitError.BodySizeExceedsLimitError;
+exports.ParseJsonError = parseJsonError.ParseJsonError;

package/dist/{interfaces/node/error → core/errors}/index.d.ts

@@ -1,3 +1,4 @@
-export * from "./bodySizeExceedsLimitError";
+export * from "./wrongContentTypeError";
 export * from "./bodyParseWrongChunkReceived";
-export * from "./bodyParseUnknownError";
+export * from "./bodySizeExceedsLimitError";
+export * from "./parseJsonError";

package/dist/{interfaces/node/error → core/errors}/index.mjs

@@ -1,3 +1,4 @@
-export { BodySizeExceedsLimitError } from './bodySizeExceedsLimitError.mjs';
+export { WrongContentTypeError } from './wrongContentTypeError.mjs';
 export { BodyParseWrongChunkReceived } from './bodyParseWrongChunkReceived.mjs';
-export { BodyParseUnknownError } from './bodyParseUnknownError.mjs';
+export { BodySizeExceedsLimitError } from './bodySizeExceedsLimitError.mjs';
+export { ParseJsonError } from './parseJsonError.mjs';

package/dist/core/errors/parseJsonError.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+var utils = require('@duplojs/utils');
+
+class ParseJsonError extends utils.kindHeritage("parse-json-error", kind.createCoreLibKind("parse-json-error"), Error) {
+    payload;
+    error;
+    constructor(payload, error) {
+        super({}, ["Error when parse on json."]);
+        this.payload = payload;
+        this.error = error;
+    }
+}
+
+exports.ParseJsonError = ParseJsonError;

package/dist/core/errors/parseJsonError.d.ts

@@ -0,0 +1,9 @@
+declare const ParseJsonError_base: new (params: {
+    "@DuplojsHttpCore/parse-json-error"?: unknown;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/parse-json-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"parse-json-error", unknown>, unknown>;
+export declare class ParseJsonError extends ParseJsonError_base {
+    payload: string;
+    error: unknown;
+    constructor(payload: string, error: unknown);
+}
+export {};

package/dist/core/errors/parseJsonError.mjs

@@ -0,0 +1,14 @@
+import { createCoreLibKind } from '../kind.mjs';
+import { kindHeritage } from '@duplojs/utils';
+
+class ParseJsonError extends kindHeritage("parse-json-error", createCoreLibKind("parse-json-error"), Error) {
+    payload;
+    error;
+    constructor(payload, error) {
+        super({}, ["Error when parse on json."]);
+        this.payload = payload;
+        this.error = error;
+    }
+}
+
+export { ParseJsonError };

package/dist/core/errors/wrongContentTypeError.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+var utils = require('@duplojs/utils');
+
+class WrongContentTypeError extends utils.kindHeritage("wrong-content-type-error", kind.createCoreLibKind("wrong-content-type-error"), Error) {
+    expectedContentType;
+    contentType;
+    constructor(expectedContentType, contentType) {
+        super({}, [`expect content-type "${expectedContentType}" but receive "${contentType}".`]);
+        this.expectedContentType = expectedContentType;
+        this.contentType = contentType;
+    }
+}
+
+exports.WrongContentTypeError = WrongContentTypeError;

package/dist/core/errors/wrongContentTypeError.d.ts

@@ -0,0 +1,9 @@
+declare const WrongContentTypeError_base: new (params: {
+    "@DuplojsHttpCore/wrong-content-type-error"?: unknown;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/wrong-content-type-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"wrong-content-type-error", unknown>, unknown>;
+export declare class WrongContentTypeError extends WrongContentTypeError_base {
+    expectedContentType: string;
+    contentType: string;
+    constructor(expectedContentType: string, contentType: string);
+}
+export {};

package/dist/core/errors/wrongContentTypeError.mjs

@@ -0,0 +1,14 @@
+import { createCoreLibKind } from '../kind.mjs';
+import { kindHeritage } from '@duplojs/utils';
+
+class WrongContentTypeError extends kindHeritage("wrong-content-type-error", createCoreLibKind("wrong-content-type-error"), Error) {
+    expectedContentType;
+    contentType;
+    constructor(expectedContentType, contentType) {
+        super({}, [`expect content-type "${expectedContentType}" but receive "${contentType}".`]);
+        this.expectedContentType = expectedContentType;
+        this.contentType = contentType;
+    }
+}
+
+export { WrongContentTypeError };

package/dist/core/functionsBuilders/route/create.d.ts

@@ -6,8 +6,8 @@ import { type BuildStepSuccessEither, type BuildStepNotSupportEither } from "../
 import { type Steps } from "../../steps";
 import { type ResponseContract } from "../../response";
 export type BuildedRouteFunction = (request: Request) => Promise<void>;
-export type BuildRouteSuccessEither = E.EitherRight<"buildSuccess", BuildedRouteFunction>;
-export type BuildRouteNotSupportEither = E.EitherLeft<"routeNotSupport", Route>;
+export type BuildRouteSuccessEither = E.Right<"buildSuccess", BuildedRouteFunction>;
+export type BuildRouteNotSupportEither = E.Left<"routeNotSupport", Route>;
 export interface RouteFunctionBuilderParams {
     readonly globalHooksRouteLifeCycle: readonly HookRouteLifeCycle[];
     readonly environment: Environment;

package/dist/core/functionsBuilders/route/default.cjs

@@ -33,7 +33,6 @@ const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.rout
     const hookBeforeRouteExecution = utils.pipe(allHooks, utils.A.map(({ beforeRouteExecution }) => beforeRouteExecution), utils.A.filter(utils.isType("function")), utils.forward);
     const hookBeforeSendResponse = utils.pipe(allHooks, utils.A.map(({ beforeSendResponse }) => beforeSendResponse), utils.A.filter(utils.isType("function")), utils.forward);
     const hookOnConstructRequest = utils.pipe(allHooks, utils.A.map(({ onConstructRequest }) => onConstructRequest), utils.A.filter(utils.isType("function")), utils.forward);
-    const hookParseBody = utils.pipe(allHooks, utils.A.map(({ parseBody }) => parseBody), utils.A.filter(utils.isType("function")), utils.forward);
     const hookError = utils.pipe(allHooks, utils.A.map(({ error }) => error), utils.A.filter(utils.isType("function")), utils.forward);
     const hookSendResponse = utils.pipe(allHooks, utils.A.map(({ sendResponse }) => sendResponse), utils.A.filter(utils.isType("function")), utils.forward);
     const hooks = {
@@ -52,7 +51,6 @@ const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.rout
                 return newRequest;
             }
             : (params) => params.request,
-        parseBody: hook.buildHookBefore(hookParseBody),
         error: hook.buildHookErrorBefore(hookError),
         sendResponse: hook.buildHookAfter(hookSendResponse),
     };
@@ -75,15 +73,6 @@ const defaultRouteFunctionBuilder = create.createRouteFunctionBuilder(index.rout
                 }
                 floor = result;
             }
-            const parseBodyResult = await hooks.parseBody({
-                request,
-                exit: hook.exitHookFunction,
-                next: hook.nextHookFunction,
-                response: hook.createHookResponse("parseBody"),
-            });
-            if (parseBodyResult instanceof base.Response) {
-                return parseBodyResult;
-            }
             for (let index = 0; index < buildedSteps.length; index++) {
                 const result = await buildedSteps[index].buildedFunction(request, floor);
                 if (result instanceof base.Response) {

package/dist/core/functionsBuilders/route/default.mjs

@@ -31,7 +31,6 @@ const defaultRouteFunctionBuilder = createRouteFunctionBuilder(routeKind.has, as
     const hookBeforeRouteExecution = pipe(allHooks, A.map(({ beforeRouteExecution }) => beforeRouteExecution), A.filter(isType("function")), forward);
     const hookBeforeSendResponse = pipe(allHooks, A.map(({ beforeSendResponse }) => beforeSendResponse), A.filter(isType("function")), forward);
     const hookOnConstructRequest = pipe(allHooks, A.map(({ onConstructRequest }) => onConstructRequest), A.filter(isType("function")), forward);
-    const hookParseBody = pipe(allHooks, A.map(({ parseBody }) => parseBody), A.filter(isType("function")), forward);
     const hookError = pipe(allHooks, A.map(({ error }) => error), A.filter(isType("function")), forward);
     const hookSendResponse = pipe(allHooks, A.map(({ sendResponse }) => sendResponse), A.filter(isType("function")), forward);
     const hooks = {
@@ -50,7 +49,6 @@ const defaultRouteFunctionBuilder = createRouteFunctionBuilder(routeKind.has, as
                 return newRequest;
             }
             : (params) => params.request,
-        parseBody: buildHookBefore(hookParseBody),
         error: buildHookErrorBefore(hookError),
         sendResponse: buildHookAfter(hookSendResponse),
     };
@@ -73,15 +71,6 @@ const defaultRouteFunctionBuilder = createRouteFunctionBuilder(routeKind.has, as
                 }
                 floor = result;
             }
-            const parseBodyResult = await hooks.parseBody({
-                request,
-                exit: exitHookFunction,
-                next: nextHookFunction,
-                response: createHookResponse("parseBody"),
-            });
-            if (parseBodyResult instanceof Response) {
-                return parseBodyResult;
-            }
             for (let index = 0; index < buildedSteps.length; index++) {
                 const result = await buildedSteps[index].buildedFunction(request, floor);
                 if (result instanceof Response) {