go-blocks/app.go

package goblocks

import (
	"bufio"
	"database/sql"
	"embed"
	"errors"
	"fmt"
	"io"
	"log/slog"
	"os"
	"strings"
	"time"

	"aidanwoods.dev/go-paseto"

	"github.com/alexedwards/scs/v2"
	"github.com/golang-migrate/migrate/v4"
	_ "github.com/golang-migrate/migrate/v4/database/postgres"
	"github.com/golang-migrate/migrate/v4/source/iofs"
	_ "github.com/jackc/pgx/v5/stdlib"
)

var (
	logFile  *os.File
	logLevel string
)

type Environment string

const (
	EnvironmentTesting     Environment = "testing"
	EnvironmentDevelopment Environment = "development"
	EnvironmentProduction  Environment = "production"
)

type LogLevel slog.Level

type DatabaseConfig struct {
	DriverName string
	DataSource string
	Migrate    bool
}

type Config struct {
	// default "no-name-defined"
	Name string

	// default "v0.0.0"
	Version string

	// default "development"
	EnvMode Environment

	// default "debug"
	LogLevel slog.Level

	// default "UTC"
	Timezone string

	// default nil
	Paseto *Paseto

	// default map[string]DatabaseConfig{}
	Databases map[string]DatabaseConfig

	// default false
	CreateRouter bool

	// default false
	CreateSSEBroker bool

	// default false
	CreateTemplates bool

	// default false
	CreateSession bool

	// default false
	CreateMailer bool
}

type App struct {
	config    Config
	Router    *Router
	SSEBroker *SSEBroker
	Templates *Render
	Session   *scs.SessionManager
	Mailer    Mailer
}

type Paseto struct {
	SecretKey paseto.V4AsymmetricSecretKey
	PublicKey paseto.V4AsymmetricPublicKey
	Duration  time.Duration
}

func NewApp(config ...Config) *App {
	cfg := Config{
		Name:            "",
		Version:         "",
		EnvMode:         EnvironmentDevelopment,
		LogLevel:        slog.LevelDebug,
		Timezone:        "UTC",
		Paseto:          nil,
		Databases:       make(map[string]DatabaseConfig),
		CreateRouter:    false,
		CreateSSEBroker: false,
		CreateSession:   false,
		CreateMailer:    false,
		CreateTemplates: false,
	}

	slog.Debug("NewApp", "config", cfg)

	if len(config) > 0 {
		cfg = config[0]
		if cfg.LogLevel == slog.LevelDebug {
			cfg.LogLevel = slog.LevelDebug
		}
		if cfg.Timezone == "" {
			cfg.Timezone = "UTC"
		}
	}

	if cfg.Name == "" {
		cfg.Name = "no-name-defined"
	}

	if cfg.Version == "" {
		cfg.Version = "v0.0.0"
	}

	if cfg.EnvMode == "" && os.Getenv("ENV_MODE") != "" {
		cfg.EnvMode = Environment(os.Getenv("ENV_MODE"))
	}

	if os.Getenv("LOG_LEVEL") != "" {
		logLevel = os.Getenv("LOG_LEVEL")
		switch logLevel {
		case "debug":
			cfg.LogLevel = slog.LevelDebug
		case "info":
			cfg.LogLevel = slog.LevelInfo
		case "warn":
			cfg.LogLevel = slog.LevelWarn
		case "error":
			cfg.LogLevel = slog.LevelError
		default:
			cfg.LogLevel = slog.LevelInfo
		}
	}

	if cfg.Timezone == "" && os.Getenv("TIMEZONE") != "" {
		cfg.Timezone = os.Getenv("TIMEZONE")
	}

	loc, err := time.LoadLocation(cfg.Timezone)
	if err != nil {
		slog.Error("error loading timezone", "error", err, "timezone", cfg.Timezone)
		loc = time.UTC
	}
	time.Local = loc

	startRotativeLogger(cfg.LogLevel)

	if cfg.Paseto == nil {
		var ak paseto.V4AsymmetricSecretKey
		var err error

		if os.Getenv("PASETO_SECRET_KEY") != "" {
			slog.Debug("using paseto secret key from env")
			ak, err = paseto.NewV4AsymmetricSecretKeyFromHex(os.Getenv("PASETO_SECRET_KEY"))
			if err != nil {
				slog.Error("error creating secret key", "error", err)
				ak = paseto.NewV4AsymmetricSecretKey()
			}
		} else {
			ak = paseto.NewV4AsymmetricSecretKey()
		}

		pk := ak.Public()

		duration := time.Hour * 24 * 7 // 7 days by default
		if os.Getenv("PASETO_DURATION") != "" {
			durationStr := os.Getenv("PASETO_DURATION")
			durationInt, err := time.ParseDuration(durationStr)
			if err != nil {
				slog.Error("error parsing PASETO_DURATION", "error", err, "duration", durationStr)
			} else {
				duration = durationInt
			}
		}

		cfg.Paseto = &Paseto{
			SecretKey: ak,
			PublicKey: pk,
			Duration:  duration,
		}
	}

	app := &App{config: cfg}

	if cfg.CreateRouter {
		app.Router = newRouter()
	}

	// Create PGX pools automatically if there are entries in Databases with driver 'pgx'
	for dbName, dbConfig := range cfg.Databases {
		if dbConfig.DriverName == "pgx" {
			slog.Debug("creating pgx pool", "database", dbName)
			app.newPGXPool(dbName)
		}
	}

	slog.Info(
		"app config",
		"name", cfg.Name,
		"version", cfg.Version,
		"env_mode", cfg.EnvMode,
		"log_level", cfg.LogLevel,
		"timezone", cfg.Timezone,
		"paseto_public_key", cfg.Paseto.PublicKey.ExportHex(),
		"paseto_duration", cfg.Paseto.Duration.String(),
		"databases", cfg.Databases,
		"create_sse_broker", cfg.CreateSSEBroker,
		"create_templates", cfg.CreateTemplates,
		"create_session", cfg.CreateSession,
		"create_mailer", cfg.CreateMailer,
	)

	if cfg.EnvMode != EnvironmentProduction {
		slog.Debug("paseto_secret_key", "key", cfg.Paseto.SecretKey.ExportHex())
	}

	if cfg.CreateSSEBroker {
		slog.Debug("creating sse broker")
		app.SSEBroker = newSSEBroker()
	}

	if cfg.CreateTemplates {
		slog.Debug("creating templates")
		app.Templates = NewHTMLRender()

		if cfg.EnvMode == EnvironmentProduction {
			app.Templates.EnableCache = true
		}
	}

	if cfg.CreateSession {
		slog.Debug("creating session")
		app.Session = scs.New()
	}

	if cfg.CreateMailer {
		slog.Debug("creating mailer")
		app.Mailer = newMailer()
	}

	return app
}

