tsk-16: Permitting identical messages by a user (#21)

Closes #16

Reviewed-on: phoenix/textsender-api#21
Co-authored-by: phoenix <kundeng00@pm.me>
Co-committed-by: phoenix <kundeng00@pm.me>

.dockerignore.yaml

@@ -0,0 +1,9 @@
+vendor/
+
+# Ignore git directory
+.git/
+
+.gitea/
+
+# Ignore environment files (configure via docker-compose instead)
+.env*

.env.docker.sample

@@ -0,0 +1,7 @@
+JWT_SECRET=NULqYIzgt28bTiyziCd7IOO7b6LnWDW!
+DB_NAME=textsender_db
+DB_USER=textsender
+DB_PASSWORD=password
+DB_HOST=main_db
+DB_PORT=5432
+DB_SSLMODE=disable

.env.sample

@@ -1,3 +1,4 @@
+JWT_SECRET=NULqYIzgt28bTiyziCd7IOO7b6LnWDW!
 DB_NAME=textsender_db
 DB_USER=textsender
 DB_PASSWORD=password

.gitea/workflows/workflow.yaml

@@ -11,32 +11,118 @@ jobs:
     runs-on: ubuntu-24.04  # You can change this to macos-latest or windows-latest if needed
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v5
 
     - name: Set up Go
-      uses: actions/setup-go@v3
+      uses: actions/setup-go@v4
       with:
-        go-version: '1.24.5' # You can specify a specific version or 'stable'
+        go-version: '1.25.3' # You can specify a specific version or 'stable'
 
     - name: Build
-      run: go build -v ./...
-
-    - name: Test
-      run: go test -v ./...
-
-    - name: Run gofmt (optional)
-      # Uncomment to check code formatting with gofmt
       run: |
-        if [ -n "$(gofmt -l.)" ]; then
+        echo "Initializing config"
-          echo "Go code is not formatted. Please run 'gofmt -w.' to fix it."
+        mkdir -p ~/.ssh
-          exit 1
+        echo "${{ secrets.MYREPO_TOKEN }}" > ~/.ssh/textsender_models_deploy_key
-        fi
+        chmod 600 ~/.ssh/textsender_models_deploy_key
+        ssh-keyscan ${{ vars.MY_HOST }} >> ~/.ssh/known_hosts
+ 
+        eval $(ssh-agent -s)
+        ssh-add -v ~/.ssh/textsender_models_deploy_key
 
-    - name: Run golint (optional)
+        go env -w GOPRIVATE='${{ secrets.GIT_HOST_ROOT }}'
-      # Uncomment to check code style with golint
-      run: |
-        if [ -n "$(golint./...)" ]; then
-          echo "Go code has style issues. Please run 'golint./...' to see them."
-          exit 1
-        fi
 
+        echo "Creating local .gitconfig"
+        touch ~/.gitconfig
+        cat > ~/.gitconfig << "EOF"
+        [url "ssh://git@${{ secrets.GIT_HOST_ROOT }}"]
+          insteadOf = https://${{ secrets.GIT_HOST_ROOT }}
+        EOF
+
+        echo "Building binary"
+        make build
+
+        echo "Binary built"
+        file textsender-api
+
+  test:
+    name: Test
+    runs-on: ubuntu-24.04
+    services:
+      postgres:
+        image: postgres:18.0
+        env:
+          POSTGRES_USER: ${{ secrets.DB_TEST_USER }}
+          POSTGRES_PASSWORD: ${{ secrets.DB_TEST_PASSWORD }}
+          POSTGRES_DB: ${{ secrets.DB_TEST_NAME }}
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v5
+
+      - name: Setup Go
+        uses: actions/setup-go@v4
+        with:
+          go-version: '1.25.3'
+
+      - name: Install PostgreSQL client
+        run: sudo apt update && sudo apt-get install -y postgresql-client
+
+      - name: Wait for PostgreSQL to be ready
+        run: |
+          for i in {1..30}; do
+            if pg_isready -h postgres -p 5432; then
+              echo "PostgreSQL is ready"
+              exit 0
+            fi
+            echo "Waiting for PostgreSQL... Attempt $i"
+            sleep 2
+          done
+          echo "PostgreSQL did not start in time"
+          exit 1
+
+      - name: Run tests
+        env:
+          DB_NAME: ${{ secrets.DB_TEST_NAME }}
+          DB_USER: ${{ secrets.DB_TEST_USER }}
+          DB_PASSWORD: ${{ secrets.DB_TEST_PASSWORD }}
+          DB_HOST: postgres
+          DB_PORT: 5432
+          DB_SSLMODE: disable
+          SECRET_KEY: ${{ secrets.SECRET_KEY }}
+        run: |
+          echo "Parent directory"
+          echo `pwd`
+
+          echo "JWT_SECRET=$SECRET_KEY" >> .env
+          echo "DB_NAME=$DB_NAME" > .env
+          echo "DB_USER=$DB_USER" >> .env
+          echo "DB_PASSWORD=$DB_PASSWORD" >> .env
+          echo "DB_HOST=$DB_HOST" >> .env
+          echo "DB_PORT=$DB_PORT" >> .env
+          echo "DB_SSLMODE=$DB_SSLMODE" >> .env
+
+          echo "Initializing config"
+          mkdir -p ~/.ssh
+          echo "${{ secrets.MYREPO_TOKEN }}" > ~/.ssh/textsender_models_deploy_key
+          chmod 600 ~/.ssh/textsender_models_deploy_key
+          ssh-keyscan ${{ vars.MY_HOST }} >> ~/.ssh/known_hosts
+   
+          eval $(ssh-agent -s)
+          ssh-add -v ~/.ssh/textsender_models_deploy_key
+
+          go env -w GOPRIVATE='${{ secrets.GIT_HOST_ROOT }}'
+
+          echo "Creating local .gitconfig"
+          touch ~/.gitconfig
+          cat > ~/.gitconfig << "EOF"
+          [url "ssh://git@${{ secrets.GIT_HOST_ROOT }}"]
+            insteadOf = https://${{ secrets.GIT_HOST_ROOT }}
+          EOF
+
+          go test -v ./...

.gitignore

@@ -3,3 +3,4 @@
 
 .env
 .env.local
+.env.docker

Dockerfile

@@ -0,0 +1,52 @@
+# Multi-stage Dockerfile for Go application
+FROM golang:1.25.3 AS builder
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ca-certificates \
+    openssh-client git
+
+RUN mkdir -p -m 0700 ~/.ssh && \
+    ssh-keyscan git.kundeng.us >> ~/.ssh/known_hosts
+
+# Configure Git to use SSH for GitHub
+RUN git config --global url."ssh://git@git.kundeng.us".insteadOf "https://git.kundeng.us"
+
+# Set up the Go environment for private modules
+ENV GOPRIVATE=git.kundeng.us
+
+
+# Copy go mod and sum files
+COPY go.mod go.sum ./
+
+RUN --mount=type=ssh mkdir src && \
+    go mod download
+
+# Copy source code
+COPY ./cmd ./cmd
+COPY ./internal ./internal
+COPY ./Makefile .
+COPY ./.env .
+COPY ./migrations ./migrations
+
+# Build the application
+RUN CGO_ENABLED=0 GOOS=linux make build
+
+# Runtime stage
+FROM alpine:latest AS production
+
+RUN apk --no-cache add ca-certificates
+
+WORKDIR /root/
+
+# Copy the pre-built binary file from the previous stage
+COPY --from=builder /app/textsender-api .
+COPY --from=builder /app/.env ./
+COPY --from=builder /app/migrations ./migrations
+
+# Expose port
+EXPOSE 8080
+
+# Command to run the executable
+CMD ["./textsender-api"]

Makefile

@@ -0,0 +1,21 @@
+VERSION ?= $(shell git describe --tags 2>/dev/null || echo "dev")
+COMMIT ?= $(shell git rev-parse --short HEAD)
+BUILD_TIME ?= $(shell date -u +%Y-%m-%dT%H:%M:%SZ)
+GO_VERSION ?= $(shell go version | awk '{print $$3}')
+
+.PHONY: build
+build:
+	go build -ldflags="\
+		-X 'git.kundeng.us/phoenix/textsender-api/internal/version.Version=$(VERSION)' \
+		-X 'git.kundeng.us/phoenix/textsender-api/internal/version.BuildTime=$(BUILD_TIME)' \
+		-X 'git.kundeng.us/phoenix/textsender-api/internal/version.Commit=$(COMMIT)' \
+		-X 'git.kundeng.us/phoenix/textsender-api/internal/version.GoVersion=$(GO_VERSION)'" \
+		-o textsender-api cmd/api/main.go
+
+.PHONY: install
+install:
+	go install -ldflags="\
+		-X 'git.kundeng.us/phoenix/textsender-api/internal/version.Version=$(VERSION)' \
+		-X 'git.kundeng.us/phoenix/textsender-api/internal/version.BuildTime=$(BUILD_TIME)' \
+		-X 'git.kundeng.us/phoenix/textsender-api/internal/version.Commit=$(COMMIT)' \
+		-X 'git.kundeng.us/phoenix/textsender-api/internal/version.GoVersion=$(GO_VERSION)'"

README.md

@@ -4,6 +4,7 @@ A software system to process Text messaging queueing
 
 ## Getting started
 
-TODO
+### Building 
 ```BASH
+make build
 ```

cmd/api/main.go

@@ -1,17 +1,113 @@
 package main
 
-import "fmt"
+import (
-import "log"
+	"context"
-import "net/http"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
 
-import "git.kundeng.us/phoenix/textsender-api/internal/config"
+	"github.com/go-chi/chi/v5"
-import "git.kundeng.us/phoenix/textsender-api/internal/handler"
+	"github.com/go-chi/chi/v5/middleware"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/config"
+	database "git.kundeng.us/phoenix/textsender-api/internal/db"
+	"git.kundeng.us/phoenix/textsender-api/internal/handler"
+	"git.kundeng.us/phoenix/textsender-api/internal/handler/endpoint"
+	mdlware "git.kundeng.us/phoenix/textsender-api/internal/middleware"
+	"git.kundeng.us/phoenix/textsender-api/internal/services"
+	"git.kundeng.us/phoenix/textsender-api/internal/store"
+)
 
 func main() {
-	fmt.Println(config.APP_NAME)
+	cfg := config.Load()
+	if cfg == nil {
+		fmt.Println("Error initializing config")
+		os.Exit(-1)
+	} else if cfg.JWTSecret == "" {
+		fmt.Println("Error: JWTSecret not initialized")
+		os.Exit(-1)
+	}
 
-	http.HandleFunc(handler.MESSAGE_DRAFT_ENDPOINT, handler.DraftMessageHandler)
+	db, err := database.NewDatabase(cfg.GetDBConnString())
+	if err != nil {
+		log.Fatalf("Failed to connect to database: %v", err)
+	}
+	defer db.Close()
 
-	log.Println("Starting server", config.PORT)
+	ctx := context.Background()
-	log.Fatal(http.ListenAndServe(config.PortString(), nil))
+
+	if cfg.ResetDB {
+		log.Println("Resetting database")
+		if err := db.ResetDatabase(ctx); err != nil {
+			log.Fatalf("Failed to reset database: %v", err)
+		}
+		log.Println("Database reset completed. Exiting.")
+		return
+	} else {
+		if exists, err := database.TableExists(ctx, db.Pool, "contacts "); err == nil && !exists {
+			fmt.Println("Resetting database")
+			err = db.ResetDatabase(ctx)
+			if err != nil {
+				fmt.Printf("Error:%v", err)
+			}
+		} else {
+			fmt.Printf("Error:%v", err)
+		}
+	}
+
+	jwtService := services.NewJWTService(cfg.JWTSecret)
+
+	contactStore := store.NewContactStore(db.Pool)
+	messageStore := store.NewMessageStore(db.Pool)
+
+	contactHandler := handler.NewContactHandler(contactStore)
+	messageHandler := handler.NewMessageHandler(messageStore)
+
+	router := chi.NewRouter()
+
+	router.Use(middleware.Logger)
+	router.Use(middleware.Recoverer)
+	router.Use(middleware.Timeout(60 * time.Second))
+	router.Use(mdlware.JSONContentType)
+
+	router.Handle(endpoint.ADD_CONTACT_ENDPOINT, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(contactHandler.AddContact)))
+	router.Handle(endpoint.GET_CONTACT, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(contactHandler.GetContact)))
+	router.Handle(endpoint.ADD_MESSAGE, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(messageHandler.AddMessage)))
+	router.Handle(endpoint.GET_MESSAGE, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(messageHandler.GetMessage)))
+
+	// Start server
+	server := &http.Server{
+		Addr:         ":" + cfg.ServerPort,
+		Handler:      router,
+		ReadTimeout:  15 * time.Second,
+		WriteTimeout: 15 * time.Second,
+		IdleTimeout:  60 * time.Second,
+	}
+
+	// Graceful shutdown
+	go func() {
+		log.Printf("Server starting on port %s", cfg.ServerPort)
+		if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			log.Fatalf("Server failed to start: %v", err)
+		}
+	}()
+
+	// Wait for interrupt signal
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+	<-quit
+	log.Println("Shutting down server...")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	if err := server.Shutdown(ctx); err != nil {
+		log.Fatalf("Server forced to shutdown: %v", err)
+	}
+
+	log.Println("Server exited")
 }

