refactor: added handler interface to service interfaces

Author: ralvarezdev

sql/interfaces.go

@@ -16,7 +16,7 @@ type (
 
 	// Service is the interface for the service
 	Service interface {
-		DB() *sql.DB
+		Handler
 		CreateTransaction(
 			ctx context.Context,
 			fn TransactionFn,
@@ -28,12 +28,12 @@ type (
 			query *string,
 			params ...any,
 		) (sql.Result, error)
-		QueryRow(query *string, params ...any) *sql.Row
+		QueryRow(query *string, params ...any) (*sql.Row, error)
 		QueryRowWithCtx(
 			ctx any,
 			query *string,
 			params ...any,
-		) *sql.Row
+		) (*sql.Row, error)
 		ScanRow(row *sql.Row, destinations ...any) error
 	}
 )

sql/pgxpool/interfaces.go

@@ -20,7 +20,7 @@ type (
 
 	// Service is the interface for the service
 	Service interface {
-		Pool() *pgxpool.Pool
+		Handler
 		CreateTransaction(fn TransactionFn) error
 		Exec(query *string, params ...any) (*pgconn.CommandTag, error)
 		ExecWithCtx(

sql/pgxpool/service.go

@@ -2,6 +2,7 @@ package pgxpool
 
 import (
 	"context"
+	"log/slog"
 	"time"
 
 	"github.com/jackc/pgx/v5"
@@ -14,47 +15,43 @@ import (
 type (
 	// DefaultService is the default service struct
 	DefaultService struct {
-		pool       *pgxpool.Pool
+		Handler
 		statTicker *time.Ticker
+		logger     *slog.Logger
 	}
 )
 
 // NewDefaultService creates a new default service
 //
 // Parameters:
 //
-//   - pool: the pgxpool.Pool instance
+//   - config *Config: configuration for the connection
+//   - logger *slog.Logger: the logger instance
 //
 // Returns:
 //
 //   - *DefaultService: the DefaultService instance
 //   - error: if any error occurs
-func NewDefaultService(pool *pgxpool.Pool) (
+func NewDefaultService(config *Config, logger *slog.Logger) (
 	instance *DefaultService,
 	err error,
 ) {
-	// Check if the pool is nil
-	if pool == nil {
-		return nil, godatabases.ErrNilPool
+	// Create the handler
+	handler, err := NewDefaultHandler(config)
+	if err != nil {
+		return nil, err
+	}
+
+	if logger != nil {
+		logger = logger.With(slog.String("database", "pgxpool"), slog.String("service", "DefaultService"))
 	}
 
 	return &DefaultService{
-		pool: pool,
+		Handler: handler,
+		logger:  logger,
 	}, nil
 }
 
-// Pool returns the pool
-//
-// Returns:
-//
-//   - *pgxpool.Pool: the pgxpool.Pool instance
-func (d *DefaultService) Pool() *pgxpool.Pool {
-	if d == nil {
-		return nil
-	}
-	return d.pool
-}
-
 // CreateTransaction creates a transaction for the database with a context
 //
 // Parameters:
@@ -72,7 +69,15 @@ func (d *DefaultService) CreateTransaction(
 	if d == nil {
 		return godatabases.ErrNilService
 	}
-	return CreateTransaction(ctx, d.pool, fn)
+
+	// Get the pool
+	pool, err := d.Pool()
+	if err != nil {
+		return err
+	}
+
+	// Create the transaction
+	return CreateTransaction(ctx, pool, fn)
 }
 
 // ExecWithCtx executes a query with parameters and returns the result with a context
@@ -104,8 +109,14 @@ func (d *DefaultService) ExecWithCtx(
 		return nil, godatabases.ErrNilQuery
 	}
 
+	// Get the pool
+	pool, err := d.Pool()
+	if err != nil {
+		return nil, err
+	}
+
 	// Run the exec
-	commandTag, err := d.pool.Exec(ctx, *query, params...)
+	commandTag, err := pool.Exec(ctx, *query, params...)
 	if err != nil {
 		return nil, err
 	}
@@ -158,8 +169,14 @@ func (d *DefaultService) QueryWithCtx(
 		return nil, godatabases.ErrNilQuery
 	}
 
+	// Get the pool
+	pool, err := d.Pool()
+	if err != nil {
+		return nil, err
+	}
+
 	// Run the query
-	return d.pool.Query(ctx, *query, params...)
+	return pool.Query(ctx, *query, params...)
 }
 
 // Query runs a query with parameters and returns the result
@@ -209,8 +226,14 @@ func (d *DefaultService) QueryRowWithCtx(
 		return nil, godatabases.ErrNilQuery
 	}
 
+	// Get the pool
+	pool, err := d.Pool()
+	if err != nil {
+		return nil, err
+	}
+
 	// Run the query row
-	return d.pool.QueryRow(ctx, *query, params...), nil
+	return pool.QueryRow(ctx, *query, params...), nil
 }
 
 // QueryRow runs a query row with parameters and returns the result row
@@ -289,7 +312,14 @@ func (d *DefaultService) SetStatTicker(
 			case <-ctx.Done():
 				return // Exit the goroutine when the context is done
 			case <-d.statTicker.C:
-				fn(d.pool.Stat())
+				// Get the pool
+				pool, err := d.Pool()
+				if err != nil {
+					d.logger.Error("Failed to get pool for stat ticker", slog.String("error", err.Error()))
+					return
+				}
+
+				fn(pool.Stat())
 			}
 		}
 	}()

sql/service.go

@@ -10,46 +10,35 @@ import (
 type (
 	// DefaultService is the default service struct
 	DefaultService struct {
-		db *sql.DB
+		Handler
 	}
 )
 
 // NewDefaultService creates a new default service
 //
 // Parameters:
 //
-// *db *sql.DB: the database connection
+//   - config: the configuration for the connection
 //
 // Returns:
 //
 // *DefaultService: the default service
 // error: if there was an error creating the service
-func NewDefaultService(db *sql.DB) (
+func NewDefaultService(config *Config) (
 	instance *DefaultService,
 	err error,
 ) {
-	// Check if the connection is nil
-	if db == nil {
-		return nil, godatabases.ErrNilConnection
+	// Create the handler
+	handler, err := NewDefaultHandler(config)
+	if err != nil {
+		return nil, err
 	}
 
 	return &DefaultService{
-		db,
+		Handler: handler,
 	}, nil
 }
 
-// DB returns the database
-//
-// Returns:
-//
-// *sql.DB: the database
-func (d *DefaultService) DB() *sql.DB {
-	if d == nil {
-		return nil
-	}
-	return d.db
-}
-
 // CreateTransaction creates a transaction for the database
 //
 // Parameters:
@@ -69,7 +58,15 @@ func (d *DefaultService) CreateTransaction(
 	if d == nil {
 		return godatabases.ErrNilService
 	}
-	return CreateTransaction(ctx, d.db, fn, opts)
+
+	// Get the database connection
+	db, err := d.DB()
+	if err != nil {
+		return err
+	}
+
+	// Create the transaction
+	return CreateTransaction(ctx, db, fn, opts)
 }
 
 // Exec executes a query with parameters and returns the result
@@ -122,8 +119,14 @@ func (d *DefaultService) ExecWithCtx(
 		return nil, godatabases.ErrNilQuery
 	}
 
+	// Get the database connection
+	db, err := d.DB()
+	if err != nil {
+		return nil, err
+	}
+
 	// Run the exec
-	return d.db.ExecContext(ctx, *query, params...)
+	return db.ExecContext(ctx, *query, params...)
 }
 
 // QueryRow runs a query row with parameters and returns the result row
@@ -136,12 +139,13 @@ func (d *DefaultService) ExecWithCtx(
 // Returns:
 //
 // - *sql.Row: the result row
+// - error: if any error occurs
 func (d *DefaultService) QueryRow(
 	query *string,
 	params ...any,
-) *sql.Row {
+) (*sql.Row, error) {
 	if d == nil {
-		return nil
+		return nil, godatabases.ErrNilService
 	}
 	return d.QueryRowWithCtx(context.Background(), query, params...)
 }
@@ -157,22 +161,29 @@ func (d *DefaultService) QueryRow(
 // Returns:
 //
 // - *sql.Row: the result row
+// - error: if any error occurs
 func (d *DefaultService) QueryRowWithCtx(
 	ctx context.Context,
 	query *string,
 	params ...any,
-) *sql.Row {
+) (*sql.Row, error) {
 	if d == nil {
-		return nil
+		return nil, godatabases.ErrNilService
 	}
 
 	// Check if the query is nil
 	if query == nil {
-		return nil
+		return nil, godatabases.ErrNilQuery
+	}
+
+	// Get the database connection
+	db, err := d.DB()
+	if err != nil {
+		return nil, err
 	}
 
 	// Run the query row
-	return d.db.QueryRowContext(ctx, *query, params...)
+	return db.QueryRowContext(ctx, *query, params...), nil
 }
 
 // ScanRow scans a row