<>

Table of Contents

1. Overview
2. Installation
3. Usage
4. Configuration
5. Testing
6. Deployment
7. Contributing
8. License

Overview

Structure of the project:

┣📦 .github                      # Github actions
┃
┣📦 cmd                          # Command line
┃ ┗ 📂 api
┃    ┗ 📂 server                 # Setup routes, middlewares, services,...
┃    ┣ 📂 test                   # Integration tests
┃    ┗ 📜 main.go                # Api entry point
┣ 📦 config                        # Configuration
┃    ┣ 📜 env.go                 # Environment setup
┃    ┗ 📜 logger.go              # Logger setup: zerolog, openobserve, stdout
┣ 📦 constants                    # Constants: errors, mail, ...
┣ 📦 docs                         # Documents
┣ 📦 internal                     # Internal packages
┃    ┣ 📂 health                 # Health module
┃    ┃   ┣ 📜 health.go          # Health check handler
┃    ┃   ┗ 📜 route.go           # Health check route
┃    ┣ 📂 user
┃    ┃    ┣ 📂 services
┃    ┃    ┃   ┣ 📜 user.go       # User service
┃    ┃    ┃   ┗ 📜 user_test.go  # User service test
┃    ┃    ┗ 📂 handler
┃    ┃        ┣ 📜 user.go       # User handler
┃    ┃        ┗ 📜 user_test.go  # User handler test
┃    ┗ 📂 middlleware            # Middlewares
┣ 📦 pkg                          # Public packages
┃    ┣ 📂 db
┃    ┃   ┣ 📂 models             # Database models
┃    ┃   ┗ 📜 init.go            # Database connection
┃    ┣ 📂 openobserve            # Openobserve
┃    ┗ 📂 utils                  # Utilities
┃
┣ 📜 .air.toml                    # Air configuration
┣ 📜 .env.example                 # Env example
┣ 📜 .gitignore                   # Git ignore
┣ 📜 app.compose.yml              # App docker compose
┣ 📜 compose.yml                  # Docker compose
┣ 📜 Dockerfile                    # Dockerfile
┣ 📜 go.mod                       # Go modules
┣ 📜 go.sum                       # Go modules
┣ 📜 Makefile                      # Makefile
┗ 📜 README.md                    # Readme

Installation

1. Clone the repository
2. Install dependencies

• go mod tidy
• Install Air for hot reload: go install github.com/cosmtrek/air@latest

3. Set up configuration (if any)

• Copy .env.example to .env and update the values

SQLC

1. Migrate

Usage

• Run bootstrapping: make compose to start the services
  1. This will start the Openobserve service that runs on port 5080
     • You can access the Openobserve dashboard at http://localhost:5080
     • Login with the default email and password in compose.yml, or update the values
     • Access the Ingestion API - Trace
     • Copy the Authorization header value and update the OPENOBSERVE_CREDENTIAL in the .env file
     • Access the Trace Tab to view the traces
  2. This will start the MongoDB service that runs on port 27017
     • Access the MongoDB connection string and update the MONGO_URI in the .env file
• Run the application: make run
• Run the application with hot reload: make watch
• Run application with Docker: make start
• Stop the docker container: make stop
• Shutdown and clean up: make shutdown
• Restart the application: make restart

Configuration

• Update the configuration in the .env file
• Update the logger configuration in config/logger.go
• Update the environment setup in config/env.go
• Update the database connection in pkg/db/init.go
• Update the database models in pkg/db/models
• Add new routes in cmd/api/server/routes.go
• Add new services in internal/<module>/services
• Add new handlers in internal/<module>/handlers
• Add new middlewares in internal/middleware
• Add new constants in constants
• If you want to add new packages, add them in pkg such as pkg/<package>: jwt, cookie, mail, cache, oauth, s3, ...

Testing

• Run tests: make test
• Run tests with coverage: make coverage

Deployment

• With existing Dockerfile, you can deploy the application to any cloud provider
• Update the Dockerfile if needed

Contributing

• Fork the repository
• Create a new branch
• Make your changes
• Create a pull request

License