cmd/api/main_test.go

@@ -0,0 +1,82 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+	"path"
+	"testing"
+
+	"github.com/gorilla/mux"
+	"github.com/joho/godotenv"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/config"
+	"git.kundeng.us/phoenix/textsender-api/internal/db"
+	"git.kundeng.us/phoenix/textsender-api/internal/handler"
+	"git.kundeng.us/phoenix/textsender-api/internal/handler/endpoint"
+	"git.kundeng.us/phoenix/textsender-api/internal/store"
+)
+
+var testRouter *mux.Router
+
+func TestMain(m *testing.M) {
+	cfg := load()
+
+	db, err := db.NewDatabase(cfg.GetDBConnString())
+	if err != nil {
+		fmt.Println(err.Error())
+		panic("Failed to initialize database")
+	}
+	defer db.Close()
+
+	ctx := context.Background()
+	err = db.ResetDatabase(ctx)
+	if err != nil {
+		fmt.Println(err.Error())
+		panic("Failed to initialize database")
+	}
+
+	contactStore := store.NewContactStore(db.Pool)
+	contactHandler := handler.NewContactHandler(contactStore)
+
+	testRouter = mux.NewRouter()
+	testRouter.HandleFunc(endpoint.ADD_CONTACT_ENDPOINT, contactHandler.AddContact).Methods("POST")
+
+	code := m.Run()
+	os.Exit(code)
+}
+
+func load() *config.Config {
+	resetDb := flag.Bool("reset-db", false, "Reset the database schema and exit")
+	port := flag.String("port", config.PORT, "Server port")
+	flag.Parse()
+
+	cwd, _ := os.Getwd()
+	envPath := path.Join(cwd, ".env")
+
+	err := godotenv.Load(envPath)
+	if err != nil {
+		envPath = path.Join(cwd, "../..", ".env")
+		if err := godotenv.Load(envPath); err != nil {
+			panic("Error loading .env file: " + err.Error())
+		}
+	}
+
+	unpackedConnString := config.UnpackDBConnString()
+	dbConnString := unpackedConnString.Parse()
+
+	return &config.Config{
+		DBConnString: dbConnString,
+		ServerPort:   *port,
+		ResetDB:      *resetDb,
+	}
+}
+
+func resetTestDB(t *testing.T) {
+	t.Helper()
+	_, err := db.Pool.Exec(context.Background(), "DELETE FROM contacts")
+	if err != nil {
+		t.Fatalf("Failed to reset test database: %v", err)
+	}
+}

