Update go (#68)

Reviewed-on: phoenix/textsender-api#68
Co-authored-by: phoenix <mail@kundeng.us>
Co-committed-by: phoenix <mail@kundeng.us>

.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,12 @@
+JWT_SECRET=NULqYIzgt28bTiyziCd7IOO7b6LnWDW!
+DB_NAME=textsender_db
+DB_USER=textsender
+DB_PASSWORD=password
+DB_HOST=main_db
+DB_PORT=5432
+DB_SSLMODE=disable
+TWILIO_AUTH_SID=9M438C93R943U4329MCU43C34U
+TWILIO_SERVICE_SID=9M4J3X8439U398NUVT3342MC349C348T
+TWILIO_AUTH_TOKEN="f4a1f2b0b79ea3735078c2d8ee9684e1"
+TWILIO_PHONE_NUMBER=+10123456789
+ALLOWED_ORIGINS="http://textsender.com"

.env.local.sample

@@ -0,0 +1,12 @@
+JWT_SECRET=NULqYIzgt28bTiyziCd7IOO7b6LnWDW!
+DB_NAME=textsender_db
+DB_USER=textsender
+DB_PASSWORD=password
+DB_HOST=localhost
+DB_PORT=5432
+DB_SSLMODE=disable
+TWILIO_AUTH_SID=9M438C93R943U4329MCU43C34U
+TWILIO_SERVICE_SID=9M4J3X8439U398NUVT3342MC349C348T
+TWILIO_AUTH_TOKEN="f4a1f2b0b79ea3735078c2d8ee9684e1"
+TWILIO_PHONE_NUMBER=+10123456789
+ALLOWED_ORIGINS="http://textsender.com"

.env.sample

@@ -1,6 +0,0 @@
-DB_NAME=textsender_db
-DB_USER=textsender
-DB_PASSWORD=password
-DB_HOST=localhost
-DB_PORT=5432
-DB_SSLMODE=disable

.gitea/workflows/workflow.yaml

@@ -11,32 +11,120 @@ 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@v6
       with:
-        go-version: '1.24.5' # You can specify a specific version or 'stable'
+        go-version: '1.26.1' # 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 ${{ secrets.MY_HOST }} >> ~/.ssh/known_hosts
  
-    - name: Run golint (optional)
+        eval $(ssh-agent -s)
-      # Uncomment to check code style with golint
+        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
+
+        echo "Building binary"
+        make build
+
+        echo "Binary built"
+        file textsender-api
+
+  test:
+    name: Test
+    runs-on: ubuntu-24.04
+    services:
+      postgres:
+        image: postgres:18.3-alpine
+        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: |
-        if [ -n "$(golint./...)" ]; then
+          for i in {1..30}; do
-          echo "Go code has style issues. Please run 'golint./...' to see them."
+            if pg_isready -h postgres -p 5432; then
-          exit 1
+              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 "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 "TWILIO_AUTH_SID=9M438C93R943U4329MCU43C34U" >> .env
+          echo "TWILIO_SERVICE_SID=9M4J3X8439U398NUVT3342MC349C348T" >> .env
+          echo "TWILIO_AUTH_TOKEN=f4a1f2b0b79ea3735078c2d8ee9684e1" >> .env
+          echo "TWILIO_PHONE_NUMBER=10123456789" >> .env
+          echo "ALLOWED_ORIGINS=http://localhost:5173" >> .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 ${{ secrets.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,53 @@
+# Multi-stage Dockerfile for Go application
+FROM golang:1.26.1 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
+COPY ./docs ./docs
+
+# 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,18 @@ A software system to process Text messaging queueing
 
 ## Getting started
 
-TODO
+
-```BASH
+### Building 
+```SHELL
+make build
 ```
+
+
+Generate API documentation
+```
+go install github.com/swaggo/swag/cmd/swag@latest
+
+swag init --generalInfo main.go --dir ./cmd/api,./internal/handler --output docs/ --parseDependency --parseInternal
+```
+
+The API documentation can be viewed from `http://localhost:8080/swagger/index.html`.

cmd/api/main.go

@@ -1,17 +1,161 @@
 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"
+	"github.com/go-chi/cors"
+	"github.com/swaggo/http-swagger/v2"
 
+	_ "git.kundeng.us/phoenix/textsender-api/docs"
+	"git.kundeng.us/phoenix/textsender-api/internal/app"
+	"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"
+)
+
+// @title           textsender-api
+// @version         1.0
+// @description     Core API to send text messages
+
+// @host      localhost:8080
+// @BasePath  /api/v1
+
+// @securityDefinitions.apikey  BearerAuth
+// @in                          header
+// @name                        Authorization
+// @description                 JWT Bearer Token
 func main() {
-	fmt.Println(config.APP_NAME)
+	cfg, tCfg, err := config.Load()
+	if err != nil {
+		log.Fatal("Error:", err)
+	} else if cfg == nil {
+		log.Fatal("Error initializing config")
+	} else if cfg.JWTSecret == "" {
+		log.Fatal("Error: JWTSecret not initialized")
+	}
 
-	http.HandleFunc(handler.MESSAGE_DRAFT_ENDPOINT, handler.DraftMessageHandler)
+	apiApp := app.App{TwilioConfig: tCfg}
 
-	log.Println("Starting server", config.PORT)
+	db, err := database.NewDatabase(cfg.GetDBConnString())
-	log.Fatal(http.ListenAndServe(config.PortString(), nil))
+	if err != nil {
+		log.Fatal("Failed to connect to database:", err)
+	}
+	defer db.Close()
+
+	ctx := context.Background()
+
+	if cfg.ResetDB {
+		log.Println("Resetting database")
+		if err := db.ResetDatabase(ctx); err != nil {
+			log.Fatal("Failed to reset database:", err)
+		}
+		log.Println("Database reset completed. Exiting.")
+		return
+	} else {
+		if exists, err := database.TableExists(ctx, db.Pool, "contacts"); err == nil && !exists {
+			log.Println("Resetting database")
+			if err = db.ResetDatabase(ctx); err != nil {
+				log.Fatal("Error:", err)
+			}
+		} else {
+			log.Fatal("Error:", err)
+		}
+	}
+
+	jwtService := services.NewJWTService(cfg.JWTSecret)
+
+	contactStore := store.NewContactStore(db.Pool)
+	messageStore := store.NewMessageStore(db.Pool)
+	schStore := store.NewScheduledMessageStore(db.Pool)
+	schMsgEventStore := store.NewScheduledMessageEventStore(db.Pool)
+	merStore := store.NewMessageEventResponseStore(db.Pool)
+
+	contactHandler := handler.NewContactHandler(&apiApp, contactStore)
+	messageHandler := handler.NewMessageHandler(&apiApp, messageStore)
+	scheduledMessageHandler := handler.NewScheduledMessageHandler(&apiApp, schStore)
+	scheduledMessageEventHandler := handler.NewScheduledMessageEventHandler(&apiApp, schMsgEventStore, schStore)
+	scheduledMessageStatusHandler := handler.NewScheduledMessageStatusHandler(&apiApp, schMsgEventStore, schStore)
+	eventHandler := handler.NewEventResponseHandler(&apiApp, merStore)
+	instantMessageHandler := handler.NewSendInstantMessageHandler(&apiApp, merStore, contactStore, messageStore)
+
+	router := chi.NewRouter()
+
+	// Configure CORS
+	router.Use(cors.Handler(cors.Options{
+		AllowedOrigins:   cfg.AllowedOrigins,
+		AllowedMethods:   []string{"GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH"},
+		AllowedHeaders:   []string{"Accept", "Authorization", "Content-Type", "X-CSRF-Token"},
+		ExposedHeaders:   []string{"Link", "X-Total-Count"},
+		AllowCredentials: true,
+		MaxAge:           300, // 5 minutes
+	}))
+	router.Use(middleware.Logger)
+	router.Use(middleware.Recoverer)
+	router.Use(middleware.Timeout(60 * time.Second))
+	router.Use(mdlware.JSONContentType)
+
+	router.Method("POST", endpoint.ADD_CONTACT_ENDPOINT, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(contactHandler.AddContact)))
+	router.Method("GET", endpoint.GET_CONTACT, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(contactHandler.GetContact)))
+	router.Method("POST", endpoint.ADD_MESSAGE, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(messageHandler.AddMessage)))
+	router.Method("GET", endpoint.GET_MESSAGE, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(messageHandler.GetMessage)))
+	router.Method("POST", endpoint.ScheduleMessageEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageHandler.AddScheduledMessage)))
+	router.Method("POST", endpoint.AddEventToScheduledMessageEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageEventHandler.AddScheduledMessageEvent)))
+	router.Method("GET", endpoint.GetScheduledMessageEventEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageEventHandler.GetScheduledMessageEvent)))
+	router.Method("DELETE", endpoint.DeleteScheduledMessageEventEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageEventHandler.DeleteScheduledMessageEvent)))
+	router.Method("PATCH", endpoint.UpdateScheduledMessageStatusEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageStatusHandler.UpdateStatus)))
+	router.Method("GET", endpoint.GetScheduledMessageEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageHandler.GetScheduledMessage)))
+	router.Method("GET", endpoint.FetchNextScheduledMessageEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageHandler.FetchNextMessage)))
+	router.Method("POST", endpoint.RecordEventResponse, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(eventHandler.RecordResponse)))
+	router.Method("GET", endpoint.FetchMessageEventResponse, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(eventHandler.Fetch)))
+	router.Method("POST", endpoint.SendInstantMessageEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(instantMessageHandler.Send)))
+	router.Method("PATCH", endpoint.Update_Names_Endpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(contactHandler.UpdateName)))
+
+	router.Method("GET", "/swagger/*", httpSwagger.Handler(
+		httpSwagger.URL(fmt.Sprintf("http://localhost:%s/swagger/doc.json", config.PORT)),
+	))
+
+	// 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,129 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"log"
+	"net/http"
+	"os"
+	"path"
+	"testing"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/joho/godotenv"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/app"
+	"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"
+	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"
+)
+
+var testRouter *chi.Mux
+
+func TestMain(m *testing.M) {
+	cfg, apiApp := load()
+
+	database, err := db.NewDatabase(cfg.GetDBConnString())
+	if err != nil {
+		log.Println(err.Error())
+		log.Fatal("Failed to initialize database")
+	}
+	defer database.Close()
+
+	ctx := context.Background()
+
+	if cfg.ResetDB {
+		if err = database.ResetDatabase(ctx); err != nil {
+			log.Println(err.Error())
+			log.Fatalln("Failed to initialize database")
+		}
+	} else {
+		if exists, err := db.TableExists(ctx, database.Pool, "contacts "); err == nil && !exists {
+			log.Println("Resetting database")
+			err = database.ResetDatabase(ctx)
+			if err != nil {
+				log.Println("Error:", err)
+			}
+		} else {
+			log.Println("Error:", err)
+		}
+	}
+
+	jwtService := services.NewJWTService(cfg.JWTSecret)
+
+	contactStore := store.NewContactStore(database.Pool)
+	messageStore := store.NewMessageStore(db.Pool)
+	schStore := store.NewScheduledMessageStore(db.Pool)
+	schMsgEventStore := store.NewScheduledMessageEventStore(db.Pool)
+	merStore := store.NewMessageEventResponseStore(db.Pool)
+
+	contactHandler := handler.NewContactHandler(apiApp, contactStore)
+	messageHandler := handler.NewMessageHandler(apiApp, messageStore)
+	scheduledMessageHandler := handler.NewScheduledMessageHandler(apiApp, schStore)
+	scheduledMessageEventHandler := handler.NewScheduledMessageEventHandler(apiApp, schMsgEventStore, schStore)
+	scheduledMessageStatusHandler := handler.NewScheduledMessageStatusHandler(apiApp, schMsgEventStore, schStore)
+	eventHandler := handler.NewEventResponseHandler(apiApp, merStore)
+	instantMessageHandler := handler.NewSendInstantMessageHandler(apiApp, merStore, contactStore, messageStore)
+
+	testRouter = chi.NewRouter()
+	testRouter.Handle(endpoint.ADD_CONTACT_ENDPOINT, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(contactHandler.AddContact)))
+	testRouter.Handle(endpoint.GET_CONTACT, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(contactHandler.GetContact)))
+	testRouter.Handle(endpoint.ADD_MESSAGE, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(messageHandler.AddMessage)))
+	testRouter.Handle(endpoint.GET_MESSAGE, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(messageHandler.GetMessage)))
+	testRouter.Handle(endpoint.ScheduleMessageEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageHandler.AddScheduledMessage)))
+	testRouter.Method("GET", endpoint.GetScheduledMessageEventEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageEventHandler.GetScheduledMessageEvent)))
+	testRouter.Method("DELETE", endpoint.DeleteScheduledMessageEventEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageEventHandler.DeleteScheduledMessageEvent)))
+	testRouter.Method("PATCH", endpoint.UpdateScheduledMessageStatusEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageStatusHandler.UpdateStatus)))
+	testRouter.Method("GET", endpoint.GetScheduledMessageEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageHandler.GetScheduledMessage)))
+	testRouter.Method("GET", endpoint.FetchNextScheduledMessageEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageHandler.FetchNextMessage)))
+	testRouter.Method("POST", endpoint.RecordEventResponse, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(eventHandler.RecordResponse)))
+	testRouter.Method("GET", endpoint.FetchMessageEventResponse, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(eventHandler.Fetch)))
+	testRouter.Method("POST", endpoint.SendInstantMessageEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(instantMessageHandler.Send)))
+	testRouter.Method("PATCH", endpoint.Update_Names_Endpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(contactHandler.UpdateName)))
+
+	code := m.Run()
+	os.Exit(code)
+}
+
+func load() (*config.Config, *app.App) {
+	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()
+
+	if tCfg, err := config.TwilioConfig(); err != nil {
+		log.Fatal("Error: ", err)
+		return nil, nil
+	} else {
+		return &config.Config{
+			DBConnString: dbConnString,
+			ServerPort:   *port,
+			ResetDB:      *resetDb,
+		}, &app.App{TwilioConfig: tCfg}
+	}
+}
+
+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,112 @@
+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_api # 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:
+      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
+
+  catapult:
+    build:
+      context: ../catapult
+      ssh: ["default"]
+      dockerfile: Dockerfile
+    container_name: catapult
+    env_file:
+      - ../catapult/.env
+    depends_on:
+      - auth_api
+      - api
+    networks:
+      - textsender-network
+    restart: unless-stopped
+
+  # PostgreSQL Database Service
+  main_db:
+    image: postgres:18.3-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.3-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

docs/swagger.yaml

