feat(dbmanager): ✨ add support for existing SQL connections

* Introduced NewConnectionFromDB function to create connections from existing *sql.DB instances.
* Added ExistingDBProvider to wrap existing database connections for dbmanager features.
* Implemented tests for NewConnectionFromDB and ExistingDBProvider functionalities.

pkg/dbmanager/factory.go

@@ -1,6 +1,7 @@
 package dbmanager
 
 import (
+	"database/sql"
 	"fmt"
 
 	"github.com/bitechdev/ResolveSpec/pkg/dbmanager/providers"
@@ -49,3 +50,18 @@ func createProvider(dbType DatabaseType) (Provider, error) {
 // Provider is an alias to the providers.Provider interface
 // This allows dbmanager package consumers to use Provider without importing providers
 type Provider = providers.Provider
+
+// NewConnectionFromDB creates a new Connection from an existing *sql.DB
+// This allows you to use dbmanager features (ORM wrappers, health checks, etc.)
+// with a database connection that was opened outside of dbmanager
+//
+// Parameters:
+//   - name: A unique name for this connection
+//   - dbType: The database type (DatabaseTypePostgreSQL, DatabaseTypeSQLite, or DatabaseTypeMSSQL)
+//   - db: An existing *sql.DB connection
+//
+// Returns a Connection that wraps the existing *sql.DB
+func NewConnectionFromDB(name string, dbType DatabaseType, db *sql.DB) Connection {
+	provider := providers.NewExistingDBProvider(db, name)
+	return newSQLConnection(name, dbType, ConnectionConfig{Name: name, Type: dbType}, provider)
+}

pkg/dbmanager/factory_test.go

@@ -0,0 +1,210 @@
+package dbmanager
+
+import (
+	"context"
+	"database/sql"
+	"testing"
+
+	_ "github.com/mattn/go-sqlite3"
+)
+
+func TestNewConnectionFromDB(t *testing.T) {
+	// Open a SQLite in-memory database
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to open database: %v", err)
+	}
+	defer db.Close()
+
+	// Create a connection from the existing database
+	conn := NewConnectionFromDB("test-connection", DatabaseTypeSQLite, db)
+	if conn == nil {
+		t.Fatal("Expected connection to be created")
+	}
+
+	// Verify connection properties
+	if conn.Name() != "test-connection" {
+		t.Errorf("Expected name 'test-connection', got '%s'", conn.Name())
+	}
+
+	if conn.Type() != DatabaseTypeSQLite {
+		t.Errorf("Expected type DatabaseTypeSQLite, got '%s'", conn.Type())
+	}
+}
+
+func TestNewConnectionFromDB_Connect(t *testing.T) {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to open database: %v", err)
+	}
+	defer db.Close()
+
+	conn := NewConnectionFromDB("test-connection", DatabaseTypeSQLite, db)
+	ctx := context.Background()
+
+	// Connect should verify the existing connection works
+	err = conn.Connect(ctx)
+	if err != nil {
+		t.Errorf("Expected Connect to succeed, got error: %v", err)
+	}
+
+	// Cleanup
+	conn.Close()
+}
+
+func TestNewConnectionFromDB_Native(t *testing.T) {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to open database: %v", err)
+	}
+	defer db.Close()
+
+	conn := NewConnectionFromDB("test-connection", DatabaseTypeSQLite, db)
+	ctx := context.Background()
+
+	err = conn.Connect(ctx)
+	if err != nil {
+		t.Fatalf("Failed to connect: %v", err)
+	}
+	defer conn.Close()
+
+	// Get native DB
+	nativeDB, err := conn.Native()
+	if err != nil {
+		t.Errorf("Expected Native to succeed, got error: %v", err)
+	}
+
+	if nativeDB != db {
+		t.Error("Expected Native to return the same database instance")
+	}
+}
+
+func TestNewConnectionFromDB_Bun(t *testing.T) {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to open database: %v", err)
+	}
+	defer db.Close()
+
+	conn := NewConnectionFromDB("test-connection", DatabaseTypeSQLite, db)
+	ctx := context.Background()
+
+	err = conn.Connect(ctx)
+	if err != nil {
+		t.Fatalf("Failed to connect: %v", err)
+	}
+	defer conn.Close()
+
+	// Get Bun ORM
+	bunDB, err := conn.Bun()
+	if err != nil {
+		t.Errorf("Expected Bun to succeed, got error: %v", err)
+	}
+
+	if bunDB == nil {
+		t.Error("Expected Bun to return a non-nil instance")
+	}
+}
+
+func TestNewConnectionFromDB_GORM(t *testing.T) {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to open database: %v", err)
+	}
+	defer db.Close()
+
+	conn := NewConnectionFromDB("test-connection", DatabaseTypeSQLite, db)
+	ctx := context.Background()
+
+	err = conn.Connect(ctx)
+	if err != nil {
+		t.Fatalf("Failed to connect: %v", err)
+	}
+	defer conn.Close()
+
+	// Get GORM
+	gormDB, err := conn.GORM()
+	if err != nil {
+		t.Errorf("Expected GORM to succeed, got error: %v", err)
+	}
+
+	if gormDB == nil {
+		t.Error("Expected GORM to return a non-nil instance")
+	}
+}
+
+func TestNewConnectionFromDB_HealthCheck(t *testing.T) {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to open database: %v", err)
+	}
+	defer db.Close()
+
+	conn := NewConnectionFromDB("test-connection", DatabaseTypeSQLite, db)
+	ctx := context.Background()
+
+	err = conn.Connect(ctx)
+	if err != nil {
+		t.Fatalf("Failed to connect: %v", err)
+	}
+	defer conn.Close()
+
+	// Health check should succeed
+	err = conn.HealthCheck(ctx)
+	if err != nil {
+		t.Errorf("Expected HealthCheck to succeed, got error: %v", err)
+	}
+}
+
+func TestNewConnectionFromDB_Stats(t *testing.T) {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to open database: %v", err)
+	}
+	defer db.Close()
+
+	conn := NewConnectionFromDB("test-connection", DatabaseTypeSQLite, db)
+	ctx := context.Background()
+
+	err = conn.Connect(ctx)
+	if err != nil {
+		t.Fatalf("Failed to connect: %v", err)
+	}
+	defer conn.Close()
+
+	stats := conn.Stats()
+	if stats == nil {
+		t.Fatal("Expected stats to be returned")
+	}
+
+	if stats.Name != "test-connection" {
+		t.Errorf("Expected stats.Name to be 'test-connection', got '%s'", stats.Name)
+	}
+
+	if stats.Type != DatabaseTypeSQLite {
+		t.Errorf("Expected stats.Type to be DatabaseTypeSQLite, got '%s'", stats.Type)
+	}
+
+	if !stats.Connected {
+		t.Error("Expected stats.Connected to be true")
+	}
+}
+
+func TestNewConnectionFromDB_PostgreSQL(t *testing.T) {
+	// This test just verifies the factory works with PostgreSQL type
+	// It won't actually connect since we're using SQLite
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to open database: %v", err)
+	}
+	defer db.Close()
+
+	conn := NewConnectionFromDB("test-pg", DatabaseTypePostgreSQL, db)
+	if conn == nil {
+		t.Fatal("Expected connection to be created")
+	}
+
+	if conn.Type() != DatabaseTypePostgreSQL {
+		t.Errorf("Expected type DatabaseTypePostgreSQL, got '%s'", conn.Type())
+	}
+}

