overhaul

internal/database/migrations.go

@@ -0,0 +1,155 @@
+package database
+
+import (
+	"context"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+// Migrate runs all migration files in the migrations directory
+func (db *DB) Migrate(migrationsDir string) error {
+	// Create migrations table if it doesn't exist
+	if err := db.createMigrationsTable(); err != nil {
+		return fmt.Errorf("failed to create migrations table: %w", err)
+	}
+
+	// Get list of migration files
+	files, err := ioutil.ReadDir(migrationsDir)
+	if err != nil {
+		return fmt.Errorf("failed to read migrations directory: %w", err)
+	}
+
+	// Sort files by name to ensure proper order
+	var migrationFiles []string
+	for _, file := range files {
+		if !file.IsDir() && strings.HasSuffix(file.Name(), ".sql") {
+			migrationFiles = append(migrationFiles, file.Name())
+		}
+	}
+	sort.Strings(migrationFiles)
+
+	// Run each migration that hasn't been run yet
+	for _, fileName := range migrationFiles {
+		if err := db.runMigration(migrationsDir, fileName); err != nil {
+			return fmt.Errorf("failed to run migration %s: %w", fileName, err)
+		}
+	}
+
+	log.Println("All migrations completed successfully")
+	return nil
+}
+
+func (db *DB) createMigrationsTable() error {
+	query := `
+		CREATE TABLE IF NOT EXISTS migrations (
+			id SERIAL PRIMARY KEY,
+			filename VARCHAR(255) UNIQUE NOT NULL,
+			executed_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+		)
+	`
+	_, err := db.Exec(query)
+	return err
+}
+
+func (db *DB) runMigration(migrationsDir, fileName string) error {
+	// Check if migration has already been run
+	var count int
+	err := db.QueryRow("SELECT COUNT(*) FROM migrations WHERE filename = $1", fileName).Scan(&count)
+	if err != nil {
+		return fmt.Errorf("failed to check migration status: %w", err)
+	}
+
+	if count > 0 {
+		log.Printf("Migration %s already executed, skipping", fileName)
+		return nil
+	}
+
+	// Read migration file
+	filePath := filepath.Join(migrationsDir, fileName)
+	content, err := ioutil.ReadFile(filePath)
+	if err != nil {
+		return fmt.Errorf("failed to read migration file %s: %w", fileName, err)
+	}
+
+	// Execute migration in a transaction
+	tx, err := db.BeginTx(context.Background(), nil)
+	if err != nil {
+		return fmt.Errorf("failed to begin transaction: %w", err)
+	}
+	defer tx.Rollback()
+
+	// Execute migration SQL
+	_, err = tx.Exec(string(content))
+	if err != nil {
+		return fmt.Errorf("failed to execute migration %s: %w", fileName, err)
+	}
+
+	// Record that migration was executed
+	_, err = tx.Exec("INSERT INTO migrations (filename) VALUES ($1)", fileName)
+	if err != nil {
+		return fmt.Errorf("failed to record migration %s: %w", fileName, err)
+	}
+
+	// Commit transaction
+	if err = tx.Commit(); err != nil {
+		return fmt.Errorf("failed to commit migration %s: %w", fileName, err)
+	}
+
+	log.Printf("Successfully executed migration: %s", fileName)
+	return nil
+}
+
+// SeedData inserts initial data for development
+func (db *DB) SeedData() error {
+	// Check if we already have users
+	var count int
+	err := db.QueryRow("SELECT COUNT(*) FROM users").Scan(&count)
+	if err != nil {
+		return fmt.Errorf("failed to check existing users: %w", err)
+	}
+
+	if count > 0 {
+		log.Println("Database already has data, skipping seed")
+		return nil
+	}
+
+	// Insert demo user
+	hashedPassword := "$2a$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi" // "password"
+	_, err = db.Exec(`
+		INSERT INTO users (email, password_hash, name) 
+		VALUES ($1, $2, $3)
+	`, "demo@containr.dev", hashedPassword, "Demo User")
+	if err != nil {
+		return fmt.Errorf("failed to create demo user: %w", err)
+	}
+
+	// Insert demo project
+	var projectID string
+	err = db.QueryRow(`
+		INSERT INTO projects (name, description, owner_id) 
+		VALUES ($1, $2, (SELECT id FROM users WHERE email = $3))
+		RETURNING id
+	`, "Demo Project", "A sample project to showcase Containr features", "demo@containr.dev").Scan(&projectID)
+	if err != nil {
+		return fmt.Errorf("failed to create demo project: %w", err)
+	}
+
+	// Insert environments
+	environments := []string{"production", "preview", "development"}
+	for _, env := range environments {
+		_, err = db.Exec(`
+			INSERT INTO environments (name, project_id) 
+			VALUES ($1, $2)
+		`, env, projectID)
+		if err != nil {
+			return fmt.Errorf("failed to create environment %s: %w", env, err)
+		}
+	}
+
+	log.Println("Database seeded successfully")
+	return nil
+}

internal/database/postgres.go

@@ -0,0 +1,59 @@
+package database
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"time"
+
+	_ "github.com/lib/pq"
+)
+
+type DB struct {
+	*sql.DB
+}
+
+type DBConfig struct {
+	MaxOpenConns    int
+	MaxIdleConns    int
+	ConnMaxLifetime time.Duration
+	ConnMaxIdleTime time.Duration
+}
+
+func NewConnection(databaseURL string) (*DB, error) {
+	return NewConnectionWithConfig(databaseURL, DBConfig{
+		MaxOpenConns:    25,
+		MaxIdleConns:    25,
+		ConnMaxLifetime: 5 * time.Minute,
+		ConnMaxIdleTime: 5 * time.Minute,
+	})
+}
+
+func NewConnectionWithConfig(databaseURL string, config DBConfig) (*DB, error) {
+	db, err := sql.Open("postgres", databaseURL)
+	if err != nil {
+		return nil, fmt.Errorf("unable to open database: %w", err)
+	}
+
+	// Configure connection pool
+	db.SetMaxOpenConns(config.MaxOpenConns)
+	db.SetMaxIdleConns(config.MaxIdleConns)
+	db.SetConnMaxLifetime(config.ConnMaxLifetime)
+	db.SetConnMaxIdleTime(config.ConnMaxIdleTime)
+
+	// Test the connection
+	if err := db.PingContext(context.Background()); err != nil {
+		return nil, fmt.Errorf("unable to ping database: %w", err)
+	}
+
+	return &DB{DB: db}, nil
+}
+
+func (db *DB) Health(ctx context.Context) error {
+	return db.PingContext(ctx)
+}
+
+// Stats returns connection pool statistics for monitoring
+func (db *DB) Stats() sql.DBStats {
+	return db.Stats()
+}

