✨ (v3) feature: Implement new generic functions: Params, Get and Convert

ctx.go

@@ -550,7 +550,14 @@
 // Returned value is only valid within the handler. Do not store any references.
 // Make copies or use the Immutable setting instead.
 func (c *DefaultCtx) Get(key string, defaultValue ...string) string {
-	return defaultString(c.app.getString(c.fasthttp.Request.Header.Peek(key)), defaultValue)
+	return GetReqHeader(c, key, defaultValue...)
+}
+
+// GetReqHeader returns the HTTP request header specified by filed.
+// This function is generic and can handle differnet headers type values.
+func GetReqHeader[V GenericType](c Ctx, key string, defaultValue ...V) V {
+	var v V
+	return genericParseType[V](c.App().getString(c.Request().Header.Peek(key)), v, defaultValue...)
 }
 
 // GetRespHeader returns the HTTP response header specified by field.
@@ -973,22 +980,22 @@
 	return defaultString("", defaultValue)
 }
 
-// ParamsInt is used to get an integer from the route parameters
-// it defaults to zero if the parameter is not found or if the
-// parameter cannot be converted to an integer
-// If a default value is given, it will return that value in case the param
-// doesn't exist or cannot be converted to an integer
-func (c *DefaultCtx) ParamsInt(key string, defaultValue ...int) (int, error) {
-	// Use Atoi to convert the param to an int or return zero and an error
-	value, err := strconv.Atoi(c.Params(key))
-	if err != nil {
-		if len(defaultValue) > 0 {
-			return defaultValue[0], nil
-		}
-		return 0, fmt.Errorf("failed to convert: %w", err)
-	}
-
-	return value, nil
+// Params is used to get the route parameters.
+// This function is generic and can handle differnet route parameters type values.
+//
+// Example:
+//
+// http://example.com/user/:user -> http://example.com/user/john
+// Params[string](c, "user") -> returns john
+//
+// http://example.com/id/:id -> http://example.com/user/114
+// Params[int](c, "id") ->  returns 114 as integer.
+//
+// http://example.com/id/:number -> http://example.com/id/john
+// Params[int](c, "number", 0) -> returns 0 because can't parse 'john' as integer.
+func Params[V GenericType](c Ctx, key string, defaultValue ...V) V {
+	var v V
+	return genericParseType(c.Params(key), v, defaultValue...)
 }
 
 // Path returns the path part of the request URL.
@@ -1108,73 +1115,11 @@
 //	name := Query[string](c, "search") // Returns "john"
 //	age := Query[int](c, "age") // Returns 8
 //	unknown := Query[string](c, "unknown", "default") // Returns "default" since the query parameter "unknown" is not found
-func Query[V QueryType](c Ctx, key string, defaultValue ...V) V {
+func Query[V GenericType](c Ctx, key string, defaultValue ...V) V {
 	var v V
 	q := c.App().getString(c.Context().QueryArgs().Peek(key))
 
-	switch any(v).(type) {
-	case int:
-		return queryParseInt[V](q, 32, func(i int64) V { return assertValueType[V, int](int(i)) }, defaultValue...)
-	case int8:
-		return queryParseInt[V](q, 8, func(i int64) V { return assertValueType[V, int8](int8(i)) }, defaultValue...)
-	case int16:
-		return queryParseInt[V](q, 16, func(i int64) V { return assertValueType[V, int16](int16(i)) }, defaultValue...)
-	case int32:
-		return queryParseInt[V](q, 32, func(i int64) V { return assertValueType[V, int32](int32(i)) }, defaultValue...)
-	case int64:
-		return queryParseInt[V](q, 64, func(i int64) V { return assertValueType[V, int64](i) }, defaultValue...)
-	case uint:
-		return queryParseUint[V](q, 32, func(i uint64) V { return assertValueType[V, uint](uint(i)) }, defaultValue...)
-	case uint8:
-		return queryParseUint[V](q, 8, func(i uint64) V { return assertValueType[V, uint8](uint8(i)) }, defaultValue...)
-	case uint16:
-		return queryParseUint[V](q, 16, func(i uint64) V { return assertValueType[V, uint16](uint16(i)) }, defaultValue...)
-	case uint32:
-		return queryParseUint[V](q, 32, func(i uint64) V { return assertValueType[V, uint32](uint32(i)) }, defaultValue...)
-	case uint64:
-		return queryParseUint[V](q, 64, func(i uint64) V { return assertValueType[V, uint64](i) }, defaultValue...)
-	case float32:
-		return queryParseFloat[V](q, 32, func(i float64) V { return assertValueType[V, float32](float32(i)) }, defaultValue...)
-	case float64:
-		return queryParseFloat[V](q, 64, func(i float64) V { return assertValueType[V, float64](i) }, defaultValue...)
-	case bool:
-		return queryParseBool[V](q, func(b bool) V { return assertValueType[V, bool](b) }, defaultValue...)
-	case string:
-		if q == "" && len(defaultValue) > 0 {
-			return defaultValue[0]
-		}
-		return assertValueType[V, string](q)
-	case []byte:
-		if q == "" && len(defaultValue) > 0 {
-			return defaultValue[0]
-		}
-		return assertValueType[V, []byte](c.App().getBytes(q))
-	default:
-		if len(defaultValue) > 0 {
-			return defaultValue[0]
-		}
-		return v
-	}
-}
-
-type QueryType interface {
-	QueryTypeInteger | QueryTypeFloat | bool | string | []byte
-}
-
-type QueryTypeInteger interface {
-	QueryTypeIntegerSigned | QueryTypeIntegerUnsigned
-}
-
-type QueryTypeIntegerSigned interface {
-	int | int8 | int16 | int32 | int64
-}
-
-type QueryTypeIntegerUnsigned interface {
-	uint | uint8 | uint16 | uint32 | uint64
-}
-
-type QueryTypeFloat interface {
-	float32 | float64
+	return genericParseType[V](q, v, defaultValue...)
 }
 
 // Range returns a struct containing the type and a slice of ranges.
@@ -1761,3 +1706,17 @@
 	}
 	return c.bind
 }
+
+// Converts a string value to a specified type, handling errors and optional default values.
+func Convert[T any](value string, convertor func(string) (T, error), defaultValue ...T) (T, error) {
+	converted, err := convertor(value)
+	if err != nil {
+		if len(defaultValue) > 0 {
+			return defaultValue[0], nil
+		}
+
+		return converted, fmt.Errorf("failed to convert: %w", err)
+	}
+
+	return converted, nil
+}

ctx_interface.go

@@ -224,13 +224,6 @@ type Ctx interface {
 	// Make copies or use the Immutable setting to use the value outside the Handler.
 	Params(key string, defaultValue ...string) string
 
-	// ParamsInt is used to get an integer from the route parameters
-	// it defaults to zero if the parameter is not found or if the
-	// parameter cannot be converted to an integer
-	// If a default value is given, it will return that value in case the param
-	// doesn't exist or cannot be converted to an integer
-	ParamsInt(key string, defaultValue ...int) (int, error)
-
 	// Path returns the path part of the request URL.
 	// Optionally, you could override the path.
 	Path(override ...string) string