Enhances Backend with PostgreSQL, Docker & Auth Refactor

.dockerignore

@@ -0,0 +1,12 @@
+.git
+.gitignore
+
+.github
+
+Dockerfile.web
+Dockerfile.worker
+README.md
+
+.air.toml
+
+tmp

Dockerfile.web

@@ -0,0 +1,35 @@
+FROM golang:1.25-alpine AS builder
+
+WORKDIR /app
+COPY . .
+RUN go build -o web ./api/cmd/web
+
+FROM alpine:latest
+
+# Install ca-certificates for HTTPS requests and security updates
+RUN apk --no-cache add ca-certificates && \
+    apk upgrade
+
+# Create a non-root user for security
+RUN addgroup -g 1001 -S appgroup && \
+    adduser -u 1001 -S appuser -G appgroup
+
+# Create app directory
+WORKDIR /app
+
+# Copy binary with proper ownership and permissions
+COPY --from=builder --chown=appuser:appgroup /app/web ./web
+COPY --chown=appuser:appgroup .env .env
+COPY --chown=appuser:appgroup migrations/ ./migrations/
+
+RUN chmod +x ./web
+
+# Switch to non-root user
+USER appuser
+
+# Health check for monitoring
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD wget --no-verbose --tries=1 --spider http://localhost:8080/health || exit 1
+
+# Run the application
+CMD ["./web"]

Dockerfile.worker

@@ -0,0 +1,31 @@
+FROM golang:1.25-alpine AS builder
+
+WORKDIR /app
+COPY . .
+RUN go build -o worker ./api/cmd/worker
+
+FROM alpine:latest
+
+# Install ca-certificates for HTTPS requests and security updates
+RUN apk --no-cache add ca-certificates && \
+    apk upgrade
+
+# Create a non-root user for security
+RUN addgroup -g 1001 -S appgroup && \
+    adduser -u 1001 -S appuser -G appgroup
+
+# Create app directory
+WORKDIR /app
+
+# Copy binary with proper ownership and permissions
+COPY --from=builder --chown=appuser:appgroup /app/worker ./worker
+COPY --chown=appuser:appgroup .env .env
+COPY --chown=appuser:appgroup migrations/ ./migrations/
+
+RUN chmod +x ./worker
+
+# Switch to non-root user
+USER appuser
+
+# Run the application
+CMD ["./worker"]

README.md

@@ -4,51 +4,67 @@ Backend for Codex - novel reading platform.
 
 ## Details
 
-Codex-Backend is built in `GoLang`, using `Gin` for server and ~AWS-dynamoDB~ firestore (moving to Heroku Postgres) for database.
+Codex-Backend is built in `GoLang`, using `Gin` for server and ~AWS-dynamoDB~ ~firestore (moving to Heroku Postgres)~ PostgreSQL for database.
 
-It is deployed on `Heroku` (thats why the code is in api directory).
+~It is deployed on `Heroku` (thats why the code is in api directory).~
 
-air config is outdated and not recommended. use [Run](Run guide instead)
+Deployed on personal server in Docker.
 
 ## Run
 run server:
 
 ```bash
-go run api/cmd/web/main.go
+GIN_MODE=debug go run api/cmd/web/main.go
 ```
 
 ```bash
-go run api/cmd/worker/main.go
+GIN_MODE=debug go run api/cmd/worker/main.go
 ```
 
 Both are needed
 
 ## Endpoints
 
-3 Groups of endpoints: Client, Manage and User.
+5 Groups of endpoints: Client, Manage, User, Validate and Health.
 
 - Client is responsible for basic GET requests.
-- Manage is responsible for Upload/Modification operations.
+- Manage is responsible for Upload/Modification/Delete operations.
 - User is responsible for user authentication, authorization and Registration (Delete is not yet implemented).
+- Validate is responsible for validating user tokens.
+- Health is responsible for checking the health of the server.
 
-### Client: base path followed by request path
-- `/all` - Get all novels
-- `/:novel` - Get a novel by id
-- `/:novel/:chapter` - Get chapter from novel using both ids
-- `/:novel/all` - Get all chapters from novel using id
-- `/:novel/chapter` - Get cursor paginated chapters from novel using id
+### Client: `/api` followed by request path
+- GET `/all` - Get all novels
+- GET `/:novel` - Get a novel by id
+- GET `/:novel/:chapter` - Get chapter from novel using both ids
+- GET `/:novel/all` - Get all chapters from novel using id
+- GET `/:novel/chapter` - Get cursor paginated chapters from novel using id
 
-    Options: limit (max 100), cursor (chapter index (integer)) and sort ("asc" || "desc").
+Pagination querries:
+- `?limit=100` - Limit the number of results returned, Max = 200, Min = 1
+- `?cursor=""` - Encoded offset, will be handled automatically
+- `?sort="asc"` - Sort order, asc or desc
 
-    Defaults: limit=100, cursor=0, sort="desc"
+### Manage: `/api/manage` followed by request path
+- POST `/epub` Create Novel/Chapters from epub file.
 
-### Manage: `/manage` followed by request path
-- `/upload` - Upload novel
-- `/:novel` - Update novel
-- `/:novel/:chapter` - Update chapter
+- POST `/create/novel` Create Novel
+- POST `/create/chapter` Create Chapter
 
