main.go

// Package main demonstrates database connection examples.
package main

import (
	"context"
	"fmt"
	"time"

	"github.com/yigithankarabulut/wirekit"
	"github.com/yigithankarabulut/wirekit/mongox"
	"go.uber.org/zap"
)

// User represents a user model.
type User struct {
	ID    uint   `gorm:"primaryKey"`
	Name  string `gorm:"size:100"`
	Email string `gorm:"uniqueIndex"`
}

// PostgresGORM demonstrates PostgreSQL with GORM.
func PostgresGORM() {
	fmt.Println("\n--- PostgreSQL with GORM ---")

	db, err := wirekit.Postgres().GORM().
		WithDSN("host=localhost user=postgres password=secret dbname=myapp port=5432 sslmode=disable").
		WithMaxIdleConns(10).
		WithMaxOpenConns(100).
		WithConnMaxLifetime(time.Hour).
		Connect()
	if err != nil {
		wirekit.Error("failed to connect to postgres", zap.Error(err))
		return
	}

	wirekit.Info("connected to postgres with GORM")

	// Auto-migrate tables
	if err := db.AutoMigrate(&User{}); err != nil {
		wirekit.Error("failed to auto-migrate tables", zap.Error(err))
	}

	// Create a user
	user := User{Name: "John Doe", Email: "john@example.com"}
	if err := db.Create(&user).Error; err != nil {
		wirekit.Error("failed to create user", zap.Error(err))
	}

	// Query
	var users []User
	db.Find(&users)
	fmt.Printf("Found %d users\n", len(users))
}

// PostgresPGX demonstrates PostgreSQL with pgx.
func PostgresPGX(ctx context.Context) {
	fmt.Println("\n--- PostgreSQL with PGX ---")

	pool, err := wirekit.Postgres().PGX().
		WithDSN("postgres://user:password@localhost:5432/mydb").
		WithMaxConns(25).
		WithMinConns(5).
		Connect(ctx)
	if err != nil {
		wirekit.Error("failed to connect with pgx", zap.Error(err))
		return
	}
	defer pool.Close()

	wirekit.Info("connected to postgres with pgx")

	// Query example
	row := pool.QueryRow(ctx, "SELECT id, name FROM users WHERE id = $1", 1)
	var id int
	var name string
	if err := row.Scan(&id, &name); err != nil {
		wirekit.Debug("query failed", zap.Error(err))
	}
}

// PostgresSQL demonstrates PostgreSQL with database/sql.
func PostgresSQL() {
	fmt.Println("\n--- PostgreSQL with database/sql ---")

	sqlDB, err := wirekit.Postgres().SQL().
		WithDSN("postgres://user:password@localhost:5432/mydb?sslmode=disable").
		WithMaxIdleConns(10).
		WithMaxOpenConns(100).
		Connect()
	if err != nil {
		wirekit.Error("failed to connect with database/sql", zap.Error(err))
		return
	}
	defer func() {
		if err := sqlDB.Close(); err != nil {
			wirekit.Error("failed to close database/sql", zap.Error(err))
		}
	}()

	wirekit.Info("connected to postgres with database/sql")

	rows, err := sqlDB.Query("SELECT * FROM users LIMIT 10")
	if err == nil {
		defer func() {
			if err := rows.Close(); err != nil {
				wirekit.Error("failed to close rows", zap.Error(err))
			}
		}()
	}
}

// MongoDBConnection demonstrates MongoDB connection.
func MongoDBConnection(ctx context.Context) {
	fmt.Println("\n--- MongoDB ---")

	client, mongoDB, err := wirekit.Mongo().
		WithURI("mongodb://localhost:27017").
		WithDatabase("myapp").
		WithTimeout(10 * time.Second).
		WithMaxPoolSize(100).
		WithMinPoolSize(10).
		ConnectWithDB(ctx)
	if err != nil {
		wirekit.Error("failed to connect to MongoDB", zap.Error(err))
		return
	}
	defer func() {
		if err := client.Disconnect(ctx); err != nil {
			wirekit.Error("failed to disconnect from MongoDB", zap.Error(err))
		}
	}()

	wirekit.Info("connected to MongoDB")

	// Get collection
	collection := mongoDB.Collection("users")
	fmt.Printf("Collection: %s\n", collection.Name())
}

// MongoDBHelpers demonstrates MongoDB helper functions.
func MongoDBHelpers() {
	fmt.Println("\n--- MongoDB Helpers ---")

	// ObjectID utilities
	objectID := wirekit.MongoX.NewObjectID()
	fmt.Println("New ObjectID:", objectID.Hex())

	hexString := "507f1f77bcf86cd799439011"
	parsedID := wirekit.MongoX.ToObjectID(hexString)
	fmt.Println("Parsed ObjectID:", parsedID.Hex())

	isValid := wirekit.MongoX.IsValidObjectID(hexString)
	fmt.Println("Is Valid ObjectID:", isValid)

	// Filter builder
	filter := mongox.Filter().
		Eq("status", "active").
		Gte("age", 18).
		In("role", []string{"admin", "user"}).
		Regex("email", ".*@example.com", "i").
		Build()
	fmt.Printf("Filter: %+v\n", filter)

	// Update builder
	update := mongox.Update().
		Set("name", "John Doe").
		Set("updated_at", time.Now()).
		Inc("login_count", 1).
		Unset("temp_field").
		Push("tags", "new-tag").
		Build()
	fmt.Printf("Update: %+v\n", update)
}

func main() {
	ctx := context.Background()

	wirekit.Log(wirekit.Zap).WithLevel("info").Init()

	PostgresGORM()
	PostgresPGX(ctx)
	PostgresSQL()
	MongoDBConnection(ctx)
	MongoDBHelpers()

	wirekit.Info("database example completed")
}