REST API Design Rules
Tags: webdev, backend, api, design
Published: 2024-06-01 21:44:05

## Why is it important to write clean REST-API Designs

In today's interconnected world, well-designed REST APIs are the backbone of efficient and scalable applications.

Writing clean REST API designs is crucial for several reasons:

* **Enhanced Usability:** A well-designed API is intuitive and easy to use, making it accessible to developers of all skill levels. This simplifies integration and reduces the learning curve.

* **Improved Maintainability:** Clean code promotes maintainability by making it easier to identify and fix bugs, add features, and scale the API. This ensures long-term stability and reduces development costs.

* **Increased Security:** A well-structured API with proper authentication and authorization mechanisms helps prevent unauthorized access, data breaches, and other security vulnerabilities.

* **Enhanced Performance:** A clean design optimizes performance by using efficient data structures, avoiding unnecessary calls, and minimizing latency. This provides a seamless user experience and improves overall application performance.

* **Reduced Development Time:** Well-defined API specifications and clear documentation enable faster development by eliminating guesswork and reducing the need for extensive testing. This saves valuable development time and resources.

* **Improved Scalability:** A clean design allows for easy scalability by providing a modular architecture that can be easily expanded to handle increased traffic or new features. This ensures the API can grow with the application's needs.

* **Increased Reusability:** A well-designed API can be reused across multiple applications, reducing duplication and promoting consistency. This simplifies development and saves time and effort.

* **Improved Documentation:** Clean designs are easier to document, making it clear to developers how the API works and how to use it effectively. This reduces confusion and improves adoption.

## URI Rules

**The structure of a url is as follows**

**`scheme :// authority / path [?query][#fragment]`**

for instance

`https://soccer.api.org/teams/dortmund/players?name=Rona#2`


There are two types of resources

1. Collection resources: contains a collection of resources. It can be likened to a database relation 

2. Singleton resources: contains a single resource. It can be likened to a database record.

---
When designing Rest-Api's 

1 Collection resources should be plural

```diff
+ soccer.api.org/teams/dortmund
- soccer.api.org/team/dortmund
```

2 Singleton resources should be singular and can be replaced by the unique id representing the resource in the database system behind the api

```diff
+soccer.api.org/teams/dortmund/players/58c1aaae-205a-11ef-aeea-a64c74618950
```

3 No **trailing forward slashes** in your URI's

```diff
+soccer.api.org/teams/dortmund/players
-soccer.api.org/teams/dortmund/players/
```

4 Use **hyphens** instead of **underscores** to improve readability of API's 

```diff
+ api.blog.com/blogs/this-is-my-blog
- api.blog.com/blogs/this_is_my_blog
```

5 **Lowercase letters** are prefered to **Uppercase letters** in URI paths

```diff
+ api.example.com/my-api/my-resource
- api.example.com/My-Api/My-Resource
```

6 No **file extensions** in URI's

```diff
+ api.example.com/api/resource
- api.example.com/api/resource.json
```

7 CRUD function names should **not**  be used in URI's 

```diff
+ DELETE api.example.com/api/resource
- GET api.example.com/api.resource/delete
```

8 The query component of the URI's can only be used in collection resources

```diff
+ GET /users?role=admin
```

9 The query component of a URI should be used to paginate collection results

```diff
+ GET /users?pageSize=25&pageStartIndex=50
```

## HTTP Method Rules


| HTTP METHOD | Uses                                                                                                              |
| ----------- | ----------------------------------------------------------------------------------------------------------------- |
| POST        | To create a new resource. similar to create                                                                       |
| GET         | To get the representation of a resource. similar to read                                                          |
| PUT         | To update a resource by replacing the **whole** resource                                                          |
| DELETE      | To delete a resource                                                                                              |
| PATCH       | To update a resource by changing the part of the resource that is required without replacing the entire resource. |
| HEAD        | To get only the response head not the body                                                                        |
| OPTIONS     | To get all available options for a particular resource                                                            |

> PUT can be used for both creating and updating a resource. However, following best practices, it's generally recommended to use POST for creating new resources and PUT for fully replacing existing ones.

---

## Versioning

Versioning an api can be important for:

**Maintaining backward compatibility:** Versioning allows you to introduce new features without breaking existing integrations that rely on older API versions. Users can continue using the familiar endpoints while those seeking new features can adopt the versioned API.

**Ensuring a consistent and well-designed API:** Consistent naming conventions across versions contribute to a user-friendly experience. Changing endpoints disrupts this experience, and versioning helps avoid it.

---

# Conclusion

Now that you're armed with these REST API design rules, it's time to put them into action! Share your API creations in the comments below, and let's build a world of well-designed and developer-friendly APIs together.