pathparams.go

// Copyright 2026 Company.info B.V.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package reqbind

import (
	"fmt"
	"net/http"
	"reflect"
	"strconv"
	"strings"
)

// decodePathParams populates struct fields from HTTP request path parameters using reflection.
func decodePathParams(request http.Request, target any, urlTemplate string) error {
	fieldValues := target.(reflect.Value)

	if fieldValues.Kind() != reflect.Struct {
		return fmt.Errorf("decode path params: target is not a struct")
	}

	if len(urlTemplate) == 0 {
		return fmt.Errorf("decode path params: url template is not provided")
	}

	params, err := extractParams(request.URL.Path, urlTemplate)
	if err != nil {
		return err
	}

	// Iterate over the struct fields.
	for i := 0; i < fieldValues.NumField(); i++ {

		pathParamName := fieldValues.Type().Field(i).Tag.Get(GoReqTag)

		if pathParamName == "" || pathParamName == "-" {
			continue
		}

		pathParamValue, ok := params[pathParamName]
		if !ok {
			return fmt.Errorf("decode path params: pathParam %s not found", pathParamName)
		}

		if pathParamValue == "" {
			continue
		}

		field := fieldValues.Field(i)
		if !field.IsValid() || !field.CanSet() {
			continue
		}

		switch field.Kind() {
		case reflect.String:
			field.SetString(pathParamValue)
		case reflect.Int:
			if intValue, err := strconv.Atoi(pathParamValue); err == nil {
				field.SetInt(int64(intValue))
			}
		default:
			return fmt.Errorf("decode path params: unsupported kind %s", field.Kind())
		}
	}

	return nil
}

// extractParams extracts the parameters based on the given URL pattern.
func extractParams(url, template string) (map[string]string, error) {
	urlParts := strings.Split(url, "/")
	templateParts := strings.Split(template, "/")

	if len(urlParts) < len(templateParts) {
		return nil, fmt.Errorf("decode path params: invalid url path")
	}
	params := make(map[string]string)

	for i, templatePart := range templateParts {
		if strings.HasPrefix(templatePart, ":") {
			paramName := templatePart[1:]
			if paramName == "" {
				return nil, fmt.Errorf("decode path params:: invalid url template")
			}
			params[paramName] = urlParts[i]
		} else if templatePart != urlParts[i] {
			return nil, fmt.Errorf("decode path params: invalid url path")
		}
	}

	return params, nil
}