feat: making register, login authentication and connect to whatsapp by terminal qrcode

.env.example

@@ -0,0 +1,10 @@
+DB_HOST = 
+DB_USER = 
+DB_PASSWORD = 
+DB_PORT = 
+DB_NAME =
+HOST_ADDRESS = 
+HOST_PORT = 
+SALT = 
+LOG_PATH = 
+JWT_SECRET_KEY = 

config/database_config.go

@@ -3,7 +3,6 @@ package config
 import (
 	"fmt"
 	"log"
-	"strings"
 
 	"gorm.io/driver/postgres"
 	"gorm.io/gorm"
@@ -13,24 +12,13 @@ type DatabaseConfig interface {
 	AutoMigrateAll(entities ...interface{}) error
 	GetInstance() *gorm.DB
 }
-
 type databaseConfig struct {
 	db *gorm.DB
 }
 
 func NewDatabaseConfig(DB_HOST, DB_USER, DB_PASSWORD, DB_NAME, DB_PORT string) DatabaseConfig {
-	// Clean inputs to remove accidental whitespace from secrets
-	DB_HOST = strings.TrimSpace(DB_HOST)
-	DB_USER = strings.TrimSpace(DB_USER)
-	DB_PASSWORD = strings.TrimSpace(DB_PASSWORD)
-	DB_NAME = strings.TrimSpace(DB_NAME)
-	DB_PORT = strings.TrimSpace(DB_PORT)
-
-	// Debug logging to see connection details (quoted to spot hidden spaces)
-	log.Printf("Connecting to DB: Host='%s' User='%s' Port='%s' DBName='%s'", DB_HOST, DB_USER, DB_PORT, DB_NAME)
-
 	dsn := fmt.Sprintf(
-		"host=%s user=%s password=%s dbname=%s port=%s TimeZone=Asia/Jakarta ",
+		"host=%s user=%s password=%s dbname=%s port=%s sslmode=disable TimeZone=Asia/Jakarta ",
 		DB_HOST, DB_USER, DB_PASSWORD, DB_NAME, DB_PORT,
 	)
 
@@ -61,4 +49,4 @@ func (cfg *databaseConfig) AutoMigrateAll(entities ...interface{}) error {
 
 func (cfg *databaseConfig) GetInstance() *gorm.DB {
 	return cfg.db
-}
+}

config/env_config.go

@@ -2,6 +2,9 @@ package config
 
 import (
 	"os"
+	"strconv"
+	"strings"
+
 	"github.com/joho/godotenv"
 )
 
@@ -10,12 +13,16 @@ type EnvConfig interface {
 	GetLogPath() string
 	GetHostAddress() string
 	GetHostPort() string
+	GetEmailVerificationDuration() int
 	GetDatabaseHost() string
 	GetDatabasePort() string
 	GetDatabaseUser() string
 	GetDatabasePassword() string
 	GetDatabaseName() string
 	GetSalt() string
+	GetSupabaseURL() string
+	GetSupabaseKey() string
+	GetSupabaseBucket() string
 }
 
 type envConfig struct {
@@ -31,7 +38,12 @@ func NewEnvConfig(timezone string) EnvConfig {
 }
 
 func (e *envConfig) GetTCPAddress() string {
-	return os.Getenv("HOST_ADDRESS") + ":" + os.Getenv("HOST_PORT")
+	host := os.Getenv("HOST_ADDRESS")
+	port := os.Getenv("HOST_PORT")
+	if port == "" {
+		port = "8080"
+	}
+	return host + ":" + port
 }
 
 func (e *envConfig) GetLogPath() string {
@@ -46,6 +58,14 @@ func (e *envConfig) GetHostPort() string {
 	return os.Getenv("HOST_PORT")
 }
 
+func (e *envConfig) GetEmailVerificationDuration() int {
+	duration, err := strconv.Atoi(os.Getenv("EMAIL_VERIFICATION_DURATION"))
+	if err != nil {
+		return 0 // Default value if parsing fails
+	}
+	return duration
+}
+
 func (e *envConfig) GetDatabaseHost() string {
 	return os.Getenv("DB_HOST")
 }
@@ -73,3 +93,15 @@ func (e *envConfig) GetSalt() string {
 	}
 	return salt
 }
+
+func (e *envConfig) GetSupabaseURL() string {
+	return strings.TrimSpace(os.Getenv("SUPABASE_URL"))
+}
+
+func (e *envConfig) GetSupabaseKey() string {
+	return strings.TrimSpace(os.Getenv("SUPABASE_SERVICE_KEY"))
+}
+
+func (e *envConfig) GetSupabaseBucket() string {
+	return strings.TrimSpace(os.Getenv("SUPABASE_BUCKET_NAME"))
+}

controllers/auth_controller.go

@@ -0,0 +1,53 @@
+package controllers
+
+import (
+	"whatsapp-backend/models/dto"
+	"whatsapp-backend/services"
+	"whatsapp-backend/utils"
+	"github.com/gin-gonic/gin"
+)
+
+type AuthController interface {
+	Register(ctx *gin.Context)
+	Login(ctx *gin.Context)
+}
+
+type authController struct {
+	authService services.AuthService
+}
+
+func NewAuthController(authService services.AuthService) AuthController {
+	return &authController{authService: authService}
+}
+
+func (c *authController) Register(ctx *gin.Context) {
+	var req dto.RegisterRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		utils.SendResponse[any, any](ctx, nil, nil, err)
+		return
+	}
+
+	resp, err := c.authService.Register(req)
+	if err != nil {
+		utils.SendResponse[any, any](ctx, nil, nil, err)
+		return
+	}
+
+	utils.SendResponse[dto.AuthResponse, any](ctx, nil, *resp, nil)
+}
+
+func (c *authController) Login(ctx *gin.Context) {
+	var req dto.LoginRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		utils.SendResponse[any, any](ctx, nil, nil, err)
+		return
+	}
+
+	resp, err := c.authService.Login(req)
+	if err != nil {
+		utils.SendResponse[any, any](ctx, nil, nil, err)
+		return
+	}
+
+	utils.SendResponse[dto.AuthResponse, any](ctx, nil, *resp, nil)
+}

controllers/connection_controller.go

@@ -0,0 +1,89 @@
+package controllers
+
+import (
+	"context"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+
+	"whatsapp-backend/models/dto"
+	entity "whatsapp-backend/models/entity"
+	http_error "whatsapp-backend/models/error"
+	"whatsapp-backend/services"
+	"whatsapp-backend/utils"
+)
+
+type ConnectionController interface {
+	Connect(ctx *gin.Context)
+	GetStatus(ctx *gin.Context)
+}
+
+type connectionController struct {
+	connectionService services.ConnectionService
+}
+
+func NewConnectionController(connectionService services.ConnectionService) ConnectionController {
+	return &connectionController{connectionService}
+}
+
+func (cc *connectionController) Connect(ctx *gin.Context) {
+	// 1. Extract UserID from Context (set by AuthMiddleware)
+	userID, exists := ctx.Get("user_id")
+	if !exists {
+		utils.SendResponse[any, any](ctx, dto.AuthResponse{}, nil, http_error.UNAUTHORIZED)
+		return
+	}
+	accountID := userID.(uuid.UUID)
+
+	// 2. Bind JSON (Optional)
+	var req dto.ConnectRequest
+	_ = ctx.ShouldBindJSON(&req)
+
+	// 3. Trigger connection in background
+	go func() {
+		_ = cc.connectionService.Connect(context.Background(), accountID)
+	}()
+
+	// 4. Return Standardized Response
+	response := dto.ConnectResponse{
+		Message:   entity.CONNECTION_INIT_SUCCESS,
+		AccountID: accountID,
+		Details:   entity.QR_SCAN_INSTRUCTION,
+	}
+
+	utils.SendResponse[dto.ConnectResponse, any](ctx, dto.AuthResponse{}, response, nil)
+}
+
+func (cc *connectionController) GetStatus(ctx *gin.Context) {
+	userID, exists := ctx.Get("user_id")
+	if !exists {
+		utils.SendResponse[any, any](ctx, dto.AuthResponse{}, nil, http_error.UNAUTHORIZED)
+		return
+	}
+	accountID := userID.(uuid.UUID)
+
+	client, err := cc.connectionService.GetActiveClient(accountID)
+	if err != nil {
+		response := dto.ConnectionStatusResponse{
+			AccountID: accountID,
+			Status:    entity.WHATSAPP_STATUS_DISCONNECTED,
+		}
+		utils.SendResponse[dto.ConnectionStatusResponse, any](ctx, dto.AuthResponse{}, response, nil)
+		return
+	}
+
+	status := entity.WHATSAPP_STATUS_DISCONNECTED
+	if client.IsConnected() {
+		status = entity.WHATSAPP_STATUS_CONNECTED
+	} else if client.IsLoggedIn() {
+		status = entity.WHATSAPP_STATUS_CONNECTING
+	}
+
+	response := dto.ConnectionStatusResponse{
+		AccountID: accountID,
+		Status:    status,
+		JID:       client.Store.ID.String(),
+	}
+
+	utils.SendResponse[dto.ConnectionStatusResponse, any](ctx, dto.AuthResponse{}, response, nil)
+}

go.mod

@@ -3,18 +3,27 @@ module whatsapp-backend
 go 1.24.5
 
 require (
+	github.com/gin-contrib/gzip v1.2.5
 	github.com/gin-gonic/gin v1.11.0
+	github.com/golang-jwt/jwt/v5 v5.3.0
 	github.com/google/uuid v1.6.0
 	github.com/joho/godotenv v1.5.1
+	github.com/mdp/qrterminal/v3 v3.2.1
+	go.mau.fi/whatsmeow v0.0.0-20251217143725-11cf47c62d32
+	golang.org/x/crypto v0.46.0
 	gorm.io/driver/postgres v1.6.0
 	gorm.io/gorm v1.31.1
 )
 
 require (
+	filippo.io/edwards25519 v1.1.0 // indirect
+	github.com/beeper/argo-go v1.1.2 // indirect
 	github.com/bytedance/gopkg v0.1.3 // indirect
 	github.com/bytedance/sonic v1.14.2 // indirect
 	github.com/bytedance/sonic/loader v0.4.0 // indirect
 	github.com/cloudwego/base64x v0.1.6 // indirect
+	github.com/coder/websocket v1.8.14 // indirect
+	github.com/elliotchance/orderedmap/v3 v3.1.0 // indirect
 	github.com/gabriel-vasile/mimetype v1.4.12 // indirect
 	github.com/gin-contrib/sse v1.1.0 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
@@ -31,20 +40,27 @@ require (
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/klauspost/cpuid/v2 v2.3.0 // indirect
 	github.com/leodido/go-urn v1.4.0 // indirect
+	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
+	github.com/petermattis/goid v0.0.0-20251121121749-a11dd1a45f9a // indirect
 	github.com/quic-go/qpack v0.6.0 // indirect
 	github.com/quic-go/quic-go v0.58.0 // indirect
+	github.com/rs/zerolog v1.34.0 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.3.1 // indirect
-	go.uber.org/mock v0.6.0 // indirect
+	github.com/vektah/gqlparser/v2 v2.5.27 // indirect
+	go.mau.fi/libsignal v0.2.1 // indirect
+	go.mau.fi/util v0.9.4 // indirect
 	golang.org/x/arch v0.23.0 // indirect
-	golang.org/x/crypto v0.46.0 // indirect
+	golang.org/x/exp v0.0.0-20251209150349-8475f28825e9 // indirect
 	golang.org/x/net v0.48.0 // indirect
 	golang.org/x/sync v0.19.0 // indirect
 	golang.org/x/sys v0.39.0 // indirect
+	golang.org/x/term v0.38.0 // indirect
 	golang.org/x/text v0.32.0 // indirect
 	google.golang.org/protobuf v1.36.11 // indirect
+	rsc.io/qr v0.2.0 // indirect
 )

go.sum

@@ -1,3 +1,13 @@
+filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
+filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
+github.com/DATA-DOG/go-sqlmock v1.5.2 h1:OcvFkGmslmlZibjAjaHm3L//6LiuBgolP7OputlJIzU=
+github.com/DATA-DOG/go-sqlmock v1.5.2/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU=
+github.com/agnivade/levenshtein v1.2.1 h1:EHBY3UOn1gwdy/VbFwgo4cxecRznFk7fKWN1KOX7eoM=
+github.com/agnivade/levenshtein v1.2.1/go.mod h1:QVVI16kDrtSuwcpd0p1+xMC6Z/VfhtCyDIjcwga4/DU=
+github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883 h1:bvNMNQO63//z+xNgfBlViaCIJKLlCJ6/fmUseuG0wVQ=
+github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883/go.mod h1:rCTlJbsFo29Kk6CurOXKm700vrz8f0KW0JNfpkRJY/8=
+github.com/beeper/argo-go v1.1.2 h1:UQI2G8F+NLfGTOmTUI0254pGKx/HUU/etbUGTJv91Fs=
+github.com/beeper/argo-go v1.1.2/go.mod h1:M+LJAnyowKVQ6Rdj6XYGEn+qcVFkb3R/MUpqkGR0hM4=
 github.com/bytedance/gopkg v0.1.3 h1:TPBSwH8RsouGCBcMBktLt1AymVo2TVsBVCY4b6TnZ/M=
 github.com/bytedance/gopkg v0.1.3/go.mod h1:576VvJ+eJgyCzdjS+c4+77QF3p7ubbtiKARP3TxducM=
 github.com/bytedance/sonic v1.14.2 h1:k1twIoe97C1DtYUo+fZQy865IuHia4PR5RPiuGPPIIE=
@@ -6,11 +16,18 @@ github.com/bytedance/sonic/loader v0.4.0 h1:olZ7lEqcxtZygCK9EKYKADnpQoYkRQxaeY2N
 github.com/bytedance/sonic/loader v0.4.0/go.mod h1:AR4NYCk5DdzZizZ5djGqQ92eEhCCcdf5x77udYiSJRo=
 github.com/cloudwego/base64x v0.1.6 h1:t11wG9AECkCDk5fMSoxmufanudBtJ+/HemLstXDLI2M=
 github.com/cloudwego/base64x v0.1.6/go.mod h1:OFcloc187FXDaYHvrNIjxSe8ncn0OOM8gEHfghB2IPU=
+github.com/coder/websocket v1.8.14 h1:9L0p0iKiNOibykf283eHkKUHHrpG7f65OE3BhhO7v9g=
+github.com/coder/websocket v1.8.14/go.mod h1:NX3SzP+inril6yawo5CQXx8+fk145lPDC6pumgx0mVg=
+github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/elliotchance/orderedmap/v3 v3.1.0 h1:j4DJ5ObEmMBt/lcwIecKcoRxIQUEnw0L804lXYDt/pg=
+github.com/elliotchance/orderedmap/v3 v3.1.0/go.mod h1:G+Hc2RwaZvJMcS4JpGCOyViCnGeKf0bTYCGTO4uhjSo=
 github.com/gabriel-vasile/mimetype v1.4.12 h1:e9hWvmLYvtp846tLHam2o++qitpguFiYCKbn0w9jyqw=
 github.com/gabriel-vasile/mimetype v1.4.12/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s=
+github.com/gin-contrib/gzip v1.2.5 h1:fIZs0S+l17pIu1P5XRJOo/YNqfIuPCrZZ3TWB7pjckI=
+github.com/gin-contrib/gzip v1.2.5/go.mod h1:aomRgR7ftdZV3uWY0gW/m8rChfxau0n8YVvwlOHONzw=
 github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w=
 github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM=
 github.com/gin-gonic/gin v1.11.0 h1:OW/6PLjyusp2PPXtyxKHU0RbX6I/l28FTdDlae5ueWk=
@@ -27,6 +44,9 @@ github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
 github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
 github.com/goccy/go-yaml v1.19.1 h1:3rG3+v8pkhRqoQ/88NYNMHYVGYztCOCIZ7UQhu7H+NE=
 github.com/goccy/go-yaml v1.19.1/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
+github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
+github.com/golang-jwt/jwt/v5 v5.3.0 h1:pv4AsKCKKZuqlgs5sUmn4x8UlGa0kEVt/puTpKx9vvo=
+github.com/golang-jwt/jwt/v5 v5.3.0/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
@@ -52,8 +72,17 @@ github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzh
 github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
 github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
 github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
+github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-sqlite3 v1.14.32 h1:JD12Ag3oLy1zQA+BNn74xRgaBbdhbNIDYvQUEuuErjs=
+github.com/mattn/go-sqlite3 v1.14.32/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
+github.com/mdp/qrterminal/v3 v3.2.1 h1:6+yQjiiOsSuXT5n9/m60E54vdgFsw0zhADHhHLrFet4=
+github.com/mdp/qrterminal/v3 v3.2.1/go.mod h1:jOTmXvnBsMy5xqLniO0R++Jmjs2sTm9dFSuQ5kpz/SU=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
@@ -61,12 +90,20 @@ github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9G
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
 github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
 github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
+github.com/petermattis/goid v0.0.0-20251121121749-a11dd1a45f9a h1:VweslR2akb/ARhXfqSfRbj1vpWwYXf3eeAUyw/ndms0=
+github.com/petermattis/goid v0.0.0-20251121121749-a11dd1a45f9a/go.mod h1:pxMtw7cyUw6B2bRH0ZBANSPg+AoSud1I1iyJHI69jH4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/quic-go/qpack v0.6.0 h1:g7W+BMYynC1LbYLSqRt8PBg5Tgwxn214ZZR34VIOjz8=
 github.com/quic-go/qpack v0.6.0/go.mod h1:lUpLKChi8njB4ty2bFLX2x4gzDqXwUpaO1DP9qMDZII=
 github.com/quic-go/quic-go v0.58.0 h1:ggY2pvZaVdB9EyojxL1p+5mptkuHyX5MOSv4dgWF4Ug=
 github.com/quic-go/quic-go v0.58.0/go.mod h1:upnsH4Ju1YkqpLXC305eW3yDZ4NfnNbmQRCMWS58IKU=
+github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
+github.com/rs/zerolog v1.34.0 h1:k43nTLIwcTVQAncfCw4KZ2VY6ukYoZaBPNOE8txlOeY=
+github.com/rs/zerolog v1.34.0/go.mod h1:bJsvje4Z08ROH4Nhs5iH600c3IkWhwp44iRc54W6wYQ=
+github.com/sergi/go-diff v1.3.1 h1:xkr+Oxo4BOQKmkn/B9eMK0g5Kg/983T9DqqPHwYqD+8=
+github.com/sergi/go-diff v1.3.1/go.mod h1:aMJSSKb2lpPvRNec0+w3fl7LP9IOFzdc9Pa4NFbPK1I=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
@@ -83,19 +120,33 @@ github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS
 github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
 github.com/ugorji/go/codec v1.3.1 h1:waO7eEiFDwidsBN6agj1vJQ4AG7lh2yqXyOXqhgQuyY=
 github.com/ugorji/go/codec v1.3.1/go.mod h1:pRBVtBSKl77K30Bv8R2P+cLSGaTtex6fsA2Wjqmfxj4=
+github.com/vektah/gqlparser/v2 v2.5.27 h1:RHPD3JOplpk5mP5JGX8RKZkt2/Vwj/PZv0HxTdwFp0s=
+github.com/vektah/gqlparser/v2 v2.5.27/go.mod h1:D1/VCZtV3LPnQrcPBeR/q5jkSQIPti0uYCP/RI0gIeo=
+go.mau.fi/libsignal v0.2.1 h1:vRZG4EzTn70XY6Oh/pVKrQGuMHBkAWlGRC22/85m9L0=
+go.mau.fi/libsignal v0.2.1/go.mod h1:iVvjrHyfQqWajOUaMEsIfo3IqgVMrhWcPiiEzk7NgoU=
+go.mau.fi/util v0.9.4 h1:gWdUff+K2rCynRPysXalqqQyr2ahkSWaestH6YhSpso=
+go.mau.fi/util v0.9.4/go.mod h1:647nVfwUvuhlZFOnro3aRNPmRd2y3iDha9USb8aKSmM=
+go.mau.fi/whatsmeow v0.0.0-20251217143725-11cf47c62d32 h1:NeE9eEYY4kEJVCfCXaAU27LgAPugPHRHJdC9IpXFPzI=
+go.mau.fi/whatsmeow v0.0.0-20251217143725-11cf47c62d32/go.mod h1:S4OWR9+hTx+54+jRzl+NfRBXnGpPm5IRPyhXB7haSd0=
 go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y=
 go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU=
 golang.org/x/arch v0.23.0 h1:lKF64A2jF6Zd8L0knGltUnegD62JMFBiCPBmQpToHhg=
 golang.org/x/arch v0.23.0/go.mod h1:dNHoOeKiyja7GTvF9NJS1l3Z2yntpQNzgrjh1cU103A=
 golang.org/x/crypto v0.46.0 h1:cKRW/pmt1pKAfetfu+RCEvjvZkA9RimPbh7bhFjGVBU=
 golang.org/x/crypto v0.46.0/go.mod h1:Evb/oLKmMraqjZ2iQTwDwvCtJkczlDuTmdJXoZVzqU0=
+golang.org/x/exp v0.0.0-20251209150349-8475f28825e9 h1:MDfG8Cvcqlt9XXrmEiD4epKn7VJHZO84hejP9Jmp0MM=
+golang.org/x/exp v0.0.0-20251209150349-8475f28825e9/go.mod h1:EPRbTFwzwjXj9NpYyyrvenVh9Y+GFeEvMNh7Xuz7xgU=
 golang.org/x/net v0.48.0 h1:zyQRTTrjc33Lhh0fBgT/H3oZq9WuvRR5gPC70xpDiQU=
 golang.org/x/net v0.48.0/go.mod h1:+ndRgGjkh8FGtu1w1FGbEC31if4VrNVMuKTgcAAnQRY=
 golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
 golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.39.0 h1:CvCKL8MeisomCi6qNZ+wbb0DN9E5AATixKsvNtMoMFk=
 golang.org/x/sys v0.39.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/term v0.38.0 h1:PQ5pkm/rLO6HnxFR7N2lJHOZX6Kez5Y1gDSJla6jo7Q=
+golang.org/x/term v0.38.0/go.mod h1:bSEAKrOT1W+VSu9TSCMtoGEOUcKxOKgl3LE5QEF/xVg=
 golang.org/x/text v0.32.0 h1:ZD01bjUt1FQ9WJ0ClOL5vxgxOI/sVCNgX1YtKwcY0mU=
 golang.org/x/text v0.32.0/go.mod h1:o/rUWzghvpD5TXrTIBuJU77MTaN0ljMWE47kxGJQ7jY=
 google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
@@ -108,3 +159,5 @@ gorm.io/driver/postgres v1.6.0 h1:2dxzU8xJ+ivvqTRph34QX+WrRaJlmfyPqXmoGVjMBa4=
 gorm.io/driver/postgres v1.6.0/go.mod h1:vUw0mrGgrTK+uPHEhAdV4sfFELrByKVGnaVRkXDhtWo=
 gorm.io/gorm v1.31.1 h1:7CA8FTFz/gRfgqgpeKIBcervUn3xSyPUmr6B2WXJ7kg=
 gorm.io/gorm v1.31.1/go.mod h1:XyQVbO2k6YkOis7C2437jSit3SsDK72s7n7rsSHd+Gs=
+rsc.io/qr v0.2.0 h1:6vBLea5/NRMVTz8V66gipeLycZMl/+UlFmk8DvqQ6WY=
+rsc.io/qr v0.2.0/go.mod h1:IF+uZjkb9fqyeF/4tlBoynqmQxUoPfWEKh921coOuXs=

middleware/auth_middleware.go

@@ -0,0 +1,58 @@
+package middleware
+
+import (
+	"strings"
+	"whatsapp-backend/config"
+	http_error "whatsapp-backend/models/error"
+	"whatsapp-backend/utils"
+
+	"github.com/gin-gonic/gin"
+	"github.com/golang-jwt/jwt/v5"
+)
+
+type AuthMiddleware interface {
+	RequireAuth() gin.HandlerFunc
+}
+
+type authMiddleware struct {
+	jwtConfig config.JWTConfig
+}
+
+func NewAuthMiddleware(jwtConfig config.JWTConfig) AuthMiddleware {
+	return &authMiddleware{jwtConfig: jwtConfig}
+}
+
+func (m *authMiddleware) RequireAuth() gin.HandlerFunc {
+	return func(ctx *gin.Context) {
+		authHeader := ctx.GetHeader("Authorization")
+		if authHeader == "" {
+			utils.SendResponse[any, any](ctx, nil, nil, http_error.UNAUTHORIZED)
+			ctx.Abort()
+			return
+		}
+
+		tokenString := strings.Replace(authHeader, "Bearer ", "", 1)
+		token, err := jwt.ParseWithClaims(tokenString, &utils.JWTClaims{}, func(token *jwt.Token) (interface{}, error) {
+			return []byte(m.jwtConfig.GetSecretKey()), nil
+		})
+
+		if err != nil || !token.Valid {
+			utils.SendResponse[any, any](ctx, nil, nil, http_error.INVALID_TOKEN)
+			ctx.Abort()
+			return
+		}
+
+		claims, ok := token.Claims.(*utils.JWTClaims)
+		if !ok {
+			utils.SendResponse[any, any](ctx, nil, nil, http_error.INVALID_TOKEN)
+			ctx.Abort()
+			return
+		}
+
+		// Set user info in context
+		ctx.Set("user_id", claims.UserID)
+		ctx.Set("username", claims.Username)
+
+		ctx.Next()
+	}
+}

models/dto/auth_dto.go

@@ -0,0 +1,19 @@
+package dto
+
+import "github.com/google/uuid"
+
+type RegisterRequest struct {
+	Username string `json:"username" binding:"required,min=3"`
+	Password string `json:"password" binding:"required,min=6"`
+}
+
+type LoginRequest struct {
+	Username string `json:"username" binding:"required"`
+	Password string `json:"password" binding:"required"`
+}
+
+type AuthResponse struct {
+	Token    string    `json:"token"`
+	UserID   uuid.UUID `json:"user_id"`
+	Username string    `json:"username"`
+}

models/dto/connection_dto.go

@@ -0,0 +1,19 @@
+package dto
+
+import "github.com/google/uuid"
+
+type ConnectRequest struct {
+	// Add fields here if needed in the future, e.g. force refresh
+}
+
+type ConnectResponse struct {
+	Message   string    `json:"message"`
+	AccountID uuid.UUID `json:"account_id"`
+	Details   string    `json:"details"`
+}
+
+type ConnectionStatusResponse struct {
+	AccountID uuid.UUID `json:"account_id"`
+	Status    string    `json:"status"`
+	JID       string    `json:"jid,omitempty"`
+}

models/dto/http_response_dto.go

@@ -9,7 +9,7 @@ type SuccessResponse[TResponse any] struct {
 
 type ErrorResponse struct {
 	Status   string `json:"status"`
-	Error    error  `json:"errors"`
+	Error    any    `json:"errors"`
 	Message  any    `json:"message"`
 	MetaData any    `json:"meta_data"`
-}
+}

models/entity/constant.go

@@ -0,0 +1,11 @@
+package models
+
+const (
+	CONNECTION_SUCCESS_MESSAGE = "Connection initialized. Please scan the QR code in your terminal."
+	CONNECTION_INIT_SUCCESS    = "Connection process initiated successfully"
+	QR_SCAN_INSTRUCTION        = "Check terminal for QR code scanning"
+	POSTGRES_DIALECT           = "postgres"
+	WHATSAPP_STATUS_CONNECTED    = "connected"
+	WHATSAPP_STATUS_DISCONNECTED = "disconnected"
+	WHATSAPP_STATUS_CONNECTING   = "connecting"
+)

models/entity/entity.go

@@ -1 +1,22 @@
 package models
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+type WhatsAppAccount struct {
+	ID          uuid.UUID      `gorm:"primaryKey;type:uuid;default:gen_random_uuid()" json:"id"`
+	AccountName string         `gorm:"size:100;not null" json:"account_name"`
+	JID         string         `gorm:"column:jid;size:255;uniqueIndex" json:"jid"`
+	IsActive    bool           `gorm:"default:false" json:"is_active"`
+	CreatedAt   time.Time      `json:"created_at"`
+	UpdatedAt   time.Time      `json:"updated_at"`
+	DeletedAt   gorm.DeletedAt `gorm:"index" json:"deleted_at"`
+}
+
+func (WhatsAppAccount) TableName() string {
+	return "whatsapp_accounts"
+}

models/entity/user_entity.go

@@ -0,0 +1,21 @@
+package models
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+type User struct {
+	ID        uuid.UUID      `gorm:"primaryKey;type:uuid;default:gen_random_uuid()" json:"id"`
+	Username  string         `gorm:"size:100;uniqueIndex;not null" json:"username"`
+	Password  string         `gorm:"not null" json:"-"` // Do not return password in JSON
+	CreatedAt time.Time      `json:"created_at"`
+	UpdatedAt time.Time      `json:"updated_at"`
+	DeletedAt gorm.DeletedAt `gorm:"index" json:"deleted_at"`
+}
+
+func (User) TableName() string {
+	return "users"
+}

models/error/error.go

@@ -24,4 +24,20 @@ var (
 	EVENT_FINISHED              = errors.New("The event has ended, you were disallowed to do the exam!")
 	EVENT_NOT_STARTED           = errors.New("Take it easy, event hasn't starting yet! you cannot do the exam!")
 	EXAMS_SUBMITTED             = errors.New("You've submitted the exam, you were diasallowed to answer the question!")
+
+	// Auth Errors
+	ERR_USER_ALREADY_EXISTS     = errors.New("User already exists")
+	ERR_TOKEN_GENERATION_FAILED = errors.New("Failed to generate token")
+	ERR_USER_NOT_FOUND          = errors.New("User not found")
+	ERR_WRONG_PASSWORD          = errors.New("Wrong password")
+
+	// WhatsApp Connection Errors
+	ERR_INVALID_ACCOUNT_ID       = errors.New("Invalid account ID format")
+	ERR_CLIENT_INIT_FAILED       = errors.New("Failed to initialize WhatsApp client")
+	ERR_CLIENT_CONNECT_FAILED    = errors.New("Failed to connect to WhatsApp socket")
+	ERR_CLIENT_NOT_FOUND_FOR_ACC = errors.New("WhatsApp client not found for this account")
+	ERR_INVALID_JID              = errors.New("Invalid JID format")
+	ERR_DB_CONNECTION_FAILED     = errors.New("Failed to get database connection")
+	ERR_SQLSTORE_FAILED          = errors.New("Failed to initialize SQL store")
+	ERR_DEVICE_STORE_FAILED      = errors.New("Failed to retrieve device from store")
 )

provider/controller_provider.go

@@ -1,11 +1,32 @@
 package provider
 
+import "whatsapp-backend/controllers"
+
 type ControllerProvider interface {
+	ProvideConnectionController() controllers.ConnectionController
+	ProvideAuthController() controllers.AuthController
 }
 
 type controllerProvider struct {
+	connectionController controllers.ConnectionController
+	authController       controllers.AuthController
 }
 
 func NewControllerProvider(servicesProvider ServicesProvider) ControllerProvider {
-	return &controllerProvider{}
+
+	connectionController := controllers.NewConnectionController(servicesProvider.ProvideConnectionService())
+	authController := controllers.NewAuthController(servicesProvider.ProvideAuthService())
+
+	return &controllerProvider{
+		connectionController: connectionController,
+		authController:       authController,
+	}
+}
+
+func (c *controllerProvider) ProvideConnectionController() controllers.ConnectionController {
+	return c.connectionController
+}
+
+func (c *controllerProvider) ProvideAuthController() controllers.AuthController {
+	return c.authController
 }

provider/middleware_provider.go

@@ -1,11 +1,23 @@
 package provider
 
+import (
+	"whatsapp-backend/middleware"
+)
+
 type MiddlewareProvider interface {
+	ProvideAuthMiddleware() middleware.AuthMiddleware
 }
 
 type middlewareProvider struct {
+	authMiddleware middleware.AuthMiddleware
+}
+
+func NewMiddlewareProvider(servicesProvider ServicesProvider, configProvider ConfigProvider) MiddlewareProvider {
+	return &middlewareProvider{
+		authMiddleware: middleware.NewAuthMiddleware(configProvider.ProvideJWTConfig()),
+	}
 }
 
-func NewMiddlewareProvider(servicesProvider ServicesProvider) MiddlewareProvider {
-	return &middlewareProvider{}
+func (m *middlewareProvider) ProvideAuthMiddleware() middleware.AuthMiddleware {
+	return m.authMiddleware
 }

provider/provider.go

@@ -1,6 +1,8 @@
 package provider
 
 import (
+	entity "whatsapp-backend/models/entity"
+
 	"github.com/gin-gonic/gin"
 )
 
@@ -27,8 +29,13 @@ func NewAppProvider() AppProvider {
 	repositoriesProvider := NewRepositoriesProvider(configProvider)
 	servicesProvider := NewServicesProvider(repositoriesProvider, configProvider)
 	controllerProvider := NewControllerProvider(servicesProvider)
-	middlewareProvider := NewMiddlewareProvider(servicesProvider)
-	// configProvider.ProvideDatabaseConfig().AutoMigrateAll()
+	middlewareProvider := NewMiddlewareProvider(servicesProvider, configProvider)
+
+	// Auto-Migrate Entities
+	_ = configProvider.ProvideDatabaseConfig().AutoMigrateAll(
+		&entity.WhatsAppAccount{},
+		&entity.User{},
+	)
 
 	return &appProvider{
 		ginRouter:            ginRouter,

provider/repositories_provider.go

@@ -1,11 +1,32 @@
 package provider
 
+import "whatsapp-backend/repositories"
+
 type RepositoriesProvider interface {
+	ProvideConnectionRepository() repositories.ConnectionRepository
+	ProvideAuthRepository() repositories.AuthRepository
 }
 
 type repositoriesProvider struct {
+	connectionRepository repositories.ConnectionRepository
+	authRepository       repositories.AuthRepository
 }
 
 func NewRepositoriesProvider(cfg ConfigProvider) RepositoriesProvider {
-	return &repositoriesProvider{}
+	db := cfg.ProvideDatabaseConfig().GetInstance()
+	connectionRepository, _ := repositories.NewConnectionRepository(db)
+	authRepository := repositories.NewAuthRepository(db)
+
+	return &repositoriesProvider{
+		connectionRepository: connectionRepository,
+		authRepository:       authRepository,
+	}
+}
+
+func (rp *repositoriesProvider) ProvideConnectionRepository() repositories.ConnectionRepository {
+	return rp.connectionRepository
+}
+
+func (rp *repositoriesProvider) ProvideAuthRepository() repositories.AuthRepository {
+	return rp.authRepository
 }

provider/services_provider.go

@@ -1,11 +1,31 @@
 package provider
 
+import "whatsapp-backend/services"
+
 type ServicesProvider interface {
+	ProvideConnectionService() services.ConnectionService
+	ProvideAuthService() services.AuthService
 }
 
 type servicesProvider struct {
+	connectionService services.ConnectionService
+	authService       services.AuthService
 }
 
 func NewServicesProvider(repoProvider RepositoriesProvider, configProvider ConfigProvider) ServicesProvider {
-	return &servicesProvider{}
+	connectionService := services.NewConnectionService(repoProvider.ProvideConnectionRepository())
+	authService := services.NewAuthService(repoProvider.ProvideAuthRepository(), configProvider.ProvideJWTConfig())
+
+	return &servicesProvider{
+		connectionService: connectionService,
+		authService:       authService,
+	}
+}
+
+func (s *servicesProvider) ProvideConnectionService() services.ConnectionService {
+	return s.connectionService
+}
+
+func (s *servicesProvider) ProvideAuthService() services.AuthService {
+	return s.authService
 }

repositories/auth_repository.go

@@ -0,0 +1,32 @@
+package repositories
+
+import (
+	entity "whatsapp-backend/models/entity"
+
+	"gorm.io/gorm"
+)
+
+type AuthRepository interface {
+	CreateUser(user *entity.User) error
+	FindUserByUsername(username string) (*entity.User, error)
+}
+
+type authRepository struct {
+	db *gorm.DB
+}
+
+func NewAuthRepository(db *gorm.DB) AuthRepository {
+	return &authRepository{db: db}
+}
+
+func (r *authRepository) CreateUser(user *entity.User) error {
+	return r.db.Create(user).Error
+}
+
+func (r *authRepository) FindUserByUsername(username string) (*entity.User, error) {
+	var user entity.User
+	if err := r.db.Where("username = ?", username).First(&user).Error; err != nil {
+		return nil, err
+	}
+	return &user, nil
+}

repositories/connection_repositories.go

@@ -0,0 +1,121 @@
+package repositories
+
+import (
+	"context"
+	"fmt"
+
+	entity "whatsapp-backend/models/entity"
+	http_error "whatsapp-backend/models/error"
+
+	"github.com/google/uuid"
+	"go.mau.fi/whatsmeow"
+	"go.mau.fi/whatsmeow/store"
+	"go.mau.fi/whatsmeow/store/sqlstore"
+	"go.mau.fi/whatsmeow/types"
+	waLog "go.mau.fi/whatsmeow/util/log"
+	"gorm.io/gorm"
+)
+
+type ConnectionRepository interface {
+	InitializeClient(ctx context.Context, accountID uuid.UUID) (*whatsmeow.Client, <-chan whatsmeow.QRChannelItem, error)
+	UpdateAccountStatus(accountID uuid.UUID, jid string, isActive bool) error
+	DeleteDevice(accountID uuid.UUID) error
+}
+
+type connectionRepository struct {
+	db        *gorm.DB
+	container *sqlstore.Container
+}
+
+// NewConnectionRepository initializes the SQLStore ONCE during app startup
+func NewConnectionRepository(db *gorm.DB) (ConnectionRepository, error) {
+	sqlDB, err := db.DB()
+	if err != nil {
+		return nil, http_error.ERR_DB_CONNECTION_FAILED
+	}
+
+	// whatsmeow requires its own logger for the store
+	dbLog := waLog.Stdout("Database", "INFO", true)
+
+	// We use "postgres" because your connection is Postgres.
+	// whatsmeow_device, whatsmeow_session, etc.
+	container := sqlstore.NewWithDB(sqlDB, entity.POSTGRES_DIALECT, dbLog)
+	if err := container.Upgrade(context.Background()); err != nil {
+		return nil, http_error.ERR_SQLSTORE_FAILED
+	}
+
+	return &connectionRepository{
+		db:        db,
+		container: container,
+	}, nil
+}
+
+func (r *connectionRepository) InitializeClient(ctx context.Context, accountID uuid.UUID) (*whatsmeow.Client, <-chan whatsmeow.QRChannelItem, error) {
+	var acc entity.WhatsAppAccount
+
+	// 1. Find or Create your GORM entity
+	acc = entity.WhatsAppAccount{
+		ID:          accountID,
+		AccountName: "Default Device",
+	}
+	if err := r.db.FirstOrCreate(&acc, entity.WhatsAppAccount{ID: accountID}).Error; err != nil {
+		return nil, nil, http_error.ERR_DB_CONNECTION_FAILED
+	}
+
+	var deviceStore *store.Device
+	var err error
+
+	// 2. Determine if we use an existing session (JID) or start a new one
+	if acc.JID != "" {
+		jid, parseErr := types.ParseJID(acc.JID)
+		if parseErr != nil {
+			return nil, nil, http_error.ERR_INVALID_JID
+		}
+		deviceStore, err = r.container.GetDevice(ctx, jid)
+	} else {
+		// No JID means this is a fresh account/new login
+		deviceStore = r.container.NewDevice()
+	}
+
+	if err != nil {
+		return nil, nil, http_error.ERR_DEVICE_STORE_FAILED
+	}
+
+	// 3. Create the whatsmeow client
+	clientLog := waLog.Stdout(fmt.Sprintf("Client-%s", accountID), "INFO", true)
+	client := whatsmeow.NewClient(deviceStore, clientLog)
+
+	// 4. Generate QR Channel if not logged in
+	var qrChan <-chan whatsmeow.QRChannelItem
+	if client.Store.ID == nil {
+		qrChan, _ = client.GetQRChannel(ctx)
+	}
+
+	return client, qrChan, nil
+}
+
+func (r *connectionRepository) UpdateAccountStatus(accountID uuid.UUID, jid string, isActive bool) error {
+	// Updates both the JID (bridge) and the active status in your GORM entity
+	return r.db.Model(&entity.WhatsAppAccount{ID: accountID}).Updates(map[string]interface{}{
+		"jid":       jid,
+		"is_active": isActive,
+	}).Error
+}
+
+func (r *connectionRepository) DeleteDevice(accountID uuid.UUID) error {
+	var acc entity.WhatsAppAccount
+	if err := r.db.First(&acc, accountID).Error; err != nil {
+		return err
+	}
+
+	if acc.JID != "" {
+		jid, _ := types.ParseJID(acc.JID)
+		device, err := r.container.GetDevice(context.Background(), jid)
+		if err == nil && device != nil {
+			_ = device.Delete(context.Background()) // Pass context
+		}
+	}
+
+	// Also clear from DB
+	return r.UpdateAccountStatus(accountID, "", false)
+}

repositories/repositories.go

@@ -0,0 +1 @@
+package repositories

router/auth_router.go

@@ -0,0 +1,18 @@
+package router
+
+import (
+	"whatsapp-backend/provider"
+
+	"github.com/gin-contrib/gzip"
+	"github.com/gin-gonic/gin"
+)
+
+func AuthRouter(router *gin.Engine, controller provider.ControllerProvider) {
+	authController := controller.ProvideAuthController()
+	routerGroup := router.Group("/api/auth") 
+	routerGroup.Use(gzip.Gzip(gzip.DefaultCompression))
+	{
+		routerGroup.POST("/register", authController.Register)
+		routerGroup.POST("/login", authController.Login)
+	}
+}

router/connection_router.go

@@ -0,0 +1,20 @@
+package router
+
+import (
+	"whatsapp-backend/provider"
+
+	"github.com/gin-contrib/gzip"
+	"github.com/gin-gonic/gin"
+)
+
+func ConnectionRouter(router *gin.Engine, controller provider.ControllerProvider, middleware provider.MiddlewareProvider) {
+	connectionController := controller.ProvideConnectionController()
+	authMiddleware := middleware.ProvideAuthMiddleware()
+
+	routerGroup := router.Group("/api/whatsapp", authMiddleware.RequireAuth())
+	routerGroup.Use(gzip.Gzip(gzip.DefaultCompression))
+	{
+		routerGroup.POST("/connect", connectionController.Connect)
+		routerGroup.GET("/status", connectionController.GetStatus)
+	}
+}

router/router.go

@@ -5,6 +5,13 @@ import (
 )
 
 func RunRouter(appProvider provider.AppProvider) {
-	router, config := appProvider.ProvideRouter(), appProvider.ProvideConfig()
-	router.Run(config.ProvideEnvConfig().GetTCPAddress())
+	router, controller, config, middleware := appProvider.ProvideRouter(), appProvider.ProvideControllers(), appProvider.ProvideConfig(), appProvider.ProvideMiddlewares()
+
+	ConnectionRouter(router, controller, middleware)
+	AuthRouter(router, controller)
+
+	err := router.Run(config.ProvideEnvConfig().GetTCPAddress())
+	if err != nil {
+		panic(err)
+	}
 }

services/auth_service.go

@@ -0,0 +1,87 @@
+package services
+
+import (
+	"whatsapp-backend/config"
+	"whatsapp-backend/models/dto"
+	entity "whatsapp-backend/models/entity"
+	http_error "whatsapp-backend/models/error"
+	"whatsapp-backend/repositories"
+	"whatsapp-backend/utils"
+)
+
+type AuthService interface {
+	Register(req dto.RegisterRequest) (*dto.AuthResponse, error)
+	Login(req dto.LoginRequest) (*dto.AuthResponse, error)
+}
+
+type authService struct {
+	authRepo  repositories.AuthRepository
+	jwtConfig config.JWTConfig
+}
+
+func NewAuthService(authRepo repositories.AuthRepository, jwtConfig config.JWTConfig) AuthService {
+	return &authService{
+		authRepo:  authRepo,
+		jwtConfig: jwtConfig,
+	}
+}
+
+func (s *authService) Register(req dto.RegisterRequest) (*dto.AuthResponse, error) {
+	// 1. Check if user exists
+	if _, err := s.authRepo.FindUserByUsername(req.Username); err == nil {
+		return nil, http_error.ERR_USER_ALREADY_EXISTS
+	}
+
+	// 2. Hash Password
+	hashedPassword, err := utils.HashPassword(req.Password)
+	if err != nil {
+		return nil, err
+	}
+
+	// 3. Create User
+	user := &entity.User{
+		Username: req.Username,
+		Password: hashedPassword,
+	}
+
+	if err := s.authRepo.CreateUser(user); err != nil {
+		return nil, err
+	}
+
+	// 4. Generate Token
+	token, err := utils.GenerateToken(user.ID, user.Username, s.jwtConfig)
+	if err != nil {
+		return nil, http_error.ERR_TOKEN_GENERATION_FAILED
+	}
+
+	return &dto.AuthResponse{
+		Token:    token,
+		UserID:   user.ID,
+		Username: user.Username,
+	}, nil
+}
+
+func (s *authService) Login(req dto.LoginRequest) (*dto.AuthResponse, error) {
+	// 1. Find User
+	user, err := s.authRepo.FindUserByUsername(req.Username)
+	if err != nil {
+		return nil, http_error.ERR_USER_NOT_FOUND
+	}
+
+	// 2. Check Password
+	if !utils.CheckPasswordHash(req.Password, user.Password) {
+		return nil, http_error.ERR_WRONG_PASSWORD
+	}
+
+	// 3. Generate Token
+	token, err := utils.GenerateToken(user.ID, user.Username, s.jwtConfig)
+	if err != nil {
+		return nil, http_error.ERR_TOKEN_GENERATION_FAILED
+	}
+
+	return &dto.AuthResponse{
+		Token:    token,
+		UserID:   user.ID,
+		Username: user.Username,
+	}, nil
+}

services/connection_service.go

@@ -0,0 +1,108 @@
+package services
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"sync"
+	http_error "whatsapp-backend/models/error"
+	"whatsapp-backend/repositories"
+
+	"github.com/google/uuid"
+	"github.com/mdp/qrterminal/v3"
+	"go.mau.fi/whatsmeow"
+	"go.mau.fi/whatsmeow/types/events"
+)
+
+type ConnectionService interface {
+	Connect(ctx context.Context, accountID uuid.UUID) error
+	GetActiveClient(accountID uuid.UUID) (*whatsmeow.Client, error)
+}
+
+type connectionService struct {
+	connectionRepo repositories.ConnectionRepository
+	activeClients  sync.Map
+}
+
+func NewConnectionService(connectionRepo repositories.ConnectionRepository) ConnectionService {
+	return &connectionService{
+		connectionRepo: connectionRepo,
+	}
+}
+
+func (s *connectionService) Connect(ctx context.Context, accountID uuid.UUID) error {
+	if existingClient, ok := s.activeClients.Load(accountID); ok {
+		client := existingClient.(*whatsmeow.Client)
+		if client.IsConnected() {
+			return nil // Already connected, no action needed
+		}
+	}
+
+	// 2. Fetch or Init Client from Repository
+	// We assume your Repo now has a method that takes accountID and returns (client, qrChan, err)
+	// by looking up the entity in the DB first.
+	client, qrChan, err := s.connectionRepo.InitializeClient(ctx, accountID)
+	if err != nil {
+		return http_error.ERR_CLIENT_INIT_FAILED
+	}
+
+	// 3. Register Event Handlers
+	// This is the "hook" that updates your database when the status changes
+	client.AddEventHandler(func(evt interface{}) {
+		s.handleWhatsAppEvent(accountID, client, evt)
+	})
+
+	// 4. Handle QR Channel in a background goroutine
+	if qrChan != nil {
+		go func() {
+			for evt := range qrChan {
+				if evt.Event == "code" {
+					fmt.Printf("\n[ACCOUNT %s] SCAN THIS QR CODE:\n", accountID)
+					qrterminal.GenerateHalfBlock(evt.Code, qrterminal.L, os.Stdout)
+				} else {
+					fmt.Printf("[ACCOUNT %s] Login Event: %s\n", accountID, evt.Event)
+				}
+			}
+		}()
+	}
+
+	// 5. Connect to WhatsApp Socket
+	if err := client.Connect(); err != nil {
+		_ = s.connectionRepo.DeleteDevice(accountID) // CLEANUP
+		return http_error.ERR_CLIENT_CONNECT_FAILED
+	}
+
+	// 6. Store in-memory
+	s.activeClients.Store(accountID, client)
+
+	return nil
+}
+
+func (s *connectionService) GetActiveClient(accountID uuid.UUID) (*whatsmeow.Client, error) {
+	val, ok := s.activeClients.Load(accountID)
+	if !ok {
+		return nil, http_error.ERR_CLIENT_NOT_FOUND_FOR_ACC
+	}
+	return val.(*whatsmeow.Client), nil
+}
+
+// handleWhatsAppEvent coordinates between the live socket and your database
+func (s *connectionService) handleWhatsAppEvent(accountID uuid.UUID, client *whatsmeow.Client, evt interface{}) {
+	switch evt.(type) {
+	case *events.Connected:
+		// When the socket confirms connection, update the JID in your DB entity
+		if client.Store.ID != nil {
+			_ = s.connectionRepo.UpdateAccountStatus(accountID, client.Store.ID.String(), true)
+		}
+
+	case *events.LoggedOut:
+		// Cleanup when the user unlinks the device from their phone
+		s.activeClients.Delete(accountID)
+		_ = s.connectionRepo.UpdateAccountStatus(accountID, "", false)
+
+	case *events.Disconnected:
+		// Temporary network loss - whatsmeow handles auto-reconnect,
+		// but we might want to log this.
+		fmt.Printf("Account %s disconnected from WhatsApp\n", accountID)
+	}
+}

services/service.go

@@ -1 +1 @@
-package services
+package services

utils/jwt_util.go

@@ -0,0 +1,28 @@
+package utils
+
+import (
+	"time"
+	"whatsapp-backend/config"
+	"github.com/golang-jwt/jwt/v5"
+	"github.com/google/uuid"
+)
+
+type JWTClaims struct {
+	UserID   uuid.UUID `json:"user_id"`
+	Username string    `json:"username"`
+	jwt.RegisteredClaims
+}
+
+func GenerateToken(userID uuid.UUID, username string, jwtConfig config.JWTConfig) (string, error) {
+	claims := JWTClaims{
+		UserID:   userID,
+		Username: username,
+		RegisteredClaims: jwt.RegisteredClaims{
+			ExpiresAt: jwt.NewNumericDate(time.Now().Add(24 * time.Hour)), // 1 day expiration
+			IssuedAt:  jwt.NewNumericDate(time.Now()),
+		},
+	}
+
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	return token.SignedString([]byte(jwtConfig.GetSecretKey()))
+}

utils/password_util.go

@@ -0,0 +1,13 @@
+package utils
+
+import "golang.org/x/crypto/bcrypt"
+
+func HashPassword(password string) (string, error) {
+	bytes, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
+	return string(bytes), err
+}
+
+func CheckPasswordHash(password, hash string) bool {
+	err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
+	return err == nil
+}

utils/response_util.go

@@ -6,6 +6,7 @@ import (
 	http_error "whatsapp-backend/models/error"
 
 	"github.com/gin-gonic/gin"
+	"github.com/go-playground/validator/v10"
 	"gorm.io/gorm"
 )
 
@@ -60,7 +61,43 @@ func ResponseFAILED[TMetaData any](c *gin.Context, metaData TMetaData, err error
 		})
 		return
 	} else {
-		c.JSON(405, dto.ErrorResponse{
+		// Check for Validation Errors
+		var validationErrors validator.ValidationErrors
+		if errors.As(err, &validationErrors) {
+			friendlyErrors := make([]string, len(validationErrors))
+			for i, fieldError := range validationErrors {
+				friendlyErrors[i] = msgForTag(fieldError)
+			}
+			c.JSON(400, dto.ErrorResponse{
+				Status:   "error",
+				Error:    friendlyErrors,
+				Message:  "Validation Failed",
+				MetaData: nil,
+			})
+			return
+		}
+
+		// Check for Auth Errors
+		if errors.Is(err, http_error.ERR_USER_NOT_FOUND) || errors.Is(err, http_error.ERR_WRONG_PASSWORD) {
+			c.JSON(401, dto.ErrorResponse{
+				Status:   "error",
+				Error:    err,
+				Message:  err.Error(),
+				MetaData: metaData,
+			})
+			return
+		} else if errors.Is(err, http_error.ERR_USER_ALREADY_EXISTS) {
+			c.JSON(409, dto.ErrorResponse{
+				Status:   "error",
+				Error:    err,
+				Message:  err.Error(),
+				MetaData: metaData,
+			})
+			return
+		}
+
+		// Default to 500
+		c.JSON(500, dto.ErrorResponse{
 			Status:   "error",
 			Error:    err,
 			Message:  err.Error(),
@@ -85,3 +122,17 @@ func SendResponse[Tdata any, TMetaData any](c *gin.Context, metaData TMetaData,
 	}
 
 }
+
+func msgForTag(fe validator.FieldError) string {
+	switch fe.Tag() {
+	case "required":
+		return "This field is required"
+	case "email":
+		return "Invalid email format"
+	case "min":
+		return fe.Field() + " must be longer than " + fe.Param() + " characters"
+	case "max":
+		return fe.Field() + " must be shorter than " + fe.Param() + " characters"
+	}
+	return fe.Error() // Default error message
+}