重构接口

convenient/entity_crud/service.go

@@ -16,7 +16,7 @@ import (
 	"reflect"
 )
 
-func Create(tableName string, callbacks *Callbacks[string]) binding.ServiceFunc[string] {
+func Create(tableName string, callbacks *CreateCallbacks) binding.ServiceFunc[string] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (string, error) {
 		object := objects[0]
 		if object == nil {
@@ -32,17 +32,22 @@ func Create(tableName string, callbacks *Callbacks[string]) binding.ServiceFunc[
 
 		err := e.GenerateID()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, "")
+			return callbackOnCreateErrorReturn(callbacks, e, make(map[string]any), err, i)
 		}
 
 		err = e.ForCreate()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, "")
+			return callbackOnCreateErrorReturn(callbacks, e, make(map[string]any), err, i)
 		}
 
-		err = callbackBeforeDBOperate(callbacks, e, i, dbExecutor)
+		prepared, err := callbackPrepareCreate(callbacks, e, i)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, "")
+			return callbackOnCreateErrorReturn(callbacks, e, make(map[string]any), err, i)
+		}
+
+		err = callbackBeforeCreate(callbacks, e, prepared, i, nil)
+		if err != nil {
+			return callbackOnCreateErrorReturn(callbacks, e, prepared, err, i)
 		}
 
 		err = database.InsertEntity(dbExecutor, tableName, e)
@@ -51,19 +56,19 @@ func Create(tableName string, callbacks *Callbacks[string]) binding.ServiceFunc[
 				err = fserr.New(e.DomainCNName() + "已存在")
 			}
 
-			return callbackOnErrorReturn(callbacks, e, err, i, "")
+			return callbackOnCreateErrorReturn(callbacks, e, prepared, err, i)
 		}
 
-		err = callbackAfterDBOperate(callbacks, e, i, dbExecutor)
+		err = callbackAfterCreate(callbacks, e, prepared, i, nil)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, "")
+			return callbackOnCreateErrorReturn(callbacks, e, prepared, err, i)
 		}
 
-		return callbackOnSuccessReturn(callbacks, e, i, e.GetID())
+		return callbackOnCreateSuccessReturn(callbacks, e, prepared, i, e.GetID())
 	}
 }
 
-func Delete(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+func Delete(tableName string, callbacks *DeleteCallbacks) binding.ServiceFunc[any] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
 		object := objects[0]
 		if object == nil {
@@ -79,29 +84,34 @@ func Delete(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any
 
 		err := e.ForDelete()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, nil)
+			return nil, callbackOnDeleteErrorReturn(callbacks, e, make(map[string]any), err, i)
+		}
+
+		prepared, err := callbackPrepareDelete(callbacks, e, i)
+		if err != nil {
+			return nil, callbackOnDeleteErrorReturn(callbacks, e, make(map[string]any), err, i)
 		}
 
-		err = callbackBeforeDBOperate(callbacks, e, i, dbExecutor)
+		err = callbackBeforeDelete(callbacks, e, prepared, i, nil)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, nil)
+			return nil, callbackOnDeleteErrorReturn(callbacks, e, prepared, err, i)
 		}
 
 		err = database.DeleteEntity(dbExecutor, tableName, e)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, nil)
+			return nil, callbackOnDeleteErrorReturn(callbacks, e, prepared, err, i)
 		}
 
-		err = callbackAfterDBOperate(callbacks, e, i, dbExecutor)
+		err = callbackAfterDelete(callbacks, e, prepared, i, nil)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, nil)
+			return nil, callbackOnDeleteErrorReturn(callbacks, e, prepared, err, i)
 		}
 
-		return callbackOnSuccessReturn(callbacks, e, i, nil)
+		return nil, callbackOnDeleteSuccessReturn(callbacks, e, prepared, i)
 	}
 }
 
-func Update(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+func Update(tableName string, callbacks *UpdateCallbacks) binding.ServiceFunc[any] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
 		object := objects[0]
 		if object == nil {
@@ -117,7 +127,7 @@ func Update(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any
 
 		err := e.ForUpdate()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, nil)
+			return nil, callbackOnUpdateErrorReturn(callbacks, e, make(map[string]any), err, i)
 		}
 
 		exist, err := database.CheckExist(dbExecutor, &sql.CheckExistExecuteParams{
@@ -125,36 +135,41 @@ func Update(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any
 			Conditions: sql.NewConditions().Equal(entity.ColumnID, e.GetID()),
 		})
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, nil)
+			return nil, callbackOnUpdateErrorReturn(callbacks, e, make(map[string]any), err, i)
 		}
 
 		if !exist {
 			err := fserr.New(e.DomainCNName() + "不存在")
-			return callbackOnErrorReturn(callbacks, e, err, i, nil)
+			return nil, callbackOnUpdateErrorReturn(callbacks, e, make(map[string]any), err, i)
 		}
 
-		err = callbackBeforeDBOperate(callbacks, e, i, dbExecutor)
+		prepared, err := callbackPrepareUpdate(callbacks, e, i)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, nil)
+			return nil, callbackOnUpdateErrorReturn(callbacks, e, make(map[string]any), err, i)
+		}
+
+		err = callbackBeforeUpdate(callbacks, e, prepared, i, nil)
+		if err != nil {
+			return nil, callbackOnUpdateErrorReturn(callbacks, e, prepared, err, i)
 		}
 
 		err = database.UpdateEntity(dbExecutor, tableName, e)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, nil)