internal/database/redis.go

@@ -0,0 +1,54 @@
+package database
+
+import (
+	"context"
+	"time"
+
+	"github.com/go-redis/redis/v8"
+)
+
+type Redis struct {
+	Client *redis.Client
+}
+
+func NewRedis(redisURL string) *Redis {
+	opt, err := redis.ParseURL(redisURL)
+	if err != nil {
+		// Fallback to default Redis options if URL parsing fails
+		opt = &redis.Options{
+			Addr:     "localhost:6379",
+			Password: "",
+			DB:       0,
+		}
+	}
+
+	client := redis.NewClient(opt)
+
+	return &Redis{Client: client}
+}
+
+func (r *Redis) Close() error {
+	return r.Client.Close()
+}
+
+func (r *Redis) Health(ctx context.Context) error {
+	_, err := r.Client.Ping(ctx).Result()
+	return err
+}
+
+func (r *Redis) Set(ctx context.Context, key string, value interface{}, expiration time.Duration) error {
+	return r.Client.Set(ctx, key, value, expiration).Err()
+}
+
+func (r *Redis) Get(ctx context.Context, key string) (string, error) {
+	return r.Client.Get(ctx, key).Result()
+}
+
+func (r *Redis) Del(ctx context.Context, keys ...string) error {
+	return r.Client.Del(ctx, keys...).Err()
+}
+
+func (r *Redis) Exists(ctx context.Context, key string) (bool, error) {
+	result, err := r.Client.Exists(ctx, key).Result()
+	return result > 0, err
+}