docker-compose.yaml

@@ -0,0 +1,97 @@
+version: '3.8' # Use a recent version
+
+services:
+  api:
+    build: # Tells docker-compose to build the Dockerfile in the current directory
+      context: .
+      ssh: ["default"]  # Uses host's SSH agent
+    container_name: textsender # Optional: Give the container a specific name
+    ports:
+      # Map host port 8000 to container port 3000 (adjust as needed)
+      - "8080:8080"
+    env_file:
+      - .env
+    depends_on:
+      main_db:
+        condition: service_healthy # Wait for the DB to be healthy before starting the app
+    networks:
+      - textsender-network
+    restart: unless-stopped # Optional: Restart policy
+
+  auth_api:
+    build: # Tells docker-compose to build the Dockerfile in the current directory
+      context: ../textsender-auth
+      ssh: ["default"]  # Uses host's SSH agent
+      dockerfile: Dockerfile
+    container_name: textsender_auth # Optional: Give the container a specific name
+    ports:
+      # Map host port 8000 to container port 3000 (adjust as needed)
+      - "9080:9080"
+    env_file:
+      - ../textsender-auth/.env
+    depends_on:
+      auth_db:
+        condition: service_healthy # Wait for the DB to be healthy before starting the app
+    networks:
+      - textsender-network
+    restart: unless-stopped # Optional: Restart policy
+
+  # PostgreSQL Database Service
+  main_db:
+    image: postgres:18.0-alpine # Use an official Postgres image (Alpine variant is smaller)
+    container_name: textsender_db # Optional: Give the container a specific name
+    environment:
+      # These MUST match the user, password, and database name in the DATABASE_URL above
+      POSTGRES_USER: ${POSTGRES_AUTH_USER:-textsender}
+      POSTGRES_PASSWORD: ${POSTGRES_AUTH_PASSWORD:-password}
+      POSTGRES_DB: ${POSTGRES_AUTH_DB:-textsender_db}
+    volumes:
+      # Persist database data using a named volume
+      - postgres_data:/var/lib/postgresql/data
+    ports:
+      - "5432:5432"
+    healthcheck:
+        # Checks if Postgres is ready to accept connections
+        test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER -d $$POSTGRES_DB"]
+        interval: 10s
+        timeout: 5s
+        retries: 5
+        start_period: 10s
+    networks:
+      - textsender-network
+    restart: always # Optional: Restart policy
+
+  auth_db:
+    image: postgres:18.0-alpine # Use an official Postgres image (Alpine variant is smaller)
+    container_name: textsender_auth_db # Optional: Give the container a specific name
+    environment:
+      # These MUST match the user, password, and database name in the DATABASE_URL above
+      POSTGRES_USER: ${POSTGRES_AUTH_USER:-textsender_auth}
+      POSTGRES_PASSWORD: ${POSTGRES_AUTH_PASSWORD:-password}
+      POSTGRES_DB: ${POSTGRES_AUTH_DB:-textsender_auth_db}
+    volumes:
+      # Persist database data using a named volume
+      - postgres_data_auth:/var/lib/postgresql/data
+    ports:
+      - "5433:5432"
+    healthcheck:
+        # Checks if Postgres is ready to accept connections
+        test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER -d $$POSTGRES_DB"]
+        interval: 10s
+        timeout: 5s
+        retries: 5
+        start_period: 10s
+    networks:
+      - textsender-network
+    restart: always # Optional: Restart policy
+
+# Define the named volume for data persistence
+volumes:
+  postgres_data:
+    driver: local # Use the default local driver
+  postgres_data_auth:
+    driver: local # Use the default local driver
+
+networks:
+  textsender-network:
+    driver: bridge

go.mod

@@ -3,3 +3,27 @@ module git.kundeng.us/phoenix/textsender-api
 go 1.25.3
 
 require github.com/google/uuid v1.6.0
+
+require (
+	git.kundeng.us/phoenix/textsender-models v0.0.4-2-2f78d9b1e6-556
+	github.com/go-chi/chi/v5 v5.2.3
+	github.com/golang-jwt/jwt/v5 v5.3.0
+	github.com/gorilla/mux v1.8.1
+	github.com/jackc/pgx/v5 v5.7.6
+	github.com/joho/godotenv v1.5.1
+	github.com/stretchr/testify v1.11.1
+)
+
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/jackc/pgpassfile v1.0.0 // indirect
+	github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
+	github.com/jackc/puddle/v2 v2.2.2 // indirect
+	github.com/kr/text v0.2.0 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/rogpeppe/go-internal v1.14.1 // indirect
+	golang.org/x/crypto v0.42.0 // indirect
+	golang.org/x/sync v0.17.0 // indirect
+	golang.org/x/text v0.29.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

go.sum

@@ -1,2 +1,49 @@
+git.kundeng.us/phoenix/textsender-models v0.0.4-2-2f78d9b1e6-556 h1:BRF4JrIVZMa3kZOaRfHNLJTcspD1RWRoCTcabn+CAIA=
+git.kundeng.us/phoenix/textsender-models v0.0.4-2-2f78d9b1e6-556/go.mod h1:lx5MCnOgGgsdpwzrfi9uph5xmkeb6H8AuexUNGss2no=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+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/go-chi/chi/v5 v5.2.3 h1:WQIt9uxdsAbgIYgid+BpYc+liqQZGMHRaUwp0JUcvdE=
+github.com/go-chi/chi/v5 v5.2.3/go.mod h1:L2yAIGWB3H+phAw1NxKwWM+7eUH/lU8pOMm5hHcoops=
+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/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
+github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
+github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
+github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
+github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
+github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
+github.com/jackc/pgx/v5 v5.7.6 h1:rWQc5FwZSPX58r1OQmkuaNicxdmExaEz5A2DO2hUuTk=
+github.com/jackc/pgx/v5 v5.7.6/go.mod h1:aruU7o91Tc2q2cFp5h4uP3f6ztExVpyVv88Xl/8Vl8M=
+github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
+github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
+github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
+github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
+github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
+github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+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/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
+github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+golang.org/x/crypto v0.42.0 h1:chiH31gIWm57EkTXpwnqf8qeuMUi0yekh6mT2AvFlqI=
+golang.org/x/crypto v0.42.0/go.mod h1:4+rDnOTJhQCx2q7/j6rAN5XDw8kPjeaXEUR2eL94ix8=
+golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug=
+golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/text v0.29.0 h1:1neNs90w9YzJ9BocxfsQNHKuAT4pkghyXc4nhZ6sJvk=
+golang.org/x/text v0.29.0/go.mod h1:7MhJOA9CD2qZyOKYazxdYMF85OwPdEr9jTtBpO7ydH4=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/config/config.go

@@ -1,13 +1,129 @@
 package config
 
