feat: add BeforeFind hook

callbacks/callbacks.go

@@ -48,6 +48,7 @@
 	createCallback.Clauses = config.CreateClauses
 
 	queryCallback := db.Callback().Query()
+	queryCallback.Register("gorm:before_query", BeforeQuery)
 	queryCallback.Register("gorm:query", Query)
 	queryCallback.Register("gorm:preload", Preload)
 	queryCallback.Register("gorm:after_query", AfterQuery)

callbacks/interfaces.go

@@ -34,6 +34,10 @@ type AfterDeleteInterface interface {
 	AfterDelete(*gorm.DB) error
 }
 
+type BeforeFindInterface interface {
+	BeforeFind(*gorm.DB) error
+}
+
 type AfterFindInterface interface {
 	AfterFind(*gorm.DB) error
 }

callbacks/query.go

@@ -11,6 +11,18 @@ import (
 	"gorm.io/gorm/utils"
 )
 
+func BeforeQuery(db *gorm.DB) {
+	if db.Error == nil && db.Statement.Schema != nil && !db.Statement.SkipHooks && db.Statement.Schema.BeforeFind {
+		callMethod(db, func(value interface{}, tx *gorm.DB) bool {
+			if i, ok := value.(BeforeFindInterface); ok {
+				db.AddError(i.BeforeFind(tx))
+				return true
+			}
+			return false
+		})
+	}
+}
+
 func Query(db *gorm.DB) {
 	if db.Error == nil {
 		BuildQuerySQL(db)

schema/callbacks_test.go

@@ -31,7 +31,7 @@ func TestCallback(t *testing.T) {
 		}
 	}
 
-	for _, str := range []string{"BeforeCreate", "BeforeUpdate", "AfterUpdate", "AfterSave", "BeforeDelete", "AfterDelete", "AfterFind"} {
+	for _, str := range []string{"BeforeCreate", "BeforeUpdate", "AfterUpdate", "AfterSave", "BeforeDelete", "AfterDelete", "BeforeFind", "AfterFind"} {
 		if reflect.Indirect(reflect.ValueOf(user)).FieldByName(str).Interface().(bool) {
 			t.Errorf("%v should be false", str)
 		}

schema/schema.go

@@ -24,6 +24,7 @@ const (
 	callbackTypeAfterSave    callbackType = "AfterSave"
 	callbackTypeBeforeDelete callbackType = "BeforeDelete"
 	callbackTypeAfterDelete  callbackType = "AfterDelete"
+	callbackTypeBeforeFind   callbackType = "BeforeFind"
 	callbackTypeAfterFind    callbackType = "AfterFind"
 )
 
@@ -52,7 +53,7 @@ type Schema struct {
 	BeforeUpdate, AfterUpdate bool
 	BeforeDelete, AfterDelete bool
 	BeforeSave, AfterSave     bool
-	AfterFind                 bool
+	BeforeFind, AfterFind     bool
 	err                       error
 	initialized               chan struct{}
 	namer                     Namer
@@ -308,7 +309,7 @@ func ParseWithSpecialTableName(dest interface{}, cacheStore *sync.Map, namer Nam
 		callbackTypeBeforeUpdate, callbackTypeAfterUpdate,
 		callbackTypeBeforeSave, callbackTypeAfterSave,
 		callbackTypeBeforeDelete, callbackTypeAfterDelete,
-		callbackTypeAfterFind,
+		callbackTypeBeforeFind, callbackTypeAfterFind,
 	}
 	for _, cbName := range callbackTypes {
 		if methodValue := callBackToMethodValue(modelValue, cbName); methodValue.IsValid() {
@@ -396,6 +397,8 @@ func callBackToMethodValue(modelType reflect.Value, cbType callbackType) reflect
 		return modelType.MethodByName(string(callbackTypeBeforeDelete))
 	case callbackTypeAfterDelete:
 		return modelType.MethodByName(string(callbackTypeAfterDelete))
+	case callbackTypeBeforeFind:
+		return modelType.MethodByName(string(callbackTypeBeforeFind))
 	case callbackTypeAfterFind:
 		return modelType.MethodByName(string(callbackTypeAfterFind))
 	default:

tests/hooks_test.go

@@ -609,3 +609,99 @@ func TestPropagateUnscoped(t *testing.T) {
 		t.Fatalf("unscoped did not propagate")
 	}
 }
+
+type Product7 struct {
+	gorm.Model
+	Code                string
+	Price               float64
+	BeforeFindCallTimes int64 `gorm:"-"`
+}
+
+func (s *Product7) BeforeFind(tx *gorm.DB) error {
+	s.BeforeFindCallTimes++
+	return nil
+}
+
+// Modifies transient field
+func TestBeforeFindHookCallCount(t *testing.T) {
+	DB.Migrator().DropTable(&Product7{})
+	DB.AutoMigrate(&Product7{})
+
+	p := Product7{Code: "before_find_count", Price: 100}
+	DB.Save(&p)
+
+	var result Product7
+
+	DB.First(&result, "code = ?", "before_find_count")
+	if result.BeforeFindCallTimes != 1 {
+		t.Errorf("Expected 1, got %d", result.BeforeFindCallTimes)
+	}
+
+	DB.First(&result, "code = ?", "before_find_count")
+	if result.BeforeFindCallTimes != 2 {
+		t.Errorf("Expected 2, got %d", result.BeforeFindCallTimes)
+	}
+}
+
+type Product8 struct {
+	gorm.Model
+	Code  string
+	Price float64
+}
+
+func (s *Product8) BeforeFind(tx *gorm.DB) error {
+	tx.Statement.Where("price > ?", 50)
+
+	return nil
+}
+
+func TestBeforeFindModifiesQuery(t *testing.T) {
+	DB.Migrator().DropTable(&Product8{})
+	DB.AutoMigrate(&Product8{})
+
+	p1 := Product8{Code: "A", Price: 30}
+	DB.Create(&p1)
+
+	var result Product8
+
+	DB.Find(&result)
+
+	if (result != Product8{}) {
+		t.Errorf("BeforeFind should filter results, got %v", result)
+	}
+
+	p2 := Product8{Code: "B", Price: 100}
+	DB.Create(&p2)
+
+	DB.Find(&result)
+
+	if result.Code != "B" {
+		t.Errorf("BeforeFind should filter results, got %v", result)
+	}
+}
+
+type Product9 struct {
+	gorm.Model
+	Code  string
+	Price float64
+}
+
+func (s *Product9) BeforeFind(tx *gorm.DB) error {
+	s.Price = 200
+	return nil
+}
+
+func TestDatabaseOverwritesBeforeFindChanges(t *testing.T) {
+	DB.Migrator().DropTable(&Product9{})
+	DB.AutoMigrate(&Product9{})
+
+	p := Product9{Code: "price_overwrite", Price: 100}
+	DB.Save(&p)
+
+	var result Product9
+	DB.First(&result, "code = ?", "price_overwrite")
+
+	if result.Price != 100 {
+		t.Errorf("Price should be loaded from database, got %f", result.Price)
+	}
+}