Go Clean Architecture

https://github.com/wesionaryteam/go_clean_architecture
Admin
A Go Clean Architecture implementation utilizing the Gin Web Framework, Uber-go/fx for dependency...
Tokens:3,766
Snippets:31
Trust Score:8.7
License:Apache-2.0
Update:1 year ago
Show doc for...
Tokens:
Raw
### Starting Application Locally

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/README.md

This command executes the `main.go` entry point of the Go application, specifically invoking the `app:serve` command. This starts the web server locally, making the application accessible for development and testing.

```zsh
go run main.go app:serve
```

--------------------------------

### Starting Application with Docker Compose

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/README.md

This command starts the application services defined in the `docker-compose.yml` file in detached mode (`-d`). It orchestrates the setup and execution of all necessary containers, such as the application server and database, ensuring the application runs within a Dockerized environment. `sudo` might be needed for permission issues.

```zsh
docker-compose up -d
```

--------------------------------

### Setting Up Linter with Make

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/README.md

This command executes the `lint-setup` target defined in the project's `Makefile`. It is used to configure the linter, typically involving setting up a Git pre-commit hook to ensure code quality before commits. This requires Python3 to be installed as a prerequisite.

```zsh
make lint-setup
```

--------------------------------

### Initializing Environment Variables

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/README.md

This command copies the example environment variables file (`.env.example`) to `.env`. The `.env` file is then used to configure the application's environment, including database credentials and AWS S3 bucket name, which must be updated by the user.

```zsh
cp .env.example .env
```

--------------------------------

### Installing Atlas CLI

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/README.md

This command downloads and executes the Atlas CLI installation script from `https://atlasgo.sh`. Atlas is used for declarative database schema migrations, enabling versioned and diff-based schema changes. This is a prerequisite for managing database migrations in the project.

```sh
curl -sSf https://atlasgo.sh | sh
```

--------------------------------

### Example: Discovering Specific Go Module Update

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/UPDATING_DEPENDENCIES.md

This example demonstrates the output of `go list -m -u` when checking for updates for a specific module, `cloud.google.com/go/firestore`. It shows the current installed version and the latest available version in brackets.

```zsh
go list -m -u cloud.google.com/go/firestore
cloud.google.com/go/firestore v1.2.0 [v1.6.1]
```

--------------------------------

### Getting Specific Go Dependency Version

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/UPDATING_DEPENDENCIES.md

This command fetches and installs a specific numbered version of a Go module by appending the module path with `@` followed by the desired version. It's used for precise version control or rolling back to a known stable version.

```zsh
go get example.com/theirmodule@v1.3.4
```

--------------------------------

### Configuring Database Environment Variables for Atlas

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/README.md

This snippet shows example environment variables required in the `.env` file for Atlas to connect to the database. These variables specify the database user, password, name, and the port for forwarding, enabling Atlas to perform schema migrations against the configured database.

```env
DB_USER=root
DB_PASS=secret
DB_NAME=exampledb
DB_FORWARD_PORT=3306
```

--------------------------------

### Getting Latest Go Dependency Version

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/UPDATING_DEPENDENCIES.md

This command fetches and installs the absolute latest version of a specified Go module by appending `@latest` to the module path. It's a convenient way to update a single dependency to its most recent release.

```zsh
go get example.com/theirmodule@latest
```

--------------------------------

### Defining Go Fx Module for User Feature

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/devguide/AddingEndpoints.md

This Go snippet defines an `fx.Module` for the 'user' feature, showcasing dependency injection setup. It uses `fx.Provide` to register various components (Repository, Service, Controller, Route) and `fx.Invoke` to automatically execute the `RegisterRoute` function upon application startup.

```Go
	var Module = fx.Module("user",
		fx.Options(
			fx.Provide(
				NewRepository,
				NewService,
				NewController,
				NewRoute,
			),

			fx.Invoke(RegisterRoute),
		))
```

--------------------------------

### Using Predefined Common Errors in Go Handlers

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/devguide/HandlingErrors.md

This example shows how to integrate predefined errors from the `errorz` package into a Gin handler. It demonstrates using `responses.HandleError` with `errorz.ErrInvalidInput` to return consistent error responses based on application logic, improving code reusability and error handling standardization.