-import "fmt"
+import (
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"strconv"
 
-const PORT = 8080
+	"github.com/joho/godotenv"
 
+	"git.kundeng.us/phoenix/textsender-api/internal/version"
+)
+
+type Config struct {
+	DBConnString string
+	ServerPort   string
+	ResetDB      bool
+	JWTSecret    string `env:"JWT_SECRET" required:"true"`
+}
+
+type ConnectionInfo struct {
+	Username string
+	Password string
+	Database string
+	Host     string
+	Port     int
+	SslMode  string
+}
+
+const PORT = "8080"
 const APP_NAME = "textsender-api"
 
 func PortString() string {
-	portMessage := fmt.Sprintf(":%d", PORT)
+	portMessage := fmt.Sprintf(":%s", PORT)
 
 	return portMessage
 }
+
+func (ci ConnectionInfo) Parse() string {
+	return fmt.Sprintf("postgres://%s:%s@%s:%d/%s?sslmode=%s", ci.Username, ci.Password, ci.Host, ci.Port, ci.Database, ci.SslMode)
+}
+
+func PrintName() {
+	fmt.Println(APP_NAME)
+	fmt.Println(version.String())
+}
+
+func Load() *Config {
+	versionFlag := flag.Bool("version", false, "Print version information")
+	resetDb := flag.Bool("reset-db", false, "Reset the database schema and exit")
+	port := flag.String("port", PORT, "Server port")
+	flag.Parse()
+
+	if *versionFlag {
+		fmt.Println(version.String())
+		os.Exit(-1)
+	}
+
+	err := godotenv.Load()
+	if err != nil {
+		log.Fatal("Error loading .env file")
+	}
+
+	unpackedConnString := UnpackDBConnString()
+	dbConnString := unpackedConnString.Parse()
+
+	return &Config{
+		DBConnString: dbConnString,
+		ServerPort:   *port,
+		ResetDB:      *resetDb,
+		JWTSecret:    os.Getenv("JWT_SECRET"),
+	}
+}
+
+func UnpackDBConnString() (connInfo ConnectionInfo) {
+	username := os.Getenv("DB_USER")
+	password := os.Getenv("DB_PASSWORD")
+	host := os.Getenv("DB_HOST")
+	port := os.Getenv("DB_PORT")
+	database := os.Getenv("DB_NAME")
+	sslMode := os.Getenv("DB_SSLMODE")
+
+	if username != "" {
+		connInfo.Username = username
+	} else {
+		connInfo.Username = "user"
+	}
+
+	if password != "" {
+		connInfo.Password = password
+	} else {
+		connInfo.Password = "password"
+	}
+
+	if host != "" {
+		connInfo.Host = host
+	} else {
+		connInfo.Host = "localhost"
+	}
+
+	if port != "" {
+		num, err := strconv.Atoi(port)
+		if err != nil {
+			return
+		}
+		connInfo.Port = num
+	} else {
+		connInfo.Port = 5432
+	}
+
+	if database != "" {
+		connInfo.Database = database
+	} else {
+		connInfo.Database = "textsender_db"
+	}
+
+	if sslMode != "" {
+		connInfo.SslMode = sslMode
+	} else {
+		connInfo.SslMode = "disable"
+	}
+
+	return
+}
+
+func (c *Config) GetDBConnString() string {
+	return c.DBConnString
+}

internal/db/connection.go

@@ -0,0 +1,136 @@
+// db/connection.go
+package db
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"os"
+	"path"
+	"strings"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+var Pool *pgxpool.Pool
+
+type Database struct {
+	Pool *pgxpool.Pool
+}
+
+func NewDatabase(connString string) (*Database, error) {
+	ctx := context.Background()
+	// Parse the connection string and create pool configuration
+	config, err := pgxpool.ParseConfig(connString)
+	if err != nil {
+		return nil, fmt.Errorf("unable to parse DSN: %v", err)
+	}
+
+	// Configure connection pool settings
+	config.MaxConns = 25
+	config.MinConns = 5
+	config.MaxConnLifetime = time.Hour
+	config.MaxConnIdleTime = 30 * time.Minute
+	config.HealthCheckPeriod = time.Minute
+
+	// Configure connection timeouts
+	config.ConnConfig.ConnectTimeout = 10 * time.Second
+	config.ConnConfig.RuntimeParams["timezone"] = "UTC"
+
+	// Create the connection pool
+	pool, err := pgxpool.NewWithConfig(ctx, config)
+	if err != nil {
+		return nil, fmt.Errorf("unable to create connection pool: %v", err)
+	}
+
+	// Test the connection with a short timeout
+	if err := pool.Ping(ctx); err != nil {
+		pool.Close()
+		return nil, fmt.Errorf("unable to ping database: %v", err)
+	}
+
+	log.Printf("Successfully connected to database")
+	return &Database{Pool: pool}, nil
+}
+
+func TableExists(ctx context.Context, conn *pgxpool.Pool, tableName string) (bool, error) {
+	var exists bool
+
+	query := `
+        SELECT EXISTS (
+            SELECT FROM information_schema.tables
+            WHERE table_schema = 'public'
+            AND table_name = $1
+        );
+    `
+
+	err := conn.QueryRow(ctx, query, tableName).Scan(&exists)
+	if err != nil {
+		return false, fmt.Errorf("error checking if table exists: %w", err)
+	}
+
+	return exists, nil
+}
+
+func (db *Database) Close() {
+	if db.Pool != nil {
+		db.Pool.Close()
+		log.Println("Database connection pool closed")
+	}
+}
+
+// HealthCheck verifies the database connection is still alive
+func (db *Database) HealthCheck(ctx context.Context) error {
+	return db.Pool.Ping(ctx)
+}
+
+// GetPoolStats returns connection pool statistics
+func (db *Database) GetPoolStats() string {
+	stats := db.Pool.Stat()
+	return fmt.Sprintf("TotalConns: %d, IdleConns: %d, AcquiredConns: %d",
+		stats.TotalConns(), stats.IdleConns(), stats.AcquiredConns())
+}
+
+func (db *Database) ResetDatabase(ctx context.Context) error {
+	tx, err := db.Pool.Begin(ctx)
+	if err != nil {
+		return fmt.Errorf("Transaction unable to begin: %v", err)
+	}
+	defer tx.Rollback(ctx)
+
+	schemaContent, err := os.ReadFile("migrations/schema.sql")
+	if err != nil {
+		log.Println("Default migrations not found. Checking different directory")
+		cwd, _ := os.Getwd()
+		migrationsPath := path.Join(cwd, "../..", "migrations/schema.sql")
+		schemaContent, err = os.ReadFile(migrationsPath)
+		if err != nil {
+			return fmt.Errorf("error reading schema file: %v", err)
+		}
+	}
+
+	for _, stmt := range strings.Split(string(schemaContent), ";") {
+		stmt = strings.TrimSpace(stmt)
+		if stmt == "" {
+			continue
+		}
+
+		if strings.HasPrefix(stmt, "--") {
+			continue
+		}
+
+		_, err := tx.Exec(ctx, stmt)
+		if err != nil {
+			return fmt.Errorf("error executing SQL statement: %v\nStatement: %s", err, stmt)
+		}
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return fmt.Errorf("unable to commit transaction: %v", err)
+	}
+
+	log.Println("Database schema applied successfully")
+
+	return nil
+}

internal/handler/contact.go

@@ -5,26 +5,35 @@ import (
 	"net/http"
 
 	"github.com/google/uuid"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/store"
+	"git.kundeng.us/phoenix/textsender-models/pkg/contact"
 )
 
 type RequestAddContact struct {
-	PhoneNumber string `json:"phone_number"`
+	PhoneNumber string    `json:"phone_number"`
-	UserId uuid.UUID`json:"user_id"`
+	UserId      uuid.UUID `json:"user_id"`
 }
 
