@duplojs/http 0.5.1 → 0.6.2

package/dist/client/httpClient.cjs

@@ -140,6 +140,11 @@ function createHttpClient(clientParams) {
             path,
             ...params,
         })),
+        patch: ((path, params) => self.request({
+            method: "PATCH",
+            path,
+            ...params,
+        })),
         delete: ((path, params) => self.request({
             method: "DELETE",
             path,

package/dist/client/httpClient.d.ts

@@ -45,6 +45,7 @@ export interface HttpClient<GenericServerRoute extends ServerRoute = ServerRoute
     get: HttpClientRequestMethod<GenericServerRoute, GenericHookParams, "GET">;
     post: HttpClientRequestMethod<GenericServerRoute, GenericHookParams, "POST">;
     put: HttpClientRequestMethod<GenericServerRoute, GenericHookParams, "PUT">;
+    patch: HttpClientRequestMethod<GenericServerRoute, GenericHookParams, "PATCH">;
     delete: HttpClientRequestMethod<GenericServerRoute, GenericHookParams, "DELETE">;
 }
 export interface CreateHttpClientParams {

package/dist/client/httpClient.mjs

@@ -118,6 +118,11 @@ function createHttpClient(clientParams) {
             path,
             ...params,
         })),
+        patch: ((path, params) => self.request({
+            method: "PATCH",
+            path,
+            ...params,
+        })),
         delete: ((path, params) => self.request({
             method: "DELETE",
             path,

package/dist/client/queryToString.cjs

@@ -9,7 +9,7 @@ function queryToString(query) {
         if (!value) {
             return pv;
         }
-        if (Array.isArray(value)) {
+        if (value instanceof Array) {
             value.forEach((subValue) => {
                 pv.push(`${key}=${subValue}`);
             });

package/dist/client/queryToString.mjs

@@ -7,7 +7,7 @@ function queryToString(query) {
         if (!value) {
             return pv;
         }
-        if (Array.isArray(value)) {
+        if (value instanceof Array) {
             value.forEach((subValue) => {
                 pv.push(`${key}=${subValue}`);
             });

package/dist/client/unexpectedResponseError.d.ts

@@ -6,7 +6,7 @@ export interface RequestErrorContent {
 }
 declare const UnexpectedInformationResponseError_base: new (params: {
     "@DuplojsHttpClient/unexpected-information-response-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-information-response-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-information-response-error", unknown>, unknown> & Error;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-information-response-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-information-response-error", unknown>, unknown> & Error;
 export declare class UnexpectedInformationResponseError extends UnexpectedInformationResponseError_base {
     information: string | string[];
     response: RequestErrorContent | ClientResponse;
@@ -14,7 +14,7 @@ export declare class UnexpectedInformationResponseError extends UnexpectedInform
 }
 declare const UnexpectedCodeResponseError_base: new (params: {
     "@DuplojsHttpClient/unexpected-code-response-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-code-response-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-code-response-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-code-response-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-code-response-error", unknown>, unknown>;
 export declare class UnexpectedCodeResponseError extends UnexpectedCodeResponseError_base {
     code: string | string[];
     response: RequestErrorContent | ClientResponse;
@@ -22,7 +22,7 @@ export declare class UnexpectedCodeResponseError extends UnexpectedCodeResponseE
 }
 declare const UnexpectedResponseTypeError_base: new (params: {
     "@DuplojsHttpClient/unexpected-response-type-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-response-type-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-response-type-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-response-type-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-response-type-error", unknown>, unknown>;
 export declare class UnexpectedResponseTypeError extends UnexpectedResponseTypeError_base {
     expectType: "informational" | "successful" | "redirection" | "clientError" | "serverError";
     response: RequestErrorContent | ClientResponse;
@@ -30,7 +30,7 @@ export declare class UnexpectedResponseTypeError extends UnexpectedResponseTypeE
 }
 declare const UnexpectedResponseError_base: new (params: {
     "@DuplojsHttpClient/unexpected-response-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-response-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-response-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpClient/unexpected-response-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"unexpected-response-error", unknown>, unknown>;
 export declare class UnexpectedResponseError extends UnexpectedResponseError_base {
     response: RequestErrorContent | ClientResponse;
     constructor(response: RequestErrorContent | ClientResponse);

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

@@ -15,12 +15,12 @@ declare module "./builder" {
             readonly preflightSteps: GenericDefinition["preflightSteps"];
             readonly steps: readonly [];
             readonly hooks: readonly [
-                ...GenericDefinition["hooks"],
-                ...GenericHooks
+                ...GenericHooks,
+                ...GenericDefinition["hooks"]
             ];
             readonly metadata: readonly [
-                ...GenericDefinition["metadata"],
-                ...GenericMetadata
+                ...GenericMetadata,
+                ...GenericDefinition["metadata"]
             ];
         }, GenericFloor, (GenericRequest & NeverCoalescing<MakeRequestFromHooks<GenericHooks>, Request>)>;
     }

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);
+});

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 []> {
+        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>;
+    }
+}

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/index.cjs

@@ -18,6 +18,7 @@ var stringIdentifier = require('./stringIdentifier.cjs');
 require('./metadata/index.cjs');
 var implementHttpServer = require('./implementHttpServer.cjs');
 var narrowingInput = require('./narrowingInput.cjs');
+require('./clean/index.cjs');
 var checker = require('./builders/checker.cjs');
 var builder = require('./builders/route/builder.cjs');
 var store = require('./builders/route/store.cjs');

package/dist/core/index.d.ts

@@ -16,3 +16,4 @@ export * from "./stringIdentifier";
 export * from "./metadata";
 export * from "./implementHttpServer";
 export * from "./narrowingInput";
+export * from "./clean";

package/dist/core/index.mjs

@@ -16,6 +16,7 @@ export { createCoreLibStringIdentifier } from './stringIdentifier.mjs';
 import './metadata/index.mjs';
 export { implementHttpServer } from './implementHttpServer.mjs';
 export { createNarrowingInput } from './narrowingInput.mjs';
+import './clean/index.mjs';
 export { checkerBuilder, useCheckerBuilder } from './builders/checker.mjs';
 export { routeBuilderHandler, useRouteBuilder } from './builders/route/builder.mjs';
 export { routeStore } from './builders/route/store.mjs';

package/dist/core/response/contract.d.ts

@@ -283,7 +283,7 @@ export declare namespace ResponseContract {
     }>>(information: GenericInformation, schema?: (GenericSchema & ForbiddenBigintDataParser<GenericSchema>) | undefined) => NoInfer<Contract<"511", GenericInformation, NeverCoalescing<GenericSchema, DP.DataParserEmpty<DP.DataParserDefinitionEmpty>>>>;
     const Error_base: new (params: {
         "@DuplojsHttpCore/contract-error"?: unknown;
-    }, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/contract-error", unknown>, unknown> & Kind<import("@duplojs/utils").KindDefinition<"contract-error", unknown>, unknown> & globalThis.Error;
+    }, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/contract-error", unknown>, unknown> & Kind<import("@duplojs/utils").KindDefinition<"contract-error", unknown>, unknown> & globalThis.Error;
     export class Error extends Error_base {
         information: string;
         dataParserError?: DP.DataParserError | undefined;

package/dist/core/response/hook.d.ts

@@ -2,7 +2,7 @@ import { type ResponseCode, Response } from "../response";
 import { type HookRouteLifeCycle } from "../route/hooks";
 declare const HookResponse_base: new (params: {
     "@DuplojsHttpCore/hook-response"?: unknown;
-}, parentParams: [code: any, information: any, body: any]) => Response<any, any, any> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/hook-response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"hook-response", unknown>, unknown>;
+}, parentParams: readonly [code: any, information: any, body: any]) => Response<any, any, any> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/hook-response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"hook-response", unknown>, unknown>;
 export declare class HookResponse<GenericCode extends ResponseCode = ResponseCode, GenericInformation extends string = string, GenericBody extends unknown = unknown> extends HookResponse_base {
     code: GenericCode;
     information: GenericInformation;

package/dist/core/response/predicted.d.ts

@@ -1,7 +1,7 @@
 import { type ResponseCode, Response } from "../response";
 declare const PredictedResponse_base: new (params: {
     "@DuplojsHttpCore/predicted-response"?: unknown;
-}, parentParams: [code: any, information: any, body: any]) => Response<any, any, any> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/predicted-response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"predicted-response", unknown>, unknown>;
+}, parentParams: readonly [code: any, information: any, body: any]) => Response<any, any, any> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/predicted-response", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"predicted-response", unknown>, unknown>;
 export declare class PredictedResponse<GenericCode extends ResponseCode = ResponseCode, GenericInformation extends string = string, GenericBody extends unknown = unknown> extends PredictedResponse_base {
     code: GenericCode;
     information: GenericInformation;

package/dist/core/router/buildError.d.ts

@@ -2,7 +2,7 @@ import { type Route } from "../route";
 import { type Steps } from "../steps";
 declare const RouterBuildError_base: new (params: {
     "@DuplojsHttpCore/router-build-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/router-build-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"router-build-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpCore/router-build-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"router-build-error", unknown>, unknown>;
 export declare class RouterBuildError extends RouterBuildError_base {
     route: Route;
     element: Route | Steps;

package/dist/interfaces/node/createHttpServer.cjs

@@ -51,6 +51,9 @@ function createHttpServer(inputHub, params) {
                 response: serverResponse,
             },
         }, whenUncaughtError));
+        if (hub.config.environment === "BUILD") {
+            return server;
+        }
         return new Promise((resolve) => {
             server.listen({
                 port: httpServerParams.port,

package/dist/interfaces/node/createHttpServer.mjs

@@ -49,6 +49,9 @@ function createHttpServer(inputHub, params) {
                 response: serverResponse,
             },
         }, whenUncaughtError));
+        if (hub.config.environment === "BUILD") {
+            return server;
+        }
         return new Promise((resolve) => {
             server.listen({
                 port: httpServerParams.port,

package/dist/interfaces/node/error/bodyParseUnknownError.d.ts

@@ -1,6 +1,6 @@
 declare const BodyParseUnknownError_base: new (params: {
     "@DuplojsHttpInterfacesNode/body-parse-unknown-error"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpInterfacesNode/body-parse-unknown-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-parse-unknown-error", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpInterfacesNode/body-parse-unknown-error", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-parse-unknown-error", unknown>, unknown>;
 export declare class BodyParseUnknownError extends BodyParseUnknownError_base {
     contentType: string;
     unknownError: unknown;

package/dist/interfaces/node/error/bodyParseWrongChunkReceived.d.ts

@@ -1,6 +1,6 @@
 declare const BodyParseWrongChunkReceived_base: new (params: {
     "@DuplojsHttpInterfacesNode/body-parse-wrong-chunk-received"?: unknown;
-}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpInterfacesNode/body-parse-wrong-chunk-received", unknown>, unknown> & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"body-parse-wrong-chunk-received", unknown>, unknown>;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("@duplojs/utils").Kind<import("@duplojs/utils").KindDefinition<"@DuplojsHttpInterfacesNode/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 {
     wrongChunk: unknown;
     constructor(wrongChunk: unknown);

package/dist/interfaces/node/error/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: [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>;
+}, 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>;
 export declare class BodySizeExceedsLimitError extends BodySizeExceedsLimitError_base {
     bytesInString: BytesInString | number;
     constructor(bytesInString: BytesInString | number);

package/dist/plugins/openApiGenerator/makeOpenApiRoute.cjs

@@ -4,12 +4,20 @@ require('../../core/builders/index.cjs');
 require('../../core/metadata/index.cjs');
 require('../../core/response/index.cjs');
 var utils = require('@duplojs/utils');
+var metadata$1 = require('../codeGenerator/metadata.cjs');
+var metadata = require('./metadata.cjs');
 var builder = require('../../core/builders/route/builder.cjs');
 var ignoreByRouteStore = require('../../core/metadata/ignoreByRouteStore.cjs');
 var contract = require('../../core/response/contract.cjs');
 
 function makeOpenApiRoute(routePath, openApiPage) {
-    return builder.useRouteBuilder("GET", routePath, { metadata: [ignoreByRouteStore.IgnoreByRouteStoreMetadata()] })
+    return builder.useRouteBuilder("GET", routePath, {
+        metadata: [
+            ignoreByRouteStore.IgnoreByRouteStoreMetadata(),
+            metadata.IgnoreByOpenApiGeneratorMetadata(),
+            metadata$1.IgnoreByCodeGeneratorMetadata(),
+        ],
+    })
         .handler(contract.ResponseContract.ok("swaggerUi", utils.DP.string()), (__, { response }) => response("swaggerUi", openApiPage)
         .setHeader("content-type", "text/html"));
 }

package/dist/plugins/openApiGenerator/makeOpenApiRoute.d.ts

@@ -3,7 +3,7 @@ import type { RoutePath } from "../../core/route";
 import { DP } from "@duplojs/utils";
 export declare function makeOpenApiRoute(routePath: RoutePath, openApiPage: string): import("../../core/route").Route<{
     readonly method: "GET";
-    readonly metadata: readonly [import("../../core/metadata").Metadata<"ignore-by-route-store", unknown>];
+    readonly metadata: readonly [import("../../core/metadata").Metadata<"ignore-by-route-store", unknown>, import("../../core/metadata").Metadata<"ignore-by-open-api-generator", unknown>, import("../../core/metadata").Metadata<"ignore-by-code-generator", unknown>];
     readonly hooks: readonly [];
     readonly preflightSteps: readonly [];
     readonly paths: readonly [`/${string}`];

package/dist/plugins/openApiGenerator/makeOpenApiRoute.mjs

@@ -2,12 +2,20 @@ import '../../core/builders/index.mjs';
 import '../../core/metadata/index.mjs';
 import '../../core/response/index.mjs';
 import { DP } from '@duplojs/utils';
+import { IgnoreByCodeGeneratorMetadata } from '../codeGenerator/metadata.mjs';
+import { IgnoreByOpenApiGeneratorMetadata } from './metadata.mjs';
 import { useRouteBuilder } from '../../core/builders/route/builder.mjs';
 import { IgnoreByRouteStoreMetadata } from '../../core/metadata/ignoreByRouteStore.mjs';
 import { ResponseContract } from '../../core/response/contract.mjs';
 
 function makeOpenApiRoute(routePath, openApiPage) {
-    return useRouteBuilder("GET", routePath, { metadata: [IgnoreByRouteStoreMetadata()] })
+    return useRouteBuilder("GET", routePath, {
+        metadata: [
+            IgnoreByRouteStoreMetadata(),
+            IgnoreByOpenApiGeneratorMetadata(),
+            IgnoreByCodeGeneratorMetadata(),
+        ],
+    })
         .handler(ResponseContract.ok("swaggerUi", DP.string()), (__, { response }) => response("swaggerUi", openApiPage)
         .setHeader("content-type", "text/html"));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/http",
-  "version": "0.5.1",
+  "version": "0.6.2",
   "author": "mathcovax",
   "license": "MIT",
   "type": "module",
@@ -10,16 +10,19 @@
   },
   "scripts": {
     "build": "rollup --config",
+    "docs:dev": "npm -w docs run docs:dev",
+    "docs:build": "npm -w docs run docs:build",
+    "docs:preview": "npm -w docs run docs:preview",
     "test:tu": "vitest --coverage",
     "test:tu:bench": "vitest bench",
     "test:tu:watch": "vitest --coverage --watch",
     "test:tu:update": "vitest --coverage --update",
-    "test:types": "tsc -p tests/core/tsconfig.json && tsc -p tests/client/tsconfig.json && tsc -p tests/interfaces/node/tsconfig.json && tsc -p tests/interfaces/bun/tsconfig.json && tsc -p tests/interfaces/deno/tsconfig.json && tsc -p tests/plugins/codeGenerator/tsconfig.json && tsc -p tests/plugins/openApiGenerator/tsconfig.json && npm -w integration run test:types",
-    "test:lint": "eslint",
-    "test:lint:fix": "eslint --fix",
+    "test:types": "tsc -p tests/core/tsconfig.json && tsc -p tests/client/tsconfig.json && tsc -p tests/interfaces/node/tsconfig.json && tsc -p tests/interfaces/bun/tsconfig.json && tsc -p tests/interfaces/deno/tsconfig.json && tsc -p tests/plugins/codeGenerator/tsconfig.json && tsc -p tests/plugins/openApiGenerator/tsconfig.json && npm -w integration run test:types && npm -w docs run test:types",
+    "test:lint": "eslint --quiet",
+    "test:lint:fix": "eslint --fix --quiet",
     "prepare": "husky"
   },
-  "types": "./dist/index.d.ts",
+  "types": "./dist/core/index.d.ts",
   "exports": {
     ".": {
       "import": "./dist/core/index.mjs",
@@ -63,7 +66,7 @@
   ],
   "peerDependencies": {
     "@duplojs/data-parser-tools": ">=0.2.4 <1.0.0",
-    "@duplojs/utils": ">=1.4.40 <2.0.0"
+    "@duplojs/utils": ">=1.4.57 <2.0.0"
   },
   "devDependencies": {
     "@commitlint/cli": "19.8.1",
@@ -89,7 +92,8 @@
     "vitest": "3.2.4"
   },
   "workspaces": [
-    "integration"
+    "integration",
+    "docs"
   ],
   "keywords": [],
   "engines": {