Function parseParamLocation

huma.go:132–193

parseParamLocation inspects the tags on f to determine which request parameter location it represents (path, query, header, form, or cookie). It populates a paramFieldInfo with the location, name, and any location-specific settings such as explode and style for query params, or type coercion for coo

(f reflect.StructField, registry Registry)

// Panics if the field type is a pointer, which is not currently supported for
// any parameter location.
func parseParamLocation(f reflect.StructField, registry Registry) (*paramLocation, bool) {
	pfi := &paramFieldInfo{Type: f.Type}

	if reflect.PointerTo(f.Type).Implements(paramWrapperType) {
		pfi.Type = reflect.New(f.Type).Interface().(ParamWrapper).Receiver().Type()
	}

	if def := f.Tag.Get("default"); def != "" {
		pfi.Default = def
	}

	result := &paramLocation{pfi: pfi}

	switch {
	case f.Tag.Get("path") != "":
		pfi.Loc = "path"
		pfi.Name = f.Tag.Get("path")
		pfi.Required = true
	case f.Tag.Get("query") != "":
		raw := f.Tag.Get("query")
		split := strings.Split(raw, ",")
		pfi.Loc = "query"
		pfi.Name = split[0]
		// If `in` is `query` then `explode` defaults to true. Parsing is *much*
		// easier if we use comma-separated values, so we disable explode by default.
		if slices.Contains(split[1:], "explode") {
			pfi.Explode = true
		}
		if slices.Contains(split[1:], styleDeepObject) {
			pfi.Style = styleDeepObject
		}
		result.explode = &pfi.Explode
	case f.Tag.Get("header") != "":
		pfi.Loc = "header"
		pfi.Name = f.Tag.Get("header")
	case f.Tag.Get("form") != "":
		pfi.Loc = "form"
		pfi.Name = f.Tag.Get("form")
		pfi.Required = !getConfig[registryConfig](registry).FieldsOptionalByDefault
	case f.Tag.Get("cookie") != "":
		pfi.Loc = "cookie"
		pfi.Name = f.Tag.Get("cookie")
		if f.Type == cookieType {
			// Special case: parsed from a string input to an `http.Cookie` struct.
			pfi.Type = stringType
		}
	default:
		return nil, false
	}

	// Pointer check comes after tag detection — untagged pointer fields are fine.
	if f.Type.Kind() == reflect.Pointer {
		// TODO: support pointers? The problem is that when we dynamically
		// create an instance of the input struct the `params.Every(...)`
		// call cannot set them as the value is `reflect.Invalid` unless
		// dynamically allocated, but we don't know when to allocate until
		// after the `Every` callback has run. Doable, but a bigger change.
		panic("pointers are not supported for form/header/path/query parameters")