feat(37): suggest params path

package.json

@@ -90,7 +90,7 @@
   "peerDependencies": {
     "@duplojs/data-parser-tools": ">=0.2.9 <1.0.0",
     "@duplojs/server-utils": ">=0.2.2 <1.0.0",
-    "@duplojs/utils": ">=1.5.15 <2.0.0"
+    "@duplojs/utils": ">=1.7.0 <2.0.0"
   },
   "devDependencies": {
     "@commitlint/cli": "19.8.1",

scripts/core/builders/route/checker.ts

@@ -5,7 +5,6 @@ import { type O, type MaybeArray, type NeverCoalescing, type FixDeepFunctionInfe
 import { routeBuilderHandler } from "./builder";
 import { type GetCheckerInput, type Checker, type GetCheckerResult, type GetCheckerOptions } from "@core/checker";
 import { type ClientErrorResponseCode, type ResponseContract } from "@core/response";
-import { type Request } from "@core/request";
 import { type Metadata } from "@core/metadata";
 
 declare module "./builder" {

scripts/core/builders/route/extract.ts

@@ -6,6 +6,23 @@ import { routeBuilderHandler } from "./builder";
 import { type ClientErrorResponseCode, type ResponseContract } from "@core/response";
 import { type Request } from "@core/request";
 import { type Metadata } from "@core/metadata";
+import { type ExtractParamsKeyFromPath } from "@core/types";
+
+type HandleParamsInference<
+	GenericShape extends ExtractShape,
+	GenericPath extends string,
+> = (
+	& GenericShape
+	& {
+		params?: ExtractParamsKeyFromPath<GenericPath> extends infer InferredKey extends string
+			? (
+				& Partial<Record<InferredKey, DP.DataParser>>
+				& Record<string, DP.DataParser>
+				& Record<Exclude<keyof GenericShape["params"], InferredKey>, never>
+			)
+			: {};
+	}
+);
 
 declare module "./builder" {
 	interface RouteBuilder<
@@ -20,7 +37,10 @@ declare module "./builder" {
 			) = never,
 			const GenericMetadata extends readonly Metadata[] = readonly [],
 		>(
-			shape: GenericShape,
+			shape: HandleParamsInference<
+				GenericShape,
+				GenericDefinition["paths"][number]
+			>,
 			responseContract?: GenericResponseContract,
 			...metadata: GenericMetadata,
 		): RouteBuilder<

scripts/core/clean/constraint.ts

@@ -1,14 +1,18 @@
-import { type DP, DPE, keyWrappedValue } from "@duplojs/utils";
-import { type ConstrainedType, constrainedTypeKind, createConstraint, type EligiblePrimitive } from "@duplojs/utils/clean";
+import { type DP, DPE, C } from "@duplojs/utils";
+import "@duplojs/utils/clean";
+
+interface ToExtractParserParams {
+	coerce?: boolean;
+}
 
 declare module "@duplojs/utils/clean" {
 	interface ConstraintHandler<
 		GenericName extends string = string,
-		GenericPrimitiveValue extends EligiblePrimitive = EligiblePrimitive,
+		GenericPrimitiveValue extends C.EligiblePrimitive = C.EligiblePrimitive,
 		GenericCheckers extends readonly DP.DataParserChecker[] = readonly DP.DataParserChecker[],
 	> {
-		toExtractParser(): DPE.ContractExtended<
-			ConstrainedType<
+		toExtractParser(params?: ToExtractParserParams): DPE.ContractExtended<
+			C.ConstrainedType<
 				GenericName,
 				GenericPrimitiveValue
 			>,
@@ -19,39 +23,27 @@ declare module "@duplojs/utils/clean" {
 	}
 }
 
-createConstraint.overrideHandler.setMethod(
+C.createConstraint.overrideHandler.setMethod(
 	"toExtractParser",
-	(self) => {
-		const dataParserWithCheckers = self
-			.primitiveHandler
-			.dataParser
-			.addChecker(...self.checkers as never);
-
-		const valueContainer = constrainedTypeKind.setTo(
-			{},
-			{ [self.name]: null },
-		);
-
-		const dataParser = DPE.transform(
-			dataParserWithCheckers,
-			(input) => ({
-				...valueContainer,
-				[keyWrappedValue]: input,
-			}) as never,
+	(self, params) => {
+		const innerDataParser = C.toMapDataParser(
+			self,
+			params,
 		);
 
-		return dataParser;
+		return DPE.lazy(
+			() => innerDataParser,
+		) as never;
 	},
 );
 
-createConstraint.overrideHandler.setMethod(
+C.createConstraint.overrideHandler.setMethod(
 	"toEndpointSchema",
 	(self) => {
-		const dataParser = self
-			.primitiveHandler
-			.dataParser
-			.addChecker(...self.checkers as never) as never;
+		const innerDataParser = self.internal.dataParser;
 
-		return DPE.lazy(() => dataParser);
+		return DPE.lazy(
+			() => innerDataParser,
+		) as never;
 	},
 );

scripts/core/clean/constraintsSet.ts

@@ -1,18 +1,22 @@
-import { A, DPE, keyWrappedValue, O, pipe, type UnionToIntersection } from "@duplojs/utils";
-import { constrainedTypeKind, createConstraintsSet, type EligiblePrimitive, type GetConstraint, type Primitive } from "@duplojs/utils/clean";
+import { DPE, type UnionToIntersection, C } from "@duplojs/utils";
+import "@duplojs/utils/clean";
+
+interface ToExtractParserParams {
+	coerce?: boolean;
+}
 
 declare module "@duplojs/utils/clean" {
 	interface ConstraintsSetHandler<
-		GenericPrimitiveValue extends EligiblePrimitive = EligiblePrimitive,
+		GenericPrimitiveValue extends C.EligiblePrimitive = C.EligiblePrimitive,
 		GenericConstraintsHandler extends readonly ConstraintHandler[] = readonly [],
 	> {
-		toExtractParser(): DPE.ContractExtended<
+		toExtractParser(params?: ToExtractParserParams): DPE.ContractExtended<
 			(
-				& Primitive<GenericPrimitiveValue>
+				& C.Primitive<GenericPrimitiveValue>
 				& UnionToIntersection<
 					GenericConstraintsHandler[number] extends infer InferredConstraint
 						? InferredConstraint extends ConstraintHandler
-							? GetConstraint<InferredConstraint>
+							? C.GetConstraint<InferredConstraint>
 							: never
 						: never
 				>
@@ -24,57 +28,27 @@ declare module "@duplojs/utils/clean" {
 	}
 }
 
-createConstraintsSet.overrideHandler.setMethod(
+C.createConstraintsSet.overrideHandler.setMethod(
 	"toExtractParser",
-	(self) => {
-		const checkers = A.flatMap(
-			self.constraints,
-			({ checkers }) => checkers,
-		);
-
-		const dataParserWithCheckers = self
-			.primitiveHandler
-			.dataParser
-			.addChecker(...checkers as never);
-
-		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,
-			}) as never,
+	(self, params) => {
+		const innerDataParser = C.toMapDataParser(
+			self,
+			params,
 		);
 
-		return dataParser;
+		return DPE.lazy(
+			() => innerDataParser,
+		) as never;
 	},
 );
 
-createConstraintsSet.overrideHandler.setMethod(
+C.createConstraintsSet.overrideHandler.setMethod(
 	"toEndpointSchema",
 	(self) => {
-		const checkers = A.flatMap(
-			self.constraints,
-			({ checkers }) => checkers,
-		);
-
-		const dataParserWithCheckers = self
-			.primitiveHandler
-			.dataParser
-			.addChecker(...checkers as never) as never;
+		const innerDataParser = self.internal.dataParser;
 
 		return DPE.lazy(
-			() => dataParserWithCheckers,
-		);
+			() => innerDataParser,
+		) as never;
 	},
 );

scripts/core/clean/entity.ts

@@ -1,6 +1,10 @@
 import { DP, DPE, type IsEqual, type SimplifyTopLevel, type IsExtends, pipe, O, A, C, type MaybeArray } from "@duplojs/utils";
 import "@duplojs/utils/clean";
 
+interface ToExtractParserParams {
+	coerce?: boolean;
+}
+
 interface ToEndpointSchemaParams {
 	addEntityName?: boolean | string;
 }
@@ -16,7 +20,8 @@ declare module "@duplojs/utils/clean" {
 			const GenericKey extends MaybeArray<keyof GenericEntityProperties>
 			= readonly (keyof GenericEntityProperties)[],
 		>(
-			keys?: GenericKey
+			keys?: GenericKey,
+			params?: ToExtractParserParams
 		): GenericKey extends readonly any[]
 			? ReturnType<
 				typeof DPE.object<
@@ -67,11 +72,11 @@ declare module "@duplojs/utils/clean" {
 
 C.createEntity.overrideHandler.setMethod(
 	"toExtractParser",
-	(self, keys) => {
+	(self, keys, params) => {
 		if (typeof keys === "string") {
 			return C.entityPropertyDefinitionToDataParser(
 				self.propertiesDefinition[keys]!,
-				(newTypeHandler) => newTypeHandler.toExtractParser(),
+				(newTypeHandler) => newTypeHandler.toExtractParser(params),
 			);
 		}
 
@@ -84,7 +89,7 @@ C.createEntity.overrideHandler.setMethod(
 					key,
 					C.entityPropertyDefinitionToDataParser(
 						value,
-						(newTypeHandler) => newTypeHandler.toExtractParser(),
+						(newTypeHandler) => newTypeHandler.toExtractParser(params),
 					),
 				),
 			),

scripts/core/clean/newType.ts

@@ -1,5 +1,9 @@
-import { A, DPE, keyWrappedValue, O, pipe } from "@duplojs/utils";
-import { constrainedTypeKind, createNewType, type NewType, newTypeKind } from "@duplojs/utils/clean";
+import { C, DPE } from "@duplojs/utils";
+import "@duplojs/utils/clean";
+
+interface ToExtractParserParams {
+	coerce?: boolean;
+}
 
 declare module "@duplojs/utils/clean" {
 	interface NewTypeHandler<
@@ -8,8 +12,8 @@ declare module "@duplojs/utils/clean" {
 		GenericConstraintsHandler extends readonly ConstraintHandler[] = readonly ConstraintHandler[],
 		GenericInput extends unknown = unknown,
 	> {
-		toExtractParser(): DPE.ContractExtended<
-			NewType<
+		toExtractParser(params?: ToExtractParserParams): DPE.ContractExtended<
+			C.NewType<
 				GenericName,
 				GenericValue,
 				GenericConstraintsHandler[number]["name"]
@@ -21,36 +25,27 @@ declare module "@duplojs/utils/clean" {
 	}
 }
 
-createNewType.overrideHandler.setMethod(
+C.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,
+	(self, params) => {
+		const innerDataParser = C.toMapDataParser(
+			self,
+			params,
 		);
 
-		const dataParser = DPE.transform(
-			self.dataParser,
-			(input) => ({
-				...valueContainer,
-				[keyWrappedValue]: input,
-			}) as never,
-		);
-
-		return dataParser;
+		return DPE.lazy(
+			() => innerDataParser,
+		) as never;
 	},
 );
 
-createNewType.overrideHandler.setMethod(
+C.createNewType.overrideHandler.setMethod(
 	"toEndpointSchema",
-	(self) => DPE.lazy(() => self.dataParser),
+	(self) => {
+		const innerDataParser = self.internal.dataParser;
+
+		return DPE.lazy(
+			() => innerDataParser,
+		) as never;
+	},
 );