@@ -0,0 +1,810 @@
+basePath: /api/v1
+definitions:
+  contact.Contact:
+    properties:
+      first_name:
+        type: string
+      id:
+        type: string
+      last_name:
+        type: string
+      nickname:
+        type: string
+      phone_number:
+        type: string
+      user_id:
+        type: string
+    type: object
+  event.MessageEventResponse:
+    properties:
+      contact_id:
+        type: string
+      id:
+        type: string
+      message_id:
+        type: string
+      response:
+        additionalProperties: {}
+        type: object
+      scheduled_message_event_id:
+        type: string
+      sent:
+        type: string
+      status:
+        type: string
+      user_id:
+        type: string
+    type: object
+  handler.AddContactResponse:
+    properties:
+      data:
+        items:
+          $ref: '#/definitions/contact.Contact'
+        type: array
+      message:
+        type: string
+    type: object
+  handler.AddMessageResponse:
+    properties:
+      data:
+        items:
+          $ref: '#/definitions/message.Message'
+        type: array
+      message:
+        type: string
+    type: object
+  handler.AddScheduledMessageEventResponse:
+    properties:
+      data:
+        items:
+          $ref: '#/definitions/scheduling.ScheduledMessageEvent'
+        type: array
+      message:
+        type: string
+    type: object
+  handler.AddScheduledMessageResponse:
+    properties:
+      data:
+        items:
+          $ref: '#/definitions/scheduling.ScheduledMessage'
+        type: array
+      message:
+        type: string
+    type: object
+  handler.DeleteScheduledMessageEventResponse:
+    properties:
+      data:
+        items:
+          $ref: '#/definitions/scheduling.ScheduledMessageEvent'
+        type: array
+      message:
+        type: string
+    type: object
+  handler.FetchNextMessageResponse:
+    properties:
+      data:
+        items:
+          $ref: '#/definitions/scheduling.ScheduledMessage'
+        type: array
+      message:
+        type: string
+    type: object
+  handler.GetContactResponse:
+    properties:
+      data:
+        items:
+          $ref: '#/definitions/contact.Contact'
+        type: array
+      message:
+        type: string
+    type: object
+  handler.GetMessageEventResponseFetchedResponse:
+    properties:
+      data:
+        items:
+          $ref: '#/definitions/event.MessageEventResponse'
+        type: array
+      message:
+        type: string
+    type: object
+  handler.GetMessageResponse:
+    properties:
+      data:
+        items:
+          $ref: '#/definitions/message.Message'
+        type: array
+      message:
+        type: string
+    type: object
+  handler.GetScheduledMessageEventResponse:
+    properties:
+      data:
+        items:
+          $ref: '#/definitions/scheduling.ScheduledMessageEvent'
+        type: array
+      message:
+        type: string
+    type: object
+  handler.GetScheduledMessageResponse:
+    properties:
+      data:
+        items:
+          $ref: '#/definitions/scheduling.ScheduledMessage'
+        type: array
+      message:
+        type: string
+    type: object
+  handler.RecordEventRequest:
+    properties:
+      contact_id:
+        type: string
+      message_id:
+        type: string
+      response:
+        additionalProperties: {}
+        type: object
+      scheduled_message_event_id:
+        type: string
+      sent:
+        type: string
+      status:
+        type: string
+      user_id:
+        type: string
+    type: object
+  handler.RecordEventResponse:
+    properties:
+      data:
+        items:
+          $ref: '#/definitions/event.MessageEventResponse'
+        type: array
+      message:
+        type: string
+    type: object
+  handler.RequestAddContact:
+    properties:
+      first_name:
+        type: string
+      last_name:
+        type: string
+      nickname:
+        type: string
+      phone_number:
+        type: string
+      user_id:
+        type: string
+    type: object
+  handler.RequestAddMessage:
+    properties:
+      content:
+        type: string
+      user_id:
+        type: string
+    type: object
+  handler.RequestAddScheduledMessage:
+    properties:
+      scheduled:
+        type: string
+      status:
+        type: string
+      user_id:
+        type: string
+    type: object
+  handler.RequestAddScheduledMessageEvent:
+    properties:
+      contact_id:
+        type: string
+      message_id:
+        type: string
+      scheduled_message_id:
+        type: string
+    type: object
+  handler.RequestScheduledMessageStatus:
+    properties:
+      scheduled_message_id:
+        type: string
+      status:
+        type: string
+    type: object
+  handler.ScheduledMessageChange:
+    properties:
+      old_status:
+        type: string
+      scheduled_message:
+        $ref: '#/definitions/scheduling.ScheduledMessage'
+    type: object
+  handler.ScheduledMessageStatusResponse:
+    properties:
+      data:
+        items:
+          $ref: '#/definitions/handler.ScheduledMessageChange'
+        type: array
+      message:
+        type: string
+    type: object
+  handler.SendInstantMessageRequest:
+    properties:
+      contact_ids:
+        items:
+          type: string
+        type: array
+      message_id:
+        type: string
+      user_id:
+        type: string
+    type: object
+  handler.SendInstantMessageResponse:
+    properties:
+      data:
+        items:
+          $ref: '#/definitions/event.MessageEventResponse'
+        type: array
+      message:
+        type: string
+    type: object
+  handler.UpdateNameRequest:
+    properties:
+      contact_id:
+        type: string
+      first_name:
+        type: string
+      last_name:
+        type: string
+      nickname:
+        type: string
+      user_id:
+        type: string
+    type: object
+  handler.UpdateNameResponse:
+    properties:
+      data:
+        items:
+          $ref: '#/definitions/contact.Contact'
+        type: array
+      message:
+        type: string
+    type: object
+  message.Message:
+    properties:
+      content:
+        type: string
+      id:
+        type: string
+      user_id:
+        type: string
+    type: object
+  scheduling.ScheduledMessage:
+    properties:
+      created:
+        type: string
+      id:
+        type: string
+      scheduled:
+        type: string
+      status:
+        type: string
+      user_id:
+        type: string
+    type: object
+  scheduling.ScheduledMessageEvent:
+    properties:
+      contact_id:
+        type: string
+      created:
+        type: string
+      id:
+        type: string
+      message_id:
+        type: string
+      scheduled_message_id:
+        type: string
+    type: object
+host: localhost:8080
+info:
+  contact: {}
+  description: Core API to send text messages
+  title: textsender-api
+  version: "1.0"
+paths:
+  /contact:
+    get:
+      consumes:
+      - application/json
+      description: Get a contact record to have a recipient to send a text to (requires
+        JWT)
+      parameters:
+      - description: Contact Id
+        in: path
+        name: id
+        required: true
+        type: string
+      - description: User Id
+        in: path
+        name: user_id
+        required: true
+        type: string
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/handler.GetContactResponse'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/handler.GetContactResponse'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/handler.GetContactResponse'
+      security:
+      - BearerAuth: []
+      summary: Get contact
+      tags:
+      - contacts
+  /contact/new:
+    post:
+      consumes:
+      - application/json
+      description: Add a contact record to have a recipient to send a text to (requires
+        JWT)
+      parameters:
+      - description: Data to add contact
+        in: body
+        name: request
+        required: true
+        schema:
+          $ref: '#/definitions/handler.RequestAddContact'
+      produces:
+      - application/json
+      responses:
+        "201":
+          description: Created
+          schema:
+            $ref: '#/definitions/handler.AddContactResponse'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/handler.AddContactResponse'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/handler.AddContactResponse'
+      security:
+      - BearerAuth: []
+      summary: Add contact
+      tags:
+      - contacts
+  /contact/update:
+    patch:
+      consumes:
+      - application/json
+      description: Update the first, last, or nickname of a Contact (requires JWT)
+      parameters:
+      - description: Data to update contact's names
+        in: body
+        name: request
+        required: true
+        schema:
+          $ref: '#/definitions/handler.UpdateNameRequest'
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/handler.UpdateNameResponse'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/handler.UpdateNameResponse'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/handler.UpdateNameResponse'
+      security:
+      - BearerAuth: []
+      summary: Update names of Contact
+      tags:
+      - contacts
+  /instant/message:
+    post:
+      consumes:
+      - application/json
+      description: Send a message without the constraints of scheduled messages (requires
+        JWT)
+      parameters:
+      - description: Send an instnt message
+        in: body
+        name: request
+        required: true
+        schema:
+          $ref: '#/definitions/handler.SendInstantMessageRequest'
+      produces:
+      - application/json
+      responses:
+        "201":
+          description: Created
+          schema:
+            $ref: '#/definitions/handler.SendInstantMessageResponse'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/handler.SendInstantMessageResponse'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/handler.SendInstantMessageResponse'
+      security:
+      - BearerAuth: []
+      summary: Send instant message
+      tags:
+      - messages
+  /message:
+    get:
+      consumes:
+      - application/json
+      description: Get a message record to have a recipient to send a text to (requires
+        JWT)
+      parameters:
+      - description: Message Id
+        in: path
+        name: id
+        required: true
+        type: string
+      - description: User Id
+        in: path
+        name: user_id
+        required: true
+        type: string
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/handler.GetMessageResponse'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/handler.GetMessageResponse'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/handler.GetMessageResponse'
+      security:
+      - BearerAuth: []
+      summary: Get message
+      tags:
+      - messages
+  /message/new:
+    post:
+      consumes:
+      - application/json
+      description: Add a message record to send a text to (requires JWT)
+      parameters:
+      - description: Data to add message
+        in: body
+        name: request
+        required: true
+        schema:
+          $ref: '#/definitions/handler.RequestAddMessage'
+      produces:
+      - application/json
+      responses:
+        "201":
+          description: Created
+          schema:
+            $ref: '#/definitions/handler.AddMessageResponse'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/handler.AddMessageResponse'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/handler.AddMessageResponse'
+      security:
+      - BearerAuth: []
+      summary: Add message
+      tags:
+      - messages
+  /schedule/message:
+    get:
+      consumes:
+      - application/json
+      description: Get a scheduled message (requires JWT)
+      parameters:
+      - description: Contact Id
+        in: path
+        name: id
+        required: true
+        type: string
+      - description: User Id
+        in: path
+        name: user_id
+        required: true
+        type: string
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/handler.GetScheduledMessageResponse'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/handler.GetScheduledMessageResponse'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/handler.GetScheduledMessageResponse'
+      security:
+      - BearerAuth: []
+      summary: Get scheduled message
+      tags:
+      - scheduled messages
+    post:
+      consumes:
+      - application/json
+      description: Adds a scheduled message (requires JWT)
+      parameters:
+      - description: Data to add scheduled message
+        in: body
+        name: request
+        required: true
+        schema:
+          $ref: '#/definitions/handler.RequestAddScheduledMessage'
+      produces:
+      - application/json
+      responses:
+        "201":
+          description: Created
+          schema:
+            $ref: '#/definitions/handler.AddScheduledMessageResponse'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/handler.AddScheduledMessageResponse'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/handler.AddScheduledMessageResponse'
+      security:
+      - BearerAuth: []
+      summary: Add scheduled message
+      tags:
+      - scheduled messages
+  /schedule/message/event:
+    get:
+      consumes:
+      - application/json
+      description: Gets a scheduled message event (requires JWT)
+      parameters:
+      - description: Contact Id
+        in: path
+        name: id
+        required: true
+        type: string
+      - description: Scheduled Message Id
+        in: path
+        name: scheduled_message_id
+        required: true
+        type: string
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/handler.GetScheduledMessageEventResponse'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/handler.GetScheduledMessageEventResponse'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/handler.GetScheduledMessageEventResponse'
+      security:
+      - BearerAuth: []
+      summary: Get scheduled message event
+      tags:
+      - scheduled message events
+    post:
+      consumes:
+      - application/json
+      description: Add a scheduled message event (requires JWT)
+      parameters:
+      - description: Data to add scheduled message event
+        in: body
+        name: request
+        required: true
+        schema:
+          $ref: '#/definitions/handler.RequestAddScheduledMessageEvent'
+      produces:
+      - application/json
+      responses:
+        "201":
+          description: Created
+          schema:
+            $ref: '#/definitions/handler.AddScheduledMessageEventResponse'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/handler.AddScheduledMessageEventResponse'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/handler.AddScheduledMessageEventResponse'
+      security:
+      - BearerAuth: []
+      summary: Add scheduled message event
+      tags:
+      - scheduled message events
+  /schedule/message/event/{id}:
+    delete:
+      consumes:
+      - application/json
+      description: Deletes a scheduled message event (requires JWT)
+      parameters:
+      - description: scheduled message event Id
+        format: uuid
+        in: path
+        name: id
+        required: true
+        type: string
+      produces:
+      - application/json
+      responses:
+        "201":
+          description: Created
+          schema:
+            $ref: '#/definitions/handler.DeleteScheduledMessageEventResponse'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/handler.DeleteScheduledMessageEventResponse'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/handler.DeleteScheduledMessageEventResponse'
+      security:
+      - BearerAuth: []
+      summary: Delete scheduled message event
+      tags:
+      - scheduled message events
+  /schedule/message/event/response:
+    get:
+      consumes:
+      - application/json
+      description: Fetches a MessageEventResponse given a user id (requires JWT)
+      parameters:
+      - description: User Id
+        in: path
+        name: user_id
+        required: true
+        type: string
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/handler.GetMessageEventResponseFetchedResponse'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/handler.GetMessageEventResponseFetchedResponse'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/handler.GetMessageEventResponseFetchedResponse'
+      security:
+      - BearerAuth: []
+      summary: Fetcht MessageEventResponse
+      tags:
+      - message
+  /schedule/message/event/response/record:
+    post:
+      consumes:
+      - application/json
+      description: Saves the result of sending a text message (requires JWT)
+      parameters:
+      - description: Data to add MessageEventResponse
+        in: body
+        name: request
+        required: true
+        schema:
+          $ref: '#/definitions/handler.RecordEventRequest'
+      produces:
+      - application/json
+      responses:
+        "201":
+          description: Created
+          schema:
+            $ref: '#/definitions/handler.RecordEventResponse'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/handler.RecordEventResponse'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/handler.RecordEventResponse'
+      security:
+      - BearerAuth: []
+      summary: Record MessageEventResponse
+      tags:
+      - message
+  /schedule/message/fetch:
+    get:
+      consumes:
+      - application/json
+      description: Fetches a scheduled message that is available to be processed (requires
+        JWT)
+      produces:
+      - application/json
+      responses:
+        "200":
+          description: OK
+          schema:
+            $ref: '#/definitions/handler.FetchNextMessageResponse'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/handler.FetchNextMessageResponse'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/handler.FetchNextMessageResponse'
+      security:
+      - BearerAuth: []
+      summary: Fetch scheduled message
+      tags:
+      - scheduled messages
+  /schedule/message/status/update:
+    patch:
+      consumes:
+      - application/json
+      description: Update the status of a scheduled message (requires JWT)
+      parameters:
+      - description: Used to update scheduled message status
+        in: body
+        name: request
+        required: true
+        schema:
+          $ref: '#/definitions/handler.RequestScheduledMessageStatus'
+      produces:
+      - application/json
+      responses:
+        "201":
+          description: Created
+          schema:
+            $ref: '#/definitions/handler.ScheduledMessageStatusResponse'
+        "400":
+          description: Bad Request
+          schema:
+            $ref: '#/definitions/handler.ScheduledMessageStatusResponse'
+        "404":
+          description: Not Found
+          schema:
+            $ref: '#/definitions/handler.ScheduledMessageStatusResponse'
+        "500":
+          description: Internal Server Error
+          schema:
+            $ref: '#/definitions/handler.ScheduledMessageStatusResponse'
+      security:
+      - BearerAuth: []
+      summary: Update status
+      tags:
+      - status
+securityDefinitions:
+  BearerAuth:
+    description: JWT Bearer Token
+    in: header
+    name: Authorization
+    type: apiKey
+swagger: "2.0"

go.mod

@@ -1,5 +1,48 @@
 module git.kundeng.us/phoenix/textsender-api
 
-go 1.25.3
+go 1.26.1
 
