Project Structure

import { StrictMode } from 'react'
import { createRoot } from 'react-dom/client'
import './index.css'
import App from './App.tsx'

createRoot(document.getElementById('root')!).render(
  <StrictMode>
    <App />
  </StrictMode>,
)

import { useState } from 'react'
import './App.css'

function App() {
  const [count, setCount] = useState(0)

  return (
    <>
      <h1>Vite + React</h1>
      <div className="card">
        <button onClick={() => setCount((count) => count + 1)}>
          count is {count}
        </button>
      </div>
    </>
  )
}

export default App

@tailwind base;
@tailwind components;
@tailwind utilities;

package main

import (
  "fmt"
  "log"
  _ "time/tzdata"

  "backend/auth"
  "backend/configs"

  _ "github.com/joho/godotenv/autoload"
  "github.com/labstack/echo/v4"
  "github.com/labstack/echo/v4/middleware"
)

func main() {
  var app = echo.New()
  app.Use(middleware.Logger())
  app.Use(middleware.Recover())
  app.Use(middleware.CORS())

  configs.ConnectDB()

  // public routes
  app.POST("/register", auth.HandleUserRegistration)
  app.POST("/login", auth.HandleUserLogin)

  port := fmt.Sprintf(":%s", configs.EnvPort())
  log.Fatal(app.Start(port))
}

package users

import (
  "context"
  "time"
  "backend/configs"
  "go.mongodb.org/mongo-driver/bson"
)

type User struct {
  ID          string    `json:"id" bson:"_id"`
  Email       string    `json:"email" bson:"email"`
  Phone       string    `json:"phone" bson:"phone"`
  Password    []byte    `json:"password" bson:"password"`
  Role        string    `json:"role" bson:"role"`
  Status      string    `json:"status" bson:"status"`
  AccountType string    `json:"account_type" bson:"account_type"`
  CreatedAt   time.Time `json:"created_at" bson:"created_at"`
  UpdatedAt   time.Time `json:"updated_at" bson:"updated_at"`
}

func (u *User) CreateNewUser() error {
  _, err := configs.StoreRequestInDb(*u, "users")
  if err != nil {
    return err
  }
  return nil
}

func GetUserByEmail(email string) (User, error) {
  var user User
  err := configs.MI.DB.Collection("users").FindOne(
    context.TODO(), 
    bson.M{"email": email},
  ).Decode(&user)
  if err != nil {
    return user, err
  }
  return user, nil
}

package auth

import (
  "fmt"
  "time"
  "backend/users"
  "github.com/google/uuid"
  "golang.org/x/crypto/bcrypt"
)

func processUserLogin(email, password string) (string, bool, error) {
  user, err := users.GetUserByEmail(email)
  if err != nil {
    return "", false, err
  }
  if user.Status != "active" {
    return "", false, fmt.Errorf("user is not active")
  }
  errr := bcrypt.CompareHashAndPassword(user.Password, []byte(password))
  if errr != nil {
    return "", false, fmt.Errorf("the password provided is not valid")
  }

  return user.ID, true, nil
}

func createNewUser(email string, password []byte) (users.User, error) {
  uid := uuid.New().String()
  hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), 14)
  if err != nil {
    return users.User{}, err
  }
  user := users.User{
    Email:     email,
    Status:    "pending",
    Password:  hashedPassword,
    ID:        uid,
    CreatedAt: time.Now(),
  }
  err = user.CreateNewUser()
  if err != nil {
    return users.User{}, err
  }
  return user, nil
}

package auth

import (
  "backend/configs"
  "backend/users"
  "net/http"
  "time"
  "github.com/golang-jwt/jwt/v5"
  "github.com/labstack/echo/v4"
)

type Claims struct {
  Name   string `json:"name"`
  UserId string `json:"user_id"`
  jwt.Claims
}

func GenerateTokensAndSetCookies(user *users.User, c echo.Context) (string, error) {
  accessToken, exp, err := generateAccessToken(user)
  if err != nil {
    return "", err
  }

  setTokenCookie(accessTokenCookieName, accessToken, exp, c)
  setUserCookie(user, exp, c)

  return accessToken, nil
}

func generateToken(user *users.User, expirationTime time.Time, secret []byte) (string, time.Time, error) {
  claims := &Claims{
    UserId: user.ID,
    Claims: jwt.MapClaims{
      "exp": expirationTime.Unix(),
    },
  }

  token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
  tokenString, err := token.SignedString(secret)
  if err != nil {
    return "", time.Now(), err
  }

  return tokenString, expirationTime, nil
}

package configs

import (
  "context"
  "fmt"
  "log"
  "go.mongodb.org/mongo-driver/bson"
  "go.mongodb.org/mongo-driver/mongo"
  "go.mongodb.org/mongo-driver/mongo/options"
)

type MongoInstance struct {
  Client *mongo.Client
  DB     *mongo.Database
}

var MI MongoInstance

func ConnectDB() {
  dbName := fmt.Sprintf("%s-backend", AppEnv())
  serverAPI := options.ServerAPI(options.ServerAPIVersion1)
  opts := options.Client().ApplyURI(EnvMongoURI()).SetServerAPIOptions(serverAPI)
  client, err := mongo.Connect(context.TODO(), opts)
  if err != nil {
    log.Fatalf(err.Error())
  }

  var result bson.M
  if err := client.Database(dbName).RunCommand(
    context.TODO(), 
    bson.D{{Key: "ping", Value: 1}},
  ).Decode(&result); err != nil {
    log.Fatalf(err.Error())
  }
  fmt.Println("Pinged your deployment. You successfully connected to MongoDB!")

  MI = MongoInstance{
    Client: client,
    DB:     client.Database(dbName),
  }
}