# jufaa/fitness-app-backend architecture

> Architecture diagram of the GitHub repository jufaa/fitness-app-backend, generated by GitDiagram from its file tree, README and a sample of source files (last updated 2025-07-08). It is an AI-made overview: check details against the source.

- Interactive diagram: https://gitdiagram.com/jufaa/fitness-app-backend
- Repository: https://github.com/jufaa/fitness-app-backend

## Overview

##### Project Type and Purpose
- This is a backend service (“fitness-app-backend”) implemented in Node.js/TypeScript.
- It exposes a RESTful API (Express) for managing users, exercises, muscles, routines, and routine‐exercise mappings in a fitness app.
- The architecture follows a Clean/Hexagonal style with distinct layers: presentation (controllers), application (use‐cases), domain (entities & interfaces), and infrastructure (ORM repositories, DB, middlewares).

##### File Structure Analysis
- Top-level config and tooling: package.json, tsconfig.json, eslint.config.mjs, jest.config.js, .prettierrc, .env.example.
- src/presentation: Express routers & controllers—entry point for HTTP requests.
- src/application/use-cases: Business logic organized by aggregate (users, exercises, routines, etc.).
- src/domain: Entities models and repository interfaces (IUserRepository, IExerciseRepository, etc.).
- src/infrastructure:
- database: Sequelize-based implementations of repository interfaces and DB sync scripts.
- middlewares: auth, role checking, logging (Morgan).
- schemas: request/response validation or ORM schemas.
- libs and utils: logger, JWT, config.
- src/shared: Shared TypeScript types and helpers (e.g., Express augmentation, JWT utilities).
- tests: Jest tests.

##### README Insights
- Minimal content (project name only), so rely on conventions and file structure to infer architecture.

a. Main Components
- Clients (Web/Mobile/UI)
- HTTP/API Layer: Express Server, Global Middlewares (authMiddleware, morganMiddleware, roleMiddleware)
- Presentation Layer: Routers → Controllers
- Application Layer: Use-Case Handlers (e.g., GetAllExerciseUseCase)
- Domain Layer: Entities (User, Exercise, Routine, etc.), Repository Interfaces
- Infrastructure Layer: Sequelize Repositories, Database (e.g., PostgreSQL/MySQL)
- Shared Services: Logger, JWT Service, Config Loader
- External Systems (optional): Auth provider or third-party logging/metrics

b. Relationships and Data Flow
1. Client → HTTP Request → Middleware chain (auth, logging)
2. Middleware → Route matching → Controller
3. Controller → Invoke Use Case in Application layer, passing DTOs
4. Use Case → Calls Repository Interface (e.g., IUserRepository)
5. Infrastructure Repository Implementation (Sequelize) → Queries Database → Returns Entities
6. Use Case → Domain Entities → Controller → HTTP Response
7. Shared JWT Utility for token generation/validation in authMiddleware

c. Architectural Patterns & Principles
- Clean/Hexagonal Architecture: clear separation of concerns, dependency inversion (application depends on repository interfaces, not implementations).
- Single Responsibility: each layer handles a distinct responsibility.
- Dependency Injection (through constructor injection in controllers/use-cases).
- Layered validation: request schemas in infrastructure/schemas.

d. Key Technologies & Frameworks
- Node.js, TypeScript, Express
- Sequelize ORM (SQL DB)
- Jest for testing
- Morgan for HTTP logging, custom logger (winston or similar)
- JWT for authentication

##### Detailed Elements
- Authentication flow: JWT validation in authMiddleware.
- Error or exception handling flow if relevant.
- Configuration loader (config.ts) feeding environment variables into DB connection and JWT secrets.

## Diagram (Mermaid)

