amitshekhariitbhu/go-backend-clean-architecture
Go Backend Clean Architecture
This is a Go backend template that structures a web service into domain, usecase, controller, and repository layers with strict dependency inversion. It provides a foundation for building maintainable and testable REST APIs by separating business logic from transport and data access concerns.
The project implements JWT-based authentication, issuing access and refresh tokens for user signup, login, and protected endpoint access. It uses the Gin HTTP framework to build a Docker-packaged REST API with public and private route groups, request validation, and middleware-based authentication. Dependencies are wired through explicit constructor calls at application startup without a dependency injection framework.
Data persistence is handled through a repository interface that abstracts MongoDB interactions behind a contract, enabling testable data access. The codebase supports mock-based layered testing, allowing verification of business logic and data access in isolation by substituting real dependencies with generated mock implementations. Configuration is loaded from a .env file and unmarshaled into a typed struct for runtime use.
Features
- Go Clean Architecture Templates - Provides a foundational Go backend template with strict clean architecture layering for maintainable and testable REST APIs.
- Registration and Profile Retrievals - Registers new users with email and password and returns profile data after JWT authentication.
- Data Abstraction Layers - Abstracts database interactions behind an interface so usecases can operate without knowing storage details.
- Domain Data Structure Declarations - Declares domain models and interface contracts that define the boundaries between architecture layers.
- Repository Pattern Abstractions - Abstracts MongoDB interactions behind a repository interface for testable data access.
- Access and Refresh Token Issuances - Generates short-lived access tokens and long-lived refresh tokens with separate signing secrets for user authentication.
- JWT Authentications - Issues and validates signed JWT access and refresh tokens for user authentication.
- Three-Layer Clean Architecture - Structures code into delivery, use-case, and repository layers with strict inward-only dependency rules.
- Dependency Inversion Patterns - Separates code into domain, usecase, controller, and repository layers with strict dependency inversion.
- Usecase Layer Executions - Implements a dedicated usecase layer that orchestrates business logic independently of transport and data access.
- Gin-Based Frameworks - Ships a REST API built on the Gin HTTP framework with public and private routes.
- Middleware-Based Endpoint Protections - Uses middleware to intercept requests and validate JWT tokens before granting access to protected API routes.
- Authenticated Route Separations - Separates API routes into public and JWT-protected groups with middleware-based authentication.
- User-Scoped Task CRUD - Implements create and list operations for tasks scoped to the authenticated user via JWT.
- Request Validation - Validates incoming request payloads for required fields and correct types, returning 400 errors.
- User-Scoped Task Management - Implements create and list operations for tasks scoped to the authenticated user via JWT.
- MongoDB Repository Abstractions - Persists data through a repository interface that abstracts MongoDB interactions behind a contract for testable data access.
- Interface Mock Generators - Generates mock implementations from Go interfaces to replace real dependencies in unit tests.
- Refresh Token Rotation - Accepts a valid refresh token to issue a new access and refresh token pair without requiring re-login.
- Identity Payload Extractions - Decodes validated JWT tokens to retrieve user ID and name for downstream request handling.
- Isolated Layer Testing - Replaces real databases and repositories with generated mocks to verify each layer's behavior without external dependencies.
- Dependency Mocking - Verifies business logic and data access in isolation using generated mock implementations.
- Dependency-Mocked Unit Testers - Tests business logic and data access in isolation by substituting real dependencies with mocks.
- Dependency Mocking - Substitutes real databases with generated mocks to verify controller, usecase, and repository behavior.
- Use Case Tests with Mocked Dependencies - Tests use cases by injecting mocked repositories to verify business logic under success and error conditions.
- User Profiles - Returns the authenticated user's name and email via a protected profile endpoint.
