Software Engineering Stack Exchange is a question and answer site for professionals, academics, and students working within the systems development life cycle. It only takes a minute to sign up.
Sign up to join this community
What's the best practice around updating information received from the request?
Update all the columns with the values received in the request object? What if there are columns that should be updated when posted by admin and not by the regular user? We have a lot of such situations.
Should the backend check what attributes are getting a different value from what is saved in the DB?
P.S: We are using Dynamo and AWS API gateway and this is a serverless application
A PUT request always places one thing in the service.
You need to decide what that one thing is. Two of the choices are:
If you select one path, you can easily PUT new properties independently, at the cost of doing many puts when you have many properties to update. There is a risk in this approach, as in a collection of operations, you'll need to monitor and manage every operation was succesfully executed.
If you select the other pat, you can easily PUT new objects, which will always be consistently placed with all properties at the new correct value.
A PATCH request modifies an existing thing
The HTML PATCH verb is a relatively new construct. In this approach, you operate like a PUT, but you only include the portions of the object that have new values. The server receives this request, and will merge the existing object with the request. Typically this is done by locating JSON node above the value, and replacing the node with the new value. For example
Person: {
Age: 5,
Height: 30,
Hobbies: [ 'crayons', 'dancing', 'singing' ]
}
would only replace the Person.Age, Person.Height, and Person.Hobbies values, even if there are also Person.Name, Person.Weight, and Person.Gender properties already in the object at that URL.
What's the best practice around updating information received from the request?
What a PUT message means (semantics): replace the representation of the target resource with the representation in the message-body of the request.
What the server should do when it receives a request to replace the representation of the target resource? Whatever you think is best.
An origin server SHOULD verify that the PUT representation is consistent with any constraints the server has for the target resource that cannot or will not be changed by the PUT.... When a PUT representation is inconsistent with the target resource, the origin server SHOULD either make them consistent, by transforming the representation or changing the resource configuration, or respond with an appropriate error message containing sufficient information to explain why the representation is unsuitable. -- RFC 7231
So it is completely in bounds to make changes that are not an exact match with what the request asks for. You need to be a little bit careful with your response not to imply that you've accepted the representation as is when in fact you've made some changes to it.
How the server actually makes the change is beyond the scope of PUT; HTTP gives us a shared understanding for what the message means, but implementations are free to do what they like with the message.
Therefore: pulling out your server's representation, selectively making changes, and then saving your result is fine (from the perspective of REST/HTTP).