```Go
import (
    "github.com/gin-gonic/gin"
    "clean-architecture/pkg/errorz"
    "clean-architecture/pkg/framework"
    "clean-architecture/pkg/responses"
)

func ExampleHandler(c *gin.Context) {
    logger := framework.NewLogger()

    // Simulate an error condition
    if true { // Replace with actual condition
        responses.HandleError(logger, c, errorz.ErrInvalidInput)
        return
    }

    responses.SuccessJSON(c, http.StatusOK, "Operation successful")
}
```

--------------------------------

### Registering Routes with Fx Invoke in Go Module

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/devguide/AddingEndpoints.md

This Go snippet demonstrates how to register routes within an `fx.Module` using `fx.Invoke`. It ensures that the `RegisterRoute` function, responsible for setting up API endpoints, is automatically called as part of the application's dependency injection lifecycle when the application starts.

```Go
package user

import (
	"go.uber.org/fx"
)

// Module provides the dependencies for the user domain
var Module = fx.Module("user",
	fx.Provide(
		NewRepository,
		NewService,
		NewController,
		NewRoute,
	),
	fx.Invoke(RegisterRoute),
)
```

--------------------------------

### Handling Generic Errors in Go

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/devguide/HandlingErrors.md

This example illustrates `responses.HandleError` for processing generic Go errors. It logs the error and sends a `500 Internal Server Error` response by default for unhandled exceptions, ensuring robust error management and Sentry integration for analysis.

```Go
import (
	"github.com/gin-gonic/gin"
	"clean-architecture/pkg/errorz"
	"clean-architecture/pkg/framework"
	"clean-architecture/pkg/responses"
)

func GenericErrorHandler(c *gin.Context) {
	logger := framework.NewLogger()

	// Example of a generic error
	err := errors.New("Something went wrong")
	responses.HandleError(logger, c, err)
}
```

--------------------------------

### Handling Validation Errors in Go

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/devguide/HandlingErrors.md

This example demonstrates `responses.HandleValidationError`, which is used to process and respond to validation errors. It logs the error and sends a `400 Bad Request` HTTP response, providing a consistent way to inform clients about invalid input.

```Go
import (
	"github.com/gin-gonic/gin"
	"clean-architecture/pkg/framework"
	"clean-architecture/pkg/responses"
)

func ValidationErrorHandler(c *gin.Context) {
	logger := framework.NewLogger()
	err := errors.New("Invalid input data")
	responses.HandleValidationError(logger, c, err)
}
```

--------------------------------

### Sending Error JSON Response in Go

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/devguide/HandlingErrors.md

This example illustrates the use of `responses.ErrorJSON` to send an error-specific JSON response. It accepts the Gin context, an HTTP status code (e.g., `http.StatusBadRequest`), and an error message string, providing a standardized format for API errors.

```Go
import (
	"github.com/gin-gonic/gin"
	"clean-architecture/pkg/responses"
)

func ErrorHandler(c *gin.Context) {
	err := "Something went wrong"
	responses.ErrorJSON(c, http.StatusBadRequest, err)
}
```

--------------------------------

### Displaying Available Application Commands

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/README.md

This command executes the `main.go` entry point with the `-help` flag. It displays a list of all available commands and their descriptions, providing guidance on how to interact with the application's various functionalities.

```zsh
go run main.go -help
```

--------------------------------

### Generating Go Test Coverage Report

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/README.md

These commands first run all Go tests and generate a coverage profile (`cover.txt`) for all packages (`-coverpkg=./...`). The second command then uses the `go tool cover` to convert this profile into an HTML report (`index.html`), which can be opened in a browser to visualize code coverage.

```zsh
go test ./... -v -coverprofile cover.txt -coverpkg=./...
go tool cover -html=cover.txt -o index.html
```

--------------------------------

### Initializing Database Dependency in Go

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/devguide/AddingEndpoints.md

This Go function demonstrates how a dependency provider, `NewDatabase`, can return a non-pointer type (`Database`) while accepting a pointer type (`*framework.Env`). This illustrates the flexibility in dependency type handling within the `framework` package.

```Go
package infrastructure 

// NewDatabase creates a new database instance
func NewDatabase(logger framework.Logger, env *framework.Env) Database {
}
```

--------------------------------

### Implementing User Repository with Database Interaction in Go

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/devguide/AddingEndpoints.md

This Go code defines a `Repository` struct for the user domain, embedding `infrastructure.Database` to enable database operations. The `NewRepository` function provides dependency injection for the database and logger, while `ExampleMethod` demonstrates a basic database query using `r.DB.Find`.