pkg/dbmanager/providers/existing_db.go

@@ -0,0 +1,111 @@
+package providers
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"sync"
+
+	"go.mongodb.org/mongo-driver/mongo"
+)
+
+// ExistingDBProvider wraps an existing *sql.DB connection
+// This allows using dbmanager features with a database connection
+// that was opened outside of the dbmanager package
+type ExistingDBProvider struct {
+	db   *sql.DB
+	name string
+	mu   sync.RWMutex
+}
+
+// NewExistingDBProvider creates a new provider wrapping an existing *sql.DB
+func NewExistingDBProvider(db *sql.DB, name string) *ExistingDBProvider {
+	return &ExistingDBProvider{
+		db:   db,
+		name: name,
+	}
+}
+
+// Connect verifies the existing database connection is valid
+// It does NOT create a new connection, but ensures the existing one works
+func (p *ExistingDBProvider) Connect(ctx context.Context, cfg ConnectionConfig) error {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if p.db == nil {
+		return fmt.Errorf("database connection is nil")
+	}
+
+	// Verify the connection works
+	if err := p.db.PingContext(ctx); err != nil {
+		return fmt.Errorf("failed to ping existing database: %w", err)
+	}
+
+	return nil
+}
+
+// Close closes the underlying database connection
+func (p *ExistingDBProvider) Close() error {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if p.db == nil {
+		return nil
+	}
+
+	return p.db.Close()
+}
+
+// HealthCheck verifies the connection is alive
+func (p *ExistingDBProvider) HealthCheck(ctx context.Context) error {
+	p.mu.RLock()
+	defer p.mu.RUnlock()
+
+	if p.db == nil {
+		return fmt.Errorf("database connection is nil")
+	}
+
+	return p.db.PingContext(ctx)
+}
+
+// GetNative returns the wrapped *sql.DB
+func (p *ExistingDBProvider) GetNative() (*sql.DB, error) {
+	p.mu.RLock()
+	defer p.mu.RUnlock()
+
+	if p.db == nil {
+		return nil, fmt.Errorf("database connection is nil")
+	}
+
+	return p.db, nil
+}
+
+// GetMongo returns an error since this is a SQL database
+func (p *ExistingDBProvider) GetMongo() (*mongo.Client, error) {
+	return nil, ErrNotMongoDB
+}
+
+// Stats returns connection statistics
+func (p *ExistingDBProvider) Stats() *ConnectionStats {
+	p.mu.RLock()
+	defer p.mu.RUnlock()
+
+	stats := &ConnectionStats{
+		Name:      p.name,
+		Type:      "sql", // Generic since we don't know the specific type
+		Connected: p.db != nil,
+	}
+
+	if p.db != nil {
+		dbStats := p.db.Stats()
+		stats.OpenConnections = dbStats.OpenConnections
+		stats.InUse = dbStats.InUse
+		stats.Idle = dbStats.Idle
+		stats.WaitCount = dbStats.WaitCount
+		stats.WaitDuration = dbStats.WaitDuration
+		stats.MaxIdleClosed = dbStats.MaxIdleClosed
+		stats.MaxLifetimeClosed = dbStats.MaxLifetimeClosed
+	}
+
+	return stats
+}

pkg/dbmanager/providers/existing_db_test.go

@@ -0,0 +1,194 @@
+package providers
+
+import (
+	"context"
+	"database/sql"
+	"testing"
+	"time"
+
+	_ "github.com/mattn/go-sqlite3"
+)
+
+func TestNewExistingDBProvider(t *testing.T) {
+	// Open a SQLite in-memory database
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to open database: %v", err)
+	}
+	defer db.Close()
+
+	// Create provider
+	provider := NewExistingDBProvider(db, "test-db")
+	if provider == nil {
+		t.Fatal("Expected provider to be created")
+	}
+
+	if provider.name != "test-db" {
+		t.Errorf("Expected name 'test-db', got '%s'", provider.name)
+	}
+}
+
+func TestExistingDBProvider_Connect(t *testing.T) {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to open database: %v", err)
+	}
+	defer db.Close()
+
+	provider := NewExistingDBProvider(db, "test-db")
+	ctx := context.Background()
+
+	// Connect should verify the connection works
+	err = provider.Connect(ctx, nil)
+	if err != nil {
+		t.Errorf("Expected Connect to succeed, got error: %v", err)
+	}
+}
+
+func TestExistingDBProvider_Connect_NilDB(t *testing.T) {
+	provider := NewExistingDBProvider(nil, "test-db")
+	ctx := context.Background()
+
+	err := provider.Connect(ctx, nil)
+	if err == nil {
+		t.Error("Expected Connect to fail with nil database")
+	}
+}
+
+func TestExistingDBProvider_GetNative(t *testing.T) {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to open database: %v", err)
+	}
+	defer db.Close()
+
+	provider := NewExistingDBProvider(db, "test-db")
+
+	nativeDB, err := provider.GetNative()
+	if err != nil {
+		t.Errorf("Expected GetNative to succeed, got error: %v", err)
+	}
+
+	if nativeDB != db {
+		t.Error("Expected GetNative to return the same database instance")
+	}
+}
+
+func TestExistingDBProvider_GetNative_NilDB(t *testing.T) {
+	provider := NewExistingDBProvider(nil, "test-db")
+
+	_, err := provider.GetNative()
+	if err == nil {
+		t.Error("Expected GetNative to fail with nil database")
+	}
+}
+
+func TestExistingDBProvider_HealthCheck(t *testing.T) {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to open database: %v", err)
+	}
+	defer db.Close()
+
+	provider := NewExistingDBProvider(db, "test-db")
+	ctx := context.Background()
+
+	err = provider.HealthCheck(ctx)
+	if err != nil {
+		t.Errorf("Expected HealthCheck to succeed, got error: %v", err)
+	}
+}
+
+func TestExistingDBProvider_HealthCheck_ClosedDB(t *testing.T) {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to open database: %v", err)
+	}
+
+	provider := NewExistingDBProvider(db, "test-db")
+
+	// Close the database
+	db.Close()
+
+	ctx := context.Background()
+	err = provider.HealthCheck(ctx)
+	if err == nil {
+		t.Error("Expected HealthCheck to fail with closed database")
+	}
+}
+
+func TestExistingDBProvider_GetMongo(t *testing.T) {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to open database: %v", err)
+	}
+	defer db.Close()
+
+	provider := NewExistingDBProvider(db, "test-db")
+
+	_, err = provider.GetMongo()
+	if err != ErrNotMongoDB {
+		t.Errorf("Expected ErrNotMongoDB, got: %v", err)
+	}
+}
+
+func TestExistingDBProvider_Stats(t *testing.T) {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to open database: %v", err)
+	}
+	defer db.Close()
+
+	// Set some connection pool settings to test stats
+	db.SetMaxOpenConns(10)
+	db.SetMaxIdleConns(5)
+	db.SetConnMaxLifetime(time.Hour)
+
+	provider := NewExistingDBProvider(db, "test-db")
+
+	stats := provider.Stats()
+	if stats == nil {
+		t.Fatal("Expected stats to be returned")
+	}
+
+	if stats.Name != "test-db" {
+		t.Errorf("Expected stats.Name to be 'test-db', got '%s'", stats.Name)
+	}
+
+	if stats.Type != "sql" {
+		t.Errorf("Expected stats.Type to be 'sql', got '%s'", stats.Type)
+	}
+
+	if !stats.Connected {
+		t.Error("Expected stats.Connected to be true")
+	}
+}
+
+func TestExistingDBProvider_Close(t *testing.T) {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("Failed to open database: %v", err)
+	}
+
+	provider := NewExistingDBProvider(db, "test-db")
+
+	err = provider.Close()
+	if err != nil {
+		t.Errorf("Expected Close to succeed, got error: %v", err)
+	}
+
+	// Verify the database is closed
+	err = db.Ping()
+	if err == nil {
+		t.Error("Expected database to be closed")
+	}
+}
+
+func TestExistingDBProvider_Close_NilDB(t *testing.T) {
+	provider := NewExistingDBProvider(nil, "test-db")
+
+	err := provider.Close()
+	if err != nil {
+		t.Errorf("Expected Close to succeed with nil database, got error: %v", err)
+	}
+}

