feat: spotify oauth

backend/cmd/server/main.go

@@ -6,7 +6,6 @@ import (
 
 	"platnm/internal/config"
 	"platnm/internal/service"
-	"platnm/internal/storage/postgres"
 
 	_ "github.com/lib/pq"
 	"github.com/sethvargo/go-envconfig"
@@ -19,13 +18,9 @@ func main() {
 		log.Fatalln("Error processing .env file: ", err)
 	}
 
-	// Connect to database
-	conn := postgres.ConnectDatabase(config.DbHost, config.DbUser, config.DbPassword, config.DbName, config.DbPort)
-	app := service.InitApp(service.Params{Conn: conn})
+	app := service.InitApp(config)
 
-	defer conn.Close()
-
-	if err := app.Listen(":8080"); err != nil {
+	if err := app.Listen(":" + config.Application.Port); err != nil {
 		log.Fatalf("Failed to start server: %v", err)
 	}
 }

backend/go.mod

@@ -4,8 +4,11 @@ go 1.22.6
 
 require (
 	github.com/gofiber/fiber/v2 v2.52.5
+	github.com/gofiber/storage/memory v1.3.4
 	github.com/jackc/pgx/v5 v5.7.0
 	github.com/lib/pq v1.10.9
+	github.com/zmb3/spotify/v2 v2.4.2
+	golang.org/x/oauth2 v0.23.0
 )
 
 require (
@@ -21,7 +24,8 @@ require (
 require (
 	github.com/andybalholm/brotli v1.0.5 // indirect
 	github.com/goccy/go-json v0.10.3
-	github.com/google/uuid v1.5.0 // indirect
+	github.com/gofiber/storage v1.3.3
+	github.com/google/uuid v1.5.0
 	github.com/klauspost/compress v1.17.0 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect

backend/internal/config/application.go

@@ -0,0 +1,6 @@
+package config
+
+type Application struct {
+	Port     string `env:"PORT, default=8080"`      // the port for the server to listen on
+	LogLevel string `env:"LOG_LEVEL, default=INFO"` // the level of event to log
+}

backend/internal/config/config.go

@@ -1,12 +1,7 @@
 package config
 
 type Config struct {
-	DbHost     string `env:"DB_HOST, required"`     // the database host to connect to
-	DbPort     string `env:"DB_PORT, required"`     // the database port to connect to
-	DbUser     string `env:"DB_USER, required"`     // the user to connect to the database with
-	DbPassword string `env:"DB_PASSWORD, required"` // the password to connect to the database with
-	DbName     string `env:"DB_NAME, required"`     // the name of the database to connect to
-
-	Port     string `env:"PORT, default=8080"`      // the port for the server to listen on
-	LogLevel string `env:"LOG_LEVEL, default=INFO"` // the level of event to log
+	Application Application
+	DB          DB
+	Spotify     Spotify
 }

backend/internal/config/db.go

@@ -0,0 +1,15 @@
+package config
+
+import "fmt"
+
+type DB struct {
+	Host     string `env:"DB_HOST, required"`     // the database host to connect to
+	Port     string `env:"DB_PORT, required"`     // the database port to connect to
+	User     string `env:"DB_USER, required"`     // the user to connect to the database with
+	Password string `env:"DB_PASSWORD, required"` // the password to connect to the database with
+	Name     string `env:"DB_NAME, required"`     // the name of the database to connect to
+}
+
+func (db *DB) Connection() string {
+	return fmt.Sprintf("host=%s user=%s password=%s dbname=%s port=%s sslmode=require statement_cache_mode=describe pgbouncer=true", db.Host, db.User, db.Password, db.Name, db.Port)
+}

backend/internal/config/spotify.go

@@ -0,0 +1,5 @@
+package config
+
+type Spotify struct {
+	RedirectURI string `env:"SPOTIFY_REDIRECT_URI, required"`
+}

backend/internal/constants/auth.go

@@ -0,0 +1,8 @@
+package constants
+
+import "time"
+
+
+const (
+	StateExpiresAfter = 5 * time.Minute
+)

backend/internal/constants/http.go

@@ -0,0 +1,5 @@
+package constants
+
+const (
+	HeaderRedirect = "X-Redirect"
+)

backend/internal/service/handler/spotify/begin.go

@@ -0,0 +1,39 @@
+package spotify
+
+import (
+	"net/http"
+	"platnm/internal/constants"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/google/uuid"
+	"golang.org/x/oauth2"
+)
+
+func (h *Handler) Begin(c *fiber.Ctx) error {
+	// uuid as state for now
+	verifier := oauth2.GenerateVerifier()
+	challenge := oauth2.S256ChallengeFromVerifier(verifier)
+	state := uuid.NewString()
+
+	url := h.authenticator.AuthURL(state,
+		oauth2.SetAuthURLParam("code_challenge_method", "S256"),
+		oauth2.SetAuthURLParam("code_challenge", challenge),
+	)
+
+	sv := stateValue{
+		verifier:  verifier,
+		challenge: challenge,
+	}
+
+	stateValue, err := sv.MarshalBinary()
+	if err != nil {
+		return err
+	}
+
+	if err := h.store.Set(state, stateValue, constants.StateExpiresAfter); err != nil {
+		return err
+	}
+
+	c.Set(constants.HeaderRedirect, url)
+	return c.SendStatus(http.StatusFound)
+}

backend/internal/service/handler/spotify/callback.go

@@ -0,0 +1,42 @@
+package spotify
+
+import (
+	"log/slog"
+	"net/http"
+	"platnm/internal/constants"
+
+	"github.com/gofiber/fiber/v2"
+	"github.com/gofiber/fiber/v2/middleware/adaptor"
+	"golang.org/x/oauth2"
+)
+
+func (h *Handler) Callback(c *fiber.Ctx) error {
+	state := c.Query("state")
+
+	sv, err := h.store.Get(state)
+	if err != nil {
+		return err
+	}
+
+	var stateValue stateValue
+	if err := stateValue.UnmarshalBinary(sv); err != nil {
+		return err
+	}
+
+	req, err := adaptor.ConvertRequest(c, false)
+	if err != nil {
+		return err
+	}
+
+	token, err := h.authenticator.Token(c.Context(), state, req, oauth2.SetAuthURLParam("code_verifier", stateValue.verifier))
+	if err != nil {
+		slog.Error("Failed to get token", "error", err)
+		return c.SendStatus(http.StatusInternalServerError)
+	}
+
+	slog.Info("Access token:", "token", token.AccessToken)
+	slog.Info("Refresh token:", "token", token.RefreshToken)
+
+	c.Set(constants.HeaderRedirect, "http://127.0.0.1:3000")
+	return c.SendStatus(http.StatusFound)
+}

backend/internal/service/handler/spotify/handler.go

@@ -0,0 +1,24 @@
+package spotify
+
+import (
+	"platnm/internal/config"
+
+	"github.com/gofiber/storage"
+	spotifyauth "github.com/zmb3/spotify/v2/auth"
+)
+
+type Handler struct {
+	store         storage.Storage
+	authenticator *spotifyauth.Authenticator
+}
+
+func NewHandler(store storage.Storage, config config.Spotify) *Handler {
+	authenticator := spotifyauth.New(
+		spotifyauth.WithRedirectURL(config.RedirectURI),
+		spotifyauth.WithScopes(spotifyauth.ScopeUserReadPrivate),
+	)
+	return &Handler{
+		store:         store,
+		authenticator: authenticator,
+	}
+}

backend/internal/service/handler/spotify/state_value.go

@@ -0,0 +1,57 @@
+package spotify
+
+import (
+	"errors"
+	"sync"
+)
+
+const (
+	verifierLen  = 43
+	challengeLen = 43
+	bufferSize   = verifierLen + challengeLen
+)
+
+var ErrInvalidStateValueLength = errors.New("invalid state value length")
+
+type stateValue struct {
+	verifier  string
+	challenge string
+}
+
+func (sv *stateValue) MarshalBinary() ([]byte, error) {
+	buffer := getBuffer()
+	copy(buffer.data[:verifierLen], sv.verifier)
+	copy(buffer.data[verifierLen:], sv.challenge)
+	return buffer.data, nil
+}
+
+// UnmarshalBinary decodes the state value from binary data.
+// Returns ErrInvalidStateValueLength if the data length is
+// not equal to bufferSize.
+func (sv *stateValue) UnmarshalBinary(data []byte) error {
+	if len(data) != bufferSize {
+		return ErrInvalidStateValueLength
+	}
+	sv.verifier = string(data[:verifierLen])
+	sv.challenge = string(data[verifierLen:])
+	putBuffer(&buffer{data: data})
+	return nil
+}
+
+type buffer struct {
+	data []byte
+}
+
+var bufferPool = sync.Pool{
+	New: func() interface{} {
+		return make([]byte, bufferSize)
+	},
+}
+
+func getBuffer() *buffer {
+	return bufferPool.Get().(*buffer)
+}
+
+func putBuffer(buffer *buffer) {
+	bufferPool.Put(buffer)
+}

backend/internal/service/server.go

@@ -1,8 +1,11 @@
 package service
 
 import (
+	"net/http"
+	"platnm/internal/config"
 	"platnm/internal/errs"
 	"platnm/internal/service/handler"
+	"platnm/internal/service/handler/spotify"
 	"platnm/internal/storage/postgres"
 
 	go_json "github.com/goccy/go-json"
@@ -11,32 +14,36 @@ import (
 	"github.com/gofiber/fiber/v2/middleware/logger"
 	"github.com/gofiber/fiber/v2/middleware/recover"
 	"github.com/gofiber/fiber/v2/middleware/requestid"
-	"github.com/jackc/pgx/v5/pgxpool"
+	"github.com/gofiber/storage/memory"
 )
 
-type Params struct {
-	Conn *pgxpool.Pool
-}
-
-func InitApp(params Params) *fiber.App {
+func InitApp(config config.Config) *fiber.App {
 	app := setupApp()
 
-	setupRoutes(app, params.Conn)
+	setupRoutes(app, config)
 
 	return app
 }
 
-func setupRoutes(app *fiber.App, conn *pgxpool.Pool) {
+func setupRoutes(app *fiber.App, config config.Config) {
 	app.Get("/health", func(c *fiber.Ctx) error {
-		return c.SendStatus(fiber.StatusOK)
+		return c.SendStatus(http.StatusOK)
 	})
 
-	repository := postgres.NewRepository(conn)
+	repository := postgres.NewRepository(config.DB)
 	userHandler := handler.NewUserHandler(repository.User)
 	app.Route("/users", func(r fiber.Router) {
 		r.Get("/", userHandler.GetUsers)
 		r.Get("/:id", userHandler.GetUserById)
 	})
+
+	app.Route("/auth", func(r fiber.Router) {
+		r.Route("/spotify", func(r fiber.Router) {
+			h := spotify.NewHandler(memory.New(), config.Spotify)
+			r.Get("/begin", h.Begin)
+			r.Get("/callback", h.Callback)
+		})
+	})
 }
 
 func setupApp() *fiber.App {

backend/internal/storage/postgres/storage.go

@@ -2,19 +2,17 @@ package postgres
 
 import (
 	"context"
-	"fmt"
 	"log"
+	"platnm/internal/config"
 	"platnm/internal/storage"
 	user "platnm/internal/storage/postgres/schema"
 
 	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 
-func ConnectDatabase(host, user, password, dbname, port string) *pgxpool.Pool {
-	connStr := fmt.Sprintf("host=%s user=%s password=%s dbname=%s port=%s sslmode=require statement_cache_mode=describe pgbouncer=true", host, user, password, dbname, port)
-
-	dbConfig, err := pgxpool.ParseConfig(connStr)
+func ConnectDatabase(config config.DB) *pgxpool.Pool {
+	dbConfig, err := pgxpool.ParseConfig(config.Connection())
 	if err != nil {
 		log.Fatal("Failed to create a config, error: ", err)
 	}
@@ -38,7 +36,9 @@ func ConnectDatabase(host, user, password, dbname, port string) *pgxpool.Pool {
 	return conn
 }
 
-func NewRepository(db *pgxpool.Pool) *storage.Repository {
+func NewRepository(config config.DB) *storage.Repository {
+	db := ConnectDatabase(config)
+
 	return &storage.Repository{
 		User: user.NewUserRepository(db),
 	}