编写API的好处是：自动而不是完全包括嵌套的对象，或者提供一个参数来指定要包括的对象？

Question

For example, we have an entity called ServiceConfig that contains a pointer to a Service and a Professional . If returned without including the fields would look like this:

{
    'type': '__Pointer', 
    'className': 'Service', 
    'objectId': 'q92he840'
}

At which point they could query again to retrieve that service. However, it is often the case that they need the Service name. In which case it is inefficient to have to query again to get the service every time.

Options:

1. Automatically return the Service . In which case, we should automatically return the Industry for that Service as well in case they need that... same applies to all. Seems like we're returning data too often here.

2. Allow them to pass an includes parameter that specifies which entities to include. Format is an array of strings where using a . can allow them to include subclasses. In this case ['Professional', 'Service.Industry'] would work.

Can anyone identify why any one solution would be better than the others? I feel that the last solution is the best, however it does not seem to be common to do to in the APIs I've seen.

Answer 1

This is a good API Design decision to spend your time on before you release an initial version. Both your approaches are valid and it all depends on what you think are the most common ways that clients would use your API.

Here are some points that you could consider:

1. You might prefer the first approach where you do not give all the data upfront. Sometimes it is about efficiency and at times it is also about security and ensuring that any additional important data is only fetched on as as needed basis and on authorization.
2. Implementing the 2nd approach is going to take more effort on part of your team to design/code and test out the API. So you might want to consider how much of effort you want to put into release 1.0
3. Since you have nested data for example, the second approach will serve you well. Several public APIs do that as a matter of fact. For eg look at the LinkedIn public API and particularly the facets section, where you can specify the fields or additional information that you would like to return.
4. Look at some of the client applications that you have written and if you can identify for sure that some data is needed anyways upfront, then it can help in designed the return data.
5. Eventually monitoring API usage and doing some analysis on the number of calls, methods invoked will give you good inputs on what to do next.

If I had to make a choice and have a little bit more leeway in terms of effort, I would go with the 2nd option, even if it is a simple version at first.