```mermaid
flowchart TB
    classDef external fill:#D3D3D3,stroke:#000,stroke-width:1px
    classDef http fill:#B0E0E6,stroke:#000,stroke-width:1px
    classDef presentation fill:#ADD8E6,stroke:#000,stroke-width:1px
    classDef application fill:#90EE90,stroke:#000,stroke-width:1px
    classDef domain fill:#FFFFE0,stroke:#000,stroke-width:1px
    classDef infrastructure fill:#FFA500,stroke:#000,stroke-width:1px
    classDef shared fill:#F0E68C,stroke:#000,stroke-width:1px

    Client["Client (Web/Mobile)"]:::external

    subgraph "HTTP/API Layer"
        ExpressServer["Express Server"]:::http
        AuthMiddleware["authMiddleware"]:::http
        MorganMiddleware["morganMiddleware"]:::http
        RoleMiddleware["roleMiddleware"]:::http
    end

    Client -->|"HTTP Request"| ExpressServer
    ExpressServer --> AuthMiddleware
    AuthMiddleware --> MorganMiddleware
    MorganMiddleware --> RoleMiddleware

    subgraph "Presentation Layer"
        subgraph Routers
            ProtectedRouter["ProtectedRouter"]:::presentation
            UserRouter["UserRouter"]:::presentation
            ExerciseRouter["ExerciseRouter"]:::presentation
            MainMuscleRouter["MainMuscleRouter"]:::presentation
            SubMuscleRouter["SubMuscleRouter"]:::presentation
            RoutineRouter["RoutineRouter"]:::presentation
            RoutineExerciseRouter["RoutineExerciseRouter"]:::presentation
        end
        subgraph Controllers
            UserController["UserController"]:::presentation
            ExerciseController["ExerciseController"]:::presentation
            MainMuscleController["MainMuscleController"]:::presentation
            SubMuscleController["SubMuscleController"]:::presentation
            RoutineController["RoutineController"]:::presentation
            RoutineExerciseController["RoutineExerciseController"]:::presentation
        end
    end

    RoleMiddleware --> ProtectedRouter
    ProtectedRouter --> UserRouter
    ProtectedRouter --> ExerciseRouter
    ProtectedRouter --> MainMuscleRouter
    ProtectedRouter --> SubMuscleRouter
    ProtectedRouter --> RoutineRouter
    ProtectedRouter --> RoutineExerciseRouter

    UserRouter --> UserController
    ExerciseRouter --> ExerciseController
    MainMuscleRouter --> MainMuscleController
    SubMuscleRouter --> SubMuscleController
    RoutineRouter --> RoutineController
    RoutineExerciseRouter --> RoutineExerciseController

    subgraph "Application Layer"
        UseCases["Use-Case Handlers"]:::application
    end

    UserController -->|"calls"| UseCases
    ExerciseController --> UseCases
    MainMuscleController --> UseCases
    SubMuscleController --> UseCases
    RoutineController --> UseCases
    RoutineExerciseController --> UseCases

    subgraph "Domain Layer"
        Entities["Entities"]:::domain
        Interfaces["Repository Interfaces"]:::domain
    end

    UseCases -->|"depends on"| Interfaces
    Interfaces --> Entities

    subgraph "Infrastructure Layer"
        subgraph "Sequelize Repositories"
            SequelizeUserRepo["SequealizeUserRepository"]:::infrastructure
            SequelizeExerciseRepo["SequalizeExerciseRepository"]:::infrastructure
            SequelizeMainMuscleRepo["SequalizeMainMuscleRepository"]:::infrastructure
            SequelizeSubMuscleRepo["SequalizeSubMuscleRepository"]:::infrastructure
            SequelizeRoutineRepo["SequalizeRoutineRepository"]:::infrastructure
            SequelizeRoutineExerciseRepo["SequealizeRoutineExerciseRepository"]:::infrastructure
        end
        Database["Database\n(PostgreSQL/MySQL)"]:::infrastructure
        subgraph "Validation Schemas"
            Schemas["Request/Response Schemas"]:::infrastructure
        end
        SyncScripts["DB Sync & Seed Scripts"]:::infrastructure
        LoggerLib["Logger (Winston)"]:::infrastructure
    end

    Interfaces --> SequelizeUserRepo
    Interfaces --> SequelizeExerciseRepo
    Interfaces --> SequelizeMainMuscleRepo
    Interfaces --> SequelizeSubMuscleRepo
    Interfaces --> SequelizeRoutineRepo
    Interfaces --> SequelizeRoutineExerciseRepo

    SequelizeUserRepo -->|"queries"| Database
    SequelizeExerciseRepo --> Database
    SequelizeMainMuscleRepo --> Database
    SequelizeSubMuscleRepo --> Database
    SequelizeRoutineRepo --> Database
    SequelizeRoutineExerciseRepo --> Database

    SyncScripts --> Database
    Schemas --> UserController
    Schemas --> ExerciseController
    Schemas --> MainMuscleController
    Schemas --> SubMuscleController
    Schemas --> RoutineController
    Schemas --> RoutineExerciseController

    subgraph "Shared Services"
        ConfigLoader["Config Loader"]:::shared
        JWTUtil["JWT Utility"]:::shared
    end

    ConfigLoader --> ExpressServer
    JWTUtil --> AuthMiddleware

    class Client external
    class ExpressServer http
    class AuthMiddleware http
    class MorganMiddleware http
    class RoleMiddleware http
    class ProtectedRouter,UserRouter,ExerciseRouter,MainMuscleRouter,SubMuscleRouter,RoutineRouter,RoutineExerciseRouter presentation
    class UserController,ExerciseController,MainMuscleController,SubMuscleController,RoutineController,RoutineExerciseController presentation
    class UseCases application
    class Entities,Interfaces domain
    class SequelizeUserRepo,SequelizeExerciseRepo,SequelizeMainMuscleRepo,SequelizeSubMuscleRepo,SequelizeRoutineRepo,SequelizeRoutineExerciseRepo,Database,Schemas,SyncScripts,LoggerLib infrastructure
    class ConfigLoader,JWTUtil shared

    click ExpressServer "https://github.com/jufaa/fitness-app-backend/blob/main/src/index.ts"
    click AuthMiddleware "https://github.com/jufaa/fitness-app-backend/blob/main/src/infrastructure/middlewares/authMiddleware.ts"
    click MorganMiddleware "https://github.com/jufaa/fitness-app-backend/blob/main/src/infrastructure/middlewares/morganMiddleware.ts"
    click RoleMiddleware "https://github.com/jufaa/fitness-app-backend/blob/main/src/infrastructure/middlewares/roleMiddleware.ts"
    click ExerciseRouter "https://github.com/jufaa/fitness-app-backend/blob/main/src/presentation/routes/ExerciseRouter.ts"
    click MainMuscleRouter "https://github.com/jufaa/fitness-app-backend/blob/main/src/presentation/routes/MainMuscleRouter.ts"
    click SubMuscleRouter "https://github.com/jufaa/fitness-app-backend/blob/main/src/presentation/routes/SubMuscleRouter.ts"
    click RoutineRouter "https://github.com/jufaa/fitness-app-backend/blob/main/src/presentation/routes/RoutineRouter.ts"
    click RoutineExerciseRouter "https://github.com/jufaa/fitness-app-backend/blob/main/src/presentation/routes/RoutineExerciseRouter.ts"
    click UserRouter "https://github.com/jufaa/fitness-app-backend/blob/main/src/presentation/routes/UserRouter.ts"
    click ProtectedRouter "https://github.com/jufaa/fitness-app-backend/blob/main/src/presentation/routes/ProtectedRouter.ts"
    click ExerciseController "https://github.com/jufaa/fitness-app-backend/blob/main/src/presentation/controllers/ExerciseController.ts"
    click MainMuscleController "https://github.com/jufaa/fitness-app-backend/blob/main/src/presentation/controllers/MainMuscleController.ts"
    click SubMuscleController "https://github.com/jufaa/fitness-app-backend/blob/main/src/presentation/controllers/SubMuscleController.ts"
    click RoutineController "https://github.com/jufaa/fitness-app-backend/blob/main/src/presentation/controllers/RoutineController.ts"
    click RoutineExerciseController "https://github.com/jufaa/fitness-app-backend/blob/main/src/presentation/controllers/RoutineExerciseController.ts"
    click UserController "https://github.com/jufaa/fitness-app-backend/blob/main/src/presentation/controllers/UserController.ts"
    click ConfigLoader "https://github.com/jufaa/fitness-app-backend/blob/main/src/shared/utils/config.ts"
    click JWTUtil "https://github.com/jufaa/fitness-app-backend/blob/main/src/shared/utils/jwt.ts"
```