-require github.com/google/uuid v1.6.0
+require (
+	git.kundeng.us/phoenix/swoosh v0.2.0
+	git.kundeng.us/phoenix/textsender-models v0.2.0
+	github.com/go-chi/chi/v5 v5.2.5
+	github.com/go-chi/cors v1.2.2
+	github.com/golang-jwt/jwt/v5 v5.3.1
+	github.com/google/uuid v1.6.0
+	github.com/jackc/pgx/v5 v5.9.1
+	github.com/joho/godotenv v1.5.1
+	github.com/stretchr/testify v1.11.1
+	github.com/swaggo/http-swagger/v2 v2.0.2
+	github.com/swaggo/swag v1.16.6
+)
+
+require (
+	github.com/KyleBanks/depth v1.2.1 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/go-openapi/jsonpointer v0.22.5 // indirect
+	github.com/go-openapi/jsonreference v0.21.5 // indirect
+	github.com/go-openapi/spec v0.22.4 // indirect
+	github.com/go-openapi/swag/conv v0.25.5 // indirect
+	github.com/go-openapi/swag/jsonname v0.25.5 // indirect
+	github.com/go-openapi/swag/jsonutils v0.25.5 // indirect
+	github.com/go-openapi/swag/loading v0.25.5 // indirect
+	github.com/go-openapi/swag/stringutils v0.25.5 // indirect
+	github.com/go-openapi/swag/typeutils v0.25.5 // indirect
+	github.com/go-openapi/swag/yamlutils v0.25.5 // indirect
+	github.com/golang/mock v1.6.0 // indirect
+	github.com/google/go-cmp v0.7.0 // 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/pkg/errors v0.9.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/rogpeppe/go-internal v1.14.1 // indirect
+	github.com/swaggo/files/v2 v2.0.2 // indirect
+	github.com/twilio/twilio-go v1.30.4 // indirect
+	go.yaml.in/yaml/v3 v3.0.4 // indirect
+	golang.org/x/mod v0.34.0 // indirect
+	golang.org/x/sync v0.20.0 // indirect
+	golang.org/x/text v0.35.0 // indirect
+	golang.org/x/tools v0.43.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

go.sum

@@ -1,2 +1,122 @@
+git.kundeng.us/phoenix/swoosh v0.2.0 h1:aecJdtRhgQofaOfki0fm+YszUuwKyfKqF5YVb20yxHI=
+git.kundeng.us/phoenix/swoosh v0.2.0/go.mod h1:NxWD9iUunLIJRgTvlZbZa6jyDHc0JPPRuTmsrxV/hMs=
+git.kundeng.us/phoenix/textsender-models v0.2.0 h1:smz8Fs8VOs1Ya23txbOM0YPRidZIsM0yE9unHF0D/nQ=
+git.kundeng.us/phoenix/textsender-models v0.2.0/go.mod h1:3CkqA/HFKPhpMYxkKn5uVbZEzEbG3sofLZE8pZ1BHO4=
+github.com/KyleBanks/depth v1.2.1 h1:5h8fQADFrWtarTdtDudMmGsC7GPbOAu6RVB3ffsVFHc=
+github.com/KyleBanks/depth v1.2.1/go.mod h1:jzSb9d0L43HxTQfT+oSA1EEp2q+ne2uh6XgeJcm8brE=
+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.5 h1:Eg4myHZBjyvJmAFjFvWgrqDTXFyOzjj7YIm3L3mu6Ug=
+github.com/go-chi/chi/v5 v5.2.5/go.mod h1:X7Gx4mteadT3eDOMTsXzmI4/rwUpOwBHLpAfupzFJP0=
+github.com/go-chi/cors v1.2.2 h1:Jmey33TE+b+rB7fT8MUy1u0I4L+NARQlK6LhzKPSyQE=
+github.com/go-chi/cors v1.2.2/go.mod h1:sSbTewc+6wYHBBCW7ytsFSn836hqM7JxpglAy2Vzc58=
+github.com/go-openapi/jsonpointer v0.22.5 h1:8on/0Yp4uTb9f4XvTrM2+1CPrV05QPZXu+rvu2o9jcA=
+github.com/go-openapi/jsonpointer v0.22.5/go.mod h1:gyUR3sCvGSWchA2sUBJGluYMbe1zazrYWIkWPjjMUY0=
+github.com/go-openapi/jsonreference v0.21.5 h1:6uCGVXU/aNF13AQNggxfysJ+5ZcU4nEAe+pJyVWRdiE=
+github.com/go-openapi/jsonreference v0.21.5/go.mod h1:u25Bw85sX4E2jzFodh1FOKMTZLcfifd1Q+iKKOUxExw=
+github.com/go-openapi/spec v0.22.4 h1:4pxGjipMKu0FzFiu/DPwN3CTBRlVM2yLf/YTWorYfDQ=
+github.com/go-openapi/spec v0.22.4/go.mod h1:WQ6Ai0VPWMZgMT4XySjlRIE6GP1bGQOtEThn3gcWLtQ=
+github.com/go-openapi/swag v0.19.15 h1:D2NRCBzS9/pEY3gP9Nl8aDqGUcPFrwG2p+CNFrLyrCM=
+github.com/go-openapi/swag/conv v0.25.5 h1:wAXBYEXJjoKwE5+vc9YHhpQOFj2JYBMF2DUi+tGu97g=
+github.com/go-openapi/swag/conv v0.25.5/go.mod h1:CuJ1eWvh1c4ORKx7unQnFGyvBbNlRKbnRyAvDvzWA4k=
+github.com/go-openapi/swag/jsonname v0.25.5 h1:8p150i44rv/Drip4vWI3kGi9+4W9TdI3US3uUYSFhSo=
+github.com/go-openapi/swag/jsonname v0.25.5/go.mod h1:jNqqikyiAK56uS7n8sLkdaNY/uq6+D2m2LANat09pKU=
+github.com/go-openapi/swag/jsonutils v0.25.5 h1:XUZF8awQr75MXeC+/iaw5usY/iM7nXPDwdG3Jbl9vYo=
+github.com/go-openapi/swag/jsonutils v0.25.5/go.mod h1:48FXUaz8YsDAA9s5AnaUvAmry1UcLcNVWUjY42XkrN4=
+github.com/go-openapi/swag/jsonutils/fixtures_test v0.25.5 h1:SX6sE4FrGb4sEnnxbFL/25yZBb5Hcg1inLeErd86Y1U=
+github.com/go-openapi/swag/jsonutils/fixtures_test v0.25.5/go.mod h1:/2KvOTrKWjVA5Xli3DZWdMCZDzz3uV/T7bXwrKWPquo=
+github.com/go-openapi/swag/loading v0.25.5 h1:odQ/umlIZ1ZVRteI6ckSrvP6e2w9UTF5qgNdemJHjuU=
+github.com/go-openapi/swag/loading v0.25.5/go.mod h1:I8A8RaaQ4DApxhPSWLNYWh9NvmX2YKMoB9nwvv6oW6g=
+github.com/go-openapi/swag/stringutils v0.25.5 h1:NVkoDOA8YBgtAR/zvCx5rhJKtZF3IzXcDdwOsYzrB6M=
+github.com/go-openapi/swag/stringutils v0.25.5/go.mod h1:PKK8EZdu4QJq8iezt17HM8RXnLAzY7gW0O1KKarrZII=
+github.com/go-openapi/swag/typeutils v0.25.5 h1:EFJ+PCga2HfHGdo8s8VJXEVbeXRCYwzzr9u4rJk7L7E=
+github.com/go-openapi/swag/typeutils v0.25.5/go.mod h1:itmFmScAYE1bSD8C4rS0W+0InZUBrB2xSPbWt6DLGuc=
+github.com/go-openapi/swag/yamlutils v0.25.5 h1:kASCIS+oIeoc55j28T4o8KwlV2S4ZLPT6G0iq2SSbVQ=
+github.com/go-openapi/swag/yamlutils v0.25.5/go.mod h1:Gek1/SjjfbYvM+Iq4QGwa/2lEXde9n2j4a3wI3pNuOQ=
+github.com/go-openapi/testify/enable/yaml/v2 v2.4.0 h1:7SgOMTvJkM8yWrQlU8Jm18VeDPuAvB/xWrdxFJkoFag=
+github.com/go-openapi/testify/enable/yaml/v2 v2.4.0/go.mod h1:14iV8jyyQlinc9StD7w1xVPW3CO3q1Gj04Jy//Kw4VM=
+github.com/go-openapi/testify/v2 v2.4.0 h1:8nsPrHVCWkQ4p8h1EsRVymA2XABB4OT40gcvAu+voFM=
+github.com/go-openapi/testify/v2 v2.4.0/go.mod h1:HCPmvFFnheKK2BuwSA0TbbdxJ3I16pjwMkYkP4Ywn54=
+github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY=
+github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
+github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc=
+github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs=
+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/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+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.9.1 h1:uwrxJXBnx76nyISkhr33kQLlUqjv7et7b9FjCen/tdc=
+github.com/jackc/pgx/v5 v5.9.1/go.mod h1:mal1tBGAFfLHvZzaYh77YS/eC6IX9OWbRV1QIIM0Jn4=
+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/localtunnel/go-localtunnel v0.0.0-20170326223115-8a804488f275 h1:IZycmTpoUtQK3PD60UYBwjaCUHUP7cML494ao9/O8+Q=
+github.com/localtunnel/go-localtunnel v0.0.0-20170326223115-8a804488f275/go.mod h1:zt6UU74K6Z6oMOYJbJzYpYucqdcQwSMPBEdSvGiaUMw=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+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/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=
+github.com/swaggo/files/v2 v2.0.2 h1:Bq4tgS/yxLB/3nwOMcul5oLEUKa877Ykgz3CJMVbQKU=
+github.com/swaggo/files/v2 v2.0.2/go.mod h1:TVqetIzZsO9OhHX1Am9sRf9LdrFZqoK49N37KON/jr0=
+github.com/swaggo/http-swagger/v2 v2.0.2 h1:FKCdLsl+sFCx60KFsyM0rDarwiUSZ8DqbfSyIKC9OBg=
+github.com/swaggo/http-swagger/v2 v2.0.2/go.mod h1:r7/GBkAWIfK6E/OLnE8fXnviHiDeAHmgIyooa4xm3AQ=
+github.com/swaggo/swag v1.16.6 h1:qBNcx53ZaX+M5dxVyTrgQ0PJ/ACK+NzhwcbieTt+9yI=
+github.com/swaggo/swag v1.16.6/go.mod h1:ngP2etMK5a0P3QBizic5MEwpRmluJZPHjXcMoj4Xesg=
+github.com/twilio/twilio-go v1.30.4 h1:Whrz37IykDD9KJI2YX4LWaGxYWZoYB7va8fASGDrLng=
+github.com/twilio/twilio-go v1.30.4/go.mod h1:QbitvbvtkV77Jn4BABAKVmxabYSjMyQG4tHey9gfPqg=
+github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
+go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.34.0 h1:xIHgNUUnW6sYkcM5Jleh05DvLOtwc6RitGHbDk4akRI=
+golang.org/x/mod v0.34.0/go.mod h1:ykgH52iCZe79kzLLMhyCUzhMci+nQj+0XkbXpNYtVjY=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
+golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8=
+golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.43.0 h1:12BdW9CeB3Z+J/I/wj34VMl8X+fEXBxVR90JeMX5E7s=
+golang.org/x/tools v0.43.0/go.mod h1:uHkMso649BX2cZK6+RpuIPXS3ho2hZo4FVwfoy1vIk0=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+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/app/app.go

@@ -0,0 +1,9 @@
+package app
+
+import (
+	auxcfg "git.kundeng.us/phoenix/textsender-models/tx0/config/auxiliary"
+)
+
+type App struct {
+	TwilioConfig *auxcfg.TwilioConfig
+}

internal/config/config.go

@@ -1,13 +1,168 @@
 package config
 
-import "fmt"
+import (
+	"flag"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
 
-const PORT = 8080
+	auxcfg "git.kundeng.us/phoenix/textsender-models/tx0/config/auxiliary"
+	"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"`
+	TwilioConfig   *auxcfg.TwilioConfig
+	AllowedOrigins []string
+}
+
+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, *auxcfg.TwilioConfig, error) {
+	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)
+	}
+
+	if err := godotenv.Load(); err != nil {
+		return nil, nil, fmt.Errorf("Error loading .env file")
+	}
+
+	unpackedConnString := UnpackDBConnString()
+	dbConnString := unpackedConnString.Parse()
+
+	if cfg, err := TwilioConfig(); err != nil {
+		return nil, nil, err
+	} else {
+		allowedOrigins := unpackAllowedOrigins()
+		return &Config{
+			DBConnString:   dbConnString,
+			ServerPort:     *port,
+			ResetDB:        *resetDb,
+			JWTSecret:      os.Getenv("JWT_SECRET"),
+			AllowedOrigins: allowedOrigins,
+		}, cfg, nil
+	}
+}
+
+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 unpackAllowedOrigins() []string {
+	allowedOriginsRaw := os.Getenv("ALLOWED_ORIGINS")
+	allowedOriginsSplit := strings.Split(allowedOriginsRaw, ",")
+	return allowedOriginsSplit
+}
+
+func TwilioConfig() (*auxcfg.TwilioConfig, error) {
+	authSid := os.Getenv("TWILIO_AUTH_SID")
+	serviceSid := os.Getenv("TWILIO_SERVICE_SID")
+	authToken := os.Getenv("TWILIO_AUTH_TOKEN")
+	phoneNumber := os.Getenv("TWILIO_PHONE_NUMBER")
+
+	if len(authSid) == 0 {
+		return nil, fmt.Errorf("Twilio config account sid not found")
+	} else if len(serviceSid) == 0 {
+		return nil, fmt.Errorf("Twilio config service sid not found")
+	} else if len(authToken) == 0 {
+		return nil, fmt.Errorf("Twilio config auth token not found")
+	} else if len(phoneNumber) == 0 {
+		return nil, fmt.Errorf("Twilio config phone number not found")
+	} else {
+		var cfg auxcfg.TwilioConfig
+		cfg.AccountSID = authSid
+		cfg.ServiceSID = serviceSid
+		cfg.AuthToken = authToken
+		cfg.Number = phoneNumber
+
+		return &cfg, nil
+	}
+}
+
+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

@@ -2,81 +2,245 @@ package handler
 
 import (
 	"fmt"
+	"log"
 	"net/http"
 
+	"git.kundeng.us/phoenix/textsender-models/tx0/contact"
 	"github.com/google/uuid"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/app"
+	"git.kundeng.us/phoenix/textsender-api/internal/store"
 )
 
+type ContactHandler struct {
+	App          *app.App
+	ContactStore store.ContactStore
+}
+
+func NewContactHandler(apiApp *app.App, str store.ContactStore) *ContactHandler {
+	return &ContactHandler{App: apiApp, ContactStore: str}
+}
+
 type RequestAddContact struct {
 	PhoneNumber string    `json:"phone_number"`
-	UserId uuid.UUID`json:"user_id"`
+	UserId      uuid.UUID `json:"user_id"`
+	Firstname   *string   `json:"first_name,omitempty"`
+	Lastname    *string   `json:"last_name,omitempty"`
+	Nickname    *string   `json:"nickname,omitempty"`
 }
 
-type LoginResponse struct {
+type AddContactResponse struct {
 	Message string            `json:"message"`
-	Data    []model.Data`json:"data"`
+	Data    []contact.Contact `json:"data"`
 }
 
-type ContactHandler struct {
+// AddContact godoc
-}
+// @Summary      Add contact
-
+// @Description  Add a contact record to have a recipient to send a text to (requires JWT)
-func NewContactHandler(store model.Store) *ContactHandler {
+// @Tags         contacts
-	return &ContactHandler{Store: store}
+// @Accept       json
-}
+// @Produce      json
-
+// @Security     BearerAuth
-func (l *ContactHandler) AddContact(w http.ResponseWriter, r *http.Request) {
+// @Param        request body      RequestAddContact true  "Data to add contact"
-	if r.Method != http.MethodPost {
+// @Success      201  {object}  AddContactResponse
-		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+// @Failure      400  {object}  AddContactResponse
-		return
+// @Failure      500  {object}  AddContactResponse
-	}
+// @Router       /contact/new [post]
-
+func (c *ContactHandler) AddContact(w http.ResponseWriter, r *http.Request) {
 	var req RequestAddContact
 	if err := ExtractFromRequest(r, &req); err != nil {
 		http.Error(w, "Invalid JSON: "+err.Error(), http.StatusBadRequest)
 	}
 	defer r.Body.Close()
 
+	newContact := contact.Contact{PhoneNumber: req.PhoneNumber, UserId: &req.UserId, Firstname: req.Firstname, Lastname: req.Lastname, Nickname: req.Nickname}
+
 	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)
+		log.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 {
+				log.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"
 			}
+		}
+	}
+
+	RespondWithJSON(w, statusCode, &resp)
+}
+
+type GetContactResponse struct {
+	Message string            `json:"message"`
+	Data    []contact.Contact `json:"data"`
+}
+
+// GetContact godoc
+// @Summary      Get contact
+// @Description  Get a contact record to have a recipient to send a text to (requires JWT)
+// @Tags         contacts
+// @Accept       json
+// @Produce      json
+// @Param        id   path      string  true  "Contact Id"
+// @Param        user_id   path      string  true  "User Id"
+// @Security     BearerAuth
+// @Success      200  {object}  GetContactResponse
+// @Failure      400  {object}  GetContactResponse
+// @Failure      500  {object}  GetContactResponse
+// @Router       /contact [get]
+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
+	}
+
+	// One or the other
+	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 = "User not found"
+				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)
+	RespondWithJSON(w, statusCode, &resp)
+}
+
+type UpdateNameRequest struct {
+	Nickname  *string   `json:"nickname,omitempty"`
+	Firstname *string   `json:"first_name,omitempty"`
+	Lastname  *string   `json:"last_name,omitempty"`
+	ContactId uuid.UUID `json:"contact_id"`
+	UserId    uuid.UUID `json:"user_id"`
+}
+
+type UpdateNameResponse struct {
+	Message string            `json:"message"`
+	Data    []contact.Contact `json:"data"`
+}
+
+// UpdateName godoc
+// @Summary      Update names of Contact
+// @Description  Update the first, last, or nickname of a Contact (requires JWT)
+// @Tags         contacts
+// @Accept       json
+// @Produce      json
+// @Security     BearerAuth
+// @Param        request body      UpdateNameRequest true  "Data to update contact's names"
+// @Success      200  {object}  UpdateNameResponse
+// @Failure      400  {object}  UpdateNameResponse
+// @Failure      500  {object}  UpdateNameResponse
+// @Router       /contact/update [patch]
+func (c *ContactHandler) UpdateName(w http.ResponseWriter, r *http.Request) {
+	var req UpdateNameRequest
+	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 UpdateNameResponse
+
+	if req.UserId == uuid.Nil {
+		statusCode = http.StatusBadRequest
+		resp.Message = "User Id not provided"
+	} else if req.ContactId == uuid.Nil {
+		statusCode = http.StatusBadRequest
+		resp.Message = "Contact Id not provided"
+	} else if req.Firstname == nil && req.Lastname == nil && req.Nickname == nil {
+		statusCode = http.StatusBadRequest
+		resp.Message = "No name provided"
+	} else {
+		ctx := r.Context()
+		if con, err := c.ContactStore.GetContactByID(ctx, req.ContactId); err != nil {
+			resp.Message = err.Error()
+			statusCode = http.StatusInternalServerError
+		} else {
+			if affectedRows, err := c.ContactStore.UpdateNames(ctx, con, req.Firstname, req.Lastname, req.Nickname); err != nil {
+				statusCode = http.StatusInternalServerError
+				resp.Message = err.Error()
+			} else {
+				log.Println("Updated", affectedRows, "rows")
+				statusCode = http.StatusOK
+				resp.Message = "Successful"
+				resp.Data = append(resp.Data, *con)
+			}
+		}
+	}
+
+	RespondWithJSON(w, statusCode, &resp)
 }

internal/handler/contact_test.go

@@ -0,0 +1,123 @@
+package handler
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"git.kundeng.us/phoenix/textsender-models/tx0/contact"
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/handler/endpoint"
+	"git.kundeng.us/phoenix/textsender-api/internal/store/mock"
+)
+
+type Request struct {
+	PhoneNumber string
+	UserId      uuid.UUID
+}
+
+func TestCreateContactWithMock(t *testing.T) {
+	mockstore := mock.NewMockContactStore()
+	apiApp, err := GetApp()
+	assert.NoError(t, err, "Error getting app")
+
+	handler := NewContactHandler(apiApp, 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 := mock.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()
+
+	apiApp, err := GetApp()
+	assert.NoError(t, err, "Error getting app")
+	contactHandler := NewContactHandler(apiApp, 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 TestUpdateContactNamesWithMock(t *testing.T) {
+	mockstore := mock.NewMockContactStore()
+	testUserId := uuid.New()
+
+	testCon := contact.Contact{PhoneNumber: "+12335403383", UserId: &testUserId}
+	ctx := t.Context()
+	var firstname, lastname, nickname string
+	firstname = "Bob"
+	lastname = "De-Buildor"
+	nickname = "With The Tool"
+	if err := mockstore.CreateContact(ctx, &testCon); err != nil {
+		assert.NoError(t, err, "Error creating contact")
+		return
+	}
+
+	var requestBody UpdateNameRequest
+	requestBody.Firstname = &firstname
+	requestBody.Lastname = &lastname
+	requestBody.Nickname = &nickname
+	requestBody.ContactId = *testCon.Id
+	requestBody.UserId = testUserId
+	jsonValue, _ := json.Marshal(requestBody)
+	req, _ := http.NewRequest("PATCH", endpoint.Update_Names_Endpoint, strings.NewReader(string(jsonValue)))
+	rr := httptest.NewRecorder()
+
+	apiApp, err := GetApp()
+	assert.NoError(t, err, "Error getting app")
+	contactHandler := NewContactHandler(apiApp, mockstore)
+	contactHandler.UpdateName(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+
+	var response UpdateNameResponse
+	err = json.Unmarshal(rr.Body.Bytes(), &response)
+	assert.NoError(t, err, "Error updating names of contact %v", err)
+
+	assert.NotEmpty(t, response.Data, "No Contact updated")
+
+	assert.NotNil(t, response.Data[0].Firstname, "Firstname should not be nil")
+	assert.NotNil(t, response.Data[0].Lastname, "Lastname should not be nil")
+	assert.NotNil(t, response.Data[0].Nickname, "Nickname should not be nil")
+}

internal/handler/draftMessage.go

@@ -4,6 +4,7 @@ import "net/http"
 
 import "git.kundeng.us/phoenix/textsender-api/internal/model"
 
+// TODO: Remove file
 func DraftMessageHandler(w http.ResponseWriter, r *http.Request) {
 	da := model.MessageItem{
 		Id:      1,

internal/handler/endpoint/endpoint.go

@@ -0,0 +1,29 @@
+package endpoint
+
+const (
+	MESSAGE_DRAFT_ENDPOINT = "/api/v1/message/draft"
+
+	ADD_MESSAGE = "/api/v1/message/new"
+	GET_MESSAGE = "/api/v1/message"
+
+	GET_CONTACT           = "/api/v1/contact"
+	ADD_CONTACT_ENDPOINT  = "/api/v1/contact/new"
+	Update_Names_Endpoint = "/api/v1/contact/update"
+
+	ScheduleMessageEndpoint     = "/api/v1/schedule/message"
+	GetScheduledMessageEndpoint = "/api/v1/schedule/message"
+
+	AddEventToScheduledMessageEndpoint   = "/api/v1/schedule/message/event"
+	GetScheduledMessageEventEndpoint     = "/api/v1/schedule/message/event"
+	DeleteScheduledMessageEventEndpoint  = "/api/v1/schedule/message/event/{id}"
+	UpdateScheduledMessageStatusEndpoint = "/api/v1/schedule/message/status/update"
+
+	FetchNextScheduledMessageEndpoint = "/api/v1/schedule/message/fetch"
+
+	// TODO: Tweak endpoint verbage for MessageEventResponse endpoint
+	// TODO: Make RecordEventResponse more consistent with MessageEventResponse
+	RecordEventResponse       = "/api/v1/schedule/message/event/response/record"
+	FetchMessageEventResponse = "/api/v1/schedule/message/event/response"
+
+	SendInstantMessageEndpoint = "/api/v1/instant/message"
+)

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

@@ -1,9 +1,11 @@
 package handler
 
-import "encoding/json"
+import (
-import "log"
+	"encoding/json"
-import "net/http"
+	"fmt"
-
+	"log"
+	"net/http"
+)
 
 func ExtractFromRequest(r *http.Request, reqItem interface{}) error {
 	err := json.NewDecoder(r.Body).Decode(&reqItem)
@@ -14,8 +16,12 @@ func ExtractFromRequest(r *http.Request, reqItem interface{}) error {
 	}
 }
 
+func InvalidJson(err error) string {
+	return fmt.Sprintf("Invalid JSON: %s", err.Error())
+}
 
 // Helper function to send JSON responses
+// TODO: Change type of data to any
 func RespondWithJSON(w http.ResponseWriter, statusCode int, data interface{}) {
 	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(statusCode)
@@ -23,3 +29,18 @@ func RespondWithJSON(w http.ResponseWriter, statusCode int, data interface{}) {
 		log.Printf("Error encoding JSON: %v", err)
 	}
 }
+
+// Gets the query parameter from the URL
+func ParseQueryParams(r *http.Request, query string) (*string, error) {
+	queryParams := r.URL.Query()
+	if _, exists := queryParams[query]; exists {
+		value := queryParams.Get(query)
+		if len(value) == 0 {
+			return nil, fmt.Errorf("Value of query parameter is empty")
+		} else {
+			return &value, nil
+		}
+	} else {
+		return nil, fmt.Errorf("Could not find query %s", query)
+	}
+}

internal/handler/helper_test.go

@@ -0,0 +1,111 @@
+package handler
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path"
+	"testing"
+	"time"
+
+	"git.kundeng.us/phoenix/textsender-models/tx0/contact"
+	"git.kundeng.us/phoenix/textsender-models/tx0/message"
+	"git.kundeng.us/phoenix/textsender-models/tx0/message/scheduling"
+	"github.com/google/uuid"
+	"github.com/joho/godotenv"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/app"
+	"git.kundeng.us/phoenix/textsender-api/internal/config"
+	"git.kundeng.us/phoenix/textsender-api/internal/db"
+)
+
+func GetApp() (*app.App, error) {
+	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())
+		}
+	}
+
+	if tCfg, err := config.TwilioConfig(); err != nil {
+		return nil, fmt.Errorf("Error: %v", err)
+	} else {
+		return &app.App{TwilioConfig: tCfg}, nil
+	}
+}
+
+func ResetTestDB(t *testing.T, tableName string) {
+	t.Helper()
+	_, err := db.Pool.Exec(context.Background(), fmt.Sprintf("DELETE FROM %s", tableName))
+	if err != nil {
+		t.Fatalf("Failed to reset test database: %v", err)
+	}
+}
+
+func ContactTest(id uuid.UUID, userId uuid.UUID) contact.Contact {
+	if id == uuid.Nil {
+		id = uuid.New()
+		return contact.Contact{Id: &id, PhoneNumber: "+10123456789", UserId: &userId}
+	} else {
+		return contact.Contact{Id: &id, PhoneNumber: "+10123456789", UserId: &userId}
+	}
+}
+
+func MessageTest(id uuid.UUID, userId uuid.UUID) message.Message {
+	if id == uuid.Nil {
+		id = uuid.New()
+		return message.Message{Id: &id, Content: "Oh how the mighty have fallen", UserId: &userId}
+	} else {
+		return message.Message{Id: &id, Content: "Oh how the mighty have fallen", UserId: &userId}
+	}
+}
+
+func ScheduledMessageTest(id uuid.UUID, userId uuid.UUID, now time.Time) scheduling.ScheduledMessage {
+	if id == uuid.Nil {
+		return scheduling.ScheduledMessage{Id: uuid.New(), UserId: userId, Scheduled: now.Add(20 * time.Minute), Status: scheduling.Pending}
+	} else {
+		return scheduling.ScheduledMessage{Id: id, UserId: userId, Scheduled: now.Add(20 * time.Minute), Status: scheduling.Pending}
+	}
+}
+
+func ScheduledMessageEventTest(messageId, contactId, scheduledMessageId uuid.UUID) scheduling.ScheduledMessageEvent {
+	return scheduling.ScheduledMessageEvent{MessageId: messageId, ContactId: contactId, ScheduledMessageId: scheduledMessageId}
+}
+
+func MERResponseInString() string {
+	return `{
+  "body": "Whoknows?",
+  "num_segments": "0",
+  "direction": "outbound-api",
+  "from": "+12243026041",
+  "to": "+16303831708",
+  "date_updated": "Sat,29Nov202519:06:59+0000",
+  "uri": "/2010-04-01/Accounts/ACefa1ef516314c9d1a68cbd657de49277/Messages/SM1193a529e7f7a840667cd1e0f13ea95a.json",
+  "account_sid": "ACefa1ef516314c9d1a68cbd657de49277",
+  "num_media": "0",
+  "status": "scheduled",
+  "messaging_service_sid": "MG803f3676706b92eb02e18dd820c447f2",
+  "sid": "SM1193a529e7f7a840667cd1e0f13ea95a",
+  "date_created": "Sat,29Nov202519:06:59+0000",
+  "api_version": "2010-04-01",
+  "subresource_uris": {
+    "media": "/2010-04-01/Accounts/ACefa1ef516314c9d1a68cbd657de49277/Messages/SM1193a529e7f7a840667cd1e0f13ea95a/Media.json"
+  }
+}`
+}
+
+func ConvertStringToMapOfAny(response string) (map[string]any, error) {
+	bytes := []byte(response)
+	var merResponse map[string]any
+	err := json.Unmarshal(bytes, &merResponse)
+	if err != nil {
+		return nil, err
+	} else {
+		return merResponse, nil
+	}
+}

internal/handler/instant_message.go

@@ -0,0 +1,189 @@
+package handler
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"net/http"
+	"strings"
+	"time"
+
+	"git.kundeng.us/phoenix/swoosh/swoop/send"
+	"git.kundeng.us/phoenix/textsender-models/tx0/contact"
+	"git.kundeng.us/phoenix/textsender-models/tx0/message"
+	"git.kundeng.us/phoenix/textsender-models/tx0/message/event"
+	"github.com/google/uuid"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/app"
+	"git.kundeng.us/phoenix/textsender-api/internal/store"
+)
+
+const Contact_Limit = 400
+
+type SendInstantMessageHandler struct {
+	App          *app.App
+	MERStore     store.MessageEventResponseStore
+	ContactStore store.ContactStore
+	MessageStore store.MessageStore
+}
+
+func NewSendInstantMessageHandler(apiApp *app.App, str store.MessageEventResponseStore, cStore store.ContactStore, mStore store.MessageStore) *SendInstantMessageHandler {
+	return &SendInstantMessageHandler{App: apiApp, MERStore: str, ContactStore: cStore, MessageStore: mStore}
+}
+
+type SendInstantMessageRequest struct {
+	ContactIds []uuid.UUID `json:"contact_ids"`
+	MessageId  uuid.UUID   `json:"message_id"`
+	UserId     uuid.UUID   `json:"user_id"`
+}
+
+type SendInstantMessageResponse struct {
+	Message string                        `json:"message"`
+	Data    []*event.MessageEventResponse `json:"data"`
+}
+
+// Sent godoc
+// @Summary      Send instant message
+// @Description  Send a message without the constraints of scheduled messages (requires JWT)
+// @Tags         messages
+// @Accept       json
+// @Produce      json
+// @Security     BearerAuth
+// @Param 	 request body 	SendInstantMessageRequest true "Send an instnt message"
+// @Success      201  {object}  SendInstantMessageResponse
+// @Failure      400  {object}  SendInstantMessageResponse
+// @Failure      500  {object}  SendInstantMessageResponse
+// @Router       /instant/message [post]
+func (s *SendInstantMessageHandler) Send(w http.ResponseWriter, r *http.Request) {
+	var req SendInstantMessageRequest
+	if err := ExtractFromRequest(r, &req); err != nil {
+		http.Error(w, InvalidJson(err), http.StatusBadRequest)
+	}
+	defer r.Body.Close()
+
+	var statusCode int
+	var resp SendInstantMessageResponse
+
+	if req.UserId == uuid.Nil {
+		statusCode = http.StatusBadRequest
+		resp.Message = "User Id is nil"
+	} else if req.MessageId == uuid.Nil {
+		statusCode = http.StatusBadRequest
+		resp.Message = "Message Id is nil"
+	} else if len(req.ContactIds) == 0 {
+		statusCode = http.StatusBadRequest
+		resp.Message = "No contacts provided"
+	} else {
+		if len(req.ContactIds) > Contact_Limit {
+			statusCode = http.StatusBadRequest
+			resp.Message = "Too many contacts"
+		} else {
+			ctx := r.Context()
+			if msg, contacts, err := s.verify(ctx, &req); err != nil {
+				statusCode = http.StatusInternalServerError
+				resp.Message = err.Error()
+			} else {
+				if msg == nil {
+					statusCode = http.StatusBadRequest
+					resp.Message = "Message is empty"
+				} else if len(contacts) == 0 {
+					statusCode = http.StatusBadRequest
+					resp.Message = "Contacts not found"
+				} else {
+					if s.App != nil {
+						msgSender := send.MessageSender{Config: s.App.TwilioConfig}
+						for _, c := range contacts {
+							if twilioResp, twilioRespObject, err := msgSender.Send(*msg, *c, nil); err != nil {
+								statusCode = http.StatusInternalServerError
+								resp.Message = err.Error()
+							} else {
+								dateStr := strings.TrimSpace(*twilioResp.DateUpdated)
+								if parsedTime, err := time.Parse(time.RFC1123Z, dateStr); err != nil {
+									statusCode = http.StatusInternalServerError
+									resp.Message = err.Error()
+								} else {
+									mer := event.MessageEventResponse{}
+									mer.Response = twilioRespObject
+									mer.UserId = req.UserId
+									mer.Sent = parsedTime
+									mer.Status = event.Message_Event_Response_Status_Instant
+									mer.ContactId = c.Id
+									mer.MessageId = msg.Id
+									if err := s.MERStore.Create(ctx, &mer); err != nil {
+										statusCode = http.StatusInternalServerError
+										resp.Message = err.Error()
+									} else {
+										statusCode = http.StatusOK
+										resp.Message = "Successful"
+										resp.Data = append(resp.Data, &mer)
+									}
+								}
+							}
+						}
+					} else {
+						statusCode = http.StatusInternalServerError
+						resp.Message = "Config not properly configured"
+					}
+				}
+			}
+		}
+	}
+
+	RespondWithJSON(w, statusCode, &resp)
+}
+
+func (s *SendInstantMessageHandler) verify(ctx context.Context, req *SendInstantMessageRequest) (*message.Message, []*contact.Contact, error) {
+	if msg, err := s.verifyMessage(ctx, req.MessageId); err != nil {
+		log.Println("Huh?")
+		return nil, nil, fmt.Errorf("Error:%v", err)
+	} else {
+		log.Println("Okay")
+		if msg != nil {
+			if contacts, err := s.verifyContacts(ctx, req.ContactIds); err != nil {
+				return nil, nil, fmt.Errorf("Error:%v", err)
+			} else {
+				if len(contacts) == 0 {
+					return msg, nil, nil
+				} else {
+					return msg, contacts, nil
+				}
+			}
+		} else {
+			log.Println("How can this be?")
+			return nil, nil, fmt.Errorf("Could not verify message")
+		}
+	}
+}
+
+func (s *SendInstantMessageHandler) verifyMessage(ctx context.Context, messageId uuid.UUID) (*message.Message, error) {
+	if msg, err := s.MessageStore.GetMessageByID(ctx, messageId); err != nil {
+		return nil, fmt.Errorf("Error getting message:%v", err)
+	} else {
+		if msg == nil {
+			log.Println("Message is nil")
+			return nil, nil
+		} else {
+			return msg, nil
+		}
+	}
+}
+
+func (s *SendInstantMessageHandler) verifyContacts(ctx context.Context, contactIds []uuid.UUID) ([]*contact.Contact, error) {
+	var contacts []*contact.Contact
+
+	for _, contactId := range contactIds {
+		if c, err := s.ContactStore.GetContactByID(ctx, contactId); err != nil {
+			return nil, fmt.Errorf("Error getting contacts:%v", err)
+		} else {
+			if c != nil {
+				contacts = append(contacts, c)
+			}
+		}
+	}
+
+	if len(contacts) == 0 {
+		return nil, nil
+	} else {
+		return contacts, nil
+	}
+}

internal/handler/message.go

@@ -0,0 +1,180 @@
+package handler
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+
+	"git.kundeng.us/phoenix/textsender-models/tx0/message"
+	"github.com/google/uuid"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/app"
+	"git.kundeng.us/phoenix/textsender-api/internal/store"
+)
+
+type MessageHandler struct {
+	App          *app.App
+	MessageStore store.MessageStore
+}
+
+func NewMessageHandler(apiApp *app.App, str store.MessageStore) *MessageHandler {
+	return &MessageHandler{App: apiApp, MessageStore: str}
+}
+
+const Message_Limit = 200
+
+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"`
+}
+
+// AddMessage godoc
+// @Summary      Add message
+// @Description  Add a message record to send a text to (requires JWT)
+// @Tags         messages
+// @Accept       json
+// @Produce      json
+// @Security     BearerAuth
+// @Param 	 request body 	RequestAddMessage true "Data to add message"
+// @Success      201  {object}  AddMessageResponse
+// @Failure      400  {object}  AddMessageResponse
+// @Failure      500  {object}  AddMessageResponse
+// @Router       /message/new [post]
+func (m *MessageHandler) AddMessage(w http.ResponseWriter, r *http.Request) {
+	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}
+
+	if isMessageValid(&newMessage) {
+		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)
+		}
+	} else {
+		statusCode = http.StatusBadRequest
+		resp.Message = fmt.Sprintf("Message length exceeds maximum limit. Current size: %d Limit: %d", len(newMessage.Content), Message_Limit)
+	}
+
+	RespondWithJSON(w, statusCode, &resp)
+}
+
+func isMessageValid(msg *message.Message) bool {
+	if len(msg.Content) <= Message_Limit {
+		return true
+	} else {
+		return false
+	}
+}
+
+type GetMessageResponse struct {
+	Message string            `json:"message"`
+	Data    []message.Message `json:"data"`
+}
+
+// GetMessage godoc
+// @Summary      Get message
+// @Description  Get a message record to have a recipient to send a text to (requires JWT)
+// @Tags         messages
+// @Accept       json
+// @Produce      json
+// @Param        id   path      string  true  "Message Id"
+// @Param        user_id   path      string  true  "User Id"
+// @Security     BearerAuth
+// @Success      200  {object}  GetMessageResponse
+// @Failure      400  {object}  GetMessageResponse
+// @Failure      500  {object}  GetMessageResponse
+// @Router       /message [get]
+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 {
+		log.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 {
+		log.Println("Checking with User Id")
+		if messages, err := c.MessageStore.GetAllMessages(ctx); err == nil {
+			log.Println("Amount of messages:", len(messages))
+			for _, msg := range messages {
+				if *msg.UserId == userId {
+					resp.Data = append(resp.Data, *msg)
+				}
+			}
+
+			if len(resp.Data) > 0 {
+				statusCode = http.StatusOK
+				resp.Message = "Successful"
+			} else {
+				statusCode = http.StatusNotFound
+				resp.Message = "Message 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_event_response.go

@@ -0,0 +1,174 @@
+package handler
+
+import (
+	"log"
+	"net/http"
+	"time"
+
+	"git.kundeng.us/phoenix/textsender-models/tx0/message/event"
+	"github.com/google/uuid"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/app"
+	"git.kundeng.us/phoenix/textsender-api/internal/store"
+)
+
+type EventResponseHandler struct {
+	App                       *app.App
+	MessageEventResponseStore store.MessageEventResponseStore
+}
+
+func NewEventResponseHandler(apiApp *app.App, str store.MessageEventResponseStore) *EventResponseHandler {
+	return &EventResponseHandler{App: apiApp, MessageEventResponseStore: str}
+}
+
+type RecordEventRequest struct {
+	ScheduledMessageEventId uuid.UUID      `json:"scheduled_message_event_id"`
+	Response                map[string]any `json:"response"`
+	UserId                  uuid.UUID      `json:"user_id"`
+	Sent                    *time.Time     `json:"sent,omitempty"`
+	Status                  string         `json:"status"`
+	ContactId               *uuid.UUID     `json:"contact_id"`
+	MessageId               *uuid.UUID     `json:"message_id"`
+}
+
+type RecordEventResponse struct {
+	Message string                        `json:"message"`
+	Data    []*event.MessageEventResponse `json:"data"`
+}
+
+// RecordMessageEventResponse godoc
+// @Summary      Record MessageEventResponse
+// @Description  Saves the result of sending a text message (requires JWT)
+// @Tags         message
+// @Accept       json
+// @Produce      json
+// @Security     BearerAuth
+// @Param        request body      RecordEventRequest true  "Data to add MessageEventResponse"
+// @Success      201  {object}  RecordEventResponse
+// @Failure      400  {object}  RecordEventResponse
+// @Failure      500  {object}  RecordEventResponse
+// @Router       /schedule/message/event/response/record [post]
+func (e *EventResponseHandler) RecordResponse(w http.ResponseWriter, r *http.Request) {
+	var req RecordEventRequest
+	if err := ExtractFromRequest(r, &req); err != nil {
+		http.Error(w, "Invalid JSON: "+err.Error(), http.StatusBadRequest)
+	}
+	defer r.Body.Close()
+
+	var statusCode int
+	var rp event.MessageEventResponse
+	var resp RecordEventResponse
+
+	if req.Sent == nil {
+		statusCode = http.StatusBadRequest
+		resp.Message = "Sent time is empty"
+	} else if req.UserId == uuid.Nil {
+		statusCode = http.StatusBadRequest
+		resp.Message = "User Id is empty"
+	} else if len(req.Response) == 0 {
+		statusCode = http.StatusBadRequest
+		resp.Message = "Response is empty"
+	} else if req.ScheduledMessageEventId == uuid.Nil {
+		statusCode = http.StatusBadRequest
+		resp.Message = "Scheduled message event Id is empty"
+	} else {
+		log.Println("Starting process to record Message Event Response")
+		rp.ScheduledMessageEventId = req.ScheduledMessageEventId
+		rp.Response = req.Response
+		rp.UserId = req.UserId
+		rp.Sent = *req.Sent
+
+		switch req.Status {
+		case event.Message_Event_Response_Status_Instant:
+			{
+				log.Println("Status:", req.Status)
+				rp.Status = req.Status
+				rp.MessageId = req.MessageId
+				rp.ContactId = req.ContactId
+			}
+		case event.Message_Event_Response_Status_Scheduled:
+			{
+				log.Println("Status:", req.Status)
+				rp.Status = req.Status
+			}
+		default:
+			{
+				statusCode = http.StatusBadRequest
+				resp.Message = "Status is invalid"
+			}
+		}
+
+		ctx := r.Context()
+		if err := e.MessageEventResponseStore.Create(ctx, &rp); err != nil {
+			log.Println("Error:", err)
+			resp.Message = err.Error()
+			statusCode = http.StatusInternalServerError
+		} else {
+			log.Println("Created Message Event Response")
+			statusCode = http.StatusCreated
+			resp.Message = "Successful"
+			resp.Data = append(resp.Data, &rp)
+		}
+	}
+
+	RespondWithJSON(w, statusCode, &resp)
+}
+
+type GetMessageEventResponseFetchedResponse struct {
+	Message string                        `json:"message"`
+	Data    []*event.MessageEventResponse `json:"data"`
+}
+
+// FetchtMessageEventResponse godoc
+// @Summary      Fetcht MessageEventResponse
+// @Description  Fetches a MessageEventResponse given a user id (requires JWT)
+// @Tags         message
+// @Accept       json
+// @Produce      json
+// @Param        user_id   path      string  true  "User Id"
+// @Security     BearerAuth
+// @Success      200  {object}  GetMessageEventResponseFetchedResponse
+// @Failure      400  {object}  GetMessageEventResponseFetchedResponse
+// @Failure      500  {object}  GetMessageEventResponseFetchedResponse
+// @Router       /schedule/message/event/response [get]
+func (e *EventResponseHandler) Fetch(w http.ResponseWriter, r *http.Request) {
+	queryParams := r.URL.Query()
+	var userId uuid.UUID
+
+	if _, exists := queryParams["user_id"]; !exists {
+		http.Error(w, "Query params", http.StatusBadRequest)
+		return
+	} else {
+		var err error
+		userId, err = uuid.Parse(queryParams.Get("user_id"))
+		if err != nil {
+			http.Error(w, "Query params", http.StatusBadRequest)
+			return
+		}
+	}
+
+	var statusCode int
+	var resp GetMessageEventResponseFetchedResponse
+
+	if userId == uuid.Nil {
+		statusCode = http.StatusBadRequest
+		resp.Message = "User Id is nil"
+	} else {
+		ctx := r.Context()
+		if sentMessages, err := e.MessageEventResponseStore.GetWithUserId(ctx, userId); err != nil {
+			statusCode = http.StatusInternalServerError
+			resp.Message = err.Error()
+		} else {
+			if len(sentMessages) == 0 {
+				statusCode = http.StatusNotFound
+				resp.Message = "Not MessageEventResponses found"
+			} else {
+				statusCode = http.StatusOK
+				resp.Message = "Successful"
+				resp.Data = sentMessages
+			}
+		}
+	}
+
+	RespondWithJSON(w, statusCode, &resp)
+}

internal/handler/message_event_response_test.go

@@ -0,0 +1,162 @@
+package handler
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	evnt "git.kundeng.us/phoenix/textsender-models/tx0/message/event"
+	"git.kundeng.us/phoenix/textsender-models/tx0/message/scheduling"
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/handler/endpoint"
+	"git.kundeng.us/phoenix/textsender-api/internal/store/mock"
+)
+
+func TestRecordMessageEventResponseWithMock(t *testing.T) {
+	now := time.Now()
+
+	mockStore := mock.NewMockScheduledMessageEventStore()
+	contactStore := mock.NewMockContactStore()
+	messageStore := mock.NewMockMessageStore()
+	schMsgStore := mock.NewMockScheduledMessageStore()
+	merStore := mock.NewMockMessageEventResponseStore()
+
+	apiApp, err := GetApp()
+	assert.NoError(t, err, "Error getting app")
+	handler := NewEventResponseHandler(apiApp, merStore)
+
+	contactId := uuid.New()
+	messageId := uuid.New()
+	scheduledMessageId := uuid.New()
+	testUserId := uuid.New()
+
+	con := ContactTest(contactId, testUserId)
+	msg := MessageTest(messageId, testUserId)
+	schMsg := ScheduledMessageTest(scheduledMessageId, testUserId, now)
+	event := scheduling.ScheduledMessageEvent{}
+
+	ctx := t.Context()
+
+	if err := contactStore.CreateContact(ctx, &con); err != nil {
+		assert.NoError(t, err, "Error creating contact: %v", err)
+	} else if err = messageStore.CreateMessage(ctx, &msg); err != nil {
+		assert.NoError(t, err, "Error creating message: %v", err)
+	} else if err = schMsgStore.CreateScheduledMessage(ctx, &schMsg); err != nil {
+		assert.NoError(t, err, "Error creating scheduled message: %v", err)
+	}
+
+	event.MessageId = *msg.Id
+	event.ContactId = *con.Id
+	event.ScheduledMessageId = schMsg.Id
+	if err := mockStore.CreateScheduledMessageEvent(ctx, &event); err != nil {
+		assert.NoError(t, err, "Error creating scheduled message event: %v", err)
+	}
+
+	sent := now.Add(30 * time.Minute)
+	var merResponse map[string]any
+	merResponse, err = ConvertStringToMapOfAny(MERResponseInString())
+	assert.NoError(t, err, "Error Converting to map[string]any")
+
+	testReq := RecordEventRequest{ScheduledMessageEventId: event.Id, Response: merResponse, UserId: schMsg.UserId, Sent: &sent, Status: evnt.Message_Event_Response_Status_Scheduled}
+	jsonValue, _ := json.Marshal(testReq)
+
+	req, _ := http.NewRequest("POST", endpoint.RecordEventResponse, strings.NewReader(string(jsonValue)))
+	rr := httptest.NewRecorder()
+
+	handler.RecordResponse(rr, req)
+
+	assert.Equal(t, http.StatusCreated, rr.Code)
+
+	var response RecordEventResponse
+	err = json.Unmarshal(rr.Body.Bytes(), &response)
+	assert.NoError(t, err, "Error parsing message event response:%v", err)
+
+	assert.NotEmpty(t, response.Data, "No message event response created")
+
+	var msgEventResp evnt.MessageEventResponse
+	msgEventResp = *response.Data[0]
+
+	assert.NotEmpty(t, msgEventResp.Response, "The response of the message event response is empty")
+	assert.Equal(t, msgEventResp.Response, testReq.Response, "Responses do not match")
+}
+
+func TestGetMessageEventResponse(t *testing.T) {
+	now := time.Now()
+
+	mockStore := mock.NewMockScheduledMessageEventStore()
+	contactStore := mock.NewMockContactStore()
+	messageStore := mock.NewMockMessageStore()
+	schMsgStore := mock.NewMockScheduledMessageStore()
+	merStore := mock.NewMockMessageEventResponseStore()
+
+	apiApp, err := GetApp()
+	assert.NoError(t, err, "Error getting app")
+	handler := NewEventResponseHandler(apiApp, merStore)
+
+	contactId := uuid.New()
+	messageId := uuid.New()
+	scheduledMessageId := uuid.New()
+	testUserId := uuid.New()
+
+	con := ContactTest(contactId, testUserId)
+	msg := MessageTest(messageId, testUserId)
+	schMsg := ScheduledMessageTest(scheduledMessageId, testUserId, now)
+
+	ctx := t.Context()
+
+	if err := contactStore.CreateContact(ctx, &con); err != nil {
+		assert.NoError(t, err, "Error creating contact: %v", err)
+	} else if err = messageStore.CreateMessage(ctx, &msg); err != nil {
+		assert.NoError(t, err, "Error creating message: %v", err)
+	} else if err = schMsgStore.CreateScheduledMessage(ctx, &schMsg); err != nil {
+		assert.NoError(t, err, "Error creating scheduled message: %v", err)
+	}
+
+	event := scheduling.ScheduledMessageEvent{}
+	event.MessageId = *msg.Id
+	event.ContactId = *con.Id
+	event.ScheduledMessageId = schMsg.Id
+	sent := now.Add(30 * time.Minute)
+	if err := mockStore.CreateScheduledMessageEvent(ctx, &event); err != nil {
+		assert.NoError(t, err, "Error creating scheduled message event: %v", err)
+	} else {
+		m := evnt.MessageEventResponse{}
+		m.ScheduledMessageEventId = event.Id
+		m.UserId = schMsg.UserId
+		m.Status = evnt.Message_Event_Response_Status_Scheduled
+		m.Sent = sent
+		var merResponse map[string]any
+		merResponse, err = ConvertStringToMapOfAny(MERResponseInString())
+		assert.NoError(t, err, "Error Converting to map[string]any")
+		m.Response = merResponse
+
+		if err := merStore.Create(ctx, &m); err != nil {
+			assert.NoError(t, err, "Error creating MessageEventResponse: %v", err)
+		}
+	}
+
+	url := fmt.Sprintf("%s?user_id=%s", endpoint.FetchMessageEventResponse, testUserId)
+	req, _ := http.NewRequest("GET", url, nil)
+	rr := httptest.NewRecorder()
+
+	handler.Fetch(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+
+	var response GetMessageEventResponseFetchedResponse
+	err = json.Unmarshal(rr.Body.Bytes(), &response)
+	assert.NoError(t, err, "Error parsing message event response: %v", err)
+
+	assert.NotEmpty(t, response.Data, "No message event response found")
+
+	var msgEventResp evnt.MessageEventResponse
+	msgEventResp = *response.Data[0]
+
+	assert.NotEmpty(t, msgEventResp.Response, "The response of the message event response is empty")
+}

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/tx0/message"
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/handler/endpoint"
+	"git.kundeng.us/phoenix/textsender-api/internal/store/mock"
+)
+
+func TestCreateMessageWithMock(t *testing.T) {
+	mockStore := mock.NewMockMessageStore()
+	apiApp, err := GetApp()
+	assert.NoError(t, err, "Error getting app")
+	handler := NewMessageHandler(apiApp, mockStore)
+
+	testUserId := uuid.New()
+	testBody := RequestAddMessage{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 := mock.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()
+
+	apiApp, err := GetApp()
+	assert.NoError(t, err, "Error getting app")
+	messageHandler := NewMessageHandler(apiApp, 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/schedule_message_status.go

@@ -0,0 +1,169 @@
+package handler
+
+import (
+	"net/http"
+
+	"git.kundeng.us/phoenix/textsender-models/tx0/message/scheduling"
+	"github.com/google/uuid"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/app"
+	"git.kundeng.us/phoenix/textsender-api/internal/store"
+)
+
+type ScheduledMessageStatusHandler struct {
+	App                        *app.App
+	ScheduledMessageEventStore store.ScheduledMessageEventStore
+	ScheduledMessageStore      store.ScheduledMessageStore
+}
+
+func NewScheduledMessageStatusHandler(apiApp *app.App, str store.ScheduledMessageEventStore, schStore store.ScheduledMessageStore) *ScheduledMessageStatusHandler {
+	return &ScheduledMessageStatusHandler{App: apiApp, ScheduledMessageEventStore: str, ScheduledMessageStore: schStore}
+}
+
+type RequestScheduledMessageStatus struct {
+	ScheduledMessageId uuid.UUID `json:"scheduled_message_id"`
+	Status             string    `json:"status"`
+}
+
+type ScheduledMessageChange struct {
+	OldStatus        string                      `json:"old_status"`
+	ScheduledMessage scheduling.ScheduledMessage `json:"scheduled_message"`
+}
+
+type ScheduledMessageStatusResponse struct {
+	Message string                   `json:"message"`
+	Data    []ScheduledMessageChange `json:"data"`
+}
+
+// UpdateStatus godoc
+// @Summary      Update status
+// @Description  Update the status of a scheduled message (requires JWT)
+// @Tags         status
+// @Accept       json
+// @Produce      json
+// @Security     BearerAuth
+// @Param request body RequestScheduledMessageStatus true "Used to update scheduled message status"
+// @Success      201  {object}  ScheduledMessageStatusResponse
+// @Failure      400  {object}  ScheduledMessageStatusResponse
+// @Failure      404  {object}  ScheduledMessageStatusResponse
+// @Failure      500  {object}  ScheduledMessageStatusResponse
+// @Router       /schedule/message/status/update [patch]
+func (s *ScheduledMessageStatusHandler) UpdateStatus(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPatch {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var req RequestScheduledMessageStatus
+	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 ScheduledMessageStatusResponse
+
+	if req.ScheduledMessageId == uuid.Nil {
+		statusCode = http.StatusBadRequest
+		resp.Message = "Scheduled messaged Id is nil"
+	} else if len(req.Status) == 0 {
+		statusCode = http.StatusBadRequest
+		resp.Message = "No status provided"
+	} else {
+		ctx := r.Context()
+
+		if schMsg, err := s.ScheduledMessageStore.Get(ctx, req.ScheduledMessageId); err != nil {
+			statusCode = http.StatusInternalServerError
+			resp.Message = err.Error()
+		} else {
+			if schMsg.Status == scheduling.Done {
+				statusCode = http.StatusNotFound
+				resp.Message = "Scheduled message has already completed"
+			} else {
+				switch req.Status {
+				case scheduling.Pending:
+					{
+						if schMsg.Status == scheduling.Processing {
+							statusCode = http.StatusBadRequest
+							resp.Message = "Message is currently processing"
+						} else {
+							if returnedStatus, err := s.ScheduledMessageStore.UpdateStatus(ctx, schMsg.Id, req.Status); err != nil {
+								statusCode = http.StatusInternalServerError
+								resp.Message = err.Error()
+							} else {
+								chg := initScheduledMessageChange(schMsg, schMsg.Status, *returnedStatus)
+								statusCode = http.StatusOK
+								resp.Message = "Successful"
+								resp.Data = append(resp.Data, chg)
+							}
+						}
+					}
+				case scheduling.Ready:
+					{
+						if events, err := s.ScheduledMessageEventStore.GetWithScheduleMessageId(ctx, schMsg.Id); err != nil {
+							statusCode = http.StatusInternalServerError
+							resp.Message = err.Error()
+						} else {
+							oldStatus := schMsg.Status
+							if schMsg.Status != scheduling.Processing && schMsg.Status != scheduling.Ready {
+								// Update status
+								if len(events) > 0 {
+									if returnedStatus, err := s.ScheduledMessageStore.UpdateStatus(ctx, schMsg.Id, req.Status); err != nil {
+										statusCode = http.StatusInternalServerError
+										resp.Message = err.Error()
+									} else {
+										chg := initScheduledMessageChange(schMsg, oldStatus, *returnedStatus)
+										statusCode = http.StatusOK
+										resp.Message = "Successful"
+										resp.Data = append(resp.Data, chg)
+									}
+								} else {
+									statusCode = http.StatusInternalServerError
+									resp.Message = "Not enough scheduled message events"
+								}
+							} else {
+								if schMsg.Status == scheduling.Processing {
+									statusCode = http.StatusBadRequest
+									resp.Message = "Scheduled messages are processing"
+								} else {
+									statusCode = http.StatusNotModified
+									resp.Message = "Status is already set"
+								}
+							}
+						}
+					}
+				case scheduling.Processing, scheduling.Done:
+					{
+						if events, err := s.ScheduledMessageEventStore.GetWithScheduleMessageId(ctx, schMsg.Id); err != nil {
+							statusCode = http.StatusInternalServerError
+							resp.Message = err.Error()
+						} else {
+							if len(events) > 0 {
+								if returnedStatus, err := s.ScheduledMessageStore.UpdateStatus(ctx, schMsg.Id, req.Status); err != nil {
+									statusCode = http.StatusInternalServerError
+									resp.Message = err.Error()
+								} else {
+									chg := initScheduledMessageChange(schMsg, schMsg.Status, *returnedStatus)
+									statusCode = http.StatusOK
+									resp.Message = "Successful"
+									resp.Data = append(resp.Data, chg)
+								}
+							} else {
+								statusCode = http.StatusInternalServerError
+								resp.Message = "Not enough scheduled message events"
+							}
+						}
+					}
+				}
+			}
+		}
+
+	}
+
+	RespondWithJSON(w, statusCode, &resp)
+}
+
+func initScheduledMessageChange(schMsg *scheduling.ScheduledMessage, oldStatus, newStatus string) ScheduledMessageChange {
+	schMsg.Status = newStatus
+	return ScheduledMessageChange{OldStatus: oldStatus, ScheduledMessage: *schMsg}
+}

internal/handler/schedule_message_status_test.go

@@ -0,0 +1,75 @@
+package handler
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	"git.kundeng.us/phoenix/textsender-models/tx0/message/scheduling"
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/handler/endpoint"
+	"git.kundeng.us/phoenix/textsender-api/internal/store/mock"
+)
+
+func TestUpdateScheduledMessageStatusWithMock(t *testing.T) {
+	now := time.Now()
+
+	schMsgEventStore := mock.NewMockScheduledMessageEventStore()
+	contactStore := mock.NewMockContactStore()
+	messageStore := mock.NewMockMessageStore()
+	schMsgStore := mock.NewMockScheduledMessageStore()
+
+	contactId := uuid.New()
+	messageId := uuid.New()
+	scheduledMessageId := uuid.New()
+	testUserId := uuid.New()
+
+	con := ContactTest(contactId, testUserId)
+	msg := MessageTest(messageId, testUserId)
+	schMsg := ScheduledMessageTest(scheduledMessageId, testUserId, now)
+	event := ScheduledMessageEventTest(*msg.Id, *con.Id, schMsg.Id)
+
+	ctx := t.Context()
+
+	if err := contactStore.CreateContact(ctx, &con); err != nil {
+		assert.NoError(t, err, "Error creating contact: %v", err)
+	} else if err = messageStore.CreateMessage(ctx, &msg); err != nil {
+		assert.NoError(t, err, "Error creating message: %v", err)
+	} else if err = schMsgStore.CreateScheduledMessage(ctx, &schMsg); err != nil {
+		assert.NoError(t, err, "Error creating scheduled message: %v", err)
+	} else if err = schMsgEventStore.CreateScheduledMessageEvent(ctx, &event); err != nil {
+		assert.NoError(t, err, "Error creating scheduled message event: %v", err)
+	}
+
+	testReq := RequestScheduledMessageStatus{}
+	testReq.Status = scheduling.Ready
+	testReq.ScheduledMessageId = schMsg.Id
+	jsonValue, _ := json.Marshal(testReq)
+	jsonBody := strings.NewReader(string(jsonValue))
+
+	req, _ := http.NewRequest("PATCH", endpoint.UpdateScheduledMessageStatusEndpoint, jsonBody)
+	rr := httptest.NewRecorder()
+
+	apiApp, err := GetApp()
+	assert.NoError(t, err, "Error getting app")
+	handler := NewScheduledMessageStatusHandler(apiApp, schMsgEventStore, schMsgStore)
+	handler.UpdateStatus(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+
+	var response ScheduledMessageStatusResponse
+	err = json.Unmarshal(rr.Body.Bytes(), &response)
+	assert.NoError(t, err, "Error creating event %v", err)
+
+	assert.NotEmpty(t, response.Data, "Data should not be empty")
+
+	changes := response.Data[0]
+	assert.NotEqual(t, changes.OldStatus, changes.ScheduledMessage.Status, "The status should not match")
+	assert.Equal(t, scheduling.Pending, changes.OldStatus, "The Old status does not match Old %s New %s", changes.OldStatus, scheduling.Pending)
+	assert.Equal(t, scheduling.Ready, changes.ScheduledMessage.Status, "Status has not been updated")
+}

internal/handler/scheduled_message.go

@@ -0,0 +1,242 @@
+package handler
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"git.kundeng.us/phoenix/textsender-models/tx0/message/scheduling"
+	"github.com/google/uuid"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/app"
+	"git.kundeng.us/phoenix/textsender-api/internal/store"
+)
+
+type ScheduledMessageHandler struct {
+	App                   *app.App
+	ScheduledMessageStore store.ScheduledMessageStore
+}
+
+func NewScheduledMessageHandler(apiApp *app.App, str store.ScheduledMessageStore) *ScheduledMessageHandler {
+	return &ScheduledMessageHandler{App: apiApp, ScheduledMessageStore: str}
+}
+
+type RequestAddScheduledMessage struct {
+	Scheduled time.Time `json:"scheduled"`
+	Status    string    `json:"status"`
+	UserId    uuid.UUID `json:"user_id"`
+}
+
+type AddScheduledMessageResponse struct {
+	Message string                        `json:"message"`
+	Data    []scheduling.ScheduledMessage `json:"data"`
+}
+
+// AddScheduledMessage godoc
+// @Summary      Add scheduled message
+// @Description  Adds a scheduled message (requires JWT)
+// @Tags         scheduled messages
+// @Accept       json
+// @Produce      json
+// @Security     BearerAuth
+// @Param        request body   RequestAddScheduledMessage   true  "Data to add scheduled message"
+// @Success      201  {object}  AddScheduledMessageResponse
+// @Failure      400  {object}  AddScheduledMessageResponse
+// @Failure      500  {object}  AddScheduledMessageResponse
+// @Router       /schedule/message [post]
+func (s *ScheduledMessageHandler) AddScheduledMessage(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var req RequestAddScheduledMessage
+	if err := ExtractFromRequest(r, &req); err != nil {
+		http.Error(w, "Invalid JSON: "+err.Error(), http.StatusBadRequest)
+	}
+	defer r.Body.Close()
+
+	scheduledMessage := scheduling.ScheduledMessage{Scheduled: req.Scheduled, Status: req.Status, UserId: req.UserId}
+
+	var statusCode int
+	var resp AddScheduledMessageResponse
+
+	if scheduledMessage.UserId == uuid.Nil {
+		statusCode = http.StatusBadRequest
+		resp.Message = "No UserId"
+	} else {
+		ctx := r.Context()
+
+		if validStatus, err := IsStatusValid(&scheduledMessage); err == nil {
+			if validStatus {
+				if valid, err := isScheduledTimeValid(&scheduledMessage); err == nil && valid {
+					if err = s.ScheduledMessageStore.CreateScheduledMessage(ctx, &scheduledMessage); err == nil {
+						statusCode = http.StatusCreated
+						resp.Data = append(resp.Data, scheduledMessage)
+						resp.Message = "Successful"
+					} else {
+						statusCode = http.StatusInternalServerError
+						resp.Message = err.Error()
+					}
+				} else {
+					statusCode = http.StatusBadRequest
+					resp.Message = "Invalid scheduled time"
+				}
+			} else {
+				statusCode = http.StatusBadRequest
+				resp.Message = "Invalid status"
+			}
+		} else {
+			statusCode = http.StatusInternalServerError
+			resp.Message = err.Error()
+		}
+	}
+
+	RespondWithJSON(w, statusCode, &resp)
+}
+
+type GetScheduledMessageResponse struct {
+	Message string                        `json:"message"`
+	Data    []scheduling.ScheduledMessage `json:"data"`
+}
+
+// GetScheduledMessage godoc
+// @Summary      Get scheduled message
+// @Description  Get a scheduled message (requires JWT)
+// @Tags         scheduled messages
+// @Accept       json
+// @Produce      json
+// @Security     BearerAuth
+// @Param        id   path      string  true  "Contact Id"
+// @Param        user_id   path      string  true  "User Id"
+// @Success      200  {object}  GetScheduledMessageResponse
+// @Failure      400  {object}  GetScheduledMessageResponse
+// @Failure      500  {object}  GetScheduledMessageResponse
+// @Router       /schedule/message [get]
+func (s *ScheduledMessageHandler) GetScheduledMessage(w http.ResponseWriter, r *http.Request) {
+	var id, userId uuid.UUID
+
+	if idParam, err := ParseQueryParams(r, "id"); err == nil {
+		var err error
+		id, err = uuid.Parse(*idParam)
+		if err != nil {
+			http.Error(w, "Error parsing Id", http.StatusBadRequest)
+			return
+		}
+	}
+	if userIdParam, err := ParseQueryParams(r, "user_id"); err == nil {
+		userId, err = uuid.Parse(*userIdParam)
+		if err != nil {
+			http.Error(w, "Error parsing Id", http.StatusBadRequest)
+			return
+		}
+	}
+
+	var resp GetScheduledMessageResponse
+	var statusCode int
+	ctx := r.Context()
+
+	if userId == uuid.Nil && id == uuid.Nil {
+		http.Error(w, "Invalid query parameters", http.StatusBadRequest)
+		return
+	} else if userId != uuid.Nil && id != uuid.Nil {
+		if schMsgs, err := s.ScheduledMessageStore.GetWithUserId(ctx, userId); err != nil {
+			statusCode = http.StatusInternalServerError
+			resp.Message = err.Error()
+		} else {
+			for _, schMsg := range schMsgs {
+				if schMsg.Id == id {
+					resp.Data = append(resp.Data, *schMsg)
+				}
+			}
+			statusCode = http.StatusOK
+			resp.Message = "Successful"
+		}
+	} else if id != uuid.Nil {
+		if schMsg, err := s.ScheduledMessageStore.Get(ctx, id); err != nil {
+			statusCode = http.StatusInternalServerError
+			resp.Message = err.Error()
+		} else {
+			statusCode = http.StatusOK
+			resp.Message = "Successful"
+			resp.Data = append(resp.Data, *schMsg)
+		}
+	} else {
+		if schMsgs, err := s.ScheduledMessageStore.GetWithUserId(ctx, userId); err != nil {
+			statusCode = http.StatusInternalServerError
+			resp.Message = err.Error()
+		} else {
+			statusCode = http.StatusOK
+			resp.Message = "Successful"
+			for _, schMsg := range schMsgs {
+				resp.Data = append(resp.Data, *schMsg)
+			}
+		}
+	}
+
+	RespondWithJSON(w, statusCode, &resp)
+}
+
+type FetchNextMessageResponse struct {
+	Message string                        `json:"message"`
+	Data    []scheduling.ScheduledMessage `json:"data"`
+}
+
+// FetchNextMessage godoc
+// @Summary      Fetch scheduled message
+// @Description  Fetches a scheduled message that is available to be processed (requires JWT)
+// @Tags         scheduled messages
+// @Accept       json
+// @Produce      json
+// @Security     BearerAuth
+// @Success      200  {object}  FetchNextMessageResponse
+// @Failure      400  {object}  FetchNextMessageResponse
+// @Failure      500  {object}  FetchNextMessageResponse
+// @Router       /schedule/message/fetch [get]
+func (s *ScheduledMessageHandler) FetchNextMessage(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	var resp FetchNextMessageResponse
+	var statusCode int
+
+	if schMsg, err := s.ScheduledMessageStore.FetchNextScheduledMessage(ctx); err != nil {
+		statusCode = http.StatusInternalServerError
+		resp.Message = err.Error()
+	} else {
+		if schMsg != nil {
+			statusCode = http.StatusOK
+			resp.Message = "Successful"
+			resp.Data = append(resp.Data, *schMsg)
+		} else {
+			statusCode = http.StatusNotFound
+			resp.Message = "No item"
+		}
+	}
+
+	RespondWithJSON(w, statusCode, &resp)
+}
+
+func isScheduledTimeValid(schMsg *scheduling.ScheduledMessage) (bool, error) {
+	now := time.Now()
+	timeCutOff := now.Add(-5 * time.Minute)
+	futureCutOff := now.Add((24 * 7) * time.Hour)
+
+	if schMsg.Scheduled.After(timeCutOff) {
+		if schMsg.Scheduled.Before(futureCutOff) {
+			return true, nil
+		} else {
+			return false, fmt.Errorf("Scheduled Time is too far in the future")
+		}
+	} else {
+		return false, nil
+	}
+}
+
+func IsStatusValid(schMsg *scheduling.ScheduledMessage) (bool, error) {
+	schMsg.Status = strings.ToUpper(schMsg.Status)
+	if schMsg.Status == scheduling.Pending {
+		return true, nil
+	} else {
+		return false, fmt.Errorf("Status is not valid for creating scheduled message %s", schMsg.Status)
+	}
+}

internal/handler/scheduled_message_event.go

@@ -0,0 +1,247 @@
+package handler
+
+import (
+	"net/http"
+	"strings"
+
+	"git.kundeng.us/phoenix/textsender-models/tx0/message/scheduling"
+	"github.com/go-chi/chi/v5"
+	"github.com/google/uuid"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/app"
+	"git.kundeng.us/phoenix/textsender-api/internal/store"
+)
+
+type ScheduledMessageEventHandler struct {
+	App                        *app.App
+	ScheduledMessageEventStore store.ScheduledMessageEventStore
+	ScheduledMessageStore      store.ScheduledMessageStore
+}
+
+func NewScheduledMessageEventHandler(apiApp *app.App, str store.ScheduledMessageEventStore, schStore store.ScheduledMessageStore) *ScheduledMessageEventHandler {
+	return &ScheduledMessageEventHandler{App: apiApp, ScheduledMessageEventStore: str, ScheduledMessageStore: schStore}
+}
+
+type RequestAddScheduledMessageEvent struct {
+	ContactId          uuid.UUID `json:"contact_id"`
+	MessageId          uuid.UUID `json:"message_id"`
+	ScheduledMessageId uuid.UUID `json:"scheduled_message_id"`
+}
+
+type AddScheduledMessageEventResponse struct {
+	Message string                             `json:"message"`
+	Data    []scheduling.ScheduledMessageEvent `json:"data"`
+}
+
+// AddScheduledMessageEvent godoc
+// @Summary      Add scheduled message event
+// @Description  Add a scheduled message event (requires JWT)
+// @Tags         scheduled message events
+// @Accept       json
+// @Produce      json
+// @Security     BearerAuth
+// @Param        request body      RequestAddScheduledMessageEvent true  "Data to add scheduled message event"
+// @Success      201  {object}  AddScheduledMessageEventResponse
+// @Failure      400  {object}  AddScheduledMessageEventResponse
+// @Failure      500  {object}  AddScheduledMessageEventResponse
+// @Router       /schedule/message/event [post]
+func (s *ScheduledMessageEventHandler) AddScheduledMessageEvent(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var req RequestAddScheduledMessageEvent
+	if err := ExtractFromRequest(r, &req); err != nil {
+		http.Error(w, "Invalid JSON: "+err.Error(), http.StatusBadRequest)
+	}
+	defer r.Body.Close()
+
+	event := scheduling.ScheduledMessageEvent{ContactId: req.ContactId, MessageId: req.MessageId, ScheduledMessageId: req.ScheduledMessageId}
+
+	var statusCode int
+	var resp AddScheduledMessageEventResponse
+
+	if event.ContactId == uuid.Nil {
+		statusCode = http.StatusBadRequest
+		resp.Message = "Contact Id is nil"
+	} else if event.MessageId == uuid.Nil {
+		statusCode = http.StatusBadRequest
+		resp.Message = "Message Id is nil"
+	} else if event.ScheduledMessageId == uuid.Nil {
+		statusCode = http.StatusBadRequest
+		resp.Message = "Scheduled Message Id is nil"
+	} else {
+		ctx := r.Context()
+
+		if schMsg, err := s.ScheduledMessageStore.Get(ctx, event.ScheduledMessageId); err != nil {
+			statusCode = http.StatusInternalServerError
+			resp.Message = err.Error()
+		} else {
+			if schMsg.Status == scheduling.Pending {
+				if exists, err := s.ScheduledMessageEventStore.Exists(ctx, &event); err == nil {
+					if exists {
+						statusCode = http.StatusBadRequest
+						resp.Message = "Event already present"
+					} else {
+						if err = s.ScheduledMessageEventStore.CreateScheduledMessageEvent(ctx, &event); err == nil {
+							statusCode = http.StatusCreated
+							resp.Message = "Successful"
+							resp.Data = append(resp.Data, event)
+						} else {
+							statusCode = http.StatusInternalServerError
+							resp.Message = err.Error()
+						}
+					}
+				} else {
+					statusCode = http.StatusInternalServerError
+					resp.Message = err.Error()
+				}
+			} else {
+				statusCode = http.StatusBadRequest
+				resp.Message = "Scheduled message cannot be modified due to the status"
+			}
+		}
+	}
+
+	RespondWithJSON(w, statusCode, &resp)
+}
+
+type GetScheduledMessageEventResponse struct {
+	Message string                             `json:"message"`
+	Data    []scheduling.ScheduledMessageEvent `json:"data"`
+}
+
+// GetScheduledMessageEvent godoc
+// @Summary      Get scheduled message event
+// @Description  Gets a scheduled message event (requires JWT)
+// @Tags         scheduled message events
+// @Accept       json
+// @Produce      json
+// @Param        id   path      string  true  "Contact Id"
+// @Param        scheduled_message_id   path      string  true  "Scheduled Message Id"
+// @Security     BearerAuth
+// @Success      200  {object}  GetScheduledMessageEventResponse
+// @Failure      400  {object}  GetScheduledMessageEventResponse
+// @Failure      500  {object}  GetScheduledMessageEventResponse
+// @Router       /schedule/message/event [get]
+func (s *ScheduledMessageEventHandler) GetScheduledMessageEvent(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		http.Error(w, "Metnot allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	var id, scheduledMessageId uuid.UUID
+	if idParam, err := ParseQueryParams(r, "id"); err == nil {
+		id, err = uuid.Parse(*idParam)
+	}
+	if scheduledMessageIdParam, err := ParseQueryParams(r, "scheduled_message_id"); err == nil {
+		scheduledMessageId, err = uuid.Parse(*scheduledMessageIdParam)
+	}
+
+	var statusCode int
+	var resp GetScheduledMessageEventResponse
+	ctx := r.Context()
+
+	if id == uuid.Nil && scheduledMessageId == uuid.Nil {
+		statusCode = http.StatusBadRequest
+		resp.Message = "Query parameters missing"
+	} else if id != uuid.Nil {
+		if event, err := s.ScheduledMessageEventStore.Get(ctx, id); err != nil {
+			resp.Message = err.Error()
+			statusCode = http.StatusInternalServerError
+		} else {
+			if event != nil {
+				resp.Message = "Successful"
+				statusCode = http.StatusOK
+				resp.Data = append(resp.Data, *event)
+			} else {
+				statusCode = http.StatusNotFound
+				resp.Message = "Scheduled message event not found"
+			}
+		}
+	} else {
+		if events, err := s.ScheduledMessageEventStore.GetWithScheduleMessageId(ctx, scheduledMessageId); err != nil {
+			statusCode = http.StatusInternalServerError
+			resp.Message = err.Error()
+		} else {
+			statusCode = http.StatusOK
+			resp.Message = "Successful"
+			for _, event := range events {
+				resp.Data = append(resp.Data, *event)
+			}
+		}
+	}
+
+	RespondWithJSON(w, statusCode, &resp)
+}
+
+type DeleteScheduledMessageEventResponse struct {
+	Message string                             `json:"message"`
+	Data    []scheduling.ScheduledMessageEvent `json:"data"`
+}
+
+// DeleteScheduledMessageEvent godoc
+// @Summary      Delete scheduled message event
+// @Description  Deletes a scheduled message event (requires JWT)
+// @Tags         scheduled message events
+// @Accept       json
+// @Produce      json
+// @Security     BearerAuth
+// @Param        id path string true "scheduled message event Id" Format(uuid)
+// @Success      201  {object}  DeleteScheduledMessageEventResponse
+// @Failure      400  {object}  DeleteScheduledMessageEventResponse
+// @Failure      500  {object}  DeleteScheduledMessageEventResponse
+// @Router       /schedule/message/event/{id} [delete]
+func (s *ScheduledMessageEventHandler) DeleteScheduledMessageEvent(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodDelete {
+		http.Error(w, "Metnot allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	id := chi.URLParam(r, "id")
+	if len(id) == 0 {
+		pathParts := strings.Split(r.URL.Path, "/")
+		if len(pathParts) < 7 {
+			http.Error(w, "Id not provided", http.StatusBadRequest)
+			return
+		} else {
+			id = pathParts[6]
+		}
+	}
+
+	var resp DeleteScheduledMessageEventResponse
+	var statusCode int
+
+	if parsedId, err := uuid.Parse(id); err != nil {
+		resp.Message = err.Error()
+		statusCode = http.StatusBadRequest
+	} else {
+		ctx := r.Context()
+		if event, err := s.ScheduledMessageEventStore.Get(ctx, parsedId); err != nil {
+			resp.Message = err.Error()
+			statusCode = http.StatusInternalServerError
+		} else {
+			if schMsg, err := s.ScheduledMessageStore.Get(ctx, event.ScheduledMessageId); err != nil {
+				resp.Message = err.Error()
+				statusCode = http.StatusInternalServerError
+			} else {
+				if schMsg.Status == scheduling.Pending {
+					if err = s.ScheduledMessageEventStore.Delete(ctx, event.Id); err != nil {
+						resp.Message = err.Error()
+						statusCode = http.StatusInternalServerError
+					} else {
+						resp.Message = "Successful"
+						resp.Data = append(resp.Data, *event)
+						statusCode = http.StatusOK
+					}
+				} else {
+					statusCode = http.StatusBadRequest
+					resp.Message = "Invalid status"
+				}
+			}
+		}
+	}
+
+	RespondWithJSON(w, statusCode, &resp)
+}

internal/handler/scheduled_message_event_test.go

@@ -0,0 +1,182 @@
+package handler
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	"git.kundeng.us/phoenix/textsender-models/tx0/message/scheduling"
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/handler/endpoint"
+	"git.kundeng.us/phoenix/textsender-api/internal/store/mock"
+)
+
+var (
+	contactId          = uuid.New()
+	messageId          = uuid.New()
+	scheduledMessageId = uuid.New()
+	testUserId         = uuid.New()
+)
+
+type CreateScheduledMessageEventRequest struct {
+	ContactId          uuid.UUID `json:"contact_id"`
+	MessageId          uuid.UUID `json:"message_id"`
+	ScheduledMessageId uuid.UUID `json:"scheduled_message_id"`
+}
+
+func TestCreateScheduledMessageEventWithMock(t *testing.T) {
+	now := time.Now()
+
+	mockStore := mock.NewMockScheduledMessageEventStore()
+	contactStore := mock.NewMockContactStore()
+	messageStore := mock.NewMockMessageStore()
+	schMsgStore := mock.NewMockScheduledMessageStore()
+
+	apiApp, err := GetApp()
+	assert.NoError(t, err, "Error getting app")
+	handler := NewScheduledMessageEventHandler(apiApp, mockStore, schMsgStore)
+
+	contactId := uuid.New()
+	messageId := uuid.New()
+	scheduledMessageId := uuid.New()
+	testUserId := uuid.New()
+
+	con := ContactTest(contactId, testUserId)
+	msg := MessageTest(messageId, testUserId)
+	schMsg := ScheduledMessageTest(scheduledMessageId, testUserId, now)
+
+	ctx := t.Context()
+
+	if err := contactStore.CreateContact(ctx, &con); err != nil {
+		assert.NoError(t, err, "Error creating contact: %v", err)
+	} else if err = messageStore.CreateMessage(ctx, &msg); err != nil {
+		assert.NoError(t, err, "Error creating message: %v", err)
+	} else if err = schMsgStore.CreateScheduledMessage(ctx, &schMsg); err != nil {
+		assert.NoError(t, err, "Error creating scheduled message: %v", err)
+	}
+
+	testReq := CreateScheduledMessageEventRequest{ContactId: contactId, MessageId: messageId, ScheduledMessageId: scheduledMessageId}
+	jsonValue, _ := json.Marshal(testReq)
+
+	req, _ := http.NewRequest("POST", endpoint.AddEventToScheduledMessageEndpoint, strings.NewReader(string(jsonValue)))
+	rr := httptest.NewRecorder()
+
+	handler.AddScheduledMessageEvent(rr, req)
+
+	assert.Equal(t, http.StatusCreated, rr.Code)
+
+	var response AddScheduledMessageEventResponse
+	err = json.Unmarshal(rr.Body.Bytes(), &response)
+	assert.NoError(t, err, "Error creating event %v", err)
+
+	assert.NotEmpty(t, response.Data, "No event created")
+
+	var event scheduling.ScheduledMessageEvent
+	event = response.Data[0]
+
+	assert.NotEmpty(t, event.Created, "Created date should not be empty")
+}
+
+func TestGetScheduledMessageEventWithMock(t *testing.T) {
+	now := time.Now()
+
+	contactStore := mock.NewMockContactStore()
+	messageStore := mock.NewMockMessageStore()
+	schMsgStore := mock.NewMockScheduledMessageStore()
+	schMsgEventStore := mock.NewMockScheduledMessageEventStore()
+	apiApp, err := GetApp()
+	assert.NoError(t, err, "Error getting app")
+	handler := NewScheduledMessageEventHandler(apiApp, schMsgEventStore, schMsgStore)
+
+	contactId := uuid.New()
+	messageId := uuid.New()
+	scheduledMessageId := uuid.New()
+	testUserId := uuid.New()
+
+	con := ContactTest(contactId, testUserId)
+	msg := MessageTest(messageId, testUserId)
+	schMsg := ScheduledMessageTest(scheduledMessageId, testUserId, now)
+	event := ScheduledMessageEventTest(*msg.Id, *con.Id, schMsg.Id)
+
+	ctx := t.Context()
+
+	if err := contactStore.CreateContact(ctx, &con); err != nil {
+		assert.NoError(t, err, "Error creating contact: %v", err)
+	} else if err = messageStore.CreateMessage(ctx, &msg); err != nil {
+		assert.NoError(t, err, "Error creating message: %v", err)
+	} else if err = schMsgStore.CreateScheduledMessage(ctx, &schMsg); err != nil {
+		assert.NoError(t, err, "Error creating scheduled message: %v", err)
+	} else if err = schMsgEventStore.CreateScheduledMessageEvent(ctx, &event); err != nil {
+		assert.NoError(t, err, "Error creating scheduled message event: %v", err)
+	}
+
+	url := fmt.Sprintf("%s?id=%s", endpoint.GetScheduledMessageEventEndpoint, event.Id.String())
+	req, _ := http.NewRequest("GET", url, nil)
+	rr := httptest.NewRecorder()
+
+	handler.GetScheduledMessageEvent(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+
+	var response GetScheduledMessageEventResponse
+	err = json.Unmarshal(rr.Body.Bytes(), &response)
+	assert.NoError(t, err, "Error creating event %v", err)
+
+	assert.NotEmpty(t, response.Data, "No event created")
+
+	msgEvent := response.Data[0]
+
+	assert.NotEmpty(t, msgEvent.Created, "Created date should not be empty")
+}
+
+func TestDeleteScheduledMessageEventWithMock(t *testing.T) {
+	now := time.Now()
+	contactStore := mock.NewMockContactStore()
+	messageStore := mock.NewMockMessageStore()
+	schMsgStore := mock.NewMockScheduledMessageStore()
+	schMsgEventStore := mock.NewMockScheduledMessageEventStore()
+	apiApp, err := GetApp()
+	assert.NoError(t, err, "Error getting app")
+	handler := NewScheduledMessageEventHandler(apiApp, schMsgEventStore, schMsgStore)
+
+	con := ContactTest(contactId, testUserId)
+	msg := MessageTest(messageId, testUserId)
+	schMsg := ScheduledMessageTest(scheduledMessageId, testUserId, now)
+	event := ScheduledMessageEventTest(*msg.Id, *con.Id, schMsg.Id)
+
+	ctx := t.Context()
+
+	if err := contactStore.CreateContact(ctx, &con); err != nil {
+		assert.NoError(t, err, "Error creating contact: %v", err)
+	} else if err = messageStore.CreateMessage(ctx, &msg); err != nil {
+		assert.NoError(t, err, "Error creating message: %v", err)
+	} else if err = schMsgStore.CreateScheduledMessage(ctx, &schMsg); err != nil {
+		assert.NoError(t, err, "Error creating scheduled message: %v", err)
+	} else if err = schMsgEventStore.CreateScheduledMessageEvent(ctx, &event); err != nil {
+		assert.NoError(t, err, "Error creating scheduled message event: %v", err)
+	}
+
+	endpointValue := strings.Replace(endpoint.DeleteScheduledMessageEventEndpoint, "{id}", event.Id.String(), 1)
+	req, _ := http.NewRequest("DELETE", endpointValue, nil)
+	rr := httptest.NewRecorder()
+
+	handler.DeleteScheduledMessageEvent(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+
+	var response DeleteScheduledMessageEventResponse
+	err = json.Unmarshal(rr.Body.Bytes(), &response)
+	assert.NoError(t, err, "Error creating event %v", err)
+
+	assert.NotEmpty(t, response.Data, "No event created")
+
+	msgEvent := response.Data[0]
+
+	assert.NotEmpty(t, msgEvent.Created, "Created date should not be empty")
+}

internal/handler/scheduled_message_test.go

@@ -0,0 +1,141 @@
+package handler
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	"git.kundeng.us/phoenix/textsender-models/tx0/message/scheduling"
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+
+	"git.kundeng.us/phoenix/textsender-api/internal/handler/endpoint"
+	"git.kundeng.us/phoenix/textsender-api/internal/store/mock"
+)
+
+type CreateScheduledMessageRequest struct {
+	Scheduled time.Time `json:"scheduled"`
+	Status    string    `json:"status"`
+	UserId    uuid.UUID `json:"user_id"`
+}
+
+func TestCreateScheduledMessageWithMock(t *testing.T) {
+	now := time.Now()
+	mockStore := mock.NewMockScheduledMessageStore()
+	apiApp, err := GetApp()
+	assert.NoError(t, err, "Error getting app")
+	handler := NewScheduledMessageHandler(apiApp, mockStore)
+
+	testUserId := uuid.New()
+	testBody := createScheduledMessageRequest(testUserId, now)
+	jsonValue, _ := json.Marshal(testBody)
+
+	req, _ := http.NewRequest("POST", endpoint.ScheduleMessageEndpoint, strings.NewReader(string(jsonValue)))
+	rr := httptest.NewRecorder()
+
+	handler.AddScheduledMessage(rr, req)
+
+	assert.Equal(t, http.StatusCreated, rr.Code)
+
+	var response AddScheduledMessageResponse
+	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 TestGetScheduledMessageWithMock(t *testing.T) {
+	now := time.Now()
+	mockStore := mock.NewMockScheduledMessageStore()
+
+	testUserId := uuid.New()
+	testBody := createScheduledMessageRequest(testUserId, now)
+
+	ctx := t.Context()
+	schMsg := scheduling.ScheduledMessage{}
+	schMsg.Scheduled = testBody.Scheduled
+	schMsg.Status = testBody.Status
+	schMsg.UserId = testBody.UserId
+	if err := mockStore.CreateScheduledMessage(ctx, &schMsg); err != nil {
+		assert.NoError(t, err, "Error Creating message %v", err)
+	}
+
+	url := fmt.Sprintf("%s?id=%s&user_id=%s", endpoint.GetScheduledMessageEndpoint, schMsg.Id, schMsg.UserId)
+	req, _ := http.NewRequest("GET", url, nil)
+	rr := httptest.NewRecorder()
+
+	apiApp, err := GetApp()
+	assert.NoError(t, err, "Error getting app")
+	handler := NewScheduledMessageHandler(apiApp, mockStore)
+	handler.GetScheduledMessage(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+
+	var response GetScheduledMessageResponse
+	err = json.Unmarshal(rr.Body.Bytes(), &response)
+	assert.NoError(t, err, "Error parsing response %v", err)
+}
+
+func TestFetchScheduledMessageWithMock(t *testing.T) {
+	now := time.Now()
+	mockStore := mock.NewMockScheduledMessageStore()
+	contactStore := mock.NewMockContactStore()
+	messageStore := mock.NewMockMessageStore()
+	schMsgEventStore := mock.NewMockScheduledMessageEventStore()
+
+	contactId := uuid.New()
+	messageId := uuid.New()
+	scheduledMessageId := uuid.New()
+	testUserId := uuid.New()
+
+	con := ContactTest(contactId, testUserId)
+	msg := MessageTest(messageId, testUserId)
+	schMsg := ScheduledMessageTest(scheduledMessageId, testUserId, now)
+	event := ScheduledMessageEventTest(*msg.Id, *con.Id, schMsg.Id)
+
+	ctx := t.Context()
+
+	if err := contactStore.CreateContact(ctx, &con); err != nil {
+		assert.NoError(t, err, "Error creating contact: %v", err)
+	} else if err = messageStore.CreateMessage(ctx, &msg); err != nil {
+		assert.NoError(t, err, "Error creating message: %v", err)
+	} else if err = mockStore.CreateScheduledMessage(ctx, &schMsg); err != nil {
+		assert.NoError(t, err, "Error creating scheduled message: %v", err)
+	} else if err = schMsgEventStore.CreateScheduledMessageEvent(ctx, &event); err != nil {
+		assert.NoError(t, err, "Error creating scheduled message event: %v", err)
+	} else if newStatus, err := mockStore.UpdateStatus(ctx, schMsg.Id, scheduling.Ready); err != nil {
+		assert.NoError(t, err, "Error updating status: %v", err)
+	} else {
+		assert.Equal(t, *newStatus, scheduling.Ready)
+	}
+
+	req, _ := http.NewRequest("GET", endpoint.FetchNextScheduledMessageEndpoint, nil)
+	rr := httptest.NewRecorder()
+
+	apiApp, err := GetApp()
+	assert.NoError(t, err, "Error getting app")
+	handler := NewScheduledMessageHandler(apiApp, mockStore)
+	handler.FetchNextMessage(rr, req)
+
+	assert.Equal(t, http.StatusOK, rr.Code)
+
+	var response FetchNextMessageResponse
+	err = json.Unmarshal(rr.Body.Bytes(), &response)
+	assert.NoError(t, err, "Error fetching scheduled message: %v", err)
+
+	assert.NotEmpty(t, response.Data, "No data")
+
+	fetchedSchMsg := response.Data[0]
+	assert.Equal(t, scheduling.Processing, fetchedSchMsg.Status, "The statuses do not match")
+}
+
+func createScheduledMessageRequest(userId uuid.UUID, now time.Time) CreateScheduledMessageRequest {
+	scheduled := now.Add(5 * time.Minute)
+	return CreateScheduledMessageRequest{Status: scheduling.Pending, UserId: userId, Scheduled: scheduled}
+}

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,49 @@
+package services
+
+import (
+	"time"
+
+	txtmodels_token "git.kundeng.us/phoenix/textsender-models/tx0/token"
+	txtmodels_user "git.kundeng.us/phoenix/textsender-models/tx0/user"
+	"github.com/golang-jwt/jwt/v5"
+)
+
+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,182 @@
+package store
+
+import (
+	"context"
+	"fmt"
+
+	"git.kundeng.us/phoenix/textsender-models/tx0/contact"
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+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)
+	UpdateNames(ctx context.Context, con *contact.Contact, firstname *string, lastname *string, nickname *string) (int64, 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, first_name, last_name, nickname)
+		VALUES ($1, $2, $3, $4, $5)
+		RETURNING id, phone_number, user_id
+	`
+
+	return s.db.QueryRow(ctx, query, con.PhoneNumber, con.UserId, con.Firstname, con.Lastname, con.Nickname).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, first_name, last_name, nickname FROM contacts WHERE id = $1`
+
+	var con contact.Contact
+	err := s.db.QueryRow(ctx, query, id).Scan(
+		&con.Id, &con.PhoneNumber, &con.UserId, &con.Firstname, &con.Lastname, &con.Nickname,
+	)
+
+	if err == pgx.ErrNoRows {
+		return nil, nil
+	} else if err != nil {
+		return nil, fmt.Errorf("getting contact by ID: %w", err)
+	} else {
+		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, first_name, last_name, nickname 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, &con.Firstname, &con.Lastname, &con.Nickname,
+	)
+
+	if err == pgx.ErrNoRows {
+		return nil, nil
+	} else if err != nil {
+		return nil, fmt.Errorf("getting contact by phone and User ID: %w", err)
+	} else {
+		return &con, nil
+	}
+}
+
+func (s *PGContactStore) GetAllContacts(ctx context.Context) ([]*contact.Contact, error) {
+	query := `SELECT id, phone_number, user_id, first_name, last_name, nickname 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, &con.Firstname, &con.Lastname, &con.Nickname,
+		); 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
+}
+
+func (s *PGContactStore) UpdateNames(ctx context.Context, con *contact.Contact, firstname *string, lastname *string, nickname *string) (int64, error) {
+	if firstname == nil && lastname == nil && nickname == nil {
+		return 0, fmt.Errorf("Names are nil")
+	} else {
+		if firstname != nil && lastname != nil && nickname != nil {
+			query := "UPDATE contacts SET first_name = $1, last_name = $2, nickname = $3 WHERE id = $4"
+			if affected, err := s.db.Exec(ctx, query, firstname, lastname, nickname, con.Id); err != nil {
+				return 0, err
+			} else {
+				con.Firstname = firstname
+				con.Lastname = lastname
+				con.Nickname = nickname
+				return affected.RowsAffected(), nil
+			}
+		} else if firstname != nil && lastname != nil {
+			query := "UPDATE contacts SET first_name = $1, last_name = $2 WHERE id = $3"
+			if affected, err := s.db.Exec(ctx, query, firstname, lastname, con.Id); err != nil {
+				return 0, err
+			} else {
+				con.Firstname = firstname
+				con.Lastname = lastname
+				return affected.RowsAffected(), nil
+			}
+		} else if lastname != nil && nickname != nil {
+			query := "UPDATE contacts SET last_name = $1, nickname = $2 WHERE id = $3"
+			if affected, err := s.db.Exec(ctx, query, lastname, nickname, con.Id); err != nil {
+				return 0, err
+			} else {
+				con.Lastname = lastname
+				con.Nickname = nickname
+				return affected.RowsAffected(), nil
+			}
+		} else if nickname != nil && firstname != nil {
+			query := "UPDATE contacts SET nickname = $1, firstname = $2 WHERE id = $3"
+			if affected, err := s.db.Exec(ctx, query, nickname, firstname, con.Id); err != nil {
+				return 0, err
+			} else {
+				con.Firstname = firstname
+				con.Nickname = nickname
+				return affected.RowsAffected(), nil
+			}
+		} else if firstname != nil {
+			query := "UPDATE contacts SET firstname = $1 WHERE id = $2"
+			if affected, err := s.db.Exec(ctx, query, firstname, con.Id); err != nil {
+				return 0, err
+			} else {
+				con.Firstname = firstname
+				return affected.RowsAffected(), nil
+			}
+		} else if lastname != nil {
+			query := "UPDATE contacts SET lastname = $1 WHERE id = $2"
+			if affected, err := s.db.Exec(ctx, query, lastname, con.Id); err != nil {
+				return 0, err
+			} else {
+				con.Lastname = lastname
+				return affected.RowsAffected(), nil
+			}
+		} else {
+			query := "UPDATE contacts SET nickname = $1 WHERE id = $2"
+			if affected, err := s.db.Exec(ctx, query, nickname, con.Id); err != nil {
+				return 0, err
+			} else {
+				con.Nickname = nickname
+				return affected.RowsAffected(), nil
+			}
+		}
+	}
+}

internal/store/message_event_response_store.go

@@ -0,0 +1,61 @@
+package store
+
+import (
+	"context"
+	"fmt"
+
+	"git.kundeng.us/phoenix/textsender-models/tx0/message/event"
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+type MessageEventResponseStore interface {
+	Create(ctx context.Context, mer *event.MessageEventResponse) error
+	GetWithUserId(ctx context.Context, userId uuid.UUID) ([]*event.MessageEventResponse, error)
+}
+
+type PGMessageEventResponseStore struct {
+	db *pgxpool.Pool
+}
+
+func NewMessageEventResponseStore(db *pgxpool.Pool) *PGMessageEventResponseStore {
+	return &PGMessageEventResponseStore{db: db}
+}
+
+func (m *PGMessageEventResponseStore) Create(ctx context.Context, mer *event.MessageEventResponse) error {
+	var query string
+	queryBase := "INSERT INTO message_event_responses"
+	queryReturn := "RETURNING id"
+
+	if mer.ScheduledMessageEventId == uuid.Nil {
+		query = fmt.Sprintf("%s (response, user_id, sent, contact_id, message_id, status) VALUES ($1, $2, $3, $4, $5, $6) %s", queryBase, queryReturn)
+		return m.db.QueryRow(ctx, query, mer.Response, mer.UserId, mer.Sent, mer.ContactId, mer.MessageId, mer.Status).Scan(&mer.Id)
+	} else {
+		query = fmt.Sprintf("%s (scheduled_message_event_id, response, user_id, sent, contact_id, message_id, status) VALUES ($1, $2, $3, $4, $5, $6, $7) %s", queryBase, queryReturn)
+		return m.db.QueryRow(ctx, query, mer.ScheduledMessageEventId, mer.Response, mer.UserId, mer.Sent, mer.ContactId, mer.MessageId, mer.Status).Scan(&mer.Id)
+	}
+}
+
+func (m *PGMessageEventResponseStore) GetWithUserId(ctx context.Context, userId uuid.UUID) ([]*event.MessageEventResponse, error) {
+	query := "SELECT id, scheduled_message_event_id, response, user_id, sent, contact_id, message_id, status FROM message_event_responses WHERE user_id = $1"
+	rows, err := m.db.Query(ctx, query, userId)
+	if err != nil {
+		return nil, fmt.Errorf("Error querying: %w", err)
+	}
+	defer rows.Close()
+
+	var sentMessages []*event.MessageEventResponse
+	for rows.Next() {
+		var msg event.MessageEventResponse
+		if err := rows.Scan(&msg.Id, &msg.ScheduledMessageEventId, &msg.Response, &msg.UserId, &msg.Sent, &msg.ContactId, &msg.MessageId, &msg.Status); err != nil {
+			return nil, fmt.Errorf("Scanning row: %w", err)
+		}
+		sentMessages = append(sentMessages, &msg)
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("Iterating message_event_responses: %w", err)
+	}
+
+	return sentMessages, nil
+}

internal/store/message_store.go

@@ -0,0 +1,95 @@
+package store
+
+import (
+	"context"
+	"fmt"
+
+	"git.kundeng.us/phoenix/textsender-models/tx0/message"
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+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/store/mock/contact_store.go

@@ -0,0 +1,146 @@
+package mock
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+
+	"git.kundeng.us/phoenix/textsender-models/tx0/contact"
+	"github.com/google/uuid"
+)
+
+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
+	}
+
+	var id uuid.UUID
+	if con.Id == nil {
+		id = uuid.New()
+		con.Id = &id
+	}
+
+	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
+}
+
+func (m *MockContactStore) UpdateNames(ctx context.Context, con *contact.Contact, firstname *string, lastname *string, nickname *string) (int64, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return 0, m.Error
+	} else if firstname == nil && lastname == nil && nickname == nil {
+		return 0, fmt.Errorf("Names are not provided")
+	} else {
+		if c, exists := m.Contacts[*con.Id]; !exists {
+			return 0, fmt.Errorf("Contact does not exist")
+		} else {
+			if firstname != nil {
+				c.Firstname = firstname
+			}
+			if lastname != nil {
+				c.Lastname = lastname
+			}
+			if nickname != nil {
+				c.Nickname = nickname
+			}
+		}
+	}
+
+	return 0, nil
+}

internal/store/mock/message_event_response_store.go

@@ -0,0 +1,81 @@
+package mock
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+
+	"git.kundeng.us/phoenix/textsender-models/tx0/message/event"
+	"github.com/google/uuid"
+)
+
+type MessageEventResponseKey struct {
+	ScheduledMessageEventId uuid.UUID
+	UserId                  uuid.UUID
+}
+type MockMessageEventResponseStore struct {
+	MessageEventResponses      map[uuid.UUID]*event.MessageEventResponse
+	MessageEventResponsesByKey map[MessageEventResponseKey]*event.MessageEventResponse
+	mu                         sync.RWMutex
+	Error                      error
+}
+
+func NewMockMessageEventResponseStore() *MockMessageEventResponseStore {
+	return &MockMessageEventResponseStore{
+		MessageEventResponses:      make(map[uuid.UUID]*event.MessageEventResponse),
+		MessageEventResponsesByKey: make(map[MessageEventResponseKey]*event.MessageEventResponse),
+	}
+}
+
+func (m *MockMessageEventResponseStore) Create(ctx context.Context, mer *event.MessageEventResponse) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return m.Error
+	}
+
+	if mer.Id == uuid.Nil {
+		mer.Id = uuid.New()
+	}
+
+	if len(mer.Response) == 0 {
+		return fmt.Errorf("Response is empty")
+	} else if mer.UserId == uuid.Nil {
+		return fmt.Errorf("User Id is nil")
+	} else {
+		key := MessageEventResponseKey{ScheduledMessageEventId: mer.ScheduledMessageEventId, UserId: mer.UserId}
+		if mer.ScheduledMessageEventId == uuid.Nil {
+			key.ScheduledMessageEventId = uuid.Nil
+		} else {
+			key.ScheduledMessageEventId = mer.ScheduledMessageEventId
+		}
+		sent := time.Now()
+		mer.Sent = sent
+
+		m.MessageEventResponses[mer.Id] = mer
+		m.MessageEventResponsesByKey[key] = mer
+
+		return nil
+	}
+}
+
+// TODO: Add code to get mock MessageEventResponse
+func (m *MockMessageEventResponseStore) GetWithUserId(ctx context.Context, userId uuid.UUID) ([]*event.MessageEventResponse, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return nil, m.Error
+	}
+
+	var messages []*event.MessageEventResponse
+	for _, msg := range m.MessageEventResponses {
+		if msg.UserId == userId {
+			messages = append(messages, msg)
+		}
+	}
+
+	return messages, nil
+}

internal/store/mock/scheduled_message_event_store.go

@@ -0,0 +1,159 @@
+package mock
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+
+	"git.kundeng.us/phoenix/textsender-models/tx0/message/scheduling"
+	"github.com/google/uuid"
+)
+
+type ScheduledMessageEventKey struct {
+	ContactId          uuid.UUID
+	MessageId          uuid.UUID
+	ScheduledMessageId uuid.UUID
+}
+
+type MockScheduledMessageEventStore struct {
+	ScheduledMessageEvents      map[uuid.UUID]*scheduling.ScheduledMessageEvent
+	ScheduledMessageEventsByKey map[ScheduledMessageEventKey]*scheduling.ScheduledMessageEvent
+	mu                          sync.RWMutex
+	Error                       error // Optional: simulate errors
+}
+
+func NewMockScheduledMessageEventStore() *MockScheduledMessageEventStore {
+	return &MockScheduledMessageEventStore{
+		ScheduledMessageEvents:      make(map[uuid.UUID]*scheduling.ScheduledMessageEvent),
+		ScheduledMessageEventsByKey: make(map[ScheduledMessageEventKey]*scheduling.ScheduledMessageEvent),
+	}
+}
+
+func (m *MockScheduledMessageEventStore) Get(ctx context.Context, id uuid.UUID) (*scheduling.ScheduledMessageEvent, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return nil, m.Error
+	}
+
+	if id == uuid.Nil {
+		return nil, fmt.Errorf("Id is nil")
+	}
+
+	if _, exists := m.ScheduledMessageEvents[id]; exists {
+		return m.ScheduledMessageEvents[id], nil
+	} else {
+		return nil, fmt.Errorf("Not found")
+	}
+}
+
+func (m *MockScheduledMessageEventStore) GetWithScheduleMessageId(ctx context.Context, schMsgId uuid.UUID) ([]*scheduling.ScheduledMessageEvent, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return nil, m.Error
+	}
+
+	if schMsgId == uuid.Nil {
+		return nil, fmt.Errorf("Scheduled message Id is nil")
+	}
+
+	var events []*scheduling.ScheduledMessageEvent
+
+	for _, event := range m.ScheduledMessageEvents {
+		if event.ScheduledMessageId == schMsgId {
+			events = append(events, event)
+		}
+	}
+
+	if len(events) > 0 {
+		return events, nil
+	} else {
+		return nil, nil
+	}
+}
+
+func (m *MockScheduledMessageEventStore) Delete(ctx context.Context, id uuid.UUID) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return m.Error
+	}
+
+	if id == uuid.Nil {
+		return fmt.Errorf("Id is nil")
+	}
+
+	if _, exists := m.ScheduledMessageEvents[id]; exists {
+		originalAmount := len(m.ScheduledMessageEvents)
+		copiedEvents := make(map[uuid.UUID]*scheduling.ScheduledMessageEvent)
+		copiedEventsKey := make(map[ScheduledMessageEventKey]*scheduling.ScheduledMessageEvent)
+
+		for i, schMsgEvent := range m.ScheduledMessageEvents {
+			key := ScheduledMessageEventKey{ContactId: schMsgEvent.ContactId, MessageId: schMsgEvent.MessageId, ScheduledMessageId: schMsgEvent.ScheduledMessageId}
+			if schMsgEvent.Id != id {
+				copiedEvents[i] = schMsgEvent
+				copiedEventsKey[key] = schMsgEvent
+			}
+		}
+
+		if originalAmount > 1 {
+			if len(copiedEvents) > 0 && len(copiedEventsKey) > 0 {
+				m.ScheduledMessageEvents = copiedEvents
+				m.ScheduledMessageEventsByKey = copiedEventsKey
+				return nil
+			} else {
+				return fmt.Errorf("Not removed")
+			}
+		} else {
+			m.ScheduledMessageEvents = make(map[uuid.UUID]*scheduling.ScheduledMessageEvent)
+			m.ScheduledMessageEventsByKey = make(map[ScheduledMessageEventKey]*scheduling.ScheduledMessageEvent)
+
+			return nil
+		}
+	} else {
+		return fmt.Errorf("Not found")
+	}
+}
+
+func (m *MockScheduledMessageEventStore) CreateScheduledMessageEvent(ctx context.Context, event *scheduling.ScheduledMessageEvent) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return m.Error
+	}
+
+	if event.Id == uuid.Nil {
+		event.Id = uuid.New()
+	}
+
+	key := ScheduledMessageEventKey{ContactId: event.ContactId, MessageId: event.MessageId, ScheduledMessageId: event.ScheduledMessageId}
+
+	if _, exists := m.ScheduledMessageEventsByKey[key]; exists {
+		return fmt.Errorf("Already exists")
+	} else {
+		event.Created = time.Now()
+		m.ScheduledMessageEvents[event.Id] = event
+		m.ScheduledMessageEventsByKey[key] = event
+		return nil
+	}
+}
+
+func (m *MockScheduledMessageEventStore) Exists(ctx context.Context, event *scheduling.ScheduledMessageEvent) (bool, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return false, m.Error
+	}
+
+	key := ScheduledMessageEventKey{ContactId: event.ContactId, MessageId: event.MessageId, ScheduledMessageId: event.ScheduledMessageId}
+	_, exists := m.ScheduledMessageEventsByKey[key]
+
+	return exists, nil
+}

internal/store/mock/scheduled_message_store.go

@@ -0,0 +1,141 @@
+package mock
+
+import (
+	"context"
+	"fmt"
+	"sync"
+
+	"git.kundeng.us/phoenix/textsender-models/tx0/message/scheduling"
+	"github.com/google/uuid"
+)
+
+type ScheduledMessageKey struct {
+	UserId uuid.UUID
+}
+
+type MockScheduledMessageStore struct {
+	ScheduledMessages      map[uuid.UUID]*scheduling.ScheduledMessage
+	ScheduledMessagesByKey map[ScheduledMessageKey]*scheduling.ScheduledMessage
+	mu                     sync.RWMutex
+	Error                  error // Optional: simulate errors
+}
+
+func NewMockScheduledMessageStore() *MockScheduledMessageStore {
+	return &MockScheduledMessageStore{
+		ScheduledMessages:      make(map[uuid.UUID]*scheduling.ScheduledMessage),
+		ScheduledMessagesByKey: make(map[ScheduledMessageKey]*scheduling.ScheduledMessage),
+	}
+}
+
+func (m *MockScheduledMessageStore) Get(ctx context.Context, id uuid.UUID) (*scheduling.ScheduledMessage, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return nil, m.Error
+	}
+
+	if id == uuid.Nil {
+		return nil, fmt.Errorf("Id is nil")
+	} else {
+		if schMsg := m.ScheduledMessages[id]; schMsg != nil {
+			return schMsg, nil
+		} else {
+			return nil, fmt.Errorf("Scheduled message does not exist")
+		}
+	}
+}
+
+func (m *MockScheduledMessageStore) FetchNextScheduledMessage(ctx context.Context) (*scheduling.ScheduledMessage, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return nil, m.Error
+	}
+
+	var schMsg *scheduling.ScheduledMessage
+	for _, msg := range m.ScheduledMessages {
+		if msg.Status == scheduling.Ready {
+			msg.Status = scheduling.Processing
+			schMsg = msg
+			break
+		}
+	}
+
+	if schMsg == nil {
+		return nil, fmt.Errorf("No scheduled message is ready")
+	} else {
+		return schMsg, nil
+	}
+}
+
+func (m *MockScheduledMessageStore) GetWithUserId(ctx context.Context, userId uuid.UUID) ([]*scheduling.ScheduledMessage, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return nil, m.Error
+	}
+
+	if userId == uuid.Nil {
+		return nil, fmt.Errorf("User Id is nil")
+	} else {
+		var schMsgs []*scheduling.ScheduledMessage
+		for _, schMsg := range m.ScheduledMessages {
+			if schMsg.UserId == userId {
+				schMsgs = append(schMsgs, schMsg)
+			}
+		}
+
+		if len(schMsgs) == 0 {
+			return nil, nil
+		} else {
+			return schMsgs, nil
+		}
+	}
+}
+
+func (m *MockScheduledMessageStore) CreateScheduledMessage(ctx context.Context, schedMsg *scheduling.ScheduledMessage) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return m.Error
+	}
+
+	if schedMsg.Id == uuid.Nil {
+		schedMsg.Id = uuid.New()
+	}
+
+	key := ScheduledMessageKey{UserId: schedMsg.UserId}
+
+	m.ScheduledMessages[schedMsg.Id] = schedMsg
+	m.ScheduledMessagesByKey[key] = schedMsg
+	return nil
+}
+
+func (m *MockScheduledMessageStore) UpdateStatus(ctx context.Context, id uuid.UUID, updatedStatus string) (*string, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.Error != nil {
+		return nil, m.Error
+	}
+
+	if id == uuid.Nil {
+		return nil, fmt.Errorf("Id is nil")
+	} else {
+		if schMsg := m.ScheduledMessages[id]; schMsg != nil {
+			key := ScheduledMessageKey{UserId: schMsg.UserId}
+
+			schMsg.Status = updatedStatus
+			m.ScheduledMessages[schMsg.Id] = schMsg
+			m.ScheduledMessagesByKey[key] = schMsg
+
+			return &updatedStatus, nil
+		} else {
+			return nil, fmt.Errorf("Scheduled message does not exist")
+		}
+	}
+}

internal/store/mock/store.go

@@ -0,0 +1,101 @@
+package mock
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+
+	"git.kundeng.us/phoenix/textsender-models/tx0/message"
+	"github.com/google/uuid"
+)
+
+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
+	}
+
+	var id uuid.UUID
+	if msg != nil {
+		if msg.Id == nil || *msg.Id == uuid.Nil {
+			id = uuid.New()
+			msg.Id = &id
+		}
+	} else {
+		return fmt.Errorf("Message not populated")
+	}
+
+	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/store/scheduled_message_event_store.go

@@ -0,0 +1,113 @@
+package store
+
+import (
+	"context"
+	"fmt"
+
+	"git.kundeng.us/phoenix/textsender-models/tx0/message/scheduling"
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+type ScheduledMessageEventStore interface {
+	Get(ctx context.Context, id uuid.UUID) (*scheduling.ScheduledMessageEvent, error)
+	GetWithScheduleMessageId(ctx context.Context, schMsgId uuid.UUID) ([]*scheduling.ScheduledMessageEvent, error)
+	Delete(ctx context.Context, id uuid.UUID) error
+	CreateScheduledMessageEvent(ctx context.Context, event *scheduling.ScheduledMessageEvent) error
+	Exists(ctx context.Context, event *scheduling.ScheduledMessageEvent) (bool, error)
+}
+
+type PGScheduledMessageEventStore struct {
+	db *pgxpool.Pool
+}
+
+func NewScheduledMessageEventStore(db *pgxpool.Pool) *PGScheduledMessageEventStore {
+	return &PGScheduledMessageEventStore{db: db}
+}
+
+func (s *PGScheduledMessageEventStore) Get(ctx context.Context, id uuid.UUID) (*scheduling.ScheduledMessageEvent, error) {
+	query := `SELECT id, contact_id, message_id, scheduled_message_id, created FROM scheduled_message_events WHERE id = $1`
+
+	var event scheduling.ScheduledMessageEvent
+	err := s.db.QueryRow(ctx, query, id).Scan(
+		&event.Id, &event.ContactId, &event.MessageId, &event.ScheduledMessageId, &event.Created,
+	)
+
+	if err == pgx.ErrNoRows {
+		return nil, nil
+	} else if err != nil {
+		return nil, fmt.Errorf("getting scheduled message event by ID: %w", err)
+	} else {
+		return &event, nil
+	}
+}
+
+func (s *PGScheduledMessageEventStore) GetWithScheduleMessageId(ctx context.Context, schMsgId uuid.UUID) ([]*scheduling.ScheduledMessageEvent, error) {
+	var events []*scheduling.ScheduledMessageEvent
+	query := `SELECT id, contact_id, message_id, scheduled_message_id, created FROM scheduled_message_events WHERE scheduled_message_id = $1
+	`
+
+	rows, err := s.db.Query(ctx, query, schMsgId)
+
+	if err != nil {
+		return nil, fmt.Errorf("Error retrieving rows from scheduled_message_Events: %w", err)
+	}
+
+	for rows.Next() {
+		var event scheduling.ScheduledMessageEvent
+
+		if err := rows.Scan(&event.Id, &event.ContactId, &event.MessageId, &event.ScheduledMessageId, &event.Created); err != nil {
+			return nil, fmt.Errorf("Error fetching data from row: %w", err)
+		} else {
+			events = append(events, &event)
+		}
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	return events, nil
+}
+
+func (s *PGScheduledMessageEventStore) Delete(ctx context.Context, id uuid.UUID) error {
+	query := `
+		DELETE FROM scheduled_message_events WHERE id = $1
+	`
+
+	commandTag, err := s.db.Exec(ctx, query, id)
+	if err != nil {
+		return fmt.Errorf("error deleting event: %w", err)
+	}
+
+	if commandTag.RowsAffected() == 0 {
+		return fmt.Errorf("no event found with id %d", id)
+	} else {
+		return nil
+	}
+}
+
+func (s *PGScheduledMessageEventStore) CreateScheduledMessageEvent(ctx context.Context, event *scheduling.ScheduledMessageEvent) error {
+	query := `
+		INSERT INTO scheduled_message_events (contact_id, message_id, scheduled_message_id)
+		VALUES ($1, $2, $3)
+		RETURNING id, created
+	`
+
+	return s.db.QueryRow(ctx, query, event.ContactId, event.MessageId, event.ScheduledMessageId).Scan(
+		&event.Id, &event.Created,
+	)
+}
+
+func (s *PGScheduledMessageEventStore) Exists(ctx context.Context, event *scheduling.ScheduledMessageEvent) (bool, error) {
+	query := `SELECT EXISTS(SELECT 1 FROM scheduled_message_events WHERE scheduled_message_id = $1 AND contact_id = $2)`
+
+	var exists bool
+	err := s.db.QueryRow(ctx, query, event.ScheduledMessageId, event.ContactId).Scan(&exists)
+	if err != nil {
+		return false, fmt.Errorf("Scheduled message event does not exist: %w", err)
+	} else {
+		return exists, nil
+	}
+}

internal/store/scheduled_message_store.go

@@ -0,0 +1,127 @@
+package store
+
+import (
+	"context"
+	"fmt"
+
+	"git.kundeng.us/phoenix/textsender-models/tx0/message/scheduling"
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+type ScheduledMessageStore interface {
+	Get(ctx context.Context, id uuid.UUID) (*scheduling.ScheduledMessage, error)
+	FetchNextScheduledMessage(ctx context.Context) (*scheduling.ScheduledMessage, error)
+	GetWithUserId(ctx context.Context, userId uuid.UUID) ([]*scheduling.ScheduledMessage, error)
+	CreateScheduledMessage(ctx context.Context, schedMsg *scheduling.ScheduledMessage) error
+	UpdateStatus(ctx context.Context, id uuid.UUID, updatedStatus string) (*string, error)
+}
+
+type PGScheduledMessageStore struct {
+	db *pgxpool.Pool
+}
+
+func NewScheduledMessageStore(db *pgxpool.Pool) *PGScheduledMessageStore {
+	return &PGScheduledMessageStore{db: db}
+}
+
+func (s *PGScheduledMessageStore) Get(ctx context.Context, id uuid.UUID) (*scheduling.ScheduledMessage, error) {
+	query := `
+		SELECT id, scheduled, created, status, user_id FROM scheduled_messages WHERE id = $1
+	`
+
+	var schMsg scheduling.ScheduledMessage
+	err := s.db.QueryRow(ctx, query, id).Scan(
+		&schMsg.Id, &schMsg.Scheduled, &schMsg.Created, &schMsg.Status, &schMsg.UserId,
+	)
+
+	if err == pgx.ErrNoRows {
+		return nil, fmt.Errorf("No rows")
+	} else if err != nil {
+		return nil, fmt.Errorf("Getting scheduled message: %w", err)
+	}
+
+	return &schMsg, nil
+}
+
+func (s *PGScheduledMessageStore) FetchNextScheduledMessage(ctx context.Context) (*scheduling.ScheduledMessage, error) {
+	query := `
+		UPDATE scheduled_messages
+		SET status = $1
+		WHERE id = (
+			SELECT id FROM scheduled_messages
+			WHERE status = $2
+			ORDER BY id
+			FOR UPDATE SKIP LOCKED
+			LIMIT 1
+		)
+		RETURNING id, scheduled, created, status, user_id
+	`
+	var schMsg scheduling.ScheduledMessage
+	err := s.db.QueryRow(ctx, query, scheduling.Processing, scheduling.Ready).Scan(
+		&schMsg.Id, &schMsg.Scheduled, &schMsg.Created, &schMsg.Status, &schMsg.UserId,
+	)
+
+	if err == pgx.ErrNoRows {
+		return nil, nil
+	} else if err != nil {
+		return nil, fmt.Errorf("Getting scheduled message: %w", err)
+	} else {
+		return &schMsg, nil
+	}
+}
+
+func (s *PGScheduledMessageStore) GetWithUserId(ctx context.Context, userId uuid.UUID) ([]*scheduling.ScheduledMessage, error) {
+	query := `
+		SELECT id, scheduled, created, status, user_id FROM scheduled_messages WHERE user_id = $1
+	`
+	rows, err := s.db.Query(ctx, query, userId)
+	if err != nil {
+		return nil, fmt.Errorf("Error retrieving rows from scheduled_messages: %w", err)
+	}
+
+	var schMsgs []*scheduling.ScheduledMessage
+
+	for rows.Next() {
+		var schMsg scheduling.ScheduledMessage
+		if err := rows.Scan(&schMsg.Id, &schMsg.Scheduled, &schMsg.Created, &schMsg.Status, &schMsg.UserId); err != nil {
+			return nil, fmt.Errorf("Error fetching data from row: %w", err)
+		} else {
+			schMsgs = append(schMsgs, &schMsg)
+		}
+	}
+
+	if err := rows.Err(); err != nil {
+		return nil, err
+	} else {
+		return schMsgs, nil
+	}
+}
+
+func (s *PGScheduledMessageStore) CreateScheduledMessage(ctx context.Context, schedMsg *scheduling.ScheduledMessage) error {
+	query := `
+		INSERT INTO scheduled_messages (scheduled, status, user_id)
+		VALUES ($1, $2, $3)
+		RETURNING id, created
+	`
+
+	return s.db.QueryRow(ctx, query, schedMsg.Scheduled, schedMsg.Status, schedMsg.UserId).Scan(
+		&schedMsg.Id, &schedMsg.Created,
+	)
+}
+
+func (s *PGScheduledMessageStore) UpdateStatus(ctx context.Context, id uuid.UUID, updatedStatus string) (*string, error) {
+	query := `
+		UPDATE scheduled_messages set status = $1 WHERE id = $2
+		RETURNING status
+	`
+
+	var returnedStatus string
+
+	if err := s.db.QueryRow(ctx, query, updatedStatus, id).Scan(&returnedStatus); err != nil {
+		return nil, err
+	} else {
+		return &returnedStatus, 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,49 @@
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+
+DROP TABLE IF EXISTS contacts CASCADE;
+DROP TABLE IF EXISTS messages CASCADE;
+DROP TABLE IF EXISTS scheduled_messages CASCADE;
+DROP TABLE IF EXISTS scheduled_message_events CASCADE;
+DROP TABLE IF EXISTS message_event_responses CASCADE;
+
+CREATE TABLE IF NOT EXISTS contacts (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    phone_number TEXT NOT NULL,
+    user_id UUID NOT NULL,
+    first_name TEXT NULL,
+    last_name TEXT NULL,
+    nickname TEXT NULL
+);
+
+CREATE TABLE IF NOT EXISTS messages (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    content TEXT NOT NULL,
+    user_id UUID NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS scheduled_messages (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    scheduled timestamptz NOT NULL,
+    created timestamptz DEFAULT now(),
+    status TEXT CHECK (status IN ('PENDING', 'READY', 'PROCESSING', 'DONE')),
+    user_id UUID NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS scheduled_message_events (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    contact_id UUID NOT NULL,
+    message_id UUID NOT NULL,
+    scheduled_message_id UUID NOT NULL,
+    created timestamptz DEFAULT now()
+);
+
+CREATE TABLE IF NOT EXISTS message_event_responses (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    scheduled_message_event_id UUID NULL,
+    response JSONB NOT NULL,
+    user_id UUID NOT NULL,
+    sent timestamptz NOT NULL,
+    contact_id UUID NULL,
+    message_id UUID NULL,
+    status TEXT CHECK (status IN ('INSTANT', 'SCHEDULED'))
+);

version/version.go

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