-### User: `/user` followed by request path
-- `/validate` - Validate user token
-- `/login` - Login user
-- `/register` - Register user
-- `/logout` - Logout user
+- PUT `/update/novel` - Update novel
+- PUT `/update/chapter` - Update chapter
+
+- DELETE `/delete/novel` - Delete novel
+- DELETE `/delete/chapter` - Delete chapter
+
+### User: `/api/user` followed by request path
+- POST `/login` - Login user
+- POST `/logout` - Logout user
+- POST `/register` - Register user
+
+### Validate: `/api/validate` followed by request path
+- GET `/` - Validate user token
+
+## Health: `/health` followed by request path
+- GET `/` - Check health of server
+For now this does nothing, but will be used to check the health of Docker image.

api/cmd/web/main.go

@@ -2,15 +2,27 @@ package main
 
 import (
 	cmn "Codex-Backend/api/common"
+	db "Codex-Backend/api/internal/database"
 	firestore_server "Codex-Backend/api/internal/server"
-	"os"
+	"context"
+	"fmt"
 
-	_ "github.com/heroku/x/hmetrics/onload"
+	"github.com/gin-gonic/gin"
 )
 
 func init() {
-	if mode := os.Getenv("GIN_MODE"); mode == "debug" {
-		cmn.LoadEnvVariables()
+	cmn.LoadEnvVariables()
+
+	mode := cmn.GetEnvVariable("GIN_MODE")
+	gin.SetMode(mode)
+
+	ctx := context.Background()
+	client, err := db.GetClient(ctx)
+	if err != nil {
+		panic(fmt.Sprintf("db new client: %v", err))
+	}
+	if err := client.EnsureSchema(ctx); err != nil {
+		panic(fmt.Sprintf("schema ensure failed: %v", err))
 	}
 }
 

api/cmd/worker/main.go

@@ -9,12 +9,15 @@ import (
 	"os/signal"
 	"syscall"
 	"time"
+
+	"github.com/gin-gonic/gin"
 )
 
 func init() {
-	if mode := os.Getenv("GIN_MODE"); mode == "debug" {
-		cmn.LoadEnvVariables()
-	}
+	cmn.LoadEnvVariables()
+
+	mode := cmn.GetEnvVariable("GIN_MODE")
+	gin.SetMode(mode)
 }
 
 func main() {

api/common/env.go

@@ -32,7 +32,20 @@ func GetDomains(v string) []string {
 		log.Fatal(&Error{Err: errors.New("Environmental Variable " + v + " Not Found"), Status: http.StatusNotFound})
 	}
 
+	domains := []string{}
+
 	result := strings.Split(env_variable, ",")
 
-	return result
+	if len(result) == 0 {
+		return []string{"*"}
+	}
+
+	for _, domain := range result {
+		cleaned := strings.TrimSpace(domain)
+		if cleaned != "" {
+			domains = append(domains, cleaned)
+		}
+	}
+
+	return domains
 }

api/common/river/client.go

@@ -3,10 +3,13 @@ package queue
 import (
 	"Codex-Backend/api/internal/service/worker"
 	"context"
+	"fmt"
 	"log"
 	"log/slog"
+	"math"
 	"os"
 	"sync"
+	"time"
 
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
@@ -19,10 +22,60 @@ var (
 	riverOnce   sync.Once
 )
 
+// func InitializeRiverClient(ctx context.Context, workers *river.Workers) *river.Client[pgx.Tx] {
+// 	dbPool, err := pgxpool.New(ctx, os.Getenv("DATABASE_URL"))
+// 	if err != nil {
+// 		panic(err)
+// 	}
+
+// 	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
+// 		Level: slog.LevelInfo,
+// 	}))
+
+// 	riverClient, err := river.NewClient(riverpgxv5.New(dbPool), &river.Config{
+// 		Logger: logger,
+// 		Queues: map[string]river.QueueConfig{
+// 			river.QueueDefault: {MaxWorkers: 10},
+// 		},
+// 		MaxAttempts: 3,
+// 		Workers:     workers,
+// 	})
+// 	if err != nil {
+// 		panic(err)
+// 	}
+
+// 	return riverClient
+// }
+
 func InitializeRiverClient(ctx context.Context, workers *river.Workers) *river.Client[pgx.Tx] {
-	dbPool, err := pgxpool.New(ctx, os.Getenv("DATABASE_URL"))
-	if err != nil {
-		panic(err)
+	var dbPool *pgxpool.Pool
+	var err error
+
+	// Retry connection with exponential backoff
+	maxRetries := 10
+	for i := range maxRetries {
+		dbPool, err = pgxpool.New(ctx, os.Getenv("DATABASE_URL"))
+		if err == nil {
+			// Test the connection
+			if pingErr := dbPool.Ping(ctx); pingErr == nil {
+				log.Printf("Successfully connected to database on attempt %d", i+1)
+				break
+			} else {
+				log.Printf("Database ping failed on attempt %d: %v", i+1, pingErr)
+				err = pingErr
+			}
+		} else {
+			log.Printf("Failed to create connection pool on attempt %d: %v", i+1, err)
+		}
+
+		if i == maxRetries-1 {
+			panic(fmt.Sprintf("Failed to connect to database after %d attempts: %v", maxRetries, err))
+		}
+
+		// Wait before retrying (exponential backoff)
+		waitTime := time.Duration(math.Pow(2, float64(i))) * time.Second
+		log.Printf("Retrying database connection in %v...", waitTime)
+		time.Sleep(waitTime)
 	}
 
 	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{