# kinal-team-1/daem-backend architecture

> Architecture diagram of the GitHub repository kinal-team-1/daem-backend, generated by GitDiagram from its file tree, README and a sample of source files (last updated 2025-03-29). It is an AI-made overview: check details against the source.

- Interactive diagram: https://gitdiagram.com/kinal-team-1/daem-backend
- Repository: https://github.com/kinal-team-1/daem-backend

## Overview

##### Main Components
- API Endpoints and Routing – Represented by files like routes.js, and the individual module routes within the src/application directory (e.g., anonymous-case.routes.js, public-case.routes.js, auth.routes.js, attachment.routes.js, user.routes.js).
- Controllers – Each module (anonymous-case, public-case, auth, attachment, etc.) has a corresponding set of controllers that manage incoming requests.
- Models/Database Layer – The models for each module define MongoDB schemas (e.g., anonymous-case.model.js, public-case.model.js, attachment.model.js, etc.) and you have a dedicated src/db module that handles the actual database connection. In addition, the daem-db directory contains BSON dump files and helper scripts to restore the MongoDB replica set.
- Middlewares – Various middleware functions (located in src/middleware) provide support for validations (coordinates, public-case, JWT, etc.) and facilitate request processing.
- Utilities – General support functions (located in src/utils) including token generation, logging, response handling, etc.
- Custom ESLint Rules – These enforce coding standards and best practices. Represent these as a “Quality/Standards” component that affects the code development process.
- Internationalization (i18n) – This folder contains locale-specific files and formatters, which is critical for supporting multiple languages.
- Testing – The tests directory (with subdirectories for api tests and utility tests) shows a comprehensive suite of tests that validate the functionality and reliability of the API endpoints.
- CI/CD and Deployment Artifacts – The presence of GitHub workflows, Dockerfile, docker-compose.yml, and environment configuration files indicate automated testing, deployment, and orchestration of containers.

##### Relationships and Interactions
- Business Logic Layer: For each module, the controllers interact with models (data storage) and utility functions to process business logic. For example, the auth module takes care of user authentication and validation, while the public-case and anonymous-case modules handle different types of reporting.
- Database Interaction: Show a connection from the models to a MongoDB instance, which might be represented by the “daem-db” data.
- File Handling and Supabase Integration: Particularly for attachments, include an external service block representing Supabase that the attachment controllers connect to.
- Middleware: Place middleware as an intermediate layer that intercepts requests between the routing and controller layers to perform functions such as JWT validation, language retrieval, file paths processing, and pagination.
- Utilities and Logging: Represent utility modules (e.g., logger, token generation) that support operations across modules, ensuring consistent error handling and logging.
- CI/CD and Development: Outside of the main runtime architecture, but as part of the overall operational ecosystem, include components for CI/CD pipelines, Docker orchestration, and custom eslint configurations that enforce coding practices.

##### Important Architectural Patterns
- Modular Design: The project clearly adheres to a modular structure where each functional concern (anonymous cases, public cases, auth, etc.) has its own dedicated directory and file organization.
- Separation of Concerns: The distinct layers (routing, controllers, models, middleware, utilities) help in isolating responsibilities.
- API-Driven Architecture: Emphasize the design where a RESTful API is central – acting as the interface between clients and various backend services.
- External Services Integration: File attachments and possibly other services are integrated via external APIs like Supabase.

##### Relevant Technologies & Frameworks
- Node.js (Express-like structure) for building the API.
- MongoDB (with BSON dumps and replica-set capabilities).
- Supabase for attachment/file handling.
- ESLint with custom rules to maintain code quality.
- Testing Framework (Japa) for robust test coverage.
- Docker for containerization and deployment orchestration.
- GitHub Actions for continuous integration and deployment.

##### Additional Detail
- Don’t shy away from including many components – the more detailed and labeled, the better it explains the overall architecture.
- The integration of configuration (env files, Docker Compose) can be noted in a side section to indicate the importance of deployment and environment management.

## Diagram (Mermaid)

