Golang GORM Implement archived_at similar to soft delete

I am working with GORM V1. I have a requirement where we would want to add an archived_at column similar to GORMs deleted_at. The entities could be archived and unarchived and by default we would want to query records with archived_at is NULL.

My current thought is to leverage GORM callbacks, to register a callback

1. To register a callback before gorm:query callback.
2. Check if the schema/model has required archived_at field.
3. If it does have the field add necessary condition.

This sounds good until here but how do I efficiently replicate the Unscoped() equivalent of archived.

• What would be the idiomatic way of fetching archived records as well? How do I indicate whether the archived_at column should be added inside the necessary callback?
• I am also going to have a case where I want to fetch just the archived records (where archived_at IS NOT NULL).

EDIT - my use case is to use both deleted_at and archived_at fields and not use one in place of another. I want to retain the ability of soft deleting along with adding the ability to archive an entity. A user could be just archived, and then may be deleted (soft delete).

Inviting feedback. This is what I have currently come up with.

callback.go

package db

import (
	"fmt"
	"reflect"

	"gorm.io/gorm"
)

const (
    GormSettingKeyUnscopeArchive = "unscope_archive"
	StructFieldNameArchivedAt    = "ArchivedAt"
)

// ArchivedQueryCallback - conditionally adds "WHERE archived_at IS NULL" if the Model being queried has the following
// 1. Struct field represented by StructFieldNameArchivedAt
// 2. GORM instance setting GormSettingKeyUnscopeArchive, See UnscopeArchive
func ArchivedQueryCallback(db *gorm.DB) {
	// Check if Model is a pointer and has an indirect struct type
	if db.Statement.Model != nil &&
		reflect.TypeOf(db.Statement.Model).Kind() == reflect.Ptr &&
		reflect.Indirect(reflect.ValueOf(db.Statement.Model)).Kind() == reflect.Struct {
		stmt := &gorm.Statement{DB: db}
		parseErr := stmt.Parse(db.Statement.Model)
		if parseErr != nil {
			panic(parseErr)
		}

		if _, archivedAtExists := stmt.Schema.FieldsByName[StructFieldNameArchivedAt]; archivedAtExists {
			v, ok := db.InstanceGet(GormSettingKeyUnscopeArchive)
			if ok {
				if v == true {
					return
				}
			}

			db.Where(fmt.Sprintf("%s IS NULL", stmt.Schema.FieldsByName[StructFieldNameArchivedAt].DBName))
		}
	}
}

scopes.go

// UnscopeArchive - sets a true value for the key GormSettingKeyUnscopeArchive
func UnscopeArchive(db *gorm.DB) *gorm.DB {
	db = db.InstanceSet(GormSettingKeyUnscopeArchive, true)

	return db
}

main.go

   type User {
       ID           string         `gorm:"primary_key" json:"id" valid:"uuidv4, optional"`
	CreatedAt    time.Time      `valid:"-" json:"created_at"`
	UpdatedAt    time.Time      `valid:"-" json:"-"`
	DeletedAt    gorm.DeletedAt `sql:"index" valid:"-" json:"-"`
	ArchivedAt   time.Time
   }

   var user []User
   ctx := context.Background()
   dbClient := InitializeGORM() //helper 
   _ := dbClient.WithContext(ctx).Find(&user).Error // SELECT * FROM users WHERE deleted_at IS NULL AND archived_at IS NULL;

   _ := dbClient.WithContext(ctx).Scopes(UnscopeArchive).Find(&user).Error // SELECT * FROM users WHERE deleted_at IS NULL;

there is no need callbacks...
just defined the ArchivedAt as DeletedAt Unscoped will used

follow is a demo:

type User struct {
	Name       string
	Age        int
	ArchivedAt gorm.DeletedAt `gorm:"index"`
}

func main() {
	db := config.CreateMysql()
	//db.Callback().Query().Before("gorm:query").Register("my_plugin:after_query", MyQuery)
	db.AutoMigrate(User{})
	us := []User{}
	db.Debug().Unscoped().Find(&us)
	//SELECT * FROM `users`
	fmt.Printf("%v\n", us)

	us2 := []User{}
	db.Debug().Find(&us2)
	//SELECT * FROM `users` WHERE `users`.`archived_at` IS NULL
	fmt.Printf("%v\n", us)
}

if you want where archived_at IS NOT NULL, you can use callbacks like follow:

type User struct {
	Name       string
	Age        int
	ArchivedAt gorm.DeletedAt `gorm:"index"`
}

func MyQuery(db *gorm.DB) {
	if db.Statement.Unscoped {
		//archived_at is NULL
		fmt.Printf("append archived_at is not NULL\n")
		db = db.Statement.Where("archived_at is not NULL")
	} else {
		//default select all
		fmt.Printf("MyQuery\n")
	}

}

func main() {
	db := config.CreateMysql()
	db.Callback().Query().Before("gorm:query").Register("my_plugin:after_query", MyQuery)
	db.AutoMigrate(User{})
	us := []User{}
	db.Debug().Unscoped().Find(&us)
	//SELECT * FROM `users` WHERE archived_at is not NULL

	fmt.Printf("%v\n", us)

	us2 := []User{}
	db.Debug().Find(&us2)
	//SELECT * FROM `users` WHERE `users`.`archived_at` IS NULL
	fmt.Printf("%v\n", us)
}

ps: hooks is better than callbacks

if want both archived_at and deleted_at

const (
	fc_all = iota //0
	fc_null
	fc_notnull
)
const FindCondition = "FindCondition"

type User struct {
	Name       string
	Age        int
	ArchivedAt sql.NullTime `gorm:"index"`
}

func MyQuery(db *gorm.DB) {
	if c, ok := db.Get(FindCondition); ok {
		switch c {
		case fc_null:
			db = db.Statement.Where("archived_at is NULL")
		case fc_notnull:
			db = db.Statement.Where("archived_at is not NULL")
		}
	}
}

func main() {
	db := config.CreateMysql()
	db.Callback().Query().Before("gorm:query").Register("my_plugin:after_query", MyQuery)
	db.AutoMigrate(User{})
	us := []User{}
	db.Debug().Set(FindCondition, fc_notnull).Find(&us)
	//SELECT * FROM `users` WHERE `users`.`archived_at` IS NOT NULL
	fmt.Printf("%v\n", us)

	us2 := []User{}
	db.Debug().Set(FindCondition, fc_null).Find(&us2)
	//SELECT * FROM `users` WHERE `users`.`archived_at` IS NULL
	fmt.Printf("%v\n", us)
}