+			return nil, callbackOnUpdateErrorReturn(callbacks, e, prepared, err, i)
 		}
 
-		err = callbackAfterDBOperate(callbacks, e, i, dbExecutor)
+		err = callbackAfterUpdate(callbacks, e, prepared, i, nil)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, nil)
+			return nil, callbackOnUpdateErrorReturn(callbacks, e, prepared, err, i)
 		}
 
-		return callbackOnSuccessReturn(callbacks, e, i, nil)
+		return nil, callbackOnUpdateSuccessReturn(callbacks, e, prepared, i)
 	}
 }
 
 type ConditionFieldCallback func(conditions *sql.Conditions, fieldName string, columnName string, value any) (hasDeal bool)
 
-func Query[O any](tableName string, callbacks *Callbacks[response.InfosData[O]], conditionFieldCallback ConditionFieldCallback) binding.ServiceFunc[response.InfosData[O]] {
+func Query[O any](tableName string, callbacks *QueryCallbacks[O], conditionFieldCallback ConditionFieldCallback) binding.ServiceFunc[response.InfosData[O]] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (response.InfosData[O], error) {
 		errResponse := response.InfosData[O]{
 			Infos: make([]O, 0),
@@ -202,9 +217,9 @@ func Query[O any](tableName string, callbacks *Callbacks[response.InfosData[O]],
 			}
 		}
 
-		err = callbackBeforeDBOperate(callbacks, e, i, dbExecutor)
+		err = callbackBeforeQuery(callbacks, e, i)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, errResponse)
+			return callbackOnQueryErrorReturn(callbacks, e, err, i)
 		}
 
 		results, totalCount, err := database.Query(dbExecutor, &sql.QueryExecuteParams{
@@ -214,18 +229,18 @@ func Query[O any](tableName string, callbacks *Callbacks[response.InfosData[O]],
 			PageSize:   queryParams.GetPageSize(),
 		})
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, errResponse)
+			return callbackOnQueryErrorReturn(callbacks, e, err, i)
 		}
 
-		err = callbackAfterDBOperate(callbacks, e, i, dbExecutor)
+		err = callbackAfterQuery(callbacks, e, i)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, errResponse)
+			return callbackOnQueryErrorReturn(callbacks, e, err, i)
 		}
 
 		infos := make([]O, 0)
 		err = sql.ParseSqlResult(results, &infos)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, errResponse)
+			return callbackOnQueryErrorReturn(callbacks, e, err, i)
 		}
 
 		output := response.InfosData[O]{
@@ -234,11 +249,11 @@ func Query[O any](tableName string, callbacks *Callbacks[response.InfosData[O]],
 			PageNo:     queryParams.GetPageNo(),
 		}
 
-		return callbackOnSuccessReturn(callbacks, e, i, output)
+		return callbackOnQuerySuccessReturn(callbacks, e, i, output)
 	}
 }
 
-func GetByID[O any](tableName string, callbacks *Callbacks[O]) binding.ServiceFunc[O] {
+func GetByID[O any](tableName string, callbacks *QueryByIDCallbacks[O]) binding.ServiceFunc[O] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (O, error) {
 		outputZero := reflectutils.Zero[O]()
 
@@ -256,12 +271,12 @@ func GetByID[O any](tableName string, callbacks *Callbacks[O]) binding.ServiceFu
 
 		err := e.CheckFieldID()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, outputZero)
+			return callbackOnQueryByIDErrorReturn(callbacks, e, err, i)
 		}
 
-		err = callbackBeforeDBOperate(callbacks, e, i, dbExecutor)
+		err = callbackBeforeQueryByID(callbacks, e, i)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, outputZero)
+			return callbackOnQueryByIDErrorReturn(callbacks, e, err, i)
 		}
 
 		result, err := database.QueryOne(dbExecutor, &sql.QueryOneExecuteParams{
@@ -273,25 +288,25 @@ func GetByID[O any](tableName string, callbacks *Callbacks[O]) binding.ServiceFu
 				err = fserr.New(e.DomainCNName() + "不存在")
 			}
 
-			return callbackOnErrorReturn(callbacks, e, err, i, outputZero)
+			return callbackOnQueryByIDErrorReturn(callbacks, e, err, i)
 		}
 
-		err = callbackAfterDBOperate(callbacks, e, i, dbExecutor)
+		err = callbackAfterQueryByID(callbacks, e, i)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, outputZero)
+			return callbackOnQueryByIDErrorReturn(callbacks, e, err, i)
 		}
 
 		info := reflectutils.Zero[O]()
 		err = sql.ParseSqlResult(result, &info)
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, outputZero)
+			return callbackOnQueryByIDErrorReturn(callbacks, e, err, i)
 		}
 
-		return callbackOnSuccessReturn(callbacks, e, i, info)
+		return callbackOnQueryByIDSuccessReturn(callbacks, e, i, info)
 	}
 }
 
-func CreateTx(tableName string, callbacks *Callbacks[string]) binding.ServiceFunc[string] {
+func CreateTx(tableName string, callbacks *CreateCallbacks) binding.ServiceFunc[string] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (string, error) {
 		object := objects[0]
 		if object == nil {
@@ -307,16 +322,21 @@ func CreateTx(tableName string, callbacks *Callbacks[string]) binding.ServiceFun
 
 		err := e.GenerateID()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, "")
+			return callbackOnCreateErrorReturn(callbacks, e, make(map[string]any), err, i)
 		}
 
 		err = e.ForCreate()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, "")
