STOP using Minimal APIs for Large Projects!

Summary

In this video, the speaker challenges the common notion of using minimal APIs for large projects, citing that they often lead to disorganized code resembling poorly written controllers. Instead, the speaker demonstrates how to effectively structure minimal APIs using static classes and typed results, showcasing better performance and reduced code complexity compared to traditional controllers. By implementing Open API documentation and mapping endpoints efficiently, developers can achieve clarity and maintainability. Ultimately, the speaker encourages experimentation with minimal APIs, emphasizing their advantages for new projects while advising against blindly following trends.

Takeaways

• 😀 Minimal APIs should not be used for large projects; they are designed for simple examples and server functions.
• 📂 Organizing a large minimal API project often results in poorly structured code, resembling bad controller implementations.
• 🔄 Using controllers from the start is recommended for larger APIs to maintain organization.
• 📜 Refactoring from controllers to minimal APIs can lead to better performance with less code.
• ⚙️ Static classes are utilized for defining minimal API endpoints, and dependency injection must be handled within methods.
• 📈 Typed results provide automatic documentation for endpoints, improving clarity regarding response bodies and status codes.
• 🗂️ Endpoint groups allow for better organization and can apply authorization and filters to all endpoints collectively.
• 📊 Minimal APIs can outperform traditional controllers, showing increased requests per second in performance tests.
• 🔍 OpenAPI can be integrated into minimal APIs for enhanced documentation, providing summaries for each endpoint.
• 💡 Developers should experiment with both minimal APIs and controllers to determine the best approach for their specific project needs.

Q & A

What are minimal APIs, and when are they typically used?

Minimal APIs are simplified interfaces for building web APIs, often used for single-page applications, teaching purposes, or serverless functions. They are designed for simplicity and quick deployment rather than extensive functionality.

Why is it advised not to use minimal APIs for large projects?

Minimal APIs can lead to poorly organized code in large projects. As developers attempt to impose structure on them, they often end up with code that resembles badly written controllers, compromising clarity and maintainability.

How does the organization of controllers compare to minimal APIs in large projects?

Controllers provide a more structured and organized approach to API development, making it easier to manage complex logic and dependencies, whereas minimal APIs can result in disorganization when scaled up.

What was demonstrated in the video regarding the transition from controllers to minimal APIs?

The video showcased a step-by-step process of refactoring a traditional controller-based API to a minimal API format, retaining functionality while reducing code complexity.

What are the steps taken to refactor a controller into a minimal API structure?

The steps include creating a static class for user endpoints, injecting dependencies directly into methods, changing return types to Typed Results, and grouping endpoints for better organization.

What is the benefit of using Typed Results in minimal APIs?

Typed Results automatically document endpoints, clarifying return types and response statuses, which enhances the overall API documentation and usability.

How were performance metrics compared between controllers and minimal APIs?

Performance was tested using k6, revealing that minimal APIs handled about 10,000 requests per second, while controllers managed around 9,000 requests per second, showcasing better performance for minimal APIs.

Is the performance difference between minimal APIs and controllers significant enough to switch existing projects?

The performance difference, while notable, may not warrant refactoring large, existing projects solely for an extra thousand requests per second; however, it is a compelling reason for new projects.

What final advice does the video give regarding choosing between minimal APIs and controllers?

The video encourages developers to conduct their own research and experimentation instead of blindly following trends, suggesting that the choice should be based on the specific needs and scale of the project.

How can authorization and endpoint filters be applied in minimal APIs?

Authorization and filters can be applied to endpoint groups in minimal APIs, allowing for modifications that affect all endpoints collectively, or overriding specific settings for individual endpoints.