How to handle patch request with unset value in golang

Handling patch requests with unset values in Golang typically involves managing partial updates, especially when you want to update only specific fields in a structure while leaving others unchanged. This is especially common when working with the PATCH method in REST APIs. A common approach to handling this issue is to use pointers for optional fields. Below, I will detail a possible implementation and provide an example.

Using Pointers to Represent Optional Fields

In Go, we can use pointers to represent optional fields within a struct. When a field is of pointer type, if it is not set, its value is nil. This provides a clear way to distinguish between fields that are unset and fields set to zero values.

Defining the Model

First, define a struct model where some fields are pointer types, allowing them to be set to nil.

go
type User struct {
    FirstName *string `json:"first_name"`
    LastName  *string `json:"last_name"`
    Age       *int    `json:"age"`
}

Parsing the Request

When receiving a PATCH request, we can parse the request body into the defined struct. Fields not provided will remain nil.

go
func updateUser(w http.ResponseWriter, r *http.Request) {
    var patchUser User
    err := json.NewDecoder(r.Body).Decode(&patchUser)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    // Assuming userID is obtained from the URL path
    userID := r.URL.Path[len("/users/"):]

    // Fetching the current user from the database
    currentUser := getUserFromDatabase(userID)

    // Applying the patch
    if patchUser.FirstName != nil {
        currentUser.FirstName = patchUser.FirstName
    }
    if patchUser.LastName != nil {
        currentUser.LastName = patchUser.LastName
    }
    if patchUser.Age != nil {
        currentUser.Age = patchUser.Age
    }

    // Updating the user in the database
    updateUserInDatabase(userID, currentUser)

    // Returning the updated user information
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(currentUser)
}

Summary

By defining fields in the struct as pointer types, we can clearly identify which fields are explicitly set by the client and which are left empty (i.e., pointers are nil). This approach is highly useful for handling PATCH requests in REST APIs because it enables partial updates to resource attributes without affecting other unspecified attributes.

The main advantage of this method is that it maintains type safety and is relatively straightforward. However, using pointers also requires performing nil checks before accessing these fields to avoid runtime errors.