+			return callbackOnCreateErrorReturn(callbacks, e, make(map[string]any), err, i)
+		}
+
+		prepared, err := callbackPrepareCreate(callbacks, e, i)
+		if err != nil {
+			return callbackOnCreateErrorReturn(callbacks, e, make(map[string]any), err, i)
 		}
 
 		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
-			err = callbackBeforeDBOperate(callbacks, e, i, tx)
+			err = callbackBeforeCreate(callbacks, e, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -330,7 +350,7 @@ func CreateTx(tableName string, callbacks *Callbacks[string]) binding.ServiceFun
 				return err
 			}
 
-			err = callbackAfterDBOperate(callbacks, e, i, tx)
+			err = callbackAfterCreate(callbacks, e, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -338,14 +358,14 @@ func CreateTx(tableName string, callbacks *Callbacks[string]) binding.ServiceFun
 			return nil
 		})
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, "")
+			return callbackOnCreateErrorReturn(callbacks, e, prepared, err, i)
 		}
 
-		return callbackOnSuccessReturn(callbacks, e, i, e.GetID())
+		return callbackOnCreateSuccessReturn(callbacks, e, prepared, i, e.GetID())
 	}
 }
 
-func DeleteTx(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+func DeleteTx(tableName string, callbacks *DeleteCallbacks) binding.ServiceFunc[any] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
 		object := objects[0]
 		if object == nil {
@@ -361,11 +381,16 @@ func DeleteTx(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[a
 
 		err := e.CheckFieldID()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, nil)
+			return nil, callbackOnDeleteErrorReturn(callbacks, e, make(map[string]any), err, i)
+		}
+
+		prepared, err := callbackPrepareDelete(callbacks, e, i)
+		if err != nil {
+			return nil, callbackOnDeleteErrorReturn(callbacks, e, make(map[string]any), err, i)
 		}
 
 		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
-			err = callbackBeforeDBOperate(callbacks, e, i, tx)
+			err = callbackBeforeDelete(callbacks, e, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -375,7 +400,7 @@ func DeleteTx(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[a
 				return err
 			}
 
-			err = callbackAfterDBOperate(callbacks, e, i, tx)
+			err = callbackAfterDelete(callbacks, e, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -383,14 +408,14 @@ func DeleteTx(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[a
 			return nil
 		})
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, nil)
+			return nil, callbackOnDeleteErrorReturn(callbacks, e, prepared, err, i)
 		}
 
-		return callbackOnSuccessReturn(callbacks, e, i, nil)
+		return nil, callbackOnDeleteSuccessReturn(callbacks, e, prepared, i)
 	}
 }
 
-func UpdateTx(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[any] {
+func UpdateTx(tableName string, callbacks *UpdateCallbacks) binding.ServiceFunc[any] {
 	return func(c *api.Context, params request.Params, objects []domain.Object, i *infrastructure.Infrastructure) (any, error) {
 		object := objects[0]
 		if object == nil {
@@ -406,7 +431,7 @@ func UpdateTx(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[a
 
 		err := e.CheckFieldID()
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, nil)
+			return nil, callbackOnUpdateErrorReturn(callbacks, e, make(map[string]any), err, i)
 		}
 
 		exist, err := database.CheckExist(dbExecutor, &sql.CheckExistExecuteParams{
@@ -414,16 +439,20 @@ func UpdateTx(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[a
 			Conditions: sql.NewConditions().Equal(entity.ColumnID, e.GetID()),
 		})
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, nil)
+			return nil, callbackOnUpdateErrorReturn(callbacks, e, make(map[string]any), err, i)
 		}
 
 		if !exist {
-			err := fserr.New(e.DomainCNName() + "不存在")
-			return callbackOnErrorReturn(callbacks, e, err, i, nil)
+			return nil, callbackOnUpdateErrorReturn(callbacks, e, make(map[string]any), fserr.New(e.DomainCNName()+"不存在"), i)
+		}
+
+		prepared, err := callbackPrepareUpdate(callbacks, e, i)
+		if err != nil {
+			return nil, callbackOnUpdateErrorReturn(callbacks, e, make(map[string]any), err, i)
 		}
 
 		err = database.Transaction(dbExecutor, func(tx database.Executor) error {
-			err = callbackBeforeDBOperate(callbacks, e, i, tx)
+			err = callbackBeforeUpdate(callbacks, e, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -433,7 +462,7 @@ func UpdateTx(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[a
 				return err
 			}
 
-			err = callbackAfterDBOperate(callbacks, e, i, tx)
+			err = callbackAfterUpdate(callbacks, e, prepared, i, tx)
 			if err != nil {
 				return err
 			}
@@ -441,9 +470,9 @@ func UpdateTx(tableName string, callbacks *Callbacks[any]) binding.ServiceFunc[a
 			return nil
 		})
 		if err != nil {
-			return callbackOnErrorReturn(callbacks, e, err, i, nil)
+			return nil, callbackOnUpdateErrorReturn(callbacks, e, prepared, err, i)
 		}
 
-		return callbackOnSuccessReturn(callbacks, e, i, nil)
+		return nil, callbackOnUpdateSuccessReturn(callbacks, e, prepared, i)
 	}
 }

convenient/entity_crud/service_callbacks.go

@@ -1,62 +1,327 @@
 package entity_crud
 
 import (
+	"git.sxidc.com/go-framework/baize/framework/binding/response"
 	"git.sxidc.com/go-framework/baize/framework/core/domain/entity"
 	"git.sxidc.com/go-framework/baize/framework/core/infrastructure"
 	"git.sxidc.com/go-framework/baize/framework/core/infrastructure/database"
+	"git.sxidc.com/go-tools/utils/reflectutils"
 )
 
-type Callbacks[O any] struct {
-	BeforeDBOperate func(e entity.Entity, i *infrastructure.Infrastructure, dbExecutor database.Executor) error
-	AfterDBOperate  func(e entity.Entity, i *infrastructure.Infrastructure, dbExecutor database.Executor) error
+type CreateCallbacks struct {
+	Prepare         func(e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error)
+	Before          func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
+	After           func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
+	OnSuccessReturn func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, id string) (string, error)
+	OnErrorReturn   func(e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) (string, error)
+}
+
+func callbackPrepareCreate(callbacks *CreateCallbacks, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error) {
+	if callbacks == nil {
+		return make(map[string]any), nil
+	}
+
+	if callbacks.Prepare == nil {
+		return make(map[string]any), nil
+	}
+
+	return callbacks.Prepare(e, i)
+}
+
+func callbackBeforeCreate(callbacks *CreateCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+	if callbacks == nil {
+		return nil
+	}
+
+	if callbacks.Before == nil {
+		return nil
+	}
+
+	return callbacks.Before(e, prepared, i, tx)
+}
+
+func callbackAfterCreate(callbacks *CreateCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
+	if callbacks == nil {
+		return nil
+	}
+
+	if callbacks.After == nil {
+		return nil
+	}
+
+	return callbacks.After(e, prepared, i, dbExecutor)
+}
+
+func callbackOnCreateSuccessReturn(callbacks *CreateCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, id string) (string, error) {
+	if callbacks == nil {
+		return id, nil
+	}
+
+	if callbacks.OnSuccessReturn == nil {
+		return id, nil
+	}
+
+	return callbacks.OnSuccessReturn(e, prepared, i, id)
+}
+
+func callbackOnCreateErrorReturn(callbacks *CreateCallbacks, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) (string, error) {
+	if callbacks == nil {
+		return "", err
+	}
+
+	if callbacks.OnErrorReturn == nil {
+		return "", err
+	}
+
+	return callbacks.OnErrorReturn(e, prepared, err, i)
+}
+
+type DeleteCallbacks struct {
+	Prepare         func(e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error)
+	Before          func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
+	After           func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
+	OnSuccessReturn func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure) error
+	OnErrorReturn   func(e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) error
+}
+
+func callbackPrepareDelete(callbacks *DeleteCallbacks, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error) {
+	if callbacks == nil {
+		return make(map[string]any), nil
+	}
+
+	if callbacks.Prepare == nil {
+		return make(map[string]any), nil
+	}
+
+	return callbacks.Prepare(e, i)
+}
+
+func callbackBeforeDelete(callbacks *DeleteCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+	if callbacks == nil {
+		return nil
+	}
+
+	if callbacks.Before == nil {
+		return nil
+	}
+
+	return callbacks.Before(e, prepared, i, tx)
+}
+
+func callbackAfterDelete(callbacks *DeleteCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
+	if callbacks == nil {
+		return nil
+	}
+
+	if callbacks.After == nil {
+		return nil
+	}
+
+	return callbacks.After(e, prepared, i, dbExecutor)
+}
+
+func callbackOnDeleteSuccessReturn(callbacks *DeleteCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure) error {
+	if callbacks == nil {
+		return nil
+	}
+
+	if callbacks.OnSuccessReturn == nil {
+		return nil
+	}
+
+	return callbacks.OnSuccessReturn(e, prepared, i)
+}
+
+func callbackOnDeleteErrorReturn(callbacks *DeleteCallbacks, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) error {
+	if callbacks == nil {
+		return err
+	}
+
+	if callbacks.OnErrorReturn == nil {
+		return err
+	}
+
+	return callbacks.OnErrorReturn(e, prepared, err, i)
+}
+
+type UpdateCallbacks struct {
+	Prepare         func(e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error)
+	Before          func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
+	After           func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error
+	OnSuccessReturn func(e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure) error
+	OnErrorReturn   func(e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) error
+}
+
+func callbackPrepareUpdate(callbacks *UpdateCallbacks, e entity.Entity, i *infrastructure.Infrastructure) (map[string]any, error) {
+	if callbacks == nil {
+		return make(map[string]any), nil
+	}
+
+	if callbacks.Prepare == nil {
+		return make(map[string]any), nil
+	}
+
+	return callbacks.Prepare(e, i)
+}
+
+func callbackBeforeUpdate(callbacks *UpdateCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, tx database.Executor) error {
+	if callbacks == nil {
+		return nil
+	}
+
+	if callbacks.Before == nil {
+		return nil
+	}
+
+	return callbacks.Before(e, prepared, i, tx)
+}
+
+func callbackAfterUpdate(callbacks *UpdateCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
+	if callbacks == nil {
+		return nil
+	}
+
+	if callbacks.After == nil {
+		return nil
+	}
+
+	return callbacks.After(e, prepared, i, dbExecutor)
+}
+
+func callbackOnUpdateSuccessReturn(callbacks *UpdateCallbacks, e entity.Entity, prepared map[string]any, i *infrastructure.Infrastructure) error {
+	if callbacks == nil {
+		return nil
+	}
+
+	if callbacks.OnSuccessReturn == nil {
+		return nil
+	}
+
+	return callbacks.OnSuccessReturn(e, prepared, i)
+}
+
+func callbackOnUpdateErrorReturn(callbacks *UpdateCallbacks, e entity.Entity, prepared map[string]any, err error, i *infrastructure.Infrastructure) error {
+	if callbacks == nil {
+		return err
+	}
+
+	if callbacks.OnErrorReturn == nil {
+		return err
+	}
+
+	return callbacks.OnErrorReturn(e, prepared, err, i)
+}
+
+type QueryCallbacks[O any] struct {
+	Before          func(e entity.Entity, i *infrastructure.Infrastructure) error
+	After           func(e entity.Entity, i *infrastructure.Infrastructure) error
+	OnSuccessReturn func(e entity.Entity, i *infrastructure.Infrastructure, output response.InfosData[O]) (response.InfosData[O], error)
+	OnErrorReturn   func(e entity.Entity, err error, i *infrastructure.Infrastructure) (response.InfosData[O], error)
+}
+
+func callbackBeforeQuery[O any](callbacks *QueryCallbacks[O], e entity.Entity, i *infrastructure.Infrastructure) error {
+	if callbacks == nil {
+		return nil
+	}
+
+	if callbacks.Before == nil {
+		return nil
+	}
+
+	return callbacks.Before(e, i)
+}
+
+func callbackAfterQuery[O any](callbacks *QueryCallbacks[O], e entity.Entity, i *infrastructure.Infrastructure) error {
+	if callbacks == nil {
+		return nil
+	}
+
+	if callbacks.After == nil {
+		return nil
+	}
+
+	return callbacks.After(e, i)
+}
+
+func callbackOnQuerySuccessReturn[O any](callbacks *QueryCallbacks[O], e entity.Entity, i *infrastructure.Infrastructure, output response.InfosData[O]) (response.InfosData[O], error) {
+	if callbacks == nil {
+		return output, nil
+	}
+
+	if callbacks.OnSuccessReturn == nil {
+		return output, nil
+	}
+
+	return callbacks.OnSuccessReturn(e, i, output)
+}
+
+func callbackOnQueryErrorReturn[O any](callbacks *QueryCallbacks[O], e entity.Entity, err error, i *infrastructure.Infrastructure) (response.InfosData[O], error) {
+	if callbacks == nil {
+		return response.InfosData[O]{
+			Infos: make([]O, 0),
+		}, err
+	}
+
+	if callbacks.OnErrorReturn == nil {
+		return response.InfosData[O]{
+			Infos: make([]O, 0),
+		}, err
+	}
+
+	return callbacks.OnErrorReturn(e, err, i)
+}
+
+type QueryByIDCallbacks[O any] struct {
+	Before          func(e entity.Entity, i *infrastructure.Infrastructure) error
+	After           func(e entity.Entity, i *infrastructure.Infrastructure) error
 	OnSuccessReturn func(e entity.Entity, i *infrastructure.Infrastructure, output O) (O, error)
-	OnErrorReturn   func(e entity.Entity, err error, i *infrastructure.Infrastructure, defaultErrOutput O) (O, error)
+	OnErrorReturn   func(e entity.Entity, err error, i *infrastructure.Infrastructure) (O, error)
 }
 
-func callbackBeforeDBOperate[O any](callbacks *Callbacks[O], e entity.Entity, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
+func callbackBeforeQueryByID[O any](callbacks *QueryByIDCallbacks[O], e entity.Entity, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return nil
 	}
 
-	if callbacks.BeforeDBOperate != nil {
-		return callbacks.BeforeDBOperate(e, i, dbExecutor)
+	if callbacks.Before == nil {
+		return nil
 	}
 
-	return nil
+	return callbacks.Before(e, i)
 }
 
-func callbackAfterDBOperate[O any](callbacks *Callbacks[O], e entity.Entity, i *infrastructure.Infrastructure, dbExecutor database.Executor) error {
+func callbackAfterQueryByID[O any](callbacks *QueryByIDCallbacks[O], e entity.Entity, i *infrastructure.Infrastructure) error {
 	if callbacks == nil {
 		return nil
 	}
 
-	if callbacks.AfterDBOperate != nil {
-		return callbacks.AfterDBOperate(e, i, dbExecutor)
+	if callbacks.After == nil {
+		return nil
 	}
 
-	return nil
+	return callbacks.After(e, i)
 }
 
-func callbackOnSuccessReturn[O any](callbacks *Callbacks[O], e entity.Entity, i *infrastructure.Infrastructure, output O) (O, error) {
+func callbackOnQueryByIDSuccessReturn[O any](callbacks *QueryByIDCallbacks[O], e entity.Entity, i *infrastructure.Infrastructure, output O) (O, error) {
 	if callbacks == nil {
 		return output, nil
 	}
 
-	if callbacks.OnSuccessReturn != nil {
-		return callbacks.OnSuccessReturn(e, i, output)
+	if callbacks.OnSuccessReturn == nil {
+		return output, nil
 	}
 
-	return output, nil
+	return callbacks.OnSuccessReturn(e, i, output)
 }
 
-func callbackOnErrorReturn[O any](callbacks *Callbacks[O], e entity.Entity, err error, i *infrastructure.Infrastructure, defaultErrOutput O) (O, error) {
+func callbackOnQueryByIDErrorReturn[O any](callbacks *QueryByIDCallbacks[O], e entity.Entity, err error, i *infrastructure.Infrastructure) (O, error) {
 	if callbacks == nil {
-		return defaultErrOutput, err
+		return reflectutils.Zero[O](), err
 	}
 
-	if callbacks.OnErrorReturn != nil {
-		return callbacks.OnErrorReturn(e, err, i, defaultErrOutput)
+	if callbacks.OnErrorReturn == nil {
+		return reflectutils.Zero[O](), err
 	}
 
-	return defaultErrOutput, err
+	return callbacks.OnErrorReturn(e, err, i)
 }

convenient/entity_crud/simple.go

@@ -34,116 +34,149 @@ type Simple[I any] struct {
 	GetByIDQueryParams request.IDRequestParam
 
 	// 可选配置项，通过WithXXX配置
-	options *Options[I]
+	createOptions    *CreateOptions
+	deleteOptions    *DeleteOptions
+	updateOptions    *UpdateOptions
+	queryOptions     *QueryOptions[I]
+	queryByIDOptions *QueryByIDOptions[I]
 }
 
 func (simple *Simple[I]) bind(binder *binding.Binder) {
-	options := simple.options
+	createOptions := simple.createOptions
+	deleteOptions := simple.deleteOptions
+	updateOptions := simple.updateOptions
+	queryOptions := simple.queryOptions
+	queryByIDOptions := simple.queryByIDOptions
 
 	tableName := domain.TableName(simple.Schema, simple.Entity)
 	domainPath := domain.RelativeDomainPath(simple.Entity)
 
 	// 创建
-	if !options.disableCreate {
-		if !options.createNeedTx {
+	if !createOptions.disableCreate {
+		if !createOptions.createNeedTx {
 			binding.PostBind[string](binder, &binding.SimpleBindItem[string]{
 				Path:          domainPath + "/create",
 				ResponseFunc:  response.SendIDResponse,
 				RequestParams: simple.CreateJsonBody,
 				Objects:       []domain.Object{simple.Entity},
-				ServiceFunc:   Create(tableName, options.createCallbacks),
-			}, options.createMiddlewares...)
+				ServiceFunc:   Create(tableName, createOptions.createCallbacks),
+			}, createOptions.createMiddlewares...)
 		} else {
 			binding.PostBind(binder, &binding.SimpleBindItem[string]{
 				Path:          domainPath + "/create",
 				ResponseFunc:  response.SendIDResponse,
 				RequestParams: simple.CreateJsonBody,
 				Objects:       []domain.Object{simple.Entity},
-				ServiceFunc:   CreateTx(tableName, options.createCallbacks),
-			}, options.createMiddlewares...)
+				ServiceFunc:   CreateTx(tableName, createOptions.createCallbacks),
+			}, createOptions.createMiddlewares...)
 		}
 	}
 
 	// 删除
-	if !options.disableDelete {
-		if !options.deleteNeedTx {
+	if !deleteOptions.disableDelete {
+		if !deleteOptions.deleteNeedTx {
 			binding.DeleteBind(binder, &binding.SimpleBindItem[any]{
 				Path:          domainPath + "/delete",
 				ResponseFunc:  response.SendMsgResponse,
 				RequestParams: simple.DeleteQueryParams,
 				Objects:       []domain.Object{simple.Entity},
-				ServiceFunc:   Delete(tableName, options.deleteCallbacks),
-			}, options.deleteMiddlewares...)
+				ServiceFunc:   Delete(tableName, deleteOptions.deleteCallbacks),
+			}, deleteOptions.deleteMiddlewares...)
 		} else {
 			binding.DeleteBind(binder, &binding.SimpleBindItem[any]{
 				Path:          domainPath + "/delete",
 				ResponseFunc:  response.SendMsgResponse,
 				RequestParams: simple.DeleteQueryParams,
 				Objects:       []domain.Object{simple.Entity},
-				ServiceFunc:   DeleteTx(tableName, options.deleteCallbacks),
-			}, options.deleteMiddlewares...)
+				ServiceFunc:   DeleteTx(tableName, deleteOptions.deleteCallbacks),
+			}, deleteOptions.deleteMiddlewares...)
 		}
 	}
 
 	// 修改
-	if !options.disableUpdate {
-		if !options.updateNeedTx {
+	if !updateOptions.disableUpdate {
+		if !updateOptions.updateNeedTx {
 			binding.PutBind(binder, &binding.SimpleBindItem[any]{
 				Path:          domainPath + "/update",
 				ResponseFunc:  response.SendMsgResponse,
 				RequestParams: simple.UpdateJsonBody,
 				Objects:       []domain.Object{simple.Entity},
-				ServiceFunc:   Update(tableName, options.updateCallbacks),
-			}, options.updateMiddlewares...)
+				ServiceFunc:   Update(tableName, updateOptions.updateCallbacks),
+			}, updateOptions.updateMiddlewares...)
 		} else {
 			binding.PutBind(binder, &binding.SimpleBindItem[any]{
 				Path:          domainPath + "/update",
 				ResponseFunc:  response.SendMsgResponse,
 				RequestParams: simple.UpdateJsonBody,
 				Objects:       []domain.Object{simple.Entity},
-				ServiceFunc:   UpdateTx(tableName, options.updateCallbacks),
-			}, options.updateMiddlewares...)
+				ServiceFunc:   UpdateTx(tableName, updateOptions.updateCallbacks),
+			}, updateOptions.updateMiddlewares...)
 		}
 	}
 
 	// 查询
-	if !options.disableQuery {
+	if !queryOptions.disableQuery {
 		binding.GetBind(binder, &binding.SimpleBindItem[response.InfosData[I]]{
 			Path:          domainPath + "/query",
 			ResponseFunc:  response.SendInfosResponse[I],
 			RequestParams: simple.QueryQueryParams,
 			Objects:       []domain.Object{simple.Entity},
-			ServiceFunc:   Query[I](tableName, options.queryCallbacks, options.queryConditionFieldCallback),
-		}, options.queryMiddlewares...)
+			ServiceFunc:   Query[I](tableName, queryOptions.queryCallbacks, queryOptions.queryConditionFieldCallback),
+		}, queryOptions.queryMiddlewares...)
 	}
 
 	// 通过ID获取
-	if !options.disableQueryByID {
+	if !queryByIDOptions.disableQueryByID {
 		binding.GetBind(binder, &binding.SimpleBindItem[I]{
 			Path:          domainPath + "/get",
 			ResponseFunc:  response.SendInfoResponse[I],
 			RequestParams: simple.GetByIDQueryParams,
 			Objects:       []domain.Object{simple.Entity},
-			ServiceFunc:   GetByID[I](tableName, options.getByIDCallbacks),
-		}, options.getByIDMiddlewares...)
+			ServiceFunc:   GetByID[I](tableName, queryByIDOptions.getByIDCallbacks),
+		}, queryByIDOptions.getByIDMiddlewares...)
 	}
 }
 
-func BindSimple[I any](binder *binding.Binder, simple *Simple[I], opts ...Option[I]) {
-	options := new(Options[I])
+func BindSimple[I any](binder *binding.Binder, simple *Simple[I], opts ...any) {
+	createOptions := new(CreateOptions)
+	deleteOptions := new(DeleteOptions)
+	updateOptions := new(UpdateOptions)
+	queryOptions := new(QueryOptions[I])
+	queryByIDOptions := new(QueryByIDOptions[I])
 
 	for _, opt := range opts {
-		opt(options)
+		switch o := opt.(type) {
+		case CreateOption:
+			o(createOptions)
+		case DeleteOption:
+			o(deleteOptions)
+		case UpdateOption:
+			o(updateOptions)
+		case QueryOption[I]:
+			o(queryOptions)
+		case QueryByIDOption[I]:
+			o(queryByIDOptions)
+		default:
+			continue
+		}
 	}
 
-	simple.options = options
+	simple.createOptions = createOptions
+	simple.deleteOptions = deleteOptions
+	simple.updateOptions = updateOptions
+	simple.queryOptions = queryOptions
+	simple.queryByIDOptions = queryByIDOptions
 
 	simple.bind(binder)
 }
 
-type Option[I any] func(options *Options[I])
+type CreateOption func(options *CreateOptions)
+type DeleteOption func(options *DeleteOptions)
+type UpdateOption func(options *UpdateOptions)
+type QueryOption[I any] func(options *QueryOptions[I])
+type QueryByIDOption[I any] func(options *QueryByIDOptions[I])
 
-type Options[I any] struct {
+type CreateOptions struct {
 	// 关闭创建
 	disableCreate bool
 
@@ -151,11 +184,13 @@ type Options[I any] struct {
 	createNeedTx bool
 
 	// 创建回调
-	createCallbacks *Callbacks[string]
+	createCallbacks *CreateCallbacks
 
 	// 创建中间件
 	createMiddlewares []api.Handler
+}
 
+type DeleteOptions struct {
 	// 关闭删除
 	disableDelete bool
 
@@ -163,11 +198,13 @@ type Options[I any] struct {
 	deleteNeedTx bool
 
 	// 删除回调
-	deleteCallbacks *Callbacks[any]
+	deleteCallbacks *DeleteCallbacks
 
 	// 删除中间件
 	deleteMiddlewares []api.Handler
+}
 
+type UpdateOptions struct {
 	// 关闭更新
 	disableUpdate bool
 
@@ -175,11 +212,13 @@ type Options[I any] struct {
 	updateNeedTx bool
 
 	// 更新回调
-	updateCallbacks *Callbacks[any]
+	updateCallbacks *UpdateCallbacks
 
 	// 更新中间件
 	updateMiddlewares []api.Handler
+}
 
+type QueryOptions[I any] struct {
 	// 关闭查询
 	disableQuery bool
 
@@ -187,131 +226,133 @@ type Options[I any] struct {
 	queryConditionFieldCallback ConditionFieldCallback
 
 	// 查询回调
-	queryCallbacks *Callbacks[response.InfosData[I]]
+	queryCallbacks *QueryCallbacks[I]
 
 	// 查询中间件
 	queryMiddlewares []api.Handler
+}
 
+type QueryByIDOptions[I any] struct {
 	// 关闭根据ID查询
 	disableQueryByID bool
 
 	// 根据ID查询回调
-	getByIDCallbacks *Callbacks[I]
+	getByIDCallbacks *QueryByIDCallbacks[I]
 
 	// 根据ID查询中间件
 	getByIDMiddlewares []api.Handler
 }
 
-func WithDisableCreate[I any]() Option[I] {
-	return func(options *Options[I]) {
+func WithDisableCreate() CreateOption {
+	return func(options *CreateOptions) {
 		options.disableCreate = true
 	}
 }
 
-func WithCreateTx[I any]() Option[I] {
-	return func(options *Options[I]) {
+func WithCreateTx() CreateOption {
+	return func(options *CreateOptions) {
 		options.createNeedTx = true
 	}
 }
 
-func WithCreateCallbacks[I any](callbacks *Callbacks[string]) Option[I] {
-	return func(options *Options[I]) {
+func WithCreateCallbacks(callbacks *CreateCallbacks) CreateOption {
+	return func(options *CreateOptions) {
 		options.createCallbacks = callbacks
 	}
 }
 
-func WithCreateMiddlewares[I any](middlewares []api.Handler) Option[I] {
-	return func(options *Options[I]) {
+func WithCreateMiddlewares(middlewares []api.Handler) CreateOption {
+	return func(options *CreateOptions) {
 		options.createMiddlewares = middlewares
 	}
 }
 
-func WithDisableDelete[I any]() Option[I] {
-	return func(options *Options[I]) {
+func WithDisableDelete() DeleteOption {
+	return func(options *DeleteOptions) {
 		options.disableDelete = true
 	}
 }
 
-func WithDeleteTx[I any]() Option[I] {
-	return func(options *Options[I]) {
+func WithDeleteTx() DeleteOption {
+	return func(options *DeleteOptions) {
 		options.deleteNeedTx = true
 	}
 }
 
-func WithDeleteCallbacks[I any](callbacks *Callbacks[any]) Option[I] {
-	return func(options *Options[I]) {
+func WithDeleteCallbacks(callbacks *DeleteCallbacks) DeleteOption {
+	return func(options *DeleteOptions) {
 		options.deleteCallbacks = callbacks
 	}
 }
 
-func WithDeleteMiddlewares[I any](middlewares []api.Handler) Option[I] {
-	return func(options *Options[I]) {
+func WithDeleteMiddlewares(middlewares []api.Handler) DeleteOption {
+	return func(options *DeleteOptions) {
 		options.deleteMiddlewares = middlewares
 	}
 }
 
-func WithDisableUpdate[I any]() Option[I] {
-	return func(options *Options[I]) {
+func WithDisableUpdate() UpdateOption {
+	return func(options *UpdateOptions) {
 		options.disableUpdate = true
 	}
 }
 
-func WithUpdateTx[I any]() Option[I] {
-	return func(options *Options[I]) {
+func WithUpdateTx() UpdateOption {
+	return func(options *UpdateOptions) {
 		options.updateNeedTx = true
 	}
 }
 
-func WithUpdateCallbacks[I any](callbacks *Callbacks[any]) Option[I] {
-	return func(options *Options[I]) {
+func WithUpdateCallbacks(callbacks *UpdateCallbacks) UpdateOption {
+	return func(options *UpdateOptions) {
 		options.updateCallbacks = callbacks
 	}
 }
 
-func WithUpdateMiddlewares[I any](middlewares []api.Handler) Option[I] {
-	return func(options *Options[I]) {
+func WithUpdateMiddlewares(middlewares []api.Handler) UpdateOption {
+	return func(options *UpdateOptions) {
 		options.updateMiddlewares = middlewares
 	}
 }
 
-func WithDisableQuery[I any]() Option[I] {
-	return func(options *Options[I]) {
+func WithDisableQuery[I any]() QueryOption[I] {
+	return func(options *QueryOptions[I]) {
 		options.disableQuery = true
 	}
 }
 
-func WithQueryConditionFieldCallback[I any](callback ConditionFieldCallback) Option[I] {
-	return func(options *Options[I]) {
+func WithQueryConditionFieldCallback[I any](callback ConditionFieldCallback) QueryOption[I] {
+	return func(options *QueryOptions[I]) {
 		options.queryConditionFieldCallback = callback
 	}
 }
 
-func WithQueryCallbacks[I any](callbacks *Callbacks[response.InfosData[I]]) Option[I] {
-	return func(options *Options[I]) {
+func WithQueryCallbacks[I any](callbacks *QueryCallbacks[I]) QueryOption[I] {
+	return func(options *QueryOptions[I]) {
 		options.queryCallbacks = callbacks
 	}
 }
 
-func WithQueryMiddlewares[I any](middlewares []api.Handler) Option[I] {
-	return func(options *Options[I]) {
+func WithQueryMiddlewares[I any](middlewares []api.Handler) QueryOption[I] {
+	return func(options *QueryOptions[I]) {
 		options.queryMiddlewares = middlewares
 	}
 }
 
-func WithDisableQueryByID[I any]() Option[I] {
-	return func(options *Options[I]) {
+func WithDisableQueryByID[I any]() QueryByIDOption[I] {
+	return func(options *QueryByIDOptions[I]) {
 		options.disableQueryByID = true
 	}
 }
 
-func WithGetByIDCallbacks[I any](callbacks *Callbacks[I]) Option[I] {
-	return func(options *Options[I]) {
+func WithGetByIDCallbacks[I any](callbacks *QueryByIDCallbacks[I]) QueryByIDOption[I] {
+	return func(options *QueryByIDOptions[I]) {
 		options.getByIDCallbacks = callbacks
 	}
 }
 
-func WithGetByIDMiddlewares[I any](middlewares []api.Handler) Option[I] {
-	return func(options *Options[I]) {
+func WithGetByIDMiddlewares[I any](middlewares []api.Handler) QueryByIDOption[I] {
+	return func(options *QueryByIDOptions[I]) {
 		options.getByIDMiddlewares = middlewares
 	}
 }