Tag: adding

I've recently been thinking about managing flat vs. nested architecture when designing a RESTful API.

Would there be a problem with a system in which your nested resources can be specified in a request parameter of the API request? This is only necessary in certain complex situations, otherwise you would access it regularly via collections / instance / collections / instance.

Example:
Let's say we need to get a thread with its user comments.

Flat architecture way:

getThreadWithPostCommentUsers (threadUuid) {
const thread = new Thread ();

// by default, flat however becomes a lasagna code.
// conscious data, heavy, flexible layer.
this.http.request (& # 39; threads / & # 39; + threadUuid) .then ((threadData) => {
Object.assign (thread, threadData);

this.http.request (& # 39; threads / + + threadUuid + & # 39; / posts & # 39;). then ((posts) => {
thread.posts = posts;

posts.forEach (post => {
this.http.request (& # 39; posts / + post.uuid + & # 39; comments) .then ((comments) => {
post.comments = comments;

comments.forEach (comment => {
this.http.request ('users /' + comment.user_uuid) .then ((user) => {
comment.user = user
console.log (comment.user);
});
});
});
});
});
});
}

• Large amount of layers, lasagna code
• Flexible for efficient multiple use of data.

It feels most encapsulated and simple. However, it starts to become a little redundant and unfavorable when dealing with a lot of relationships.

Nested architecture way:

getThreadWithPostCommentUsers (threadUuid) {
const thread = new Thread ();

// by default has nested objects, very simple but inefficient
// not aware of the data, not heavy in layers, not flexible
this.http.request (& # 39; threads / & # 39; + threadUuid) .then ((threadData) => {
Object.assign (thread, threadData);

thread.posts.forEach (post => {
post.comments.forEach (comment => {
console.log (comment.user);
});
});
});
}

• Small amount of layers
• Not flexible for efficient multiple use of data.

The nested method is interesting from the point of view of convenience, but it is not very flexible if you want to minimize the data.

So my idea was to combine the two, where I can take advantage of the advantages of a simple and flat architecture, but also to load nests into a query.

Hybrid Flat and Nested Way:

getThreadWithPostCommentUsers (threadUuid) {
const thread = new Thread ();

// default flat, add nests based on the resources parameter
// flexible, data aware, no heavy layer
this.http.request (& # 39; threads / + threadUuid + & # 39 ;? resources = posts.comments.user & # 39;). then ((threadData) => {
Object.assign (thread, threadData);

thread.posts.forEach (post => {
post.comments.forEach (comment => {
console.log (comment.user);
});
});
});
}

• Small amount of layers
• Flexible for efficient multiple use of data.

My requests would be flat by default, but my requests have the ability to call some nested resources on demand without creating many custom routes and optimizing data efficiency.

The authorization would always be done at the server level, allowing only certain resources depending on the request.

Would it be a bad choice of practice / design? What are your thoughts? Is there anything for that and I reinvent the wheel?

Thank you