@duplojs/http 0.6.1 → 0.6.2

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/http",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "author": "mathcovax",
   "license": "MIT",
   "type": "module",
@@ -66,7 +66,7 @@
   ],
   "peerDependencies": {
     "@duplojs/data-parser-tools": ">=0.2.4 <1.0.0",
-    "@duplojs/utils": ">=1.4.46 <2.0.0"
+    "@duplojs/utils": ">=1.4.57 <2.0.0"
   },
   "devDependencies": {
     "@commitlint/cli": "19.8.1",