postgres

internal/auth/repository.go

@@ -4,97 +4,111 @@ import (
 	"context"
 	"time"
 
-	"go.mongodb.org/mongo-driver/v2/bson"
-	"go.mongodb.org/mongo-driver/v2/mongo"
-	"go.mongodb.org/mongo-driver/v2/mongo/options"
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
 )
 
 type Repository struct {
-	usersCollection         *mongo.Collection
-	refreshTokensCollection *mongo.Collection
+	pool *pgxpool.Pool
 }
 
-func NewRepository(db *mongo.Database) *Repository {
-	return &Repository{
-		usersCollection:         db.Collection("users"),
-		refreshTokensCollection: db.Collection("refresh_tokens"),
-	}
+func NewRepository(pool *pgxpool.Pool) *Repository {
+	return &Repository{pool: pool}
 }
 
-func (r *Repository) EnsureIndexes(ctx context.Context) error {
-	_, err := r.usersCollection.Indexes().CreateOne(ctx, mongo.IndexModel{
-		Keys:    bson.D{{Key: "email", Value: 1}},
-		Options: options.Index().SetUnique(true),
-	})
-	if err != nil {
-		return err
-	}
+func (r *Repository) Migrate(ctx context.Context) error {
+	schema := `
+	CREATE TABLE IF NOT EXISTS users (
+		id         UUID PRIMARY KEY,
+		username   TEXT NOT NULL,
+		email      TEXT NOT NULL UNIQUE,
+		password_hash TEXT NOT NULL,
+		created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+	);
 
-	_, err = r.refreshTokensCollection.Indexes().CreateMany(ctx, []mongo.IndexModel{
-		{
-			Keys:    bson.D{{Key: "token_hash", Value: 1}},
-			Options: options.Index().SetUnique(true),
-		},
-		{
-			Keys:    bson.D{{Key: "expires_at", Value: 1}},
-			Options: options.Index().SetExpireAfterSeconds(0),
-		},
-	})
+	CREATE TABLE IF NOT EXISTS refresh_tokens (
+		id         UUID PRIMARY KEY,
+		user_id    UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+		token_hash TEXT NOT NULL UNIQUE,
+		expires_at TIMESTAMPTZ NOT NULL,
+		created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+	);
+
+	CREATE INDEX IF NOT EXISTS idx_refresh_tokens_expires_at ON refresh_tokens(expires_at);
+	`
+	_, err := r.pool.Exec(ctx, schema)
 	return err
 }
 
 func (r *Repository) CreateUser(ctx context.Context, user *User) error {
-	user.ID = bson.NewObjectID()
+	user.ID = uuid.New().String()
 	user.CreatedAt = time.Now().UTC()
-	_, err := r.usersCollection.InsertOne(ctx, user)
+	_, err := r.pool.Exec(ctx,
+		`INSERT INTO users (id, username, email, password_hash, created_at) VALUES ($1, $2, $3, $4, $5)`,
+		user.ID, user.Username, user.Email, user.PasswordHash, user.CreatedAt,
+	)
 	return err
 }
 
 func (r *Repository) FindByEmail(ctx context.Context, email string) (*User, error) {
 	var user User
-	err := r.usersCollection.FindOne(ctx, bson.M{"email": email}).Decode(&user)
+	err := r.pool.QueryRow(ctx,
+		`SELECT id, username, email, password_hash, created_at FROM users WHERE email = $1`, email,
+	).Scan(&user.ID, &user.Username, &user.Email, &user.PasswordHash, &user.CreatedAt)
 	if err != nil {
 		return nil, err
 	}
 	return &user, nil
 }
 
-func (r *Repository) FindByID(ctx context.Context, id bson.ObjectID) (*User, error) {
+func (r *Repository) FindByID(ctx context.Context, id string) (*User, error) {
 	var user User
-	err := r.usersCollection.FindOne(ctx, bson.M{"_id": id}).Decode(&user)
+	err := r.pool.QueryRow(ctx,
+		`SELECT id, username, email, password_hash, created_at FROM users WHERE id = $1`, id,
+	).Scan(&user.ID, &user.Username, &user.Email, &user.PasswordHash, &user.CreatedAt)
 	if err != nil {
 		return nil, err
 	}
 	return &user, nil
 }
 
-//Refresh
-
 func (r *Repository) CreateRefreshToken(ctx context.Context, doc *RefreshTokenDoc) error {
-	doc.ID = bson.NewObjectID()
+	doc.ID = uuid.New().String()
 	doc.CreatedAt = time.Now().UTC()
-	_, err := r.refreshTokensCollection.InsertOne(ctx, doc)
+	_, err := r.pool.Exec(ctx,
+		`INSERT INTO refresh_tokens (id, user_id, token_hash, expires_at, created_at) VALUES ($1, $2, $3, $4, $5)`,
+		doc.ID, doc.UserID, doc.TokenHash, doc.ExpiresAt, doc.CreatedAt,
+	)
 	return err
 }
 
 func (r *Repository) FindRefreshTokenByHash(ctx context.Context, hash string) (*RefreshTokenDoc, error) {
 	var doc RefreshTokenDoc
-	err := r.refreshTokensCollection.FindOne(ctx, bson.M{"token_hash": hash}).Decode(&doc)
+	err := r.pool.QueryRow(ctx,
+		`SELECT id, user_id, token_hash, expires_at, created_at FROM refresh_tokens WHERE token_hash = $1`, hash,
+	).Scan(&doc.ID, &doc.UserID, &doc.TokenHash, &doc.ExpiresAt, &doc.CreatedAt)
 	if err != nil {
 		return nil, err
 	}
 	return &doc, nil
 }
 
-func (r *Repository) DeleteRefreshToken(ctx context.Context, id bson.ObjectID) error {
-	_, err := r.refreshTokensCollection.DeleteOne(ctx, bson.M{"_id": id})
+func (r *Repository) DeleteRefreshToken(ctx context.Context, id string) error {
+	_, err := r.pool.Exec(ctx, `DELETE FROM refresh_tokens WHERE id = $1`, id)
 	return err
 }
 
 func (r *Repository) DeleteRefreshTokenByHash(ctx context.Context, hash string) (bool, error) {
-	res, err := r.refreshTokensCollection.DeleteOne(ctx, bson.M{"token_hash": hash})
+	tag, err := r.pool.Exec(ctx, `DELETE FROM refresh_tokens WHERE token_hash = $1`, hash)
 	if err != nil {
 		return false, err
 	}
-	return res.DeletedCount > 0, nil
+	return tag.RowsAffected() > 0, nil
 }
+
+func (r *Repository) EnsureIndexes(ctx context.Context) error {
+	return r.Migrate(ctx)
+}
+
+var ErrNoRows = pgx.ErrNoRows