-type LoginResponse struct {
+type AddContactResponse struct {
-	Message string        `json:"message"`
+	Message string            `json:"message"`
-	Data    []model.Data`json:"data"`
+	Data    []contact.Contact `json:"data"`
+}
+
+type GetContactResponse struct {
+	Message string            `json:"message"`
+	Data    []contact.Contact `json:"data"`
 }
 
 type ContactHandler struct {
+	ContactStore store.ContactStore
 }
 
-func NewContactHandler(store model.Store) *ContactHandler {
+func NewContactHandler(str store.ContactStore) *ContactHandler {
-	return &ContactHandler{Store: store}
+	return &ContactHandler{ContactStore: str}
 }
 
-func (l *ContactHandler) AddContact(w http.ResponseWriter, r *http.Request) {
+func (c *ContactHandler) AddContact(w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodPost {
 		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
 		return
@@ -36,47 +45,110 @@ func (l *ContactHandler) AddContact(w http.ResponseWriter, r *http.Request) {
 	}
 	defer r.Body.Close()
 
+	newContact := contact.Contact{PhoneNumber: req.PhoneNumber, UserId: req.UserId}
+
 	var statusCode int
-	/*
+	var resp AddContactResponse
-	var resp LoginResponse
 
 	ctx := r.Context()
 
-	if exists, err := l.UserStore.UserExists(ctx, req.Username); err != nil {
+	if exists, err := c.ContactStore.ContactExists(ctx, newContact.PhoneNumber, newContact.UserId); err != nil {
 		fmt.Printf("Error: %v", err)
 		statusCode = http.StatusInternalServerError
 		resp.Message = err.Error()
 	} else {
-		if !exists {
+		if exists {
 			statusCode = http.StatusBadRequest
-			resp.Message = "Failure in user check"
+			resp.Message = "Cannot create contact"
 		} else {
-			if user, err := l.UserStore.GetUserByUsername(ctx, req.Username); err != nil {
+			if err := c.ContactStore.CreateContact(ctx, &newContact); err != nil {
+				fmt.Printf("Error: %v", err)
 				statusCode = http.StatusInternalServerError
 				resp.Message = err.Error()
 			} else {
-				hashing := utility.HashMash{Password: req.Password}
+				statusCode = http.StatusCreated
-				if hashing.CheckPasswordHash(req.Password, user.Password) {
+				resp.Message = "Contact created"
-					var tokGen utility.TokenGenerator
+				resp.Data = append(resp.Data, newContact)
-					secretKey := config.GetSecretKey()
-					tokGen.SetSecretKey(secretKey)
-					if token, err := tokGen.GenerateToken(*user); err != nil {
-						fmt.Println(err.Error())
-						statusCode = http.StatusInternalServerError
-						resp.Message = "Error generating token"
-					} else {
-						statusCode = http.StatusOK
-						resp.Data = append(resp.Data, *token)
-						resp.Message = "Successful"
-					}
-				} else {
-					statusCode = http.StatusNotFound
-					resp.Message = "User not found"
-				}
 			}
 		}
 	}
-	*/
 
-	RespondWithJson(w, statusCode, &resp)
+	RespondWithJSON(w, statusCode, &resp)
+}
+
+func (c *ContactHandler) GetContact(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		fmt.Println("Method:", r.Method)
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var id, userId uuid.UUID
+	queryParams := r.URL.Query()
+
+	// Check if parameter exists
+	if _, exists := queryParams["id"]; !exists {
+		if _, exists := queryParams["user_id"]; !exists {
+			fmt.Fprintf(w, "Name parameter not provided")
+			http.Error(w, "Query params", http.StatusBadRequest)
+			return
+		} else {
+			var err error
+			userId, err = uuid.Parse(queryParams.Get("user_id"))
+			if err != nil {
+				fmt.Fprintf(w, "Name parameter exists: %s", userId)
+			}
+		}
+	} else {
+		var err error
+		idTmp := queryParams.Get("id")
+		id, err = uuid.Parse(idTmp)
+		if err != nil {
+			fmt.Println("Error:", err)
+			http.Error(w, "Error parsing Id", http.StatusBadRequest)
+			return
+		}
+	}
+
+	var statusCode int
+	var resp GetContactResponse
+
+	ctx := r.Context()
+
+	if id != uuid.Nil {
+		fmt.Println("Checking with Id")
+		if con, err := c.ContactStore.GetContactByID(ctx, id); err == nil {
+			statusCode = http.StatusOK
+			resp.Message = "Successful"
+			resp.Data = append(resp.Data, *con)
+		} else {
+			statusCode = http.StatusInternalServerError
+			resp.Message = err.Error()
+		}
+	} else if userId != uuid.Nil {
+		fmt.Println("Checking with User Id")
+		if contacts, err := c.ContactStore.GetAllContacts(ctx); err == nil {
+			for _, con := range contacts {
+				if con.UserId == userId {
+					resp.Data = append(resp.Data, *con)
+				}
+			}
+
+			if len(resp.Data) > 0 {
+				statusCode = http.StatusOK
+				resp.Message = "Successful"
+			} else {
+				statusCode = http.StatusNotFound
+				resp.Message = "Contact not found"
+			}
+		} else {
+			statusCode = http.StatusInternalServerError
+			resp.Message = err.Error()
+		}
+	} else {
+		statusCode = http.StatusBadRequest
+		resp.Message = "Invalid query parameter"
+	}
+
+	RespondWithJSON(w, statusCode, &resp)
 }

internal/handler/contact_test.go

@@ -0,0 +1,84 @@
+package handler
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"git.kundeng.us/phoenix/textsender-models/pkg/contact"
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/db"
+	"git.kundeng.us/phoenix/textsender-api/internal/handler/endpoint"
+)
+
+type Request struct {
+	PhoneNumber string
+	UserId      uuid.UUID
+}
+
+func TestCreateContactWithMock(t *testing.T) {
+	mockstore := NewMockContactStore()
+	handler := NewContactHandler(mockstore)
+
+	testUserId := uuid.New()
+	testBody := Request{PhoneNumber: "+12335403383", UserId: testUserId}
+	jsonValue, _ := json.Marshal(testBody)
+
+	req, _ := http.NewRequest("POST", endpoint.ADD_CONTACT_ENDPOINT, strings.NewReader(string(jsonValue)))
+	rr := httptest.NewRecorder()
+
+	handler.AddContact(rr, req)
+
+	assert.Equal(t, http.StatusCreated, rr.Code)
+
+	var response AddContactResponse
+	err := json.Unmarshal(rr.Body.Bytes(), &response)
+	assert.NoError(t, err, "Error Creating contact %v", err)
+
+	assert.NotEmpty(t, response.Data, "No Contact created")
+
+	assert.NotNil(t, response.Data[0].Id, "Id should not be nil")
+}
+
+func TestGetContactWithMock(t *testing.T) {
+	mockstore := NewMockContactStore()
+	testUserId := uuid.New()
+
+	testCon := contact.Contact{PhoneNumber: "+12335403383", UserId: testUserId}
+	ctx := t.Context()
+	if err := mockstore.CreateContact(ctx, &testCon); err != nil {
+		assert.NoError(t, err, "Error creating contact")
+		return
+	}
+
+	url := fmt.Sprintf("%s?user_id=%s", endpoint.GET_CONTACT, testCon.UserId)
+	req, _ := http.NewRequest("GET", url, nil)
+	rr := httptest.NewRecorder()
+
+	contactHandler := NewContactHandler(mockstore)
+	contactHandler.GetContact(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+
+	var response GetContactResponse
+	err := json.Unmarshal(rr.Body.Bytes(), &response)
+	assert.NoError(t, err, "Error getting contact %v", err)
+
+	assert.NotEmpty(t, response.Data, "No Contact retrieved")
+
+	assert.NotNil(t, response.Data[0].Id, "Id should not be nil")
+}
+
+func resetTestDB(t *testing.T) {
+	t.Helper()
+	_, err := db.Pool.Exec(context.Background(), "DELETE FROM contacts")
+	if err != nil {
+		t.Fatalf("Failed to reset test database: %v", err)
+	}
+}

internal/handler/endpoint/endpoint.go

@@ -0,0 +1,7 @@
+package endpoint
+
+const MESSAGE_DRAFT_ENDPOINT = "/api/v1/message/draft"
+const ADD_MESSAGE = "/api/v1/message/new"
+const GET_MESSAGE = "/api/v1/message"
+const GET_CONTACT = "/api/v1/contact"
+const ADD_CONTACT_ENDPOINT = "/api/v1/contact/new"

internal/handler/endpoints.go

@@ -1,4 +0,0 @@
-package handler
-
-const MESSAGE_DRAFT_ENDPOINT = "/api/v1/message/draft"
-const ADD_CONTACT_ENDPOINT = "/api/v1/contact";

internal/handler/helper.go

@@ -4,7 +4,6 @@ import "encoding/json"
 import "log"
 import "net/http"
 
-
 func ExtractFromRequest(r *http.Request, reqItem interface{}) error {
 	err := json.NewDecoder(r.Body).Decode(&reqItem)
 	if err != nil {
@@ -14,7 +13,6 @@ func ExtractFromRequest(r *http.Request, reqItem interface{}) error {
 	}
 }
 
-
 // Helper function to send JSON responses
 func RespondWithJSON(w http.ResponseWriter, statusCode int, data interface{}) {
 	w.Header().Set("Content-Type", "application/json")

internal/handler/message.go

@@ -0,0 +1,141 @@
+package handler
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/google/uuid"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/store"
+	"git.kundeng.us/phoenix/textsender-models/pkg/message"
+)
+
+type RequestAddMessage struct {
+	Content string    `json:"content"`
+	UserId  uuid.UUID `json:"user_id"`
+}
+
+type AddMessageResponse struct {
+	Message string            `json:"message"`
+	Data    []message.Message `json:"data"`
+}
+
+type GetMessageResponse struct {
+	Message string            `json:"message"`
+	Data    []message.Message `json:"data"`
+}
+
+type MessageHandler struct {
+	MessageStore store.MessageStore
+}
+
+func NewMessageHandler(str store.MessageStore) *MessageHandler {
+	return &MessageHandler{MessageStore: str}
+}
+
+func (m *MessageHandler) AddMessage(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var req RequestAddMessage
+	if err := ExtractFromRequest(r, &req); err != nil {
+		http.Error(w, "Invalid JSON: "+err.Error(), http.StatusBadRequest)
+	}
+	defer r.Body.Close()
+
+	var statusCode int
+	var resp AddMessageResponse
+	newMessage := message.Message{Content: req.Content, UserId: req.UserId}
+
+	ctx := r.Context()
+
+	if err := m.MessageStore.CreateMessage(ctx, &newMessage); err != nil {
+		fmt.Println("Error:", err)
+		statusCode = http.StatusInternalServerError
+		resp.Message = err.Error()
+	} else {
+		statusCode = http.StatusCreated
+		resp.Message = "Message created"
+		resp.Data = append(resp.Data, newMessage)
+	}
+
+	RespondWithJSON(w, statusCode, &resp)
+}
+
+func (c *MessageHandler) GetMessage(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var id, userId uuid.UUID
+	queryParams := r.URL.Query()
+
+	// Check if parameter exists
+	if _, exists := queryParams["id"]; !exists {
+		if _, exists := queryParams["user_id"]; !exists {
+			fmt.Fprintf(w, "Name parameter not provided")
+			http.Error(w, "Query params", http.StatusBadRequest)
+			return
+		} else {
+			var err error
+			userId, err = uuid.Parse(queryParams.Get("user_id"))
+			if err != nil {
+				fmt.Fprintf(w, "Name parameter exists: %s", userId)
+			}
+		}
+	} else {
+		var err error
+		idTmp := queryParams.Get("id")
+		id, err = uuid.Parse(idTmp)
+		if err != nil {
+			fmt.Println("Error:", err)
+			http.Error(w, "Error parsing Id", http.StatusBadRequest)
+			return
+		}
+	}
+
+	var statusCode int
+	var resp GetMessageResponse
+
+	ctx := r.Context()
+
+	if id != uuid.Nil {
+		fmt.Println("Checking with Id")
+		if con, err := c.MessageStore.GetMessageByID(ctx, id); err == nil {
+			statusCode = http.StatusOK
+			resp.Message = "Successful"
+			resp.Data = append(resp.Data, *con)
+		} else {
+			statusCode = http.StatusInternalServerError
+			resp.Message = err.Error()
+		}
+	} else if userId != uuid.Nil {
+		fmt.Println("Checking with User Id")
+		if contacts, err := c.MessageStore.GetAllMessages(ctx); err == nil {
+			for _, con := range contacts {
+				if con.UserId == userId {
+					resp.Data = append(resp.Data, *con)
+				}
+			}
+
+			if len(resp.Data) > 0 {
+				statusCode = http.StatusOK
+				resp.Message = "Successful"
+			} else {
+				statusCode = http.StatusNotFound
+				resp.Message = "Contact not found"
+			}
+		} else {
+			statusCode = http.StatusInternalServerError
+			resp.Message = err.Error()
+		}
+	} else {
+		statusCode = http.StatusBadRequest
+		resp.Message = "Invalid query parameter"
+	}
+
+	RespondWithJSON(w, statusCode, &resp)
+}

internal/handler/message_test.go

@@ -0,0 +1,74 @@
+package handler
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"git.kundeng.us/phoenix/textsender-models/pkg/message"
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/handler/endpoint"
+)
+
+type CreateMessageRequest struct {
+	Content string    `json:"content"`
+	UserId  uuid.UUID `json:"user_id"`
+}
+
+func TestCreateMessageWithMock(t *testing.T) {
+	mockStore := NewMockMessageStore()
+	handler := NewMessageHandler(mockStore)
+
+	testUserId := uuid.New()
+	testBody := CreateMessageRequest{Content: "Who could tell?", UserId: testUserId}
+	jsonValue, _ := json.Marshal(testBody)
+
+	req, _ := http.NewRequest("POST", endpoint.ADD_MESSAGE, strings.NewReader(string(jsonValue)))
+	rr := httptest.NewRecorder()
+
+	handler.AddMessage(rr, req)
+
+	assert.Equal(t, http.StatusCreated, rr.Code)
+
+	var response AddMessageResponse
+	err := json.Unmarshal(rr.Body.Bytes(), &response)
+	assert.NoError(t, err, "Error Creating message %v", err)
+
+	assert.NotEmpty(t, response.Data, "No Message created")
+
+	assert.NotNil(t, response.Data[0].Id, "Id should not be nil")
+}
+
+func TestGetMessageWithMock(t *testing.T) {
+	mockstore := NewMockMessageStore()
+	testUserId := uuid.New()
+
+	testCon := message.Message{Content: "Who is the one that benefits?", UserId: testUserId}
+	ctx := t.Context()
+	if err := mockstore.CreateMessage(ctx, &testCon); err != nil {
+		assert.NoError(t, err, "Error creating message")
+		return
+	}
+
+	url := fmt.Sprintf("%s?user_id=%s", endpoint.GET_MESSAGE, testCon.UserId)
+	req, _ := http.NewRequest("GET", url, nil)
+	rr := httptest.NewRecorder()
+
+	messageHandler := NewMessageHandler(mockstore)
+	messageHandler.GetMessage(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+
+	var response GetMessageResponse
+	err := json.Unmarshal(rr.Body.Bytes(), &response)
+	assert.NoError(t, err, "Error getting message %v", err)
+
+	assert.NotEmpty(t, response.Data, "No Message retrieved")
+
+	assert.NotNil(t, response.Data[0].Id, "Id should not be nil")
+}

internal/handler/mock_store_test.go

@@ -0,0 +1,202 @@
+package handler
+
+import (
+	"context"
+	"errors"
+	"sync"
+
+	"github.com/google/uuid"
+
+	"git.kundeng.us/phoenix/textsender-models/pkg/contact"
+	"git.kundeng.us/phoenix/textsender-models/pkg/message"
+)
+
+type Key struct {
+	PhoneNumber string
+	UserId      uuid.UUID
+}
+
+type MockContactStore struct {
+	Contacts      map[uuid.UUID]*contact.Contact
+	ContactsByKey map[Key]*contact.Contact
+	mu            sync.RWMutex
+	Error         error // Optional: simulate errors
+}
+
+func NewMockContactStore() *MockContactStore {
+	return &MockContactStore{
+		Contacts:      make(map[uuid.UUID]*contact.Contact),
+		ContactsByKey: make(map[Key]*contact.Contact),
+	}
+}
+
+func (m *MockContactStore) CreateContact(ctx context.Context, con *contact.Contact) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return m.Error
+	}
+
+	if con.Id == uuid.Nil {
+		con.Id = uuid.New()
+	}
+
+	key := Key{PhoneNumber: con.PhoneNumber, UserId: con.UserId}
+	if _, exists := m.ContactsByKey[key]; exists {
+		return errors.New("Contact with phone number already exists")
+	}
+
+	m.Contacts[con.Id] = con
+	m.ContactsByKey[key] = con
+	return nil
+}
+
+func (m *MockContactStore) GetContactByID(ctx context.Context, id uuid.UUID) (*contact.Contact, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return nil, m.Error
+	}
+
+	if m.Error != nil {
+		return nil, m.Error
+	}
+
+	con, exists := m.Contacts[id]
+	if !exists {
+		return nil, errors.New("Contact not found")
+	}
+
+	return con, nil
+}
+
+func (m *MockContactStore) GetContactByPhone(ctx context.Context, phoneNumber string, userId uuid.UUID) (*contact.Contact, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return nil, m.Error
+	}
+
+	con, exists := m.ContactsByKey[Key{PhoneNumber: phoneNumber, UserId: userId}]
+	if !exists {
+		return nil, errors.New("Contact not found")
+	}
+
+	return con, nil
+}
+
+func (m *MockContactStore) GetAllContacts(ctx context.Context) ([]*contact.Contact, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return nil, m.Error
+	}
+
+	cons := make([]*contact.Contact, 0, len(m.Contacts))
+	for _, con := range m.Contacts {
+		cons = append(cons, con)
+	}
+
+	return cons, nil
+}
+
+func (m *MockContactStore) ContactExists(ctx context.Context, phoneNumber string, userId uuid.UUID) (bool, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return false, m.Error
+	}
+
+	_, exists := m.ContactsByKey[Key{PhoneNumber: phoneNumber, UserId: userId}]
+
+	return exists, nil
+}
+
+type MessageKey struct {
+	Content string
+	UserId  uuid.UUID
+}
+
+type MockMessageStore struct {
+	Messages      map[uuid.UUID]*message.Message
+	MessagesByKey map[MessageKey]*message.Message
+	mu            sync.RWMutex
+	Error         error // Optional: simulate errors
+}
+
+func NewMockMessageStore() *MockMessageStore {
+	return &MockMessageStore{
+		Messages:      make(map[uuid.UUID]*message.Message),
+		MessagesByKey: make(map[MessageKey]*message.Message),
+	}
+}
+
+func (m *MockMessageStore) CreateMessage(ctx context.Context, msg *message.Message) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return m.Error
+	}
+
+	if msg.Id == uuid.Nil {
+		msg.Id = uuid.New()
+	}
+
+	key := MessageKey{Content: msg.Content, UserId: msg.UserId}
+	if _, exists := m.MessagesByKey[key]; exists {
+		return errors.New("Message already exists")
+	}
+
+	m.Messages[msg.Id] = msg
+	m.MessagesByKey[key] = msg
+	return nil
+}
+
+func (m *MockMessageStore) GetAllMessages(ctx context.Context) ([]*message.Message, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return nil, m.Error
+	}
+
+	var msgs []*message.Message
+
+	for _, msg := range m.Messages {
+		msgs = append(msgs, msg)
+	}
+
+	return msgs, nil
+}
+
+func (m *MockMessageStore) GetMessageByID(ctx context.Context, id uuid.UUID) (*message.Message, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return nil, m.Error
+	}
+
+	msg := m.Messages[id]
+
+	return msg, nil
+}
+
+func (m *MockMessageStore) MessageExists(ctx context.Context, msg *message.Message) (bool, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return false, m.Error
+	}
+
+	_, exists := m.MessagesByKey[MessageKey{Content: msg.Content, UserId: msg.UserId}]
+
+	return exists, nil
+}