func (a *App) Name() string {
	return a.config.Name
}

func (a *App) Version() string {
	return a.config.Version
}

func (a *App) EnvMode() Environment {
	return a.config.EnvMode
}

func (a *App) LogLevel() slog.Level {
	return a.config.LogLevel
}

func (a *App) Timezone() string {
	return a.config.Timezone
}

func (a *App) Paseto() *Paseto {
	return a.config.Paseto
}

func (a *App) Datasource(name string) string {
	config, exists := a.config.Databases[name]
	if !exists {
		slog.Error("database configuration not found", "name", name)
		return ""
	}
	return config.DataSource
}

// MigrateDB migrates the database. The migrations must stored in the
// "database/migrations" directory inside cmd directory along with the main.go.
//
// cmd/main.go
//
// cmd/database/migrations/*.sql
func (a *App) Migrate(dbName string, database embed.FS) {
	dbConfig, exists := a.config.Databases[dbName]
	if !exists {
		slog.Error("database configuration not found", "name", dbName)
		return
	}

	if !dbConfig.Migrate {
		slog.Info("migration disabled", "database", dbName)
		return
	}

	dbConn, err := sql.Open(dbConfig.DriverName, dbConfig.DataSource)
	if err != nil {
		slog.Error("error opening database connection", "error", err, "database", dbName)
		return
	}
	defer dbConn.Close()

	d, err := iofs.New(database, "database/migrations")
	if err != nil {
		slog.Error("error creating migration source", "error", err, "database", dbName)
		return
	}

	m, err := migrate.NewWithSourceInstance("iofs", d, dbConfig.DataSource)
	if err != nil {
		slog.Error("error creating migration instance", "error", err, "database", dbName)
		return
	}

	err = m.Up()
	if err != nil && !errors.Is(err, migrate.ErrNoChange) {
		slog.Error("cannot migrate", "error", err, "database", dbName)
		panic(err)
	}
	if errors.Is(err, migrate.ErrNoChange) {
		slog.Info("migration has no changes", "database", dbName)
		return
	}

	slog.Info("migration done", "database", dbName)
}

func LoadEnvFile(envDirectory string) error {
	file, err := os.Open(envDirectory)
	if err != nil {
		return err
	}
	defer file.Close()

	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		line := scanner.Text()
		if len(line) == 0 || strings.HasPrefix(line, "#") {
			continue
		}
		parts := strings.SplitN(line, "=", 2)
		if len(parts) != 2 {
			continue
		}
		key := strings.TrimSpace(parts[0])
		value := strings.TrimSpace(parts[1])
		os.Setenv(key, value)
	}
	return scanner.Err()
}

func newLogger(level slog.Level) {
	if err := os.MkdirAll("logs", 0755); err != nil {
		fmt.Println("error creating logs directory:", err)
		return
	}

	now := time.Now().Format("2006-01-02")
	f, err := os.OpenFile(fmt.Sprintf("logs/log%s.log", now), os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
	if err != nil {
		fmt.Println("error opening log file:", err)
		return
	}

	mw := io.MultiWriter(os.Stdout, f)
	logger := slog.New(slog.NewTextHandler(mw, &slog.HandlerOptions{
		AddSource: os.Getenv("ENV_MODE") == "" || os.Getenv("ENV_MODE") == "development",
		Level:     level,
	}))

	if logFile != nil {
		logFile.Close() // Cierra el archivo anterior antes de rotar
	}

	logFile = f
	slog.SetDefault(logger)
}

func startRotativeLogger(level slog.Level) {
	newLogger(level)

	ticker := time.NewTicker(time.Hour * 24)
	go func() {
		for range ticker.C {
			newLogger(level)
		}
	}()
}