OOP and REST/JSON Design
public class Person
{
public string FirstName {get;set;}
public string MiddleName {get;set;}
public string LastName {get;set;}
public string FullName {get {return $"{FirstName} {MiddleName} {FullName}";}}
}
When creating a GET endpoint for a resource, should I...
1) Pre-compute method results such as FullName() and send to the client?
2) Re-implement methods such as FullName() client side?
Thoughts:
- Pre-computation would prevent me from having to duplicate the logic client side, and any time the FullName() logic changes, it would only have to be updated in one spot, the server
- FullName() is a pretty trivial example, but I can imagine more complex functions with ever changing rules / validation
- If we pre-compute and serialize function results, it seems like we might run into different problems
- For example, the client does not know about the function dependencies and is left guessing when to re-fetch a person to update FullName()
- A PUT/PATCH request could re-send the representation after modification
- However, this is a trivial example, and doesn't work so well when there are parent/child dependencies, etc
- For example, let's imagine a Shopping Cart and its children Line Items. Cart.TotalPrice() might be a function that sums up the line item prices and their quantities. If the client changes a single line item's quantity, the client would have to be smart enough to re-fetch the entire shopping cart to get the new total. Or..., the PUT/PATCH request could respond with the entire cart and not just the modified line item
- It seems like pre-computing and serializing function results hides object relationships/dependencies from the client, leaving the client "guessing" when state becomes stale
- It seems like re-implementing methods client side is not very DRY and could cause sync issues with ever changing business rules
Would love to hear some opinions / advice on this!
{
public string FirstName {get;set;}
public string MiddleName {get;set;}
public string LastName {get;set;}
public string FullName {get {return $"{FirstName} {MiddleName} {FullName}";}}
}
When creating a GET endpoint for a resource, should I...
1) Pre-compute method results such as FullName() and send to the client?
2) Re-implement methods such as FullName() client side?
Thoughts:
- Pre-computation would prevent me from having to duplicate the logic client side, and any time the FullName() logic changes, it would only have to be updated in one spot, the server
- FullName() is a pretty trivial example, but I can imagine more complex functions with ever changing rules / validation
- If we pre-compute and serialize function results, it seems like we might run into different problems
- For example, the client does not know about the function dependencies and is left guessing when to re-fetch a person to update FullName()
- A PUT/PATCH request could re-send the representation after modification
- However, this is a trivial example, and doesn't work so well when there are parent/child dependencies, etc
- For example, let's imagine a Shopping Cart and its children Line Items. Cart.TotalPrice() might be a function that sums up the line item prices and their quantities. If the client changes a single line item's quantity, the client would have to be smart enough to re-fetch the entire shopping cart to get the new total. Or..., the PUT/PATCH request could respond with the entire cart and not just the modified line item
- It seems like pre-computing and serializing function results hides object relationships/dependencies from the client, leaving the client "guessing" when state becomes stale
- It seems like re-implementing methods client side is not very DRY and could cause sync issues with ever changing business rules
Would love to hear some opinions / advice on this!