```Go
package user

import (
	"clean-architecture/domain/models"
	"clean-architecture/pkg/framework"
	"clean-architecture/pkg/infrastructure"
)

// Repository represents the user repository structure
type Repository struct {
	infrastructure.Database
	logger framework.Logger
}

// NewRepository initializes a new user repository
func NewRepository(db infrastructure.Database, logger framework.Logger) Repository {
	return Repository{db, logger}
}

// ExampleMethod demonstrates a database query using infrastructure.Database
func (r *Repository) ExampleMethod() error {
	r.logger.Info("[Repository...ExampleMethod]")

	var users []models.User
	err := r.DB.Find(&users).Error
	if err != nil {
		return err 
	}

	return nil
}
```

--------------------------------

### Running All Go Tests

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/README.md

This command executes all Go tests within the current module and its sub-packages (`./...`). The `-v` flag enables verbose output, showing the name of each test and its pass/fail status. This is used to verify the correctness and functionality of the application's components.

```zsh
go test ./... -v
```

--------------------------------

### Defining API Routes for User Feature in Go

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/devguide/AddingEndpoints.md

This Go snippet illustrates how to define API routes for a feature. It includes a `Route` struct holding dependencies, a `NewRoute` constructor for initialization, and a `RegisterRoute` function that uses the `infrastructure.Router` to group routes under `/api` and associate them with controller methods like `CreateUser` and `GetUserByID`.

```Go
package user

import (
	"clean-architecture/pkg/framework"
	"clean-architecture/pkg/infrastructure"
)

// Route struct
type Route struct {
	logger     framework.Logger
	handler    infrastructure.Router
	controller *Controller
}

// NewRoute initializes a new Route instance
func NewRoute(
	logger framework.Logger,
	handler infrastructure.Router,
	controller *Controller,
) *Route {
	return &Route{
		handler:    handler,
		logger:     logger,
		controller: controller,
	}
}

// RegisterRoute sets up the routes for the feature
func RegisterRoute(r *Route) {
	r.logger.Info("Setting up routes")

	api := r.handler.Group("/api")

	api.POST("/user", r.controller.CreateUser)
	api.GET("/user/:id", r.controller.GetUserByID)
}
```

--------------------------------

### Capturing Unhandled Exceptions with Sentry in Go

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/devguide/UnhandledExceptions.md

This Go function demonstrates how to capture unhandled exceptions (panics) using `defer` and `recover` within a Gin context. It utilizes `utils.CurrentSentryService.CaptureException` to send the recovered error to Sentry, ensuring that application crashes are logged for debugging. The function also returns a generic JSON error response to the client.

```Go
import (
	"errors"
	"github.com/gin-gonic/gin"
	"clean-architecture/pkg/utils"
)

func ExampleUnhandledExceptionHandler(c *gin.Context) {
	defer func() {
		if r := recover(); r != nil {
			err := errors.New("Unhandled exception occurred")
			utils.CurrentSentryService.CaptureException(err)
			c.JSON(500, gin.H{"error": "An unexpected error occurred. Please try again later."})
		}
	}()

	// Simulate an unhandled exception
	panic("Simulated panic")
}
```

--------------------------------

### Defining User Database Model in Go with GORM

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/devguide/AddingEndpoints.md

This Go snippet defines a `User` struct as a GORM model, showcasing common field types, JSON and GORM tags for database mapping and serialization. It includes a `BeforeCreate` hook to automatically generate a UUID for new records and a `TableName` method to explicitly set the database table name.

```Go
package models

import (
	"clean-architecture/domain/constants"
	"clean-architecture/pkg/types"

	_ "ariga.io/atlas-provider-gorm/gormschema"

	"github.com/google/uuid"
	"gorm.io/gorm"
)

// User model
type User struct {
	gorm.Model
	UUID       types.BinaryUUID `json:"uuid" gorm:"index;notnull;unique"`
	CognitoUID *string          `json:"-" gorm:"index;size:50;unique"`

	FirstName   string `json:"first_name" gorm:"size:255"`
	LastName    string `json:"last_name" gorm:"size:255"`

	Email string             `json:"email" gorm:"notnull;index,unique;size:255"`
	Role  constants.UserRole `json:"role" gorm:"size:25" copier:"-"`
}

// BeforeCreate auto generate uuid before creating if it's not present already
func (u *User) BeforeCreate(tx *gorm.DB) error {
	if u.UUID.String() == (types.BinaryUUID{}).String() {
		id, err := uuid.NewRandom()
		u.UUID = types.BinaryUUID(id)
		return err
	}
	return nil
}

func (*User) TableName() string {
	return "users"
}
```

