httpx

ExampleDecodeQueryParams_nestedStruct demonstrates using DecodeQueryParams with nested structs.

package main

import (
	"fmt"
	"net/url"

	"github.com/quentinalbertone/httpx"
)

func main() {
	// Define structs with nested structure
	type Location struct {
		City    string `query:"city"`
		Country string `query:"country"`
	}

	type User struct {
		Name     string   `query:"name"`
		Age      int      `query:"age"`
		Location Location `query:"loc"`
	}

	// Parse a URL with nested query parameters
	u, _ := url.Parse("https://api.example.com/users?name=Alice&age=30&loc.city=Paris&loc.country=France")

	// Decode query parameters into the struct
	var filter User
	err := httpx.DecodeQueryParams(*u, &filter)
	if err != nil {
		fmt.Printf("Error: %v\n", err)
		return
	}

	// Use the decoded values
	fmt.Printf("Name: %s\n", filter.Name)
	fmt.Printf("Age: %d\n", filter.Age)
	fmt.Printf("City: %s\n", filter.Location.City)
	fmt.Printf("Country: %s\n", filter.Location.Country)

}

Output:

Name: Alice
Age: 30
City: Paris
Country: France

ExampleJSON demonstrates the JSON utility function.

package main

import (
	"fmt"
	"net/http"
	"net/http/httptest"

	"github.com/quentinalbertone/httpx"
)

func main() {
	handler := func(w http.ResponseWriter, r *http.Request) error {
		data := struct {
			Message string `json:"message"`
			Count   int    `json:"count"`
		}{
			Message: "Hello from JSON",
			Count:   42,
		}
		return httpx.JSON(w, http.StatusOK, data)
	}

	// Create a test request
	req := httptest.NewRequest("GET", "/test", nil)
	w := httptest.NewRecorder()

	// Call the handler
	err := handler(w, req)
	if err != nil {
		panic(err)
	}

	resp := w.Result()
	fmt.Println("Status:", resp.StatusCode)
	fmt.Println("Content-Type:", resp.Header.Get("Content-Type"))
}

Output:

Status: 200
Content-Type: application/json

ExampleListenAndServe demonstrates how to start an HTTP server with graceful shutdown and a CORS middleware applied globally via WithHTTPMiddleware.

package main

import (
	"context"
	"fmt"
	"net/http"

	"github.com/quentinalbertone/httpx"
)

func main() {

	// Create a router with routes
	router := httpx.NewRouter(nil, nil)

	router.GET("/api/users", func(w http.ResponseWriter, r *http.Request) error {
		return httpx.JSON(w, http.StatusOK, []string{"Alice", "Bob"})
	})

	// CORSMiddleware sets CORS headers on every response and handles preflight requests.
	corsMiddleware := func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.Header().Set("Access-Control-Allow-Origin", "*")
			w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
			w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")

			// Handle preflight requests
			if r.Method == http.MethodOptions {
				w.WriteHeader(http.StatusOK)
				return
			}

			next.ServeHTTP(w, r)
		})
	}

	// Configure the server with custom settings
	serverConf := func(server *http.Server) {
		server.Addr = ":8080"
		// You can set other server options here:
		// server.ReadTimeout = 5 * time.Second
		// server.WriteTimeout = 10 * time.Second
		// server.IdleTimeout = 120 * time.Second
	}

	// Start the server with CORS enabled globally.
	// WithHTTPMiddleware wraps the server's handler so it applies to all
	// requests, including those that don't match any route.
	ctx := context.Background()
	if err := httpx.ListenAndServe(ctx, router,
		serverConf,
		httpx.WithHTTPMiddleware(corsMiddleware),
	); err != nil {
		fmt.Printf("Server error: %v\n", err)
	}
}

ExampleNext demonstrates middleware usage with the Next function.

package main

import (
	"fmt"
	"net/http"
	"net/http/httptest"

	"github.com/quentinalbertone/httpx"
)

func main() {
	// Custom middleware that adds a header
	headerMiddleware := func(w http.ResponseWriter, r *http.Request) error {
		w.Header().Set("X-Custom-Header", "middleware-value")
		// Call the next handler in the chain
		return httpx.Next(w, r)
	}

	router := httpx.NewRouter(nil, nil)

	// Add a route with middleware
	router.GET("/protected", headerMiddleware, func(w http.ResponseWriter, r *http.Request) error {
		return httpx.JSON(w, http.StatusOK, map[string]string{
			"message": "This response has a custom header",
		})
	})

	server := httptest.NewServer(router)
	defer server.Close()

	resp, err := http.Get(server.URL + "/protected")
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	fmt.Println("Custom Header:", resp.Header.Get("X-Custom-Header"))
}

Output:

Custom Header: middleware-value