internal/middleware/auth.go

@@ -0,0 +1,47 @@
+package middleware
+
+import (
+	"context"
+	"net/http"
+	"strings"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/services"
+)
+
+type contextKey string
+
+const (
+	UserContextKey contextKey = "user"
+)
+
+func AuthMiddleware(authService *services.JWTService) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			authHeader := r.Header.Get("Authorization")
+			if authHeader == "" {
+				http.Error(w, "Authorization header required", http.StatusUnauthorized)
+				return
+			}
+
+			// Extract token from "Bearer <token>"
+			parts := strings.Split(authHeader, " ")
+			if len(parts) != 2 || parts[0] != "Bearer" {
+				http.Error(w, "Invalid authorization header format", http.StatusUnauthorized)
+				return
+			}
+
+			token := parts[1]
+
+			// Validate token with auth service
+			user, err := authService.ValidateToken(token)
+			if err != nil {
+				http.Error(w, "Invalid token", http.StatusUnauthorized)
+				return
+			}
+
+			// Add user to context
+			ctx := context.WithValue(r.Context(), UserContextKey, user)
+			next.ServeHTTP(w, r.WithContext(ctx))
+		})
+	}
+}

internal/services/jwt_service.go

@@ -0,0 +1,50 @@
+package services
+
+import (
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+
+	txtmodels_token "git.kundeng.us/phoenix/textsender-models/pkg/token"
+	txtmodels_user "git.kundeng.us/phoenix/textsender-models/pkg/user"
+)
+
+type JWTService struct {
+	secretKey []byte
+}
+
+func NewJWTService(secretKey string) *JWTService {
+	return &JWTService{
+		secretKey: []byte(secretKey),
+	}
+}
+
+func (s *JWTService) ValidateToken(tokenString string) (*txtmodels_user.User, error) {
+	// TODO: Include more user information in the claims to populate user
+	claims := &txtmodels_token.Claims{}
+
+	token, err := jwt.ParseWithClaims(tokenString, claims, func(token *jwt.Token) (interface{}, error) {
+		// Validate the signing method
+		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
+			return nil, jwt.ErrSignatureInvalid
+		}
+		return s.secretKey, nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	if !token.Valid {
+		return nil, jwt.ErrSignatureInvalid
+	}
+
+	// Check token expiration
+	if time.Now().After(claims.ExpiresAt.Time) {
+		return nil, jwt.ErrTokenExpired
+	}
+
+	return &txtmodels_user.User{
+		Id: claims.UserId,
+	}, nil
+}

internal/store/contact_store.go

@@ -0,0 +1,115 @@
+package store
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"git.kundeng.us/phoenix/textsender-models/pkg/contact"
+)
+
+type ContactStore interface {
+	CreateContact(ctx context.Context, con *contact.Contact) error
+	GetContactByID(ctx context.Context, id uuid.UUID) (*contact.Contact, error)
+	GetContactByPhone(ctx context.Context, phone string, userId uuid.UUID) (*contact.Contact, error)
+	GetAllContacts(ctx context.Context) ([]*contact.Contact, error)
+	ContactExists(ctx context.Context, phone string, userId uuid.UUID) (bool, error)
+}
+
+type PGContactStore struct {
+	db *pgxpool.Pool
+}
+
+func NewContactStore(db *pgxpool.Pool) *PGContactStore {
+	return &PGContactStore{db: db}
+}
+
+func (s *PGContactStore) CreateContact(ctx context.Context, con *contact.Contact) error {
+	query := `
+		INSERT INTO contacts (phone_number, user_id)
+		VALUES ($1, $2)
+		RETURNING id, phone_number, user_id
+	`
+
+	return s.db.QueryRow(ctx, query, con.PhoneNumber, con.UserId).Scan(
+		&con.Id, &con.PhoneNumber, &con.UserId,
+	)
+}
+
+func (s *PGContactStore) GetContactByID(ctx context.Context, id uuid.UUID) (*contact.Contact, error) {
+	query := `SELECT id, phone_number, user_id FROM contacts WHERE id = $1`
+
+	var con contact.Contact
+	err := s.db.QueryRow(ctx, query, id).Scan(
+		&con.Id, &con.PhoneNumber, &con.UserId,
+	)
+
+	if err == pgx.ErrNoRows {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, fmt.Errorf("getting contact by ID: %w", err)
+	}
+
+	return &con, nil
+}
+
+func (s *PGContactStore) GetContactByPhone(ctx context.Context, phone string, userId uuid.UUID) (*contact.Contact, error) {
+	query := `SELECT id, phone_number, user_id FROM contacts WHERE phone_number = $1 AND user_id = $2`
+
+	var con contact.Contact
+	err := s.db.QueryRow(ctx, query, phone, userId).Scan(
+		&con.Id, &con.PhoneNumber, &con.UserId,
+	)
+
+	if err == pgx.ErrNoRows {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, fmt.Errorf("getting contact by phone and User ID: %w", err)
+	}
+
+	return &con, nil
+}
+
+func (s *PGContactStore) GetAllContacts(ctx context.Context) ([]*contact.Contact, error) {
+	query := `SELECT id, phone_number, user_id FROM contacts`
+
+	rows, err := s.db.Query(ctx, query)
+	if err != nil {
+		return nil, fmt.Errorf("querying all contacts: %w", err)
+	}
+	defer rows.Close()
+
+	var cons []*contact.Contact
+	for rows.Next() {
+		var con contact.Contact
+		if err := rows.Scan(
+			&con.Id, &con.PhoneNumber, &con.UserId,
+		); err != nil {
+			return nil, fmt.Errorf("scanning contact row: %w", err)
+		}
+		cons = append(cons, &con)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("iterating contact rows: %w", err)
+	}
+
+	return cons, nil
+}
+
+func (s *PGContactStore) ContactExists(ctx context.Context, phone string, userId uuid.UUID) (bool, error) {
+	query := `SELECT EXISTS(SELECT 1 FROM contacts WHERE phone_number = $1 AND user_id = $2)`
+
+	var exists bool
+	err := s.db.QueryRow(ctx, query, phone, userId).Scan(&exists)
+	if err != nil {
+		return false, fmt.Errorf("checking if contact exists: %w", err)
+	}
+
+	return exists, nil
+}

