Forem: MOHAMED FAWAS

E-Commerce Platform with Golang : Setting Up Go Modules and Initial Configurations

MOHAMED FAWAS — Fri, 04 Oct 2024 12:21:31 +0000

Here I have provided a step-by-step guide on how to set up the project

Create the project directory

mkdir rmshop-clean-architecture
cd rmshop-clean-architecture

Initialize Go modules

go mod init github.com/yourusername/rmshop-clean-architecture

Set up the main application entry point (cmd/api/main.go)

package main

import (
    "log"
    "net/http"

    "github.com/yourusername/rmshop-clean-architecture/internal/config"
    "github.com/yourusername/rmshop-clean-architecture/internal/server"
)

func main() {
    cfg, err := config.Load()
    if err != nil {
        log.Fatalf("Failed to load config: %v", err)
    }

    srv, err := server.New(cfg)
    if err != nil {
        log.Fatalf("Failed to create server: %v", err)
    }

    log.Printf("Starting server on :%s", cfg.Server.Port)
    if err := http.ListenAndServe(":"+cfg.Server.Port, srv); err != nil {
        log.Fatalf("Failed to start server: %v", err)
    }
}

Create a basic configuration file (internal/config/config.go)

package config

import "github.com/spf13/viper"

type Config struct {
    Server ServerConfig
    DB     DBConfig
}

type ServerConfig struct {
    Port string
}

type DBConfig struct {
    Host     string
    Port     string
    User     string
    Password string
    DBName   string
}

func Load() (*Config, error) {
    viper.SetConfigName("config")
    viper.SetConfigType("yaml")
    viper.AddConfigPath(".")
    viper.AddConfigPath("./config")

    if err := viper.ReadInConfig(); err != nil {
        return nil, err
    }

    var config Config
    if err := viper.Unmarshal(&config); err != nil {
        return nil, err
    }

    return &config, nil
}

Create a config.yaml file in the project root


server:
  port: "8080"

db:
  host: "localhost"
  port: "5432"
  user: "postgres"
  password: "your_password"
  dbname: "rmshop"

Initialize the basic server setup (internal/server/server.go)

package server

import (
    "net/http"

    "github.com/yourusername/rmshop-clean-architecture/internal/config"
)

type Server struct {
    router http.Handler
}

func New(cfg *config.Config) (*Server, error) {
    // Initialize your router, database connection, and other dependencies here
    // For now, we'll just return a basic server
    return &Server{
        router: http.NewServeMux(),
    }, nil
}

func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    s.router.ServeHTTP(w, r)
}

Install necessary dependencies

go get github.com/spf13/viper
go get github.com/lib/pq

This setup provides a solid foundation for your e-commerce project, adhering to clean architecture principles. In the next sections, we'll build upon this structure to implement our business logic, database interactions, and API endpoints.

E-Commerce Platform with Golang : Project Directory Structure

MOHAMED FAWAS — Fri, 04 Oct 2024 12:15:05 +0000

Our e-commerce platform will follow this directory structure

rmshop-clean-architecture/
│
├── cmd/
│   ├── api/
│   │   └── main.go                 # Main application entry point
│   └── seedadmin/
│       └── main.go                 # Admin seeding command
│
├── internal/
│   ├── config/
│   │   └── config.go               # Application configuration
│   │
│   ├── delivery/
│   │   └── http/
│   │       ├── handlers/
│   │       │   ├── user_handler.go
│   │       │   ├── admin_handler.go
│   │       │   ├── product_handler.go
│   │       │   └── ...
│   │       ├── middleware/
│   │       │   ├── auth.go
│   │       │   └── ...
│   │       └── routes.go
│   │
│   ├── domain/
│   │   ├── user.go
│   │   ├── product.go
│   │   └── ...
│   │
│   ├── repository/
│   │   ├── interfaces.go
│   │   └── postgres/
│   │       ├── user_repository.go
│   │       ├── product_repository.go
│   │       └── ...
│   │
│   ├── usecase/
│   │   ├── user_usecase.go
│   │   ├── product_usecase.go
│   │   └── ...
│   │
│   └── server/
│       └── server.go
│
├── pkg/
│   ├── auth/
│   │   └── jwt.go
│   ├── database/
│   │   ├── migrations.go
│   │   └── postgres.go
│   └── ...
│
├── migrations/
│   ├── 001_create_users_table.up.sql
│   ├── 001_create_users_table.down.sql
│   └── ...
│
├── go.mod
├── go.sum
└── README.md

This structure adheres to clean architecture principles

cmd/: Contains the main applications of the project.
internal/: Houses the core application code, inaccessible to other projects.
config/: Application configuration.
delivery/: Handles how the data is presented to and received from the user.
domain/: Defines core business logic and entities.
repository/: Handles data storage and retrieval.
usecase/: Contains application-specific business rules.
server/: Manages the HTTP server setup.
pkg/: Shared packages that can be used by external applications.
migrations/: Database migration files.

E-Commerce Platform with Golang : Understanding clean architecture

MOHAMED FAWAS — Fri, 04 Oct 2024 12:10:39 +0000

Understanding Clean Architecture

Clean Architecture, popularized by Robert C. Martin, is a software design philosophy that separates the elements of a design into ring levels. The main rule of clean architecture is that code dependencies can only move from the outer levels inward. This means that:

Business rules don't depend on UI or database.
Business rules don't know anything about the outside world.
The UI can change without changing the rest of the system.
The database can be swapped out without affecting the business rules.

Benefits of Clean Architecture

Independence of framework: The architecture doesn't depend on the existence of some library of feature-laden software.
Testability: The business rules can be tested without the UI, database, web server, or any other external element.
Independence of UI: The UI can change easily, without changing the rest of the system.
Independence of Database: You can swap out PostgreSQL for MongoDB, or something else entirely, without affecting the business rules.
Independence of any external agency: Your business rules don't know anything about the outside world.

Building a Robust E-Commerce Platform with Go, Clean Architecture, and PostgreSQL

MOHAMED FAWAS — Fri, 04 Oct 2024 10:24:31 +0000

Overview

Our goal is to develop a comprehensive e-commerce solution that can handle everything from product management to order processing. This platform will serve as a robust foundation for online businesses, capable of scaling to meet growing demands and adapting to changing market needs.

Key features of our e-commerce platform include:

User authentication and profile management
Product catalog with categories and subcategories
Shopping cart functionality
Secure checkout process with multiple payment options (cash on delivery and razorpay)
Order management
Inventory management
Coupon and discount system
Wishlist functionality
Admin panel for sales management

Technologies and Architecture

For this project, we're leveraging a powerful stack of modern technologies:

Go (Golang): Our backend is built entirely in Go, known for its performance, simplicity, and excellent support for concurrent operations.
PostgreSQL: As our primary database, PostgreSQL offers robust features for handling complex data relationships and transactions.
Clean Architecture: We're structuring our application following clean architecture principles, ensuring our code is modular, testable, and maintainable.
JWT (JSON Web Tokens): For secure authentication and authorization.
Razorpay: Integrated for handling secure online payments.
Cloudinary: For efficient management and delivery of product images.

What's Next?

In the upcoming posts, we'll dive deep into each aspect of our e-commerce platform. We'll start by setting up our project structure, implementing our database schema, and gradually building out each feature.

Whether you're a seasoned Go developer looking to explore clean architecture, or you're new to e-commerce development, this series will provide valuable insights and practical knowledge you can apply to your own projects.

Stay tuned for our next post, where we'll set up the project structure and lay the groundwork for our e-commerce platform!