​

Modular Architecture

Tasteful follows a clean, modular architecture that separates concerns into distinct layers. Each flavor is a self-contained module with its own business logic, data access, and configuration.

​

Inspiration from Controller/Service/Repository Pattern

Tasteful’s modular architecture follows the proven Controller/Service/Repository pattern (similar to NestJS or Angular), adapting it for Python API applications:

• Controller → Flavor: API endpoints and request/response handling
• Service: Business logic orchestration and workflow management
• Repository: Data access and persistence abstraction

This pattern maintains clear separation of concerns while providing a familiar structure for developers coming from other modern frameworks. The result is a clean, testable architecture that keeps business logic separate from HTTP concerns and data access.

​

Architecture Overview

The modular architecture is built around four key components that work together to create maintainable and scalable applications:

​

Core Components

​

1. Flavor (Controller)

The Flavor is the controller layer that defines API routes and handles HTTP requests. It should be kept as simple as possible, delegating all business logic to services. Key Principles:

• Keep controllers thin: Minimal logic, maximum delegation to services
• Handle HTTP concerns: Status codes, exceptions, request/response formatting
• Validate input: Basic request validation before passing to services
• Error handling: Convert service exceptions to appropriate HTTP responses

Responsibilities:

• Define API endpoints and routing
• Handle HTTP request/response logic
• Basic input validation and error handling
• Delegate business logic to services

​

2. Service (Business Logic)

The Service layer is where ALL business logic should live. This is the most important layer in your application - it contains the core functionality, business rules, and orchestrates complex operations. Key Principles:

• All business logic lives here: No business rules in controllers or repositories
• Validation and rules: Implement all business validation and constraints
• Orchestration: Coordinate between different repositories and external services
• Error handling: Raise meaningful business exceptions
• Private methods: Use private methods to organize complex business logic

Responsibilities:

• Implement ALL business rules and validation
• Orchestrate complex workflows and data operations
• Handle business logic errors and exceptions
• Coordinate between repositories and external services
• Maintain data consistency and integrity

​

3. Repository (Data Connection)

The Repository layer provides a clean interface for data operations and handles all persistence concerns. It abstracts away the underlying data storage implementation. Responsibilities:

• Handle database operations (CRUD)
• Manage data queries and filters
• Abstract database implementation details
• Handle database connections and transactions

---

Complete repository documentation and patterns will be available soon.

​

4. Config

The Config component manages all configuration settings for the flavor, including environment variables, feature flags, and integration settings. Responsibilities:

• Manage environment-specific settings
• Validate configuration values
• Provide default values
• Handle environment variables
• Configure external service integrations