pkg/reflection/model_utils.go

@@ -948,29 +948,35 @@ func MapToStruct(dataMap map[string]interface{}, target interface{}) error {
 		// Build list of possible column names for this field
 		var columnNames []string
 
-		// 1. Bun tag
-		if bunTag := field.Tag.Get("bun"); bunTag != "" && bunTag != "-" {
-			if colName := ExtractColumnFromBunTag(bunTag); colName != "" {
-				columnNames = append(columnNames, colName)
-			}
-		}
-
-		// 2. Gorm tag
-		if gormTag := field.Tag.Get("gorm"); gormTag != "" && gormTag != "-" {
-			if colName := ExtractColumnFromGormTag(gormTag); colName != "" {
-				columnNames = append(columnNames, colName)
-			}
-		}
-
-		// 3. JSON tag
+		// 1. JSON tag (primary - most common)
+		jsonFound := false
 		if jsonTag := field.Tag.Get("json"); jsonTag != "" && jsonTag != "-" {
 			parts := strings.Split(jsonTag, ",")
 			if len(parts) > 0 && parts[0] != "" {
 				columnNames = append(columnNames, parts[0])
+				jsonFound = true
 			}
 		}
 
-		// 4. Field name variations
+		// 2. Bun tag (fallback if no JSON tag)
+		if !jsonFound {
+			if bunTag := field.Tag.Get("bun"); bunTag != "" && bunTag != "-" {
+				if colName := ExtractColumnFromBunTag(bunTag); colName != "" {
+					columnNames = append(columnNames, colName)
+				}
+			}
+		}
+
+		// 3. Gorm tag (fallback if no JSON tag)
+		if !jsonFound {
+			if gormTag := field.Tag.Get("gorm"); gormTag != "" && gormTag != "-" {
+				if colName := ExtractColumnFromGormTag(gormTag); colName != "" {
+					columnNames = append(columnNames, colName)
+				}
+			}
+		}
+
+		// 4. Field name variations (last resort)
 		columnNames = append(columnNames, field.Name)
 		columnNames = append(columnNames, strings.ToLower(field.Name))
 		// columnNames = append(columnNames, ToSnakeCase(field.Name))
@@ -1096,6 +1102,12 @@ func setFieldValue(field reflect.Value, value interface{}) error {
 		}
 	}
 