internal/store/message_store.go

@@ -0,0 +1,96 @@
+package store
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+
+	"git.kundeng.us/phoenix/textsender-models/pkg/message"
+)
+
+type MessageStore interface {
+	GetMessageByID(ctx context.Context, id uuid.UUID) (*message.Message, error)
+	CreateMessage(ctx context.Context, msg *message.Message) error
+	GetAllMessages(ctx context.Context) ([]*message.Message, error)
+	MessageExists(ctx context.Context, msg *message.Message) (bool, error)
+}
+
+type PGMessageStore struct {
+	db *pgxpool.Pool
+}
+
+func NewMessageStore(db *pgxpool.Pool) *PGMessageStore {
+	return &PGMessageStore{db: db}
+}
+
+func (m *PGMessageStore) CreateMessage(ctx context.Context, msg *message.Message) error {
+	query := `
+	INSERT INTO messages (content, user_id)
+	VALUES ($1, $2)
+	RETURNING id
+	`
+
+	return m.db.QueryRow(ctx, query, msg.Content, msg.UserId).Scan(
+		&msg.Id,
+	)
+}
+
+func (m *PGMessageStore) MessageExists(ctx context.Context, msg *message.Message) (bool, error) {
+	query := `SELECT EXISTS(SELECT 1 FROM messages WHERE content = $1 AND user_id = $2)`
+
+	var exists bool
+	err := m.db.QueryRow(ctx, query, msg.Content, msg.UserId).Scan(&exists)
+	if err != nil {
+		return false, fmt.Errorf("checking if message exists: %w", err)
+	} else {
+		return exists, nil
+	}
+}
+
+func (m *PGMessageStore) GetAllMessages(ctx context.Context) ([]*message.Message, error) {
+	query := `SELECT id, content, user_id FROM messages`
+
+	rows, err := m.db.Query(ctx, query)
+	if err != nil {
+		return nil, fmt.Errorf("querying all messages: %w", err)
+	}
+	defer rows.Close()
+
+	var messages []*message.Message
+	for rows.Next() {
+		var msg message.Message
+		if err := rows.Scan(
+			&msg.Id, &msg.Content, &msg.UserId,
+		); err != nil {
+			return nil, fmt.Errorf("scanning message row: %w", err)
+		}
+		messages = append(messages, &msg)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("iterating message rows: %w", err)
+	}
+
+	return messages, nil
+}
+
+func (m *PGMessageStore) GetMessageByID(ctx context.Context, id uuid.UUID) (*message.Message, error) {
+	query := `SELECT id, content, user_id FROM messages WHERE id = $1`
+
+	var msg message.Message
+	err := m.db.QueryRow(ctx, query, id).Scan(
+		&msg.Id, &msg.Content, &msg.UserId,
+	)
+
+	if err == pgx.ErrNoRows {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, fmt.Errorf("getting message by ID: %w", err)
+	}
+
+	return &msg, nil
+}

internal/version/version.go

@@ -0,0 +1,17 @@
+package version
+
+import "fmt"
+
+var (
+	Version   = "dev"
+	BuildTime = "none"
+	Commit    = "unknown"
+	GoVersion = "unknown"
+)
+
+func String() string {
+	return fmt.Sprintf(
+		"Version: %s\nBuild Date: %s\nCommit: %s\nGo Version: %s",
+		Version, BuildTime, Commit, GoVersion,
+	)
+}

migrations/schema.sql

@@ -0,0 +1,15 @@
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+
+DROP TABLE IF EXISTS contacts CASCADE;
+
+CREATE TABLE contacts (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    phone_number TEXT NOT NULL,
+    user_id UUID NOT NULL
+);
+
+CREATE TABLE messages (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    content TEXT NOT NULL,
+    user_id UUID NOT NULL
+);

version/version.go

@@ -1,7 +0,0 @@
-package version
-
-var (
-	Version = "dev"
-	Commit  = "none"
-	Date    = "unknown"
-)