Skip to content

Commit 22a3cb0

Browse files
author
molly
authored
fix: parse named numeric slice parameters (#1074)
1 parent ac9959c commit 22a3cb0

3 files changed

Lines changed: 109 additions & 195 deletions

File tree

‎huma.go‎

Lines changed: 26 additions & 192 deletions
Original file line numberDiff line numberDiff line change
@@ -681,20 +681,6 @@ func transformAndWrite(api API, ctx Context, status int, ct string, body any) er
681681
return nil
682682
}
683683

684-
func parseArrElement[T any](values []string, parse func(string) (T, error)) ([]T, error) {
685-
result := make([]T, 0, len(values))
686-
687-
for i := range values {
688-
v, err := parse(values[i])
689-
if err != nil {
690-
return nil, err
691-
}
692-
result = append(result, v)
693-
}
694-
695-
return result, nil
696-
}
697-
698684
// writeHeader is a utility function to write a header value to the response.
699685
// the `write` function should be either `ctx.SetHeader` or `ctx.AppendHeader`.
700686
func writeHeader(write func(string, string), info *headerInfo, f reflect.Value) {
@@ -1895,7 +1881,8 @@ func parseInto(ctx Context, f reflect.Value, value string, preSplit []string, p
18951881
// parseSliceInto converts a slice of string values into the expected type of f
18961882
// and sets the result on f.
18971883
func parseSliceInto(f reflect.Value, values []string) (any, error) {
1898-
switch f.Type().Elem().Kind() {
1884+
elemType := f.Type().Elem()
1885+
switch elemType.Kind() {
18991886
case reflect.String:
19001887
if f.Type() == stringSliceType {
19011888
f.Set(reflect.ValueOf(values))
@@ -1912,198 +1899,45 @@ func parseSliceInto(f reflect.Value, values []string) (any, error) {
19121899
}
19131900

19141901
return values, nil
1915-
case reflect.Int:
1916-
vs, err := parseArrElement(values, func(s string) (int, error) {
1917-
val, err := strconv.ParseInt(s, 10, strconv.IntSize)
1918-
if err != nil {
1919-
return 0, err
1920-
}
1921-
1922-
return int(val), nil
1923-
})
1924-
if err != nil {
1925-
return nil, errors.New("invalid integer")
1926-
}
1927-
1928-
f.Set(reflect.ValueOf(vs))
1929-
1930-
return vs, nil
1931-
case reflect.Int8:
1932-
vs, err := parseArrElement(values, func(s string) (int8, error) {
1933-
val, err := strconv.ParseInt(s, 10, 8)
1934-
if err != nil {
1935-
return 0, err
1936-
}
1937-
1938-
return int8(val), nil
1939-
})
1940-
if err != nil {
1941-
return nil, errors.New("invalid integer")
1942-
}
1943-
1944-
f.Set(reflect.ValueOf(vs))
1945-
1946-
return vs, nil
1947-
case reflect.Int16:
1948-
vs, err := parseArrElement(values, func(s string) (int16, error) {
1949-
val, err := strconv.ParseInt(s, 10, 16)
1950-
if err != nil {
1951-
return 0, err
1952-
}
1953-
1954-
return int16(val), nil
1955-
})
1956-
if err != nil {
1957-
return nil, errors.New("invalid integer")
1958-
}
1959-
1960-
f.Set(reflect.ValueOf(vs))
1961-
1962-
return vs, nil
1963-
case reflect.Int32:
1964-
vs, err := parseArrElement(values, func(s string) (int32, error) {
1965-
val, err := strconv.ParseInt(s, 10, 32)
1966-
if err != nil {
1967-
return 0, err
1968-
}
1969-
1970-
return int32(val), nil
1971-
})
1972-
if err != nil {
1973-
return nil, errors.New("invalid integer")
1974-
}
1975-
1976-
f.Set(reflect.ValueOf(vs))
1977-
1978-
return vs, nil
1979-
case reflect.Int64:
1980-
vs, err := parseArrElement(values, func(s string) (int64, error) {
1981-
val, err := strconv.ParseInt(s, 10, 64)
1982-
if err != nil {
1983-
return 0, err
1984-
}
1985-
1986-
return val, nil
1987-
})
1988-
if err != nil {
1989-
return nil, errors.New("invalid integer")
1990-
}
1991-
1992-
f.Set(reflect.ValueOf(vs))
1993-
1994-
return vs, nil
1995-
case reflect.Uint:
1996-
vs, err := parseArrElement(values, func(s string) (uint, error) {
1997-
val, err := strconv.ParseUint(s, 10, strconv.IntSize)
1998-
if err != nil {
1999-
return 0, err
2000-
}
2001-
2002-
return uint(val), nil
2003-
})
2004-
if err != nil {
2005-
return nil, errors.New("invalid integer")
2006-
}
2007-
2008-
f.Set(reflect.ValueOf(vs))
2009-
2010-
return vs, nil
2011-
case reflect.Uint8:
2012-
vs, err := parseArrElement(values, func(s string) (uint8, error) {
2013-
val, err := strconv.ParseUint(s, 10, 8)
2014-
if err != nil {
2015-
return 0, err
2016-
}
2017-
2018-
return uint8(val), nil
2019-
})
2020-
if err != nil {
2021-
return nil, errors.New("invalid integer")
2022-
}
2023-
2024-
f.Set(reflect.ValueOf(vs))
2025-
2026-
return vs, nil
2027-
case reflect.Uint16:
2028-
vs, err := parseArrElement(values, func(s string) (uint16, error) {
2029-
val, err := strconv.ParseUint(s, 10, 16)
2030-
if err != nil {
2031-
return 0, err
2032-
}
2033-
2034-
return uint16(val), nil
2035-
})
2036-
if err != nil {
2037-
return nil, errors.New("invalid integer")
2038-
}
2039-
2040-
f.Set(reflect.ValueOf(vs))
2041-
2042-
return vs, nil
2043-
case reflect.Uint32:
2044-
vs, err := parseArrElement(values, func(s string) (uint32, error) {
2045-
val, err := strconv.ParseUint(s, 10, 32)
2046-
if err != nil {
2047-
return 0, err
2048-
}
2049-
2050-
return uint32(val), nil
2051-
})
2052-
if err != nil {
2053-
return nil, errors.New("invalid integer")
2054-
}
2055-
2056-
f.Set(reflect.ValueOf(vs))
2057-
2058-
return vs, nil
2059-
case reflect.Uint64:
2060-
vs, err := parseArrElement(values, func(s string) (uint64, error) {
2061-
val, err := strconv.ParseUint(s, 10, 64)
1902+
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
1903+
vs := reflect.MakeSlice(reflect.SliceOf(elemType), len(values), len(values))
1904+
for i, s := range values {
1905+
v, err := strconv.ParseInt(s, 10, elemType.Bits())
20621906
if err != nil {
2063-
return 0, err
1907+
return nil, errors.New("invalid integer")
20641908
}
2065-
2066-
return val, nil
2067-
})
2068-
if err != nil {
2069-
return nil, errors.New("invalid integer")
1909+
vs.Index(i).SetInt(v)
20701910
}
20711911

2072-
f.Set(reflect.ValueOf(vs))
1912+
f.Set(vs)
20731913

2074-
return vs, nil
2075-
case reflect.Float32:
2076-
vs, err := parseArrElement(values, func(s string) (float32, error) {
2077-
val, err := strconv.ParseFloat(s, 32)
1914+
return vs.Interface(), nil
1915+
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
1916+
vs := reflect.MakeSlice(reflect.SliceOf(elemType), len(values), len(values))
1917+
for i, s := range values {
1918+
v, err := strconv.ParseUint(s, 10, elemType.Bits())
20781919
if err != nil {
2079-
return 0, err
1920+
return nil, errors.New("invalid integer")
20801921
}
2081-
2082-
return float32(val), nil
2083-
})
2084-
if err != nil {
2085-
return nil, errors.New("invalid floating value")
1922+
vs.Index(i).SetUint(v)
20861923
}
20871924

2088-
f.Set(reflect.ValueOf(vs))
1925+
f.Set(vs)
20891926

2090-
return vs, nil
2091-
case reflect.Float64:
2092-
vs, err := parseArrElement(values, func(s string) (float64, error) {
2093-
val, err := strconv.ParseFloat(s, 64)
1927+
return vs.Interface(), nil
1928+
case reflect.Float32, reflect.Float64:
1929+
vs := reflect.MakeSlice(reflect.SliceOf(elemType), len(values), len(values))
1930+
for i, s := range values {
1931+
v, err := strconv.ParseFloat(s, elemType.Bits())
20941932
if err != nil {
2095-
return 0, err
1933+
return nil, errors.New("invalid floating value")
20961934
}
2097-
2098-
return val, nil
2099-
})
2100-
if err != nil {
2101-
return nil, errors.New("invalid floating value")
1935+
vs.Index(i).SetFloat(v)
21021936
}
21031937

2104-
f.Set(reflect.ValueOf(vs))
1938+
f.Set(vs)
21051939

2106-
return vs, nil
1940+
return vs.Interface(), nil
21071941
}
21081942

21091943
// Last resort: use the `encoding.TextUnmarshaler` interface.

‎huma_test.go‎

Lines changed: 53 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -528,6 +528,59 @@ func TestFeatures(t *testing.T) {
528528
"cookie": "one=foo; two=123; three=bar",
529529
},
530530
},
531+
{
532+
Name: "params-named-numeric-slices",
533+
Register: func(t *testing.T, api huma.API) {
534+
type ID int
535+
type IDs []ID
536+
type Numbers []int
537+
type Count uint16
538+
type Counts []Count
539+
type Ratio float32
540+
type Ratios []Ratio
541+
542+
huma.Register(api, huma.Operation{
543+
Method: http.MethodGet,
544+
Path: "/named-numeric-slices",
545+
}, func(ctx context.Context, input *struct {
546+
IDs IDs `query:"ids"`
547+
Numbers Numbers `query:"numbers"`
548+
Counts Counts `query:"counts"`
549+
Ratios Ratios `query:"ratios"`
550+
}) (*struct{}, error) {
551+
assert.Equal(t, IDs{1, 2}, input.IDs)
552+
assert.Equal(t, Numbers{5, 6}, input.Numbers)
553+
assert.Equal(t, Counts{3, 4}, input.Counts)
554+
assert.Equal(t, Ratios{1.5, 2.5}, input.Ratios)
555+
return nil, nil
556+
})
557+
},
558+
Method: http.MethodGet,
559+
URL: "/named-numeric-slices?ids=1,2&numbers=5,6&counts=3,4&ratios=1.5,2.5",
560+
},
561+
{
562+
Name: "params-named-numeric-slices-validation",
563+
Register: func(t *testing.T, api huma.API) {
564+
type ID int
565+
type IDs []ID
566+
567+
huma.Register(api, huma.Operation{
568+
Method: http.MethodGet,
569+
Path: "/named-numeric-slices",
570+
}, func(ctx context.Context, input *struct {
571+
IDs IDs `query:"ids" minimum:"1" uniqueItems:"true"`
572+
}) (*struct{}, error) {
573+
return nil, nil
574+
})
575+
},
576+
Method: http.MethodGet,
577+
URL: "/named-numeric-slices?ids=0,0",
578+
Assert: func(t *testing.T, resp *httptest.ResponseRecorder) {
579+
assert.Equal(t, http.StatusUnprocessableEntity, resp.Code)
580+
assert.Contains(t, resp.Body.String(), "expected number >= 1")
581+
assert.Contains(t, resp.Body.String(), "expected array items to be unique")
582+
},
583+
},
531584
{
532585
Name: "params-error",
533586
Register: func(t *testing.T, api huma.API) {

‎validate.go‎

Lines changed: 30 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -430,7 +430,17 @@ func toFloat64(v any) (float64, bool) {
430430
f, err := v.Float64()
431431
return f, err == nil
432432
default:
433-
return 0, false
433+
value := reflect.ValueOf(v)
434+
switch value.Kind() {
435+
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
436+
return float64(value.Int()), true
437+
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
438+
return float64(value.Uint()), true
439+
case reflect.Float32, reflect.Float64:
440+
return value.Float(), true
441+
default:
442+
return 0, false
443+
}
434444
}
435445
}
436446

@@ -610,8 +620,25 @@ func Validate(r Registry, s *Schema, path *PathBuffer, mode ValidateMode, v any,
610620
case []float64:
611621
handleArray(r, s, path, mode, res, arr)
612622
default:
613-
res.Add(path, v, validation.MsgExpectedArray)
614-
return
623+
value := reflect.ValueOf(v)
624+
if value.Kind() != reflect.Slice {
625+
res.Add(path, v, validation.MsgExpectedArray)
626+
return
627+
}
628+
switch value.Type().Elem().Kind() {
629+
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
630+
reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
631+
reflect.Float32, reflect.Float64:
632+
default:
633+
res.Add(path, v, validation.MsgExpectedArray)
634+
return
635+
}
636+
637+
items := make([]any, value.Len())
638+
for i := range items {
639+
items[i] = value.Index(i).Interface()
640+
}
641+
handleArray(r, s, path, mode, res, items)
615642
}
616643
case TypeObject:
617644
switch vv := v.(type) {

0 commit comments

Comments
 (0)