```mermaid
flowchart TD
    subgraph "External Layer"
        Client["External API Client"]:::external
    end

    subgraph "API Routing Layer"
        Routes["routes.js"]:::routing
        AnonRoutes["Anonymous Case Routes"]:::routing
        PublicRoutes["Public Case Routes"]:::routing
        AuthRoutes["Auth Routes"]:::routing
        AttachRoutes["Attachment Routes"]:::routing
        UserRoutes["User Routes"]:::routing
    end

    subgraph "Middleware Layer"
        Middleware["Middleware (Validation,JWT,Locale,Pagination)"]:::middleware
    end

    subgraph "Controllers Layer"
        AnonController["Anonymous Case Controller"]:::controller
        PublicController["Public Case Controller"]:::controller
        AuthController["Auth Controller"]:::controller
        AttachController["Attachment Controller"]:::controller
        UserController["User Controller"]:::controller
    end

    subgraph "Models & Database Layer"
        AnonModel["Anonymous Case Model"]:::model
        PublicModel["Public Case Model"]:::model
        AuthModel["Auth Model"]:::model
        AttachModel["Attachment Model"]:::model
        UserModel["User Model"]:::model
        DBConnection["DB Connection"]:::db
        MongoDB["MongoDB Replica Set"]:::db
        DaemDB["daem-db Repository"]:::db
    end

    subgraph "External Services"
        Supabase["Supabase Attachment Service"]:::external
    end

    subgraph "Development & Operations"
        ESLint["Custom ESLint Rules"]:::ops
        I18n["Internationalization (i18n)"]:::ops
        Testing["Test Suite"]:::ops
        CICD["CI/CD Pipeline"]:::ops
        DockerEnv["Docker & Env Config"]:::ops
    end

    %% Data flow connections
    Client --> Routes
    Routes --> AnonRoutes
    Routes --> PublicRoutes
    Routes --> AuthRoutes
    Routes --> AttachRoutes
    Routes --> UserRoutes

    AnonRoutes --> Middleware
    PublicRoutes --> Middleware
    AuthRoutes --> Middleware
    AttachRoutes --> Middleware
    UserRoutes --> Middleware

    Middleware --> AnonController
    Middleware --> PublicController
    Middleware --> AuthController
    Middleware --> AttachController
    Middleware --> UserController

    AnonController --> AnonModel
    PublicController --> PublicModel
    AuthController --> AuthModel
    AttachController --> AttachModel
    UserController --> UserModel

    AnonModel --> DBConnection
    PublicModel --> DBConnection
    AuthModel --> DBConnection
    AttachModel --> DBConnection
    UserModel --> DBConnection

    DBConnection --> MongoDB
    DBConnection --> DaemDB

    AttachController -->|"uploads"| Supabase

    %% Cross-cutting operational links (non-request flow)
    Client --- I18n
    Client --- Testing
    AuthController --- ESLint
    Routes --- CICD
    DBConnection --- DockerEnv

    %% Click Events for Routing
    click Routes "https://github.com/kinal-team-1/daem-backend/blob/master/routes.js"
    click AnonRoutes "https://github.com/kinal-team-1/daem-backend/blob/master/src/application/anonymous-case/anonymous-case.routes.js"
    click PublicRoutes "https://github.com/kinal-team-1/daem-backend/blob/master/src/application/public-case/public-case.routes.js"
    click AuthRoutes "https://github.com/kinal-team-1/daem-backend/blob/master/src/application/auth/auth.routes.js"
    click AttachRoutes "https://github.com/kinal-team-1/daem-backend/blob/master/src/application/attachment/attachment.routes.js"
    click UserRoutes "https://github.com/kinal-team-1/daem-backend/blob/master/src/application/user/user.routes.js"
    
    %% Click Events for Controllers
    click AnonController "https://github.com/kinal-team-1/daem-backend/blob/master/src/application/anonymous-case/anonymous-case.controllers.js"
    click PublicController "https://github.com/kinal-team-1/daem-backend/blob/master/src/application/public-case/public-case.controllers.js"
    click AuthController "https://github.com/kinal-team-1/daem-backend/blob/master/src/application/auth/auth.controllers.js"
    click AttachController "https://github.com/kinal-team-1/daem-backend/blob/master/src/application/attachment/attachment.controllers.js"
    click UserController "https://github.com/kinal-team-1/daem-backend/blob/master/src/application/user/user.controller.js"
    
    %% Click Events for Models/Database
    click AnonModel "https://github.com/kinal-team-1/daem-backend/blob/master/src/application/anonymous-case/anonymous-case.model.js"
    click PublicModel "https://github.com/kinal-team-1/daem-backend/blob/master/src/application/public-case/public-case.model.js"
    click AuthModel "https://github.com/kinal-team-1/daem-backend/blob/master/src/application/auth/auth.model.js"
    click AttachModel "https://github.com/kinal-team-1/daem-backend/blob/master/src/application/attachment/attachment.model.js"
    click UserModel "https://github.com/kinal-team-1/daem-backend/blob/master/src/application/user/user.model.js"
    click DBConnection "https://github.com/kinal-team-1/daem-backend/blob/master/src/db/db-connection.js"
    click DaemDB "https://github.com/kinal-team-1/daem-backend/blob/master/daem-db/mongorestore.sh"
    
    %% Click Events for Middlewares and Utilities
    click Middleware "https://github.com/kinal-team-1/daem-backend/tree/master/src/middleware"
    click Utilities "https://github.com/kinal-team-1/daem-backend/tree/master/src/utils"
    
    %% Click Events for Ops
    click ESLint "https://github.com/kinal-team-1/daem-backend/tree/master/eslint-custom-rules"
    click I18n "https://github.com/kinal-team-1/daem-backend/tree/master/i18n"
    click Testing "https://github.com/kinal-team-1/daem-backend/tree/master/tests"
    click CICD "https://github.com/kinal-team-1/daem-backend/blob/master/.github/workflows/daem-backend.yaml"
    click DockerEnv "https://github.com/kinal-team-1/daem-backend/blob/master/docker-compose.yml"

    %% Styles
    classDef external fill:#ffcc00,stroke:#333,stroke-width:2px;
    classDef routing fill:#adf,stroke:#333,stroke-width:2px;
    classDef controller fill:#bbf,stroke:#333,stroke-width:2px;
    classDef model fill:#cfc,stroke:#333,stroke-width:2px;
    classDef db fill:#afa,stroke:#333,stroke-width:2px;
    classDef middleware fill:#f9d,stroke:#333,stroke-width:2px;
    classDef ops fill:#ddd,stroke:#333,stroke-width:2px;
```