+	// If we can convert the type, do it
+	if valueReflect.Type().ConvertibleTo(field.Type()) {
+		field.Set(valueReflect.Convert(field.Type()))
+		return nil
+	}
+
 	// Handle struct types (like SqlTimeStamp, SqlDate, SqlTime which wrap SqlNull[time.Time])
 	if field.Kind() == reflect.Struct {
 
@@ -1107,9 +1119,9 @@ func setFieldValue(field reflect.Value, value interface{}) error {
 				// Call the Scan method with the value
 				results := scanMethod.Call([]reflect.Value{reflect.ValueOf(value)})
 				if len(results) > 0 {
-					// Check if there was an error
-					if err, ok := results[0].Interface().(error); ok && err != nil {
-						return err
+					// The Scan method returns error - check if it's nil
+					if !results[0].IsNil() {
+						return results[0].Interface().(error)
 					}
 					return nil
 				}
@@ -1164,12 +1176,6 @@ func setFieldValue(field reflect.Value, value interface{}) error {
 
 	}
 
-	// If we can convert the type, do it
-	if valueReflect.Type().ConvertibleTo(field.Type()) {
-		field.Set(valueReflect.Convert(field.Type()))
-		return nil
-	}
-
 	return fmt.Errorf("cannot convert %v to %v", valueReflect.Type(), field.Type())
 }
 

pkg/reflection/model_utils_stdlib_sqltypes_test.go

@@ -0,0 +1,120 @@
+package reflection_test
+
+import (
+	"database/sql"
+	"testing"
+	"time"
+
+	"github.com/bitechdev/ResolveSpec/pkg/reflection"
+)
+
+func TestMapToStruct_StandardSqlNullTypes(t *testing.T) {
+	// Test model with standard library sql.Null* types
+	type TestModel struct {
+		ID        int64           `bun:"id,pk" json:"id"`
+		Age       sql.NullInt64   `bun:"age" json:"age"`
+		Name      sql.NullString  `bun:"name" json:"name"`
+		Score     sql.NullFloat64 `bun:"score" json:"score"`
+		Active    sql.NullBool    `bun:"active" json:"active"`
+		UpdatedAt sql.NullTime    `bun:"updated_at" json:"updated_at"`
+	}
+
+	now := time.Now()
+	dataMap := map[string]any{
+		"id":         int64(100),
+		"age":        int64(25),
+		"name":       "John Doe",
+		"score":      95.5,
+		"active":     true,
+		"updated_at": now,
+	}
+
+	var result TestModel
+	err := reflection.MapToStruct(dataMap, &result)
+	if err != nil {
+		t.Fatalf("MapToStruct() error = %v", err)
+	}
+
+	// Verify ID
+	if result.ID != 100 {
+		t.Errorf("ID = %v, want 100", result.ID)
+	}
+
+	// Verify Age (sql.NullInt64)
+	if !result.Age.Valid {
+		t.Error("Age.Valid = false, want true")
+	}
+	if result.Age.Int64 != 25 {
+		t.Errorf("Age.Int64 = %v, want 25", result.Age.Int64)
+	}
+
+	// Verify Name (sql.NullString)
+	if !result.Name.Valid {
+		t.Error("Name.Valid = false, want true")
+	}
+	if result.Name.String != "John Doe" {
+		t.Errorf("Name.String = %v, want 'John Doe'", result.Name.String)
+	}
+
+	// Verify Score (sql.NullFloat64)
+	if !result.Score.Valid {
+		t.Error("Score.Valid = false, want true")
+	}
+	if result.Score.Float64 != 95.5 {
+		t.Errorf("Score.Float64 = %v, want 95.5", result.Score.Float64)
+	}
+
+	// Verify Active (sql.NullBool)
+	if !result.Active.Valid {
+		t.Error("Active.Valid = false, want true")
+	}
+	if !result.Active.Bool {
+		t.Error("Active.Bool = false, want true")
+	}
+
+	// Verify UpdatedAt (sql.NullTime)
+	if !result.UpdatedAt.Valid {
+		t.Error("UpdatedAt.Valid = false, want true")
+	}
+	if !result.UpdatedAt.Time.Equal(now) {
+		t.Errorf("UpdatedAt.Time = %v, want %v", result.UpdatedAt.Time, now)
+	}
+
+	t.Log("All standard library sql.Null* types handled correctly!")
+}
+
+func TestMapToStruct_StandardSqlNullTypes_WithNil(t *testing.T) {
+	// Test nil handling for standard library sql.Null* types
+	type TestModel struct {
+		ID   int64          `bun:"id,pk" json:"id"`
+		Age  sql.NullInt64  `bun:"age" json:"age"`
+		Name sql.NullString `bun:"name" json:"name"`
+	}
+
+	dataMap := map[string]any{
+		"id":   int64(200),
+		"age":  int64(30),
+		"name": nil, // Explicitly nil
+	}
+
+	var result TestModel
+	err := reflection.MapToStruct(dataMap, &result)
+	if err != nil {
+		t.Fatalf("MapToStruct() error = %v", err)
+	}
+
+	// Age should be valid
+	if !result.Age.Valid {
+		t.Error("Age.Valid = false, want true")
+	}
+	if result.Age.Int64 != 30 {
+		t.Errorf("Age.Int64 = %v, want 30", result.Age.Int64)
+	}
+
+	// Name should be invalid (null)
+	if result.Name.Valid {
+		t.Error("Name.Valid = true, want false (null)")
+	}
+
+	t.Log("Nil handling for sql.Null* types works correctly!")
+}

pkg/reflection/spectypes_integration_test.go

@@ -0,0 +1,364 @@
+package reflection
+
+import (
+	"testing"
+	"time"
+
+	"github.com/bitechdev/ResolveSpec/pkg/spectypes"
+	"github.com/google/uuid"
+)
+
+// TestModel contains all spectypes custom types
+type TestModel struct {
+	ID        int64                    `bun:"id,pk" json:"id"`
+	Name      spectypes.SqlString      `bun:"name" json:"name"`
+	Age       spectypes.SqlInt64       `bun:"age" json:"age"`
+	Score     spectypes.SqlFloat64     `bun:"score" json:"score"`
+	Active    spectypes.SqlBool        `bun:"active" json:"active"`
+	UUID      spectypes.SqlUUID        `bun:"uuid" json:"uuid"`
+	CreatedAt spectypes.SqlTimeStamp   `bun:"created_at" json:"created_at"`
+	BirthDate spectypes.SqlDate        `bun:"birth_date" json:"birth_date"`
+	StartTime spectypes.SqlTime        `bun:"start_time" json:"start_time"`
+	Metadata  spectypes.SqlJSONB       `bun:"metadata" json:"metadata"`
+	Count16   spectypes.SqlInt16       `bun:"count16" json:"count16"`
+	Count32   spectypes.SqlInt32       `bun:"count32" json:"count32"`
+}
+
+// TestMapToStruct_AllSpectypes verifies that MapToStruct can convert all spectypes correctly
+func TestMapToStruct_AllSpectypes(t *testing.T) {
+	testUUID := uuid.New()
+	testTime := time.Now()
+
+	tests := []struct {
+		name      string
+		dataMap   map[string]interface{}
+		validator func(*testing.T, *TestModel)
+	}{
+		{
+			name: "SqlString from string",
+			dataMap: map[string]interface{}{
+				"name": "John Doe",
+			},
+			validator: func(t *testing.T, m *TestModel) {
+				if !m.Name.Valid || m.Name.String() != "John Doe" {
+					t.Errorf("expected name='John Doe', got valid=%v, value=%s", m.Name.Valid, m.Name.String())
+				}
+			},
+		},
+		{
+			name: "SqlInt64 from int64",
+			dataMap: map[string]interface{}{
+				"age": int64(42),
+			},
+			validator: func(t *testing.T, m *TestModel) {
+				if !m.Age.Valid || m.Age.Int64() != 42 {
+					t.Errorf("expected age=42, got valid=%v, value=%d", m.Age.Valid, m.Age.Int64())
+				}
+			},
+		},
+		{
+			name: "SqlInt64 from string",
+			dataMap: map[string]interface{}{
+				"age": "99",
+			},
+			validator: func(t *testing.T, m *TestModel) {
+				if !m.Age.Valid || m.Age.Int64() != 99 {
+					t.Errorf("expected age=99, got valid=%v, value=%d", m.Age.Valid, m.Age.Int64())
+				}
+			},
+		},
+		{
+			name: "SqlFloat64 from float64",
+			dataMap: map[string]interface{}{
+				"score": float64(98.5),
+			},
+			validator: func(t *testing.T, m *TestModel) {
+				if !m.Score.Valid || m.Score.Float64() != 98.5 {
+					t.Errorf("expected score=98.5, got valid=%v, value=%f", m.Score.Valid, m.Score.Float64())
+				}
+			},
+		},
+		{
+			name: "SqlBool from bool",
+			dataMap: map[string]interface{}{
+				"active": true,
+			},
+			validator: func(t *testing.T, m *TestModel) {
+				if !m.Active.Valid || !m.Active.Bool() {
+					t.Errorf("expected active=true, got valid=%v, value=%v", m.Active.Valid, m.Active.Bool())
+				}
+			},
+		},
+		{
+			name: "SqlUUID from string",
+			dataMap: map[string]interface{}{
+				"uuid": testUUID.String(),
+			},
+			validator: func(t *testing.T, m *TestModel) {
+				if !m.UUID.Valid || m.UUID.UUID() != testUUID {
+					t.Errorf("expected uuid=%s, got valid=%v, value=%s", testUUID.String(), m.UUID.Valid, m.UUID.UUID().String())
+				}
+			},
+		},
+		{
+			name: "SqlTimeStamp from time.Time",
+			dataMap: map[string]interface{}{
+				"created_at": testTime,
+			},
+			validator: func(t *testing.T, m *TestModel) {
+				if !m.CreatedAt.Valid {
+					t.Errorf("expected created_at to be valid")
+				}
+				// Check if times are close enough (within a second)
+				diff := m.CreatedAt.Time().Sub(testTime)
+				if diff < -time.Second || diff > time.Second {
+					t.Errorf("time difference too large: %v", diff)
+				}
+			},
+		},
+		{
+			name: "SqlTimeStamp from string",
+			dataMap: map[string]interface{}{
+				"created_at": "2024-01-15T10:30:00",
+			},
+			validator: func(t *testing.T, m *TestModel) {
+				if !m.CreatedAt.Valid {
+					t.Errorf("expected created_at to be valid")
+				}
+				expected := time.Date(2024, 1, 15, 10, 30, 0, 0, time.UTC)
+				if m.CreatedAt.Time().Year() != expected.Year() ||
+					m.CreatedAt.Time().Month() != expected.Month() ||
+					m.CreatedAt.Time().Day() != expected.Day() {
+					t.Errorf("expected date 2024-01-15, got %v", m.CreatedAt.Time())
+				}
+			},
+		},
+		{
+			name: "SqlDate from string",
+			dataMap: map[string]interface{}{
+				"birth_date": "2000-05-20",
+			},
+			validator: func(t *testing.T, m *TestModel) {
+				if !m.BirthDate.Valid {
+					t.Errorf("expected birth_date to be valid")
+				}
+				expected := "2000-05-20"
+				if m.BirthDate.String() != expected {
+					t.Errorf("expected date=%s, got %s", expected, m.BirthDate.String())
+				}
+			},
+		},
+		{
+			name: "SqlTime from string",
+			dataMap: map[string]interface{}{
+				"start_time": "14:30:00",
+			},
+			validator: func(t *testing.T, m *TestModel) {
+				if !m.StartTime.Valid {
+					t.Errorf("expected start_time to be valid")
+				}
+				if m.StartTime.String() != "14:30:00" {
+					t.Errorf("expected time=14:30:00, got %s", m.StartTime.String())
+				}
+			},
+		},
+		{
+			name: "SqlJSONB from map",
+			dataMap: map[string]interface{}{
+				"metadata": map[string]interface{}{
+					"key1": "value1",
+					"key2": 123,
+				},
+			},
+			validator: func(t *testing.T, m *TestModel) {
+				if len(m.Metadata) == 0 {
+					t.Errorf("expected metadata to have data")
+				}
+				asMap, err := m.Metadata.AsMap()
+				if err != nil {
+					t.Fatalf("failed to convert metadata to map: %v", err)
+				}
+				if asMap["key1"] != "value1" {
+					t.Errorf("expected key1=value1, got %v", asMap["key1"])
+				}
+			},
+		},
+		{
+			name: "SqlJSONB from string",
+			dataMap: map[string]interface{}{
+				"metadata": `{"test":"data"}`,
+			},
+			validator: func(t *testing.T, m *TestModel) {
+				if len(m.Metadata) == 0 {
+					t.Errorf("expected metadata to have data")
+				}
+				asMap, err := m.Metadata.AsMap()
+				if err != nil {
+					t.Fatalf("failed to convert metadata to map: %v", err)
+				}
+				if asMap["test"] != "data" {
+					t.Errorf("expected test=data, got %v", asMap["test"])
+				}
+			},
+		},
+		{
+			name: "SqlJSONB from []byte",
+			dataMap: map[string]interface{}{
+				"metadata": []byte(`{"byte":"array"}`),
+			},
+			validator: func(t *testing.T, m *TestModel) {
+				if len(m.Metadata) == 0 {
+					t.Errorf("expected metadata to have data")
+				}
+				if string(m.Metadata) != `{"byte":"array"}` {
+					t.Errorf("expected {\"byte\":\"array\"}, got %s", string(m.Metadata))
+				}
+			},
+		},
+		{
+			name: "SqlInt16 from int16",
+			dataMap: map[string]interface{}{
+				"count16": int16(100),
+			},
+			validator: func(t *testing.T, m *TestModel) {
+				if !m.Count16.Valid || m.Count16.Int64() != 100 {
+					t.Errorf("expected count16=100, got valid=%v, value=%d", m.Count16.Valid, m.Count16.Int64())
+				}
+			},
+		},
+		{
+			name: "SqlInt32 from int32",
+			dataMap: map[string]interface{}{
+				"count32": int32(5000),
+			},
+			validator: func(t *testing.T, m *TestModel) {
+				if !m.Count32.Valid || m.Count32.Int64() != 5000 {
+					t.Errorf("expected count32=5000, got valid=%v, value=%d", m.Count32.Valid, m.Count32.Int64())
+				}
+			},
+		},
+		{
+			name: "nil values create invalid nulls",
+			dataMap: map[string]interface{}{
+				"name":       nil,
+				"age":        nil,
+				"active":     nil,
+				"created_at": nil,
+			},
+			validator: func(t *testing.T, m *TestModel) {
+				if m.Name.Valid {
+					t.Error("expected name to be invalid for nil value")
+				}
+				if m.Age.Valid {
+					t.Error("expected age to be invalid for nil value")
+				}
+				if m.Active.Valid {
+					t.Error("expected active to be invalid for nil value")
+				}
+				if m.CreatedAt.Valid {
+					t.Error("expected created_at to be invalid for nil value")
+				}
+			},
+		},
+		{
+			name: "all types together",
+			dataMap: map[string]interface{}{
+				"id":         int64(1),
+				"name":       "Test User",
+				"age":        int64(30),
+				"score":      float64(95.7),
+				"active":     true,
+				"uuid":       testUUID.String(),
+				"created_at": "2024-01-15T10:30:00",
+				"birth_date": "1994-06-15",
+				"start_time": "09:00:00",
+				"metadata":   map[string]interface{}{"role": "admin"},
+				"count16":    int16(50),
+				"count32":    int32(1000),
+			},
+			validator: func(t *testing.T, m *TestModel) {
+				if m.ID != 1 {
+					t.Errorf("expected id=1, got %d", m.ID)
+				}
+				if !m.Name.Valid || m.Name.String() != "Test User" {
+					t.Errorf("expected name='Test User', got valid=%v, value=%s", m.Name.Valid, m.Name.String())
+				}
+				if !m.Age.Valid || m.Age.Int64() != 30 {
+					t.Errorf("expected age=30, got valid=%v, value=%d", m.Age.Valid, m.Age.Int64())
+				}
+				if !m.Score.Valid || m.Score.Float64() != 95.7 {
+					t.Errorf("expected score=95.7, got valid=%v, value=%f", m.Score.Valid, m.Score.Float64())
+				}
+				if !m.Active.Valid || !m.Active.Bool() {
+					t.Errorf("expected active=true, got valid=%v, value=%v", m.Active.Valid, m.Active.Bool())
+				}
+				if !m.UUID.Valid {
+					t.Error("expected uuid to be valid")
+				}
+				if !m.CreatedAt.Valid {
+					t.Error("expected created_at to be valid")
+				}
+				if !m.BirthDate.Valid || m.BirthDate.String() != "1994-06-15" {
+					t.Errorf("expected birth_date=1994-06-15, got valid=%v, value=%s", m.BirthDate.Valid, m.BirthDate.String())
+				}
+				if !m.StartTime.Valid || m.StartTime.String() != "09:00:00" {
+					t.Errorf("expected start_time=09:00:00, got valid=%v, value=%s", m.StartTime.Valid, m.StartTime.String())
+				}
+				if len(m.Metadata) == 0 {
+					t.Error("expected metadata to have data")
+				}
+				if !m.Count16.Valid || m.Count16.Int64() != 50 {
+					t.Errorf("expected count16=50, got valid=%v, value=%d", m.Count16.Valid, m.Count16.Int64())
+				}
+				if !m.Count32.Valid || m.Count32.Int64() != 1000 {
+					t.Errorf("expected count32=1000, got valid=%v, value=%d", m.Count32.Valid, m.Count32.Int64())
+				}
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			model := &TestModel{}
+			if err := MapToStruct(tt.dataMap, model); err != nil {
+				t.Fatalf("MapToStruct failed: %v", err)
+			}
+			tt.validator(t, model)
+		})
+	}
+}
+
+// TestMapToStruct_PartialUpdate tests that partial updates preserve unset fields
+func TestMapToStruct_PartialUpdate(t *testing.T) {
+	// Create initial model with some values
+	initial := &TestModel{
+		ID:   1,
+		Name: spectypes.NewSqlString("Original Name"),
+		Age:  spectypes.NewSqlInt64(25),
+	}
+
+	// Update only the age field
+	partialUpdate := map[string]interface{}{
+		"age": int64(30),
+	}
+
+	// Apply partial update
+	if err := MapToStruct(partialUpdate, initial); err != nil {
+		t.Fatalf("MapToStruct failed: %v", err)
+	}
+
+	// Verify age was updated
+	if !initial.Age.Valid || initial.Age.Int64() != 30 {
+		t.Errorf("expected age=30, got valid=%v, value=%d", initial.Age.Valid, initial.Age.Int64())
+	}
+
+	// Verify name was preserved (not overwritten with zero value)
+	if !initial.Name.Valid || initial.Name.String() != "Original Name" {
+		t.Errorf("expected name='Original Name' to be preserved, got valid=%v, value=%s", initial.Name.Valid, initial.Name.String())
+	}
+
+	// Verify ID was preserved
+	if initial.ID != 1 {
+		t.Errorf("expected id=1 to be preserved, got %d", initial.ID)
+	}
+}

pkg/resolvespec/handler.go

@@ -701,97 +701,130 @@ func (h *Handler) handleUpdate(ctx context.Context, w common.ResponseWriter, url
 		// Get the primary key name
 		pkName := reflection.GetPrimaryKeyName(model)
 
-		// First, read the existing record from the database
-		existingRecord := reflect.New(reflection.GetPointerElement(reflect.TypeOf(model))).Interface()
-		selectQuery := h.db.NewSelect().Model(existingRecord)
+		// Wrap in transaction to ensure BeforeUpdate hook is inside transaction
+		err := h.db.RunInTransaction(ctx, func(tx common.Database) error {
+			// First, read the existing record from the database
+			existingRecord := reflect.New(reflection.GetPointerElement(reflect.TypeOf(model))).Interface()
+			selectQuery := tx.NewSelect().Model(existingRecord).Column("*")
 
-		// Apply conditions to select
-		if urlID != "" {
-			logger.Debug("Updating by URL ID: %s", urlID)
-			selectQuery = selectQuery.Where(fmt.Sprintf("%s = ?", common.QuoteIdent(pkName)), urlID)
-		} else if reqID != nil {
-			switch id := reqID.(type) {
-			case string:
-				logger.Debug("Updating by request ID: %s", id)
-				selectQuery = selectQuery.Where(fmt.Sprintf("%s = ?", common.QuoteIdent(pkName)), id)
-			case []string:
-				if len(id) > 0 {
-					logger.Debug("Updating by multiple IDs: %v", id)
-					selectQuery = selectQuery.Where(fmt.Sprintf("%s IN (?)", common.QuoteIdent(pkName)), id)
+			// Apply conditions to select
+			if urlID != "" {
+				logger.Debug("Updating by URL ID: %s", urlID)
+				selectQuery = selectQuery.Where(fmt.Sprintf("%s = ?", common.QuoteIdent(pkName)), urlID)
+			} else if reqID != nil {
+				switch id := reqID.(type) {
+				case string:
+					logger.Debug("Updating by request ID: %s", id)
+					selectQuery = selectQuery.Where(fmt.Sprintf("%s = ?", common.QuoteIdent(pkName)), id)
+				case []string:
+					if len(id) > 0 {
+						logger.Debug("Updating by multiple IDs: %v", id)
+						selectQuery = selectQuery.Where(fmt.Sprintf("%s IN (?)", common.QuoteIdent(pkName)), id)
+					}
 				}
 			}
-		}
 
-		if err := selectQuery.ScanModel(ctx); err != nil {
-			if err == sql.ErrNoRows {
-				logger.Warn("No records found to update")
-				h.sendError(w, http.StatusNotFound, "not_found", "No records found to update", nil)
-				return
-			}
-			logger.Error("Error fetching existing record: %v", err)
-			h.sendError(w, http.StatusInternalServerError, "update_error", "Error fetching existing record", err)
-			return
-		}
-
-		// Convert existing record to map
-		existingMap := make(map[string]interface{})
-		jsonData, err := json.Marshal(existingRecord)
-		if err != nil {
-			logger.Error("Error marshaling existing record: %v", err)
-			h.sendError(w, http.StatusInternalServerError, "update_error", "Error processing existing record", err)
-			return
-		}
-		if err := json.Unmarshal(jsonData, &existingMap); err != nil {
-			logger.Error("Error unmarshaling existing record: %v", err)
-			h.sendError(w, http.StatusInternalServerError, "update_error", "Error processing existing record", err)
-			return
-		}
-
-		// Merge only non-null and non-empty values from the incoming request into the existing record
-		for key, newValue := range updates {
-			// Skip if the value is nil
-			if newValue == nil {
-				continue
+			if err := selectQuery.ScanModel(ctx); err != nil {
+				if err == sql.ErrNoRows {
+					return fmt.Errorf("no records found to update")
+				}
+				return fmt.Errorf("error fetching existing record: %w", err)
 			}
 
-			// Skip if the value is an empty string
-			if strVal, ok := newValue.(string); ok && strVal == "" {
-				continue
+			// Convert existing record to map
+			existingMap := make(map[string]interface{})
+			jsonData, err := json.Marshal(existingRecord)
+			if err != nil {
+				return fmt.Errorf("error marshaling existing record: %w", err)
+			}
+			if err := json.Unmarshal(jsonData, &existingMap); err != nil {
+				return fmt.Errorf("error unmarshaling existing record: %w", err)
 			}
 
-			// Update the existing map with the new value
-			existingMap[key] = newValue
-		}
-
-		// Build update query with merged data
-		query := h.db.NewUpdate().Table(tableName).SetMap(existingMap)
-
-		// Apply conditions
-		if urlID != "" {
-			query = query.Where(fmt.Sprintf("%s = ?", common.QuoteIdent(pkName)), urlID)
-		} else if reqID != nil {
-			switch id := reqID.(type) {
-			case string:
-				query = query.Where(fmt.Sprintf("%s = ?", common.QuoteIdent(pkName)), id)
-			case []string:
-				query = query.Where(fmt.Sprintf("%s IN (?)", common.QuoteIdent(pkName)), id)
+			// Execute BeforeUpdate hooks inside transaction
+			hookCtx := &HookContext{
+				Context: ctx,
+				Handler: h,
+				Schema:  schema,
+				Entity:  entity,
+				Model:   model,
+				Options: options,
+				ID:      urlID,
+				Data:    updates,
+				Writer:  w,
+				Tx:      tx,
 			}
-		}
 
-		result, err := query.Exec(ctx)
+			if err := h.hooks.Execute(BeforeUpdate, hookCtx); err != nil {
+				return fmt.Errorf("BeforeUpdate hook failed: %w", err)
+			}
+
+			// Use potentially modified data from hook context
+			if modifiedData, ok := hookCtx.Data.(map[string]interface{}); ok {
+				updates = modifiedData
+			}
+
+			// Merge only non-null and non-empty values from the incoming request into the existing record
+			for key, newValue := range updates {
+				// Skip if the value is nil
+				if newValue == nil {
+					continue
+				}
+
+				// Skip if the value is an empty string
+				if strVal, ok := newValue.(string); ok && strVal == "" {
+					continue
+				}
+
+				// Update the existing map with the new value
+				existingMap[key] = newValue
+			}
+
+			// Build update query with merged data
+			query := tx.NewUpdate().Table(tableName).SetMap(existingMap)
+
+			// Apply conditions
+			if urlID != "" {
+				query = query.Where(fmt.Sprintf("%s = ?", common.QuoteIdent(pkName)), urlID)
+			} else if reqID != nil {
+				switch id := reqID.(type) {
+				case string:
+					query = query.Where(fmt.Sprintf("%s = ?", common.QuoteIdent(pkName)), id)
+				case []string:
+					query = query.Where(fmt.Sprintf("%s IN (?)", common.QuoteIdent(pkName)), id)
+				}
+			}
+
+			result, err := query.Exec(ctx)
+			if err != nil {
+				return fmt.Errorf("error updating record(s): %w", err)
+			}
+
+			if result.RowsAffected() == 0 {
+				return fmt.Errorf("no records found to update")
+			}
+
+			// Execute AfterUpdate hooks inside transaction
+			hookCtx.Result = updates
+			hookCtx.Error = nil
+			if err := h.hooks.Execute(AfterUpdate, hookCtx); err != nil {
+				return fmt.Errorf("AfterUpdate hook failed: %w", err)
+			}
+
+			return nil
+		})
+
 		if err != nil {
 			logger.Error("Update error: %v", err)
-			h.sendError(w, http.StatusInternalServerError, "update_error", "Error updating record(s)", err)
+			if err.Error() == "no records found to update" {
+				h.sendError(w, http.StatusNotFound, "not_found", "No records found to update", err)
+			} else {
+				h.sendError(w, http.StatusInternalServerError, "update_error", "Error updating record(s)", err)
+			}
 			return
 		}
 
-		if result.RowsAffected() == 0 {
-			logger.Warn("No records found to update")
-			h.sendError(w, http.StatusNotFound, "not_found", "No records found to update", nil)
-			return
-		}
-
-		logger.Info("Successfully updated %d records", result.RowsAffected())
+		logger.Info("Successfully updated record(s)")
 		// Invalidate cache for this table
 		cacheTags := buildCacheTags(schema, tableName)
 		if err := invalidateCacheForTags(ctx, cacheTags); err != nil {
@@ -849,9 +882,11 @@ func (h *Handler) handleUpdate(ctx context.Context, w common.ResponseWriter, url
 		err := h.db.RunInTransaction(ctx, func(tx common.Database) error {
 			for _, item := range updates {
 				if itemID, ok := item["id"]; ok {
+					itemIDStr := fmt.Sprintf("%v", itemID)
+
 					// First, read the existing record
 					existingRecord := reflect.New(reflection.GetPointerElement(reflect.TypeOf(model))).Interface()
-					selectQuery := tx.NewSelect().Model(existingRecord).Where(fmt.Sprintf("%s = ?", common.QuoteIdent(pkName)), itemID)
+					selectQuery := tx.NewSelect().Model(existingRecord).Column("*").Where(fmt.Sprintf("%s = ?", common.QuoteIdent(pkName)), itemID)
 					if err := selectQuery.ScanModel(ctx); err != nil {
 						if err == sql.ErrNoRows {
 							continue // Skip if record not found
@@ -869,6 +904,29 @@ func (h *Handler) handleUpdate(ctx context.Context, w common.ResponseWriter, url
 						return fmt.Errorf("failed to unmarshal existing record: %w", err)
 					}
 
+					// Execute BeforeUpdate hooks inside transaction
+					hookCtx := &HookContext{
+						Context: ctx,
+						Handler: h,
+						Schema:  schema,
+						Entity:  entity,
+						Model:   model,
+						Options: options,
+						ID:      itemIDStr,
+						Data:    item,
+						Writer:  w,
+						Tx:      tx,
+					}
+
+					if err := h.hooks.Execute(BeforeUpdate, hookCtx); err != nil {
+						return fmt.Errorf("BeforeUpdate hook failed for ID %v: %w", itemID, err)
+					}
+
+					// Use potentially modified data from hook context
+					if modifiedData, ok := hookCtx.Data.(map[string]interface{}); ok {
+						item = modifiedData
+					}
+
 					// Merge only non-null and non-empty values
 					for key, newValue := range item {
 						if newValue == nil {
@@ -884,6 +942,13 @@ func (h *Handler) handleUpdate(ctx context.Context, w common.ResponseWriter, url
 					if _, err := txQuery.Exec(ctx); err != nil {
 						return err
 					}
+
+					// Execute AfterUpdate hooks inside transaction
+					hookCtx.Result = item
+					hookCtx.Error = nil
+					if err := h.hooks.Execute(AfterUpdate, hookCtx); err != nil {
+						return fmt.Errorf("AfterUpdate hook failed for ID %v: %w", itemID, err)
+					}
 				}
 			}
 			return nil
@@ -957,9 +1022,11 @@ func (h *Handler) handleUpdate(ctx context.Context, w common.ResponseWriter, url
 			for _, item := range updates {
 				if itemMap, ok := item.(map[string]interface{}); ok {
 					if itemID, ok := itemMap["id"]; ok {
+						itemIDStr := fmt.Sprintf("%v", itemID)
+
 						// First, read the existing record
 						existingRecord := reflect.New(reflection.GetPointerElement(reflect.TypeOf(model))).Interface()
-						selectQuery := tx.NewSelect().Model(existingRecord).Where(fmt.Sprintf("%s = ?", common.QuoteIdent(pkName)), itemID)
+						selectQuery := tx.NewSelect().Model(existingRecord).Column("*").Where(fmt.Sprintf("%s = ?", common.QuoteIdent(pkName)), itemID)
 						if err := selectQuery.ScanModel(ctx); err != nil {
 							if err == sql.ErrNoRows {
 								continue // Skip if record not found
@@ -977,6 +1044,29 @@ func (h *Handler) handleUpdate(ctx context.Context, w common.ResponseWriter, url
 							return fmt.Errorf("failed to unmarshal existing record: %w", err)
 						}
 
+						// Execute BeforeUpdate hooks inside transaction
+						hookCtx := &HookContext{
+							Context: ctx,
+							Handler: h,
+							Schema:  schema,
+							Entity:  entity,
+							Model:   model,
+							Options: options,
+							ID:      itemIDStr,
+							Data:    itemMap,
+							Writer:  w,
+							Tx:      tx,
+						}
+
+						if err := h.hooks.Execute(BeforeUpdate, hookCtx); err != nil {
+							return fmt.Errorf("BeforeUpdate hook failed for ID %v: %w", itemID, err)
+						}
+
+						// Use potentially modified data from hook context
+						if modifiedData, ok := hookCtx.Data.(map[string]interface{}); ok {
+							itemMap = modifiedData
+						}
+
 						// Merge only non-null and non-empty values
 						for key, newValue := range itemMap {
 							if newValue == nil {
@@ -992,6 +1082,14 @@ func (h *Handler) handleUpdate(ctx context.Context, w common.ResponseWriter, url
 						if _, err := txQuery.Exec(ctx); err != nil {
 							return err
 						}
+
+						// Execute AfterUpdate hooks inside transaction
+						hookCtx.Result = itemMap
+						hookCtx.Error = nil
+						if err := h.hooks.Execute(AfterUpdate, hookCtx); err != nil {
+							return fmt.Errorf("AfterUpdate hook failed for ID %v: %w", itemID, err)
+						}
+
 						list = append(list, item)
 					}
 				}

pkg/restheadspec/handler.go

@@ -1110,30 +1110,6 @@ func (h *Handler) handleUpdate(ctx context.Context, w common.ResponseWriter, id
 
 	logger.Info("Updating record in %s.%s", schema, entity)
 
-	// Execute BeforeUpdate hooks
-	hookCtx := &HookContext{
-		Context:   ctx,
-		Handler:   h,
-		Schema:    schema,
-		Entity:    entity,
-		TableName: tableName,
-		Tx:        h.db,
-		Model:     model,
-		Options:   options,
-		ID:        id,
-		Data:      data,
-		Writer:    w,
-	}
-
-	if err := h.hooks.Execute(BeforeUpdate, hookCtx); err != nil {
-		logger.Error("BeforeUpdate hook failed: %v", err)
-		h.sendError(w, http.StatusBadRequest, "hook_error", "Hook execution failed", err)
-		return
-	}
-
-	// Use potentially modified data from hook context
-	data = hookCtx.Data
-
 	// Convert data to map
 	dataMap, ok := data.(map[string]interface{})
 	if !ok {
@@ -1167,6 +1143,9 @@ func (h *Handler) handleUpdate(ctx context.Context, w common.ResponseWriter, id
 	// Variable to store the updated record
 	var updatedRecord interface{}
 
+	// Declare hook context to be used inside and outside transaction
+	var hookCtx *HookContext
+
 	// Process nested relations if present
 	err := h.db.RunInTransaction(ctx, func(tx common.Database) error {
 		// Create temporary nested processor with transaction
@@ -1174,7 +1153,7 @@ func (h *Handler) handleUpdate(ctx context.Context, w common.ResponseWriter, id
 
 		// First, read the existing record from the database
 		existingRecord := reflect.New(reflection.GetPointerElement(reflect.TypeOf(model))).Interface()
-		selectQuery := tx.NewSelect().Model(existingRecord).Where(fmt.Sprintf("%s = ?", common.QuoteIdent(pkName)), targetID)
+		selectQuery := tx.NewSelect().Model(existingRecord).Column("*").Where(fmt.Sprintf("%s = ?", common.QuoteIdent(pkName)), targetID)
 		if err := selectQuery.ScanModel(ctx); err != nil {
 			if err == sql.ErrNoRows {
 				return fmt.Errorf("record not found with ID: %v", targetID)
@@ -1204,6 +1183,30 @@ func (h *Handler) handleUpdate(ctx context.Context, w common.ResponseWriter, id
 			nestedRelations = relations
 		}
 
+		// Execute BeforeUpdate hooks inside transaction
+		hookCtx = &HookContext{
+			Context:   ctx,
+			Handler:   h,
+			Schema:    schema,
+			Entity:    entity,
+			TableName: tableName,
+			Tx:        tx,
+			Model:     model,
+			Options:   options,
+			ID:        id,
+			Data:      dataMap,
+			Writer:    w,
+		}
+
+		if err := h.hooks.Execute(BeforeUpdate, hookCtx); err != nil {
+			return fmt.Errorf("BeforeUpdate hook failed: %w", err)
+		}
+
+		// Use potentially modified data from hook context
+		if modifiedData, ok := hookCtx.Data.(map[string]interface{}); ok {
+			dataMap = modifiedData
+		}
+
 		// Merge only non-null and non-empty values from the incoming request into the existing record
 		for key, newValue := range dataMap {
 			// Skip if the value is nil

pkg/restheadspec/headers.go

@@ -354,6 +354,12 @@ func (h *Handler) parseSearchOp(options *ExtendedRequestOptions, headerKey, valu
 	operator := parts[0]
 	colName := parts[1]
 
+	if strings.HasPrefix(colName, "cql") {
+		// Computed column - Will not filter on it
+		logger.Warn("Search operators on computed columns are not supported: %s", colName)
+		return
+	}
+
 	// Map operator names to filter operators
 	filterOp := h.mapSearchOperator(colName, operator, value)