--------------------------------

### Sending Basic JSON Response in Go

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/devguide/HandlingErrors.md

This snippet demonstrates how to send a generic JSON response using the `responses.JSON` function. It takes the Gin context, an HTTP status code, and a data payload, typically a map or struct, to construct the response body.

```Go
import (
	"github.com/gin-gonic/gin"
	"clean-architecture/pkg/responses"
)

func ExampleHandler(c *gin.Context) {
	data := map[string]string{"message": "Hello, World!"}
	responses.JSON(c, http.StatusOK, data)
}
```

--------------------------------

### Sending Success JSON Response in Go

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/devguide/HandlingErrors.md

This snippet shows how to use `responses.SuccessJSON` for sending successful operation responses. It takes the Gin context, an HTTP status code (e.g., `http.StatusOK`), and a success message string, ensuring consistent positive feedback from the API.

```Go
import (
	"github.com/gin-gonic/gin"
	"clean-architecture/pkg/responses"
)

func SuccessHandler(c *gin.Context) {
	msg := "Operation successful"
	responses.SuccessJSON(c, http.StatusOK, msg)
}
```

--------------------------------

### Discovering All Go Module Updates

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/UPDATING_DEPENDENCIES.md

This command lists all modules that are dependencies of the current Go module, along with their current version and the latest available version. It provides a comprehensive overview of potential updates across the entire dependency tree.

```zsh
go list -m -u all
```

--------------------------------

### Handling Custom API Errors in Go

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/devguide/HandlingErrors.md

This snippet shows `responses.HandleError` being used with a custom `errorz.APIError`. It demonstrates how to process predefined API errors, such as 'Resource not found', ensuring that specific HTTP status codes and messages are returned consistently.

```Go
import (
	"github.com/gin-gonic/gin"
	"clean-architecture/pkg/errorz"
	"clean-architecture/pkg/framework"
	"clean-architecture/pkg/responses"
)

func APIErrorHandler(c *gin.Context) {
	logger := framework.NewLogger()

	// Example of a custom API error
	apiErr := &errorz.APIError{
		StatusCode: 404,
		Message:    "Resource not found",
	}

	responses.HandleError(logger, c, apiErr)
}
```

--------------------------------

### Defining Centralized Common Errors in Go

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/devguide/HandlingErrors.md

This snippet demonstrates how to define common, reusable API errors within the `errorz` package. It centralizes error definitions like `ErrUnauthorized` and `ErrResourceNotFound` with specific HTTP status codes and messages, promoting consistency and maintainability across the application.

```Go
package errorz

import "net/http"

var (
    ErrUnauthorized = &APIError{
        StatusCode: http.StatusUnauthorized,
        Message:    "Unauthorized access",
    }

    ErrResourceNotFound = &APIError{
        StatusCode: http.StatusNotFound,
        Message:    "The requested resource was not found",
    }

    ErrInvalidInput = &APIError{
        StatusCode: http.StatusBadRequest,
        Message:    "Invalid input provided",
    }
}
```

--------------------------------

### Discovering Specific Go Module Updates

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/UPDATING_DEPENDENCIES.md

This command displays the latest available version for a specified Go module. It is useful for quickly checking for updates for a single dependency without listing all modules, providing targeted version information.

```zsh
go list -m -u example.com/theirmodule
```

--------------------------------

### Synchronizing Go Module Dependencies

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/UPDATING_DEPENDENCIES.md

This command cleans up the `go.mod` file by removing unused dependencies and adding any missing ones required by the source code. It ensures the `go.mod` and `go.sum` files accurately reflect the project's current dependency graph.

```zsh
go mod tidy
```

--------------------------------

### Updating All Go Module Dependencies

Source: https://github.com/wesionaryteam/go_clean_architecture/blob/develop/UPDATING_DEPENDENCIES.md

This command updates all direct and indirect dependencies of the current Go module to their latest compatible versions. It's typically the initial step in a comprehensive dependency update process, ensuring all modules are brought up to date.

```zsh
go get -u
```
Tokens:
Raw