Convert URL.Query (map of slices) to struct golang

It would be awesome to have a straight forward mapping from the standard library URL.Query() to an struct.

Query() returns a map like:
map[a:[aaaa] b:[bbbb] c:[cccc]]

The struct looks like:

type Thing struct {
    A    string
    B    string
    C    string
}

• I've no idea why URL.Query returns a map with array elements inside tough. (well.. I know why but a GET is not likely to have duplicated params)

Please find below the complete example of parsing get query params directly in a golang struct and then sending the struct back as response

package main

import (
	"log"
	"net/http"
	"encoding/json"
	"github.com/gorilla/schema"
)

var decoder  = schema.NewDecoder()

type EmployeeStruct struct {
	MemberId         string `schema:"memberId"`
	ActivityType     string `schema:"activityType"`
	BusinessUnitCode int    `schema:"businessUnitCode"`
}

func GetEmployee(w http.ResponseWriter, r *http.Request) {
    var employeeStruct EmployeeStruct
    
    err := decoder.Decode(&employeeStruct, r.URL.Query())
	if err != nil {
		log.Println("Error in GET parameters : ", err)
	} else {
		log.Println("GET parameters : ", employeeStruct)
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(employeeStruct)
}

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("/GetEmployee", GetEmployee)
	log.Fatal(http.ListenAndServe(":8080", mux))
}

Steps to execute & Test (Assuming you are saving above code in employee.go) :

Step 1 : go run employee.go

Step 2 : Open in browser http://localhost:8080/GetEmployee?memberId=123&activityType=Call&businessUnitCode=56

Step 3 : You should get below response in browser window

{
    "MemberId": "123",
    "ActivityType": "Call",
    "BusinessUnitCode": 56
}

Step 4 : On console you should see below

GET parameters :  {123 Call 56}

example:

filters={"reference":["docker.io/library/alpine:latest"]}

need url encode to:

filters=%7B%22reference%22%3A%5B%22docker.io%2Flibrary%2Falpine%3Alatest%22%5D%7D

and could use "github.com/gorilla/schema"

	query := struct {
		All     bool
		Filters map[string][]string `schema:"filters"`
		Digests bool
		Filter  string 
	}{}
	decoder := schema.NewDecoder()
	decoder.Decode(&query, r.URL.Query())

As pointed out by @mh-cbon gorilla schema is the ultimate solution here.

Instead for obtaining the queryParams from the URL attribute.

func handleRequest(w http.ResponseWriter, r *http.Request) {
    queryString := r.URL.Query()
    //...parsing the Values -> map[string][]string
}

The approach of gorilla schema is to ship r.PostForm to the decode function.

func handleRequest(w http.ResponseWriter, r *http.Request) {
    err := decoder.Decode(person, r.PostForm)
    //...using reflect each struct's property can be called using 
    // the PostForm(url string, data url.Values) signature
    
    fmt.Print(person.GoodJobGorilla)
}

Using ggicci/httpin

Disclaimer: I'm the creator and maintainer of this package.

httpin helps you easily decoding HTTP request data from

• Query parameters, e.g. ?name=john&is_member=true
• Headers, e.g. Authorization: xxx
• Form data, e.g. username=john&password=******
• JSON/XML Body, e.g. POST {"name":"john"}
• Path variables, e.g. /users/{username}
• File uploads

How to use?

type ListUsersInput struct {
	Page     int  `in:"query=page"`
	PerPage  int  `in:"query=per_page"`
	IsMember bool `in:"query=is_member"`
}

func ListUsers(rw http.ResponseWriter, r *http.Request) {
	input := r.Context().Value(httpin.Input).(*ListUsersInput)

	if input.IsMember {
		// Do sth.
	}
	// Do sth.
}

httpin is:

• well documented: at https://ggicci.github.io/httpin/
• well tested: coverage over 98%
• open integrated: with net/http, go-chi/chi, gorilla/mux, gin-gonic/gin, etc.
• extensible (advanced feature): by adding your custom directives. Read httpin - custom directives for more details.
• awesome mentioned: https://github.com/avelino/awesome-go#forms

Just parse the string to URL and after you can use the lib github.com/gorilla/schema to parse it

// Example to parse querystring to struct
package main

import (
	"log"
	"net/url"

	"github.com/gorilla/schema"
)

type URLParams struct {
	Code  string `schema:"code"`
	State string `schema:"state"`
}

func main() {
	var (
		params  URLParams
		decoder = schema.NewDecoder()
	)
	p := "https://www.redirect-url.com?code=CODE&state=RANDOM_ID"

	u, _ := url.Parse(p)

	err := decoder.Decode(&params, u.Query())
	if err != nil {
		log.Println("Error in Decode parameters : ", err)
	} else {
		log.Printf("Decoded parameters : %#v\n", params)
	}
}

https://go.dev/play/p/CmuPhdKh6Yg

If anyone is using Echo, query struct tag will be useful for this case.

Example Struct

type struct Name {
    FirstName string `query:"first_name"`
    LastName string `query:"last_name"`
}

Example Query Param

?first_name="shahriar"&last_name="sazid"

Code

var name Name
err := c.Bind(&name); if err != nil {
    return c.String(http.StatusBadRequest, "bad request")
}

You can use the graceful package of Echo.

I write some codes as an example, with self-explanatory comments

 package main

 import (
     "log"
     "github.com/labstacks/echo"
)

// Declare your struct with form: "" tag
type Employee struct {
    MemberId         string `form:"memberId"`
    ActivityType     string `form:"activityType"`
    BusinessUnitCode int    `form:"businessUnitCode"`
}

// Your handlers should look like this method 
// Which takes an echo.Context and returns an error
func GetEmployee(ctx echo.Context) error{
    var employee Employee
    // With Bind, you can get the Post Body or query params from http.Request
    // that is wrapped by echo.Context here 
    if err := ctx.Bind(&employee);err != nil {
        return err
    } 

    // now you can use your struct , e.g
    return ctx.json(200, employee.MemberId)
}

// now use the handler in your main function or anywhere you need
func main() {
    e := echo.New()
    e.Get("/employee", GetEmployee)
    log.Fatal(e.Start(":8080"))
}