From 6f4caba410ddf2611394af5ca795123e684f215b Mon Sep 17 00:00:00 2001 From: Daniil Kukharau Date: Sat, 2 Feb 2019 00:31:57 +0300 Subject: [PATCH] Fix collision with gorm hooks (#155) --- .../feature_demo/demo_multi_file.pb.gorm.go | 64 ++--- example/feature_demo/demo_service.pb.gorm.go | 64 ++--- example/feature_demo/demo_types.pb.gorm.go | 224 +++++++++--------- example/user/user.pb.gorm.go | 176 +++++++------- plugin/handlergen.go | 22 +- 5 files changed, 276 insertions(+), 274 deletions(-) diff --git a/example/feature_demo/demo_multi_file.pb.gorm.go b/example/feature_demo/demo_multi_file.pb.gorm.go index 0b198f93..bd1477d2 100644 --- a/example/feature_demo/demo_multi_file.pb.gorm.go +++ b/example/feature_demo/demo_multi_file.pb.gorm.go @@ -211,16 +211,16 @@ func DefaultCreateExternalChild(ctx context.Context, in *ExternalChild, db *gorm if err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(ExternalChildORMWithBeforeCreate); ok { - if db, err = hook.BeforeCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(ExternalChildORMWithBeforeCreate_); ok { + if db, err = hook.BeforeCreate_(ctx, db); err != nil { return nil, err } } if err = db.Create(&ormObj).Error; err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(ExternalChildORMWithAfterCreate); ok { - if err = hook.AfterCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(ExternalChildORMWithAfterCreate_); ok { + if err = hook.AfterCreate_(ctx, db); err != nil { return nil, err } } @@ -228,11 +228,11 @@ func DefaultCreateExternalChild(ctx context.Context, in *ExternalChild, db *gorm return &pbResponse, err } -type ExternalChildORMWithBeforeCreate interface { - BeforeCreate(context.Context, *gorm1.DB) (*gorm1.DB, error) +type ExternalChildORMWithBeforeCreate_ interface { + BeforeCreate_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type ExternalChildORMWithAfterCreate interface { - AfterCreate(context.Context, *gorm1.DB) error +type ExternalChildORMWithAfterCreate_ interface { + AfterCreate_(context.Context, *gorm1.DB) error } // DefaultReadExternalChild executes a basic gorm read call @@ -294,8 +294,8 @@ func DefaultDeleteExternalChild(ctx context.Context, in *ExternalChild, db *gorm if ormObj.Id == "" { return errors.New("A non-zero ID value is required for a delete call") } - if hook, ok := interface{}(&ormObj).(ExternalChildORMWithBeforeDelete); ok { - if db, err = hook.BeforeDelete(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(ExternalChildORMWithBeforeDelete_); ok { + if db, err = hook.BeforeDelete_(ctx, db); err != nil { return err } } @@ -303,17 +303,17 @@ func DefaultDeleteExternalChild(ctx context.Context, in *ExternalChild, db *gorm if err != nil { return err } - if hook, ok := interface{}(&ormObj).(ExternalChildORMWithAfterDelete); ok { - err = hook.AfterDelete(ctx, db) + if hook, ok := interface{}(&ormObj).(ExternalChildORMWithAfterDelete_); ok { + err = hook.AfterDelete_(ctx, db) } return err } -type ExternalChildORMWithBeforeDelete interface { - BeforeDelete(context.Context, *gorm1.DB) (*gorm1.DB, error) +type ExternalChildORMWithBeforeDelete_ interface { + BeforeDelete_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type ExternalChildORMWithAfterDelete interface { - AfterDelete(context.Context, *gorm1.DB) error +type ExternalChildORMWithAfterDelete_ interface { + AfterDelete_(context.Context, *gorm1.DB) error } func DefaultDeleteExternalChildSet(ctx context.Context, in []*ExternalChild, db *gorm1.DB) error { @@ -541,16 +541,16 @@ func DefaultCreateBlogPost(ctx context.Context, in *BlogPost, db *gorm1.DB) (*Bl if err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(BlogPostORMWithBeforeCreate); ok { - if db, err = hook.BeforeCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(BlogPostORMWithBeforeCreate_); ok { + if db, err = hook.BeforeCreate_(ctx, db); err != nil { return nil, err } } if err = db.Create(&ormObj).Error; err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(BlogPostORMWithAfterCreate); ok { - if err = hook.AfterCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(BlogPostORMWithAfterCreate_); ok { + if err = hook.AfterCreate_(ctx, db); err != nil { return nil, err } } @@ -558,11 +558,11 @@ func DefaultCreateBlogPost(ctx context.Context, in *BlogPost, db *gorm1.DB) (*Bl return &pbResponse, err } -type BlogPostORMWithBeforeCreate interface { - BeforeCreate(context.Context, *gorm1.DB) (*gorm1.DB, error) +type BlogPostORMWithBeforeCreate_ interface { + BeforeCreate_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type BlogPostORMWithAfterCreate interface { - AfterCreate(context.Context, *gorm1.DB) error +type BlogPostORMWithAfterCreate_ interface { + AfterCreate_(context.Context, *gorm1.DB) error } // DefaultReadBlogPost executes a basic gorm read call @@ -624,8 +624,8 @@ func DefaultDeleteBlogPost(ctx context.Context, in *BlogPost, db *gorm1.DB) erro if ormObj.Id == 0 { return errors.New("A non-zero ID value is required for a delete call") } - if hook, ok := interface{}(&ormObj).(BlogPostORMWithBeforeDelete); ok { - if db, err = hook.BeforeDelete(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(BlogPostORMWithBeforeDelete_); ok { + if db, err = hook.BeforeDelete_(ctx, db); err != nil { return err } } @@ -633,17 +633,17 @@ func DefaultDeleteBlogPost(ctx context.Context, in *BlogPost, db *gorm1.DB) erro if err != nil { return err } - if hook, ok := interface{}(&ormObj).(BlogPostORMWithAfterDelete); ok { - err = hook.AfterDelete(ctx, db) + if hook, ok := interface{}(&ormObj).(BlogPostORMWithAfterDelete_); ok { + err = hook.AfterDelete_(ctx, db) } return err } -type BlogPostORMWithBeforeDelete interface { - BeforeDelete(context.Context, *gorm1.DB) (*gorm1.DB, error) +type BlogPostORMWithBeforeDelete_ interface { + BeforeDelete_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type BlogPostORMWithAfterDelete interface { - AfterDelete(context.Context, *gorm1.DB) error +type BlogPostORMWithAfterDelete_ interface { + AfterDelete_(context.Context, *gorm1.DB) error } func DefaultDeleteBlogPostSet(ctx context.Context, in []*BlogPost, db *gorm1.DB) error { diff --git a/example/feature_demo/demo_service.pb.gorm.go b/example/feature_demo/demo_service.pb.gorm.go index d6ec2db7..e7a4ac79 100644 --- a/example/feature_demo/demo_service.pb.gorm.go +++ b/example/feature_demo/demo_service.pb.gorm.go @@ -235,16 +235,16 @@ func DefaultCreateIntPoint(ctx context.Context, in *IntPoint, db *gorm1.DB) (*In if err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(IntPointORMWithBeforeCreate); ok { - if db, err = hook.BeforeCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(IntPointORMWithBeforeCreate_); ok { + if db, err = hook.BeforeCreate_(ctx, db); err != nil { return nil, err } } if err = db.Create(&ormObj).Error; err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(IntPointORMWithAfterCreate); ok { - if err = hook.AfterCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(IntPointORMWithAfterCreate_); ok { + if err = hook.AfterCreate_(ctx, db); err != nil { return nil, err } } @@ -252,11 +252,11 @@ func DefaultCreateIntPoint(ctx context.Context, in *IntPoint, db *gorm1.DB) (*In return &pbResponse, err } -type IntPointORMWithBeforeCreate interface { - BeforeCreate(context.Context, *gorm1.DB) (*gorm1.DB, error) +type IntPointORMWithBeforeCreate_ interface { + BeforeCreate_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type IntPointORMWithAfterCreate interface { - AfterCreate(context.Context, *gorm1.DB) error +type IntPointORMWithAfterCreate_ interface { + AfterCreate_(context.Context, *gorm1.DB) error } // DefaultReadIntPoint executes a basic gorm read call @@ -318,8 +318,8 @@ func DefaultDeleteIntPoint(ctx context.Context, in *IntPoint, db *gorm1.DB) erro if ormObj.Id == 0 { return errors.New("A non-zero ID value is required for a delete call") } - if hook, ok := interface{}(&ormObj).(IntPointORMWithBeforeDelete); ok { - if db, err = hook.BeforeDelete(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(IntPointORMWithBeforeDelete_); ok { + if db, err = hook.BeforeDelete_(ctx, db); err != nil { return err } } @@ -327,17 +327,17 @@ func DefaultDeleteIntPoint(ctx context.Context, in *IntPoint, db *gorm1.DB) erro if err != nil { return err } - if hook, ok := interface{}(&ormObj).(IntPointORMWithAfterDelete); ok { - err = hook.AfterDelete(ctx, db) + if hook, ok := interface{}(&ormObj).(IntPointORMWithAfterDelete_); ok { + err = hook.AfterDelete_(ctx, db) } return err } -type IntPointORMWithBeforeDelete interface { - BeforeDelete(context.Context, *gorm1.DB) (*gorm1.DB, error) +type IntPointORMWithBeforeDelete_ interface { + BeforeDelete_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type IntPointORMWithAfterDelete interface { - AfterDelete(context.Context, *gorm1.DB) error +type IntPointORMWithAfterDelete_ interface { + AfterDelete_(context.Context, *gorm1.DB) error } func DefaultDeleteIntPointSet(ctx context.Context, in []*IntPoint, db *gorm1.DB) error { @@ -573,16 +573,16 @@ func DefaultCreateSomething(ctx context.Context, in *Something, db *gorm1.DB) (* if err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(SomethingORMWithBeforeCreate); ok { - if db, err = hook.BeforeCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(SomethingORMWithBeforeCreate_); ok { + if db, err = hook.BeforeCreate_(ctx, db); err != nil { return nil, err } } if err = db.Create(&ormObj).Error; err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(SomethingORMWithAfterCreate); ok { - if err = hook.AfterCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(SomethingORMWithAfterCreate_); ok { + if err = hook.AfterCreate_(ctx, db); err != nil { return nil, err } } @@ -590,11 +590,11 @@ func DefaultCreateSomething(ctx context.Context, in *Something, db *gorm1.DB) (* return &pbResponse, err } -type SomethingORMWithBeforeCreate interface { - BeforeCreate(context.Context, *gorm1.DB) (*gorm1.DB, error) +type SomethingORMWithBeforeCreate_ interface { + BeforeCreate_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type SomethingORMWithAfterCreate interface { - AfterCreate(context.Context, *gorm1.DB) error +type SomethingORMWithAfterCreate_ interface { + AfterCreate_(context.Context, *gorm1.DB) error } // DefaultApplyFieldMaskSomething patches an pbObject with patcher according to a field mask. @@ -678,16 +678,16 @@ func DefaultCreateCircle(ctx context.Context, in *Circle, db *gorm1.DB) (*Circle if err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(CircleORMWithBeforeCreate); ok { - if db, err = hook.BeforeCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(CircleORMWithBeforeCreate_); ok { + if db, err = hook.BeforeCreate_(ctx, db); err != nil { return nil, err } } if err = db.Create(&ormObj).Error; err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(CircleORMWithAfterCreate); ok { - if err = hook.AfterCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(CircleORMWithAfterCreate_); ok { + if err = hook.AfterCreate_(ctx, db); err != nil { return nil, err } } @@ -695,11 +695,11 @@ func DefaultCreateCircle(ctx context.Context, in *Circle, db *gorm1.DB) (*Circle return &pbResponse, err } -type CircleORMWithBeforeCreate interface { - BeforeCreate(context.Context, *gorm1.DB) (*gorm1.DB, error) +type CircleORMWithBeforeCreate_ interface { + BeforeCreate_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type CircleORMWithAfterCreate interface { - AfterCreate(context.Context, *gorm1.DB) error +type CircleORMWithAfterCreate_ interface { + AfterCreate_(context.Context, *gorm1.DB) error } // DefaultApplyFieldMaskCircle patches an pbObject with patcher according to a field mask. diff --git a/example/feature_demo/demo_types.pb.gorm.go b/example/feature_demo/demo_types.pb.gorm.go index 4f86dfef..efa759af 100644 --- a/example/feature_demo/demo_types.pb.gorm.go +++ b/example/feature_demo/demo_types.pb.gorm.go @@ -875,16 +875,16 @@ func DefaultCreateTestTypes(ctx context.Context, in *TestTypes, db *gorm1.DB) (* if err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(TestTypesORMWithBeforeCreate); ok { - if db, err = hook.BeforeCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(TestTypesORMWithBeforeCreate_); ok { + if db, err = hook.BeforeCreate_(ctx, db); err != nil { return nil, err } } if err = db.Create(&ormObj).Error; err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(TestTypesORMWithAfterCreate); ok { - if err = hook.AfterCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(TestTypesORMWithAfterCreate_); ok { + if err = hook.AfterCreate_(ctx, db); err != nil { return nil, err } } @@ -892,11 +892,11 @@ func DefaultCreateTestTypes(ctx context.Context, in *TestTypes, db *gorm1.DB) (* return &pbResponse, err } -type TestTypesORMWithBeforeCreate interface { - BeforeCreate(context.Context, *gorm1.DB) (*gorm1.DB, error) +type TestTypesORMWithBeforeCreate_ interface { + BeforeCreate_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type TestTypesORMWithAfterCreate interface { - AfterCreate(context.Context, *gorm1.DB) error +type TestTypesORMWithAfterCreate_ interface { + AfterCreate_(context.Context, *gorm1.DB) error } // DefaultApplyFieldMaskTestTypes patches an pbObject with patcher according to a field mask. @@ -1016,16 +1016,16 @@ func DefaultCreateTypeWithID(ctx context.Context, in *TypeWithID, db *gorm1.DB) if err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(TypeWithIDORMWithBeforeCreate); ok { - if db, err = hook.BeforeCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(TypeWithIDORMWithBeforeCreate_); ok { + if db, err = hook.BeforeCreate_(ctx, db); err != nil { return nil, err } } if err = db.Create(&ormObj).Error; err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(TypeWithIDORMWithAfterCreate); ok { - if err = hook.AfterCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(TypeWithIDORMWithAfterCreate_); ok { + if err = hook.AfterCreate_(ctx, db); err != nil { return nil, err } } @@ -1033,11 +1033,11 @@ func DefaultCreateTypeWithID(ctx context.Context, in *TypeWithID, db *gorm1.DB) return &pbResponse, err } -type TypeWithIDORMWithBeforeCreate interface { - BeforeCreate(context.Context, *gorm1.DB) (*gorm1.DB, error) +type TypeWithIDORMWithBeforeCreate_ interface { + BeforeCreate_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type TypeWithIDORMWithAfterCreate interface { - AfterCreate(context.Context, *gorm1.DB) error +type TypeWithIDORMWithAfterCreate_ interface { + AfterCreate_(context.Context, *gorm1.DB) error } // DefaultReadTypeWithID executes a basic gorm read call @@ -1099,8 +1099,8 @@ func DefaultDeleteTypeWithID(ctx context.Context, in *TypeWithID, db *gorm1.DB) if ormObj.Id == 0 { return errors.New("A non-zero ID value is required for a delete call") } - if hook, ok := interface{}(&ormObj).(TypeWithIDORMWithBeforeDelete); ok { - if db, err = hook.BeforeDelete(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(TypeWithIDORMWithBeforeDelete_); ok { + if db, err = hook.BeforeDelete_(ctx, db); err != nil { return err } } @@ -1108,17 +1108,17 @@ func DefaultDeleteTypeWithID(ctx context.Context, in *TypeWithID, db *gorm1.DB) if err != nil { return err } - if hook, ok := interface{}(&ormObj).(TypeWithIDORMWithAfterDelete); ok { - err = hook.AfterDelete(ctx, db) + if hook, ok := interface{}(&ormObj).(TypeWithIDORMWithAfterDelete_); ok { + err = hook.AfterDelete_(ctx, db) } return err } -type TypeWithIDORMWithBeforeDelete interface { - BeforeDelete(context.Context, *gorm1.DB) (*gorm1.DB, error) +type TypeWithIDORMWithBeforeDelete_ interface { + BeforeDelete_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type TypeWithIDORMWithAfterDelete interface { - AfterDelete(context.Context, *gorm1.DB) error +type TypeWithIDORMWithAfterDelete_ interface { + AfterDelete_(context.Context, *gorm1.DB) error } func DefaultDeleteTypeWithIDSet(ctx context.Context, in []*TypeWithID, db *gorm1.DB) error { @@ -1486,16 +1486,16 @@ func DefaultCreateMultiaccountTypeWithID(ctx context.Context, in *MultiaccountTy if err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithIDORMWithBeforeCreate); ok { - if db, err = hook.BeforeCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithIDORMWithBeforeCreate_); ok { + if db, err = hook.BeforeCreate_(ctx, db); err != nil { return nil, err } } if err = db.Create(&ormObj).Error; err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithIDORMWithAfterCreate); ok { - if err = hook.AfterCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithIDORMWithAfterCreate_); ok { + if err = hook.AfterCreate_(ctx, db); err != nil { return nil, err } } @@ -1503,11 +1503,11 @@ func DefaultCreateMultiaccountTypeWithID(ctx context.Context, in *MultiaccountTy return &pbResponse, err } -type MultiaccountTypeWithIDORMWithBeforeCreate interface { - BeforeCreate(context.Context, *gorm1.DB) (*gorm1.DB, error) +type MultiaccountTypeWithIDORMWithBeforeCreate_ interface { + BeforeCreate_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type MultiaccountTypeWithIDORMWithAfterCreate interface { - AfterCreate(context.Context, *gorm1.DB) error +type MultiaccountTypeWithIDORMWithAfterCreate_ interface { + AfterCreate_(context.Context, *gorm1.DB) error } // DefaultReadMultiaccountTypeWithID executes a basic gorm read call @@ -1569,8 +1569,8 @@ func DefaultDeleteMultiaccountTypeWithID(ctx context.Context, in *MultiaccountTy if ormObj.Id == 0 { return errors.New("A non-zero ID value is required for a delete call") } - if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithIDORMWithBeforeDelete); ok { - if db, err = hook.BeforeDelete(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithIDORMWithBeforeDelete_); ok { + if db, err = hook.BeforeDelete_(ctx, db); err != nil { return err } } @@ -1578,17 +1578,17 @@ func DefaultDeleteMultiaccountTypeWithID(ctx context.Context, in *MultiaccountTy if err != nil { return err } - if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithIDORMWithAfterDelete); ok { - err = hook.AfterDelete(ctx, db) + if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithIDORMWithAfterDelete_); ok { + err = hook.AfterDelete_(ctx, db) } return err } -type MultiaccountTypeWithIDORMWithBeforeDelete interface { - BeforeDelete(context.Context, *gorm1.DB) (*gorm1.DB, error) +type MultiaccountTypeWithIDORMWithBeforeDelete_ interface { + BeforeDelete_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type MultiaccountTypeWithIDORMWithAfterDelete interface { - AfterDelete(context.Context, *gorm1.DB) error +type MultiaccountTypeWithIDORMWithAfterDelete_ interface { + AfterDelete_(context.Context, *gorm1.DB) error } func DefaultDeleteMultiaccountTypeWithIDSet(ctx context.Context, in []*MultiaccountTypeWithID, db *gorm1.DB) error { @@ -1829,16 +1829,16 @@ func DefaultCreateMultiaccountTypeWithoutID(ctx context.Context, in *Multiaccoun if err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithoutIDORMWithBeforeCreate); ok { - if db, err = hook.BeforeCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithoutIDORMWithBeforeCreate_); ok { + if db, err = hook.BeforeCreate_(ctx, db); err != nil { return nil, err } } if err = db.Create(&ormObj).Error; err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithoutIDORMWithAfterCreate); ok { - if err = hook.AfterCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithoutIDORMWithAfterCreate_); ok { + if err = hook.AfterCreate_(ctx, db); err != nil { return nil, err } } @@ -1846,11 +1846,11 @@ func DefaultCreateMultiaccountTypeWithoutID(ctx context.Context, in *Multiaccoun return &pbResponse, err } -type MultiaccountTypeWithoutIDORMWithBeforeCreate interface { - BeforeCreate(context.Context, *gorm1.DB) (*gorm1.DB, error) +type MultiaccountTypeWithoutIDORMWithBeforeCreate_ interface { + BeforeCreate_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type MultiaccountTypeWithoutIDORMWithAfterCreate interface { - AfterCreate(context.Context, *gorm1.DB) error +type MultiaccountTypeWithoutIDORMWithAfterCreate_ interface { + AfterCreate_(context.Context, *gorm1.DB) error } // DefaultApplyFieldMaskMultiaccountTypeWithoutID patches an pbObject with patcher according to a field mask. @@ -1934,16 +1934,16 @@ func DefaultCreatePrimaryUUIDType(ctx context.Context, in *PrimaryUUIDType, db * if err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(PrimaryUUIDTypeORMWithBeforeCreate); ok { - if db, err = hook.BeforeCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(PrimaryUUIDTypeORMWithBeforeCreate_); ok { + if db, err = hook.BeforeCreate_(ctx, db); err != nil { return nil, err } } if err = db.Create(&ormObj).Error; err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(PrimaryUUIDTypeORMWithAfterCreate); ok { - if err = hook.AfterCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(PrimaryUUIDTypeORMWithAfterCreate_); ok { + if err = hook.AfterCreate_(ctx, db); err != nil { return nil, err } } @@ -1951,11 +1951,11 @@ func DefaultCreatePrimaryUUIDType(ctx context.Context, in *PrimaryUUIDType, db * return &pbResponse, err } -type PrimaryUUIDTypeORMWithBeforeCreate interface { - BeforeCreate(context.Context, *gorm1.DB) (*gorm1.DB, error) +type PrimaryUUIDTypeORMWithBeforeCreate_ interface { + BeforeCreate_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type PrimaryUUIDTypeORMWithAfterCreate interface { - AfterCreate(context.Context, *gorm1.DB) error +type PrimaryUUIDTypeORMWithAfterCreate_ interface { + AfterCreate_(context.Context, *gorm1.DB) error } // DefaultReadPrimaryUUIDType executes a basic gorm read call @@ -2017,8 +2017,8 @@ func DefaultDeletePrimaryUUIDType(ctx context.Context, in *PrimaryUUIDType, db * if ormObj.Id == nil || *ormObj.Id == go_uuid1.Nil { return errors.New("A non-zero ID value is required for a delete call") } - if hook, ok := interface{}(&ormObj).(PrimaryUUIDTypeORMWithBeforeDelete); ok { - if db, err = hook.BeforeDelete(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(PrimaryUUIDTypeORMWithBeforeDelete_); ok { + if db, err = hook.BeforeDelete_(ctx, db); err != nil { return err } } @@ -2026,17 +2026,17 @@ func DefaultDeletePrimaryUUIDType(ctx context.Context, in *PrimaryUUIDType, db * if err != nil { return err } - if hook, ok := interface{}(&ormObj).(PrimaryUUIDTypeORMWithAfterDelete); ok { - err = hook.AfterDelete(ctx, db) + if hook, ok := interface{}(&ormObj).(PrimaryUUIDTypeORMWithAfterDelete_); ok { + err = hook.AfterDelete_(ctx, db) } return err } -type PrimaryUUIDTypeORMWithBeforeDelete interface { - BeforeDelete(context.Context, *gorm1.DB) (*gorm1.DB, error) +type PrimaryUUIDTypeORMWithBeforeDelete_ interface { + BeforeDelete_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type PrimaryUUIDTypeORMWithAfterDelete interface { - AfterDelete(context.Context, *gorm1.DB) error +type PrimaryUUIDTypeORMWithAfterDelete_ interface { + AfterDelete_(context.Context, *gorm1.DB) error } func DefaultDeletePrimaryUUIDTypeSet(ctx context.Context, in []*PrimaryUUIDType, db *gorm1.DB) error { @@ -2295,16 +2295,16 @@ func DefaultCreatePrimaryStringType(ctx context.Context, in *PrimaryStringType, if err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(PrimaryStringTypeORMWithBeforeCreate); ok { - if db, err = hook.BeforeCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(PrimaryStringTypeORMWithBeforeCreate_); ok { + if db, err = hook.BeforeCreate_(ctx, db); err != nil { return nil, err } } if err = db.Create(&ormObj).Error; err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(PrimaryStringTypeORMWithAfterCreate); ok { - if err = hook.AfterCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(PrimaryStringTypeORMWithAfterCreate_); ok { + if err = hook.AfterCreate_(ctx, db); err != nil { return nil, err } } @@ -2312,11 +2312,11 @@ func DefaultCreatePrimaryStringType(ctx context.Context, in *PrimaryStringType, return &pbResponse, err } -type PrimaryStringTypeORMWithBeforeCreate interface { - BeforeCreate(context.Context, *gorm1.DB) (*gorm1.DB, error) +type PrimaryStringTypeORMWithBeforeCreate_ interface { + BeforeCreate_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type PrimaryStringTypeORMWithAfterCreate interface { - AfterCreate(context.Context, *gorm1.DB) error +type PrimaryStringTypeORMWithAfterCreate_ interface { + AfterCreate_(context.Context, *gorm1.DB) error } // DefaultReadPrimaryStringType executes a basic gorm read call @@ -2378,8 +2378,8 @@ func DefaultDeletePrimaryStringType(ctx context.Context, in *PrimaryStringType, if ormObj.Id == "" { return errors.New("A non-zero ID value is required for a delete call") } - if hook, ok := interface{}(&ormObj).(PrimaryStringTypeORMWithBeforeDelete); ok { - if db, err = hook.BeforeDelete(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(PrimaryStringTypeORMWithBeforeDelete_); ok { + if db, err = hook.BeforeDelete_(ctx, db); err != nil { return err } } @@ -2387,17 +2387,17 @@ func DefaultDeletePrimaryStringType(ctx context.Context, in *PrimaryStringType, if err != nil { return err } - if hook, ok := interface{}(&ormObj).(PrimaryStringTypeORMWithAfterDelete); ok { - err = hook.AfterDelete(ctx, db) + if hook, ok := interface{}(&ormObj).(PrimaryStringTypeORMWithAfterDelete_); ok { + err = hook.AfterDelete_(ctx, db) } return err } -type PrimaryStringTypeORMWithBeforeDelete interface { - BeforeDelete(context.Context, *gorm1.DB) (*gorm1.DB, error) +type PrimaryStringTypeORMWithBeforeDelete_ interface { + BeforeDelete_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type PrimaryStringTypeORMWithAfterDelete interface { - AfterDelete(context.Context, *gorm1.DB) error +type PrimaryStringTypeORMWithAfterDelete_ interface { + AfterDelete_(context.Context, *gorm1.DB) error } func DefaultDeletePrimaryStringTypeSet(ctx context.Context, in []*PrimaryStringType, db *gorm1.DB) error { @@ -2656,16 +2656,16 @@ func DefaultCreateTestTag(ctx context.Context, in *TestTag, db *gorm1.DB) (*Test if err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(TestTagORMWithBeforeCreate); ok { - if db, err = hook.BeforeCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(TestTagORMWithBeforeCreate_); ok { + if db, err = hook.BeforeCreate_(ctx, db); err != nil { return nil, err } } if err = db.Create(&ormObj).Error; err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(TestTagORMWithAfterCreate); ok { - if err = hook.AfterCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(TestTagORMWithAfterCreate_); ok { + if err = hook.AfterCreate_(ctx, db); err != nil { return nil, err } } @@ -2673,11 +2673,11 @@ func DefaultCreateTestTag(ctx context.Context, in *TestTag, db *gorm1.DB) (*Test return &pbResponse, err } -type TestTagORMWithBeforeCreate interface { - BeforeCreate(context.Context, *gorm1.DB) (*gorm1.DB, error) +type TestTagORMWithBeforeCreate_ interface { + BeforeCreate_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type TestTagORMWithAfterCreate interface { - AfterCreate(context.Context, *gorm1.DB) error +type TestTagORMWithAfterCreate_ interface { + AfterCreate_(context.Context, *gorm1.DB) error } // DefaultReadTestTag executes a basic gorm read call @@ -2739,8 +2739,8 @@ func DefaultDeleteTestTag(ctx context.Context, in *TestTag, db *gorm1.DB) error if ormObj.Id == "" { return errors.New("A non-zero ID value is required for a delete call") } - if hook, ok := interface{}(&ormObj).(TestTagORMWithBeforeDelete); ok { - if db, err = hook.BeforeDelete(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(TestTagORMWithBeforeDelete_); ok { + if db, err = hook.BeforeDelete_(ctx, db); err != nil { return err } } @@ -2748,17 +2748,17 @@ func DefaultDeleteTestTag(ctx context.Context, in *TestTag, db *gorm1.DB) error if err != nil { return err } - if hook, ok := interface{}(&ormObj).(TestTagORMWithAfterDelete); ok { - err = hook.AfterDelete(ctx, db) + if hook, ok := interface{}(&ormObj).(TestTagORMWithAfterDelete_); ok { + err = hook.AfterDelete_(ctx, db) } return err } -type TestTagORMWithBeforeDelete interface { - BeforeDelete(context.Context, *gorm1.DB) (*gorm1.DB, error) +type TestTagORMWithBeforeDelete_ interface { + BeforeDelete_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type TestTagORMWithAfterDelete interface { - AfterDelete(context.Context, *gorm1.DB) error +type TestTagORMWithAfterDelete_ interface { + AfterDelete_(context.Context, *gorm1.DB) error } func DefaultDeleteTestTagSet(ctx context.Context, in []*TestTag, db *gorm1.DB) error { @@ -3017,16 +3017,16 @@ func DefaultCreateTestTagAssociation(ctx context.Context, in *TestTagAssociation if err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(TestTagAssociationORMWithBeforeCreate); ok { - if db, err = hook.BeforeCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(TestTagAssociationORMWithBeforeCreate_); ok { + if db, err = hook.BeforeCreate_(ctx, db); err != nil { return nil, err } } if err = db.Create(&ormObj).Error; err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(TestTagAssociationORMWithAfterCreate); ok { - if err = hook.AfterCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(TestTagAssociationORMWithAfterCreate_); ok { + if err = hook.AfterCreate_(ctx, db); err != nil { return nil, err } } @@ -3034,11 +3034,11 @@ func DefaultCreateTestTagAssociation(ctx context.Context, in *TestTagAssociation return &pbResponse, err } -type TestTagAssociationORMWithBeforeCreate interface { - BeforeCreate(context.Context, *gorm1.DB) (*gorm1.DB, error) +type TestTagAssociationORMWithBeforeCreate_ interface { + BeforeCreate_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type TestTagAssociationORMWithAfterCreate interface { - AfterCreate(context.Context, *gorm1.DB) error +type TestTagAssociationORMWithAfterCreate_ interface { + AfterCreate_(context.Context, *gorm1.DB) error } // DefaultApplyFieldMaskTestTagAssociation patches an pbObject with patcher according to a field mask. @@ -3122,16 +3122,16 @@ func DefaultCreatePrimaryIncluded(ctx context.Context, in *PrimaryIncluded, db * if err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(PrimaryIncludedORMWithBeforeCreate); ok { - if db, err = hook.BeforeCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(PrimaryIncludedORMWithBeforeCreate_); ok { + if db, err = hook.BeforeCreate_(ctx, db); err != nil { return nil, err } } if err = db.Create(&ormObj).Error; err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(PrimaryIncludedORMWithAfterCreate); ok { - if err = hook.AfterCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(PrimaryIncludedORMWithAfterCreate_); ok { + if err = hook.AfterCreate_(ctx, db); err != nil { return nil, err } } @@ -3139,11 +3139,11 @@ func DefaultCreatePrimaryIncluded(ctx context.Context, in *PrimaryIncluded, db * return &pbResponse, err } -type PrimaryIncludedORMWithBeforeCreate interface { - BeforeCreate(context.Context, *gorm1.DB) (*gorm1.DB, error) +type PrimaryIncludedORMWithBeforeCreate_ interface { + BeforeCreate_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type PrimaryIncludedORMWithAfterCreate interface { - AfterCreate(context.Context, *gorm1.DB) error +type PrimaryIncludedORMWithAfterCreate_ interface { + AfterCreate_(context.Context, *gorm1.DB) error } // DefaultApplyFieldMaskPrimaryIncluded patches an pbObject with patcher according to a field mask. diff --git a/example/user/user.pb.gorm.go b/example/user/user.pb.gorm.go index 3e83f8ca..8a24690a 100644 --- a/example/user/user.pb.gorm.go +++ b/example/user/user.pb.gorm.go @@ -855,16 +855,16 @@ func DefaultCreateUser(ctx context.Context, in *User, db *gorm1.DB) (*User, erro if err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(UserORMWithBeforeCreate); ok { - if db, err = hook.BeforeCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(UserORMWithBeforeCreate_); ok { + if db, err = hook.BeforeCreate_(ctx, db); err != nil { return nil, err } } if err = db.Create(&ormObj).Error; err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(UserORMWithAfterCreate); ok { - if err = hook.AfterCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(UserORMWithAfterCreate_); ok { + if err = hook.AfterCreate_(ctx, db); err != nil { return nil, err } } @@ -872,11 +872,11 @@ func DefaultCreateUser(ctx context.Context, in *User, db *gorm1.DB) (*User, erro return &pbResponse, err } -type UserORMWithBeforeCreate interface { - BeforeCreate(context.Context, *gorm1.DB) (*gorm1.DB, error) +type UserORMWithBeforeCreate_ interface { + BeforeCreate_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type UserORMWithAfterCreate interface { - AfterCreate(context.Context, *gorm1.DB) error +type UserORMWithAfterCreate_ interface { + AfterCreate_(context.Context, *gorm1.DB) error } // DefaultReadUser executes a basic gorm read call @@ -938,8 +938,8 @@ func DefaultDeleteUser(ctx context.Context, in *User, db *gorm1.DB) error { if ormObj.Id == "" { return errors.New("A non-zero ID value is required for a delete call") } - if hook, ok := interface{}(&ormObj).(UserORMWithBeforeDelete); ok { - if db, err = hook.BeforeDelete(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(UserORMWithBeforeDelete_); ok { + if db, err = hook.BeforeDelete_(ctx, db); err != nil { return err } } @@ -947,17 +947,17 @@ func DefaultDeleteUser(ctx context.Context, in *User, db *gorm1.DB) error { if err != nil { return err } - if hook, ok := interface{}(&ormObj).(UserORMWithAfterDelete); ok { - err = hook.AfterDelete(ctx, db) + if hook, ok := interface{}(&ormObj).(UserORMWithAfterDelete_); ok { + err = hook.AfterDelete_(ctx, db) } return err } -type UserORMWithBeforeDelete interface { - BeforeDelete(context.Context, *gorm1.DB) (*gorm1.DB, error) +type UserORMWithBeforeDelete_ interface { + BeforeDelete_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type UserORMWithAfterDelete interface { - AfterDelete(context.Context, *gorm1.DB) error +type UserORMWithAfterDelete_ interface { + AfterDelete_(context.Context, *gorm1.DB) error } func DefaultDeleteUserSet(ctx context.Context, in []*User, db *gorm1.DB) error { @@ -1324,16 +1324,16 @@ func DefaultCreateEmail(ctx context.Context, in *Email, db *gorm1.DB) (*Email, e if err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(EmailORMWithBeforeCreate); ok { - if db, err = hook.BeforeCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(EmailORMWithBeforeCreate_); ok { + if db, err = hook.BeforeCreate_(ctx, db); err != nil { return nil, err } } if err = db.Create(&ormObj).Error; err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(EmailORMWithAfterCreate); ok { - if err = hook.AfterCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(EmailORMWithAfterCreate_); ok { + if err = hook.AfterCreate_(ctx, db); err != nil { return nil, err } } @@ -1341,11 +1341,11 @@ func DefaultCreateEmail(ctx context.Context, in *Email, db *gorm1.DB) (*Email, e return &pbResponse, err } -type EmailORMWithBeforeCreate interface { - BeforeCreate(context.Context, *gorm1.DB) (*gorm1.DB, error) +type EmailORMWithBeforeCreate_ interface { + BeforeCreate_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type EmailORMWithAfterCreate interface { - AfterCreate(context.Context, *gorm1.DB) error +type EmailORMWithAfterCreate_ interface { + AfterCreate_(context.Context, *gorm1.DB) error } // DefaultReadEmail executes a basic gorm read call @@ -1407,8 +1407,8 @@ func DefaultDeleteEmail(ctx context.Context, in *Email, db *gorm1.DB) error { if ormObj.Id == "" { return errors.New("A non-zero ID value is required for a delete call") } - if hook, ok := interface{}(&ormObj).(EmailORMWithBeforeDelete); ok { - if db, err = hook.BeforeDelete(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(EmailORMWithBeforeDelete_); ok { + if db, err = hook.BeforeDelete_(ctx, db); err != nil { return err } } @@ -1416,17 +1416,17 @@ func DefaultDeleteEmail(ctx context.Context, in *Email, db *gorm1.DB) error { if err != nil { return err } - if hook, ok := interface{}(&ormObj).(EmailORMWithAfterDelete); ok { - err = hook.AfterDelete(ctx, db) + if hook, ok := interface{}(&ormObj).(EmailORMWithAfterDelete_); ok { + err = hook.AfterDelete_(ctx, db) } return err } -type EmailORMWithBeforeDelete interface { - BeforeDelete(context.Context, *gorm1.DB) (*gorm1.DB, error) +type EmailORMWithBeforeDelete_ interface { + BeforeDelete_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type EmailORMWithAfterDelete interface { - AfterDelete(context.Context, *gorm1.DB) error +type EmailORMWithAfterDelete_ interface { + AfterDelete_(context.Context, *gorm1.DB) error } func DefaultDeleteEmailSet(ctx context.Context, in []*Email, db *gorm1.DB) error { @@ -1673,16 +1673,16 @@ func DefaultCreateAddress(ctx context.Context, in *Address, db *gorm1.DB) (*Addr if err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(AddressORMWithBeforeCreate); ok { - if db, err = hook.BeforeCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(AddressORMWithBeforeCreate_); ok { + if db, err = hook.BeforeCreate_(ctx, db); err != nil { return nil, err } } if err = db.Create(&ormObj).Error; err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(AddressORMWithAfterCreate); ok { - if err = hook.AfterCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(AddressORMWithAfterCreate_); ok { + if err = hook.AfterCreate_(ctx, db); err != nil { return nil, err } } @@ -1690,11 +1690,11 @@ func DefaultCreateAddress(ctx context.Context, in *Address, db *gorm1.DB) (*Addr return &pbResponse, err } -type AddressORMWithBeforeCreate interface { - BeforeCreate(context.Context, *gorm1.DB) (*gorm1.DB, error) +type AddressORMWithBeforeCreate_ interface { + BeforeCreate_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type AddressORMWithAfterCreate interface { - AfterCreate(context.Context, *gorm1.DB) error +type AddressORMWithAfterCreate_ interface { + AfterCreate_(context.Context, *gorm1.DB) error } // DefaultReadAddress executes a basic gorm read call @@ -1756,8 +1756,8 @@ func DefaultDeleteAddress(ctx context.Context, in *Address, db *gorm1.DB) error if ormObj.Id == 0 { return errors.New("A non-zero ID value is required for a delete call") } - if hook, ok := interface{}(&ormObj).(AddressORMWithBeforeDelete); ok { - if db, err = hook.BeforeDelete(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(AddressORMWithBeforeDelete_); ok { + if db, err = hook.BeforeDelete_(ctx, db); err != nil { return err } } @@ -1765,17 +1765,17 @@ func DefaultDeleteAddress(ctx context.Context, in *Address, db *gorm1.DB) error if err != nil { return err } - if hook, ok := interface{}(&ormObj).(AddressORMWithAfterDelete); ok { - err = hook.AfterDelete(ctx, db) + if hook, ok := interface{}(&ormObj).(AddressORMWithAfterDelete_); ok { + err = hook.AfterDelete_(ctx, db) } return err } -type AddressORMWithBeforeDelete interface { - BeforeDelete(context.Context, *gorm1.DB) (*gorm1.DB, error) +type AddressORMWithBeforeDelete_ interface { + BeforeDelete_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type AddressORMWithAfterDelete interface { - AfterDelete(context.Context, *gorm1.DB) error +type AddressORMWithAfterDelete_ interface { + AfterDelete_(context.Context, *gorm1.DB) error } func DefaultDeleteAddressSet(ctx context.Context, in []*Address, db *gorm1.DB) error { @@ -2026,16 +2026,16 @@ func DefaultCreateLanguage(ctx context.Context, in *Language, db *gorm1.DB) (*La if err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(LanguageORMWithBeforeCreate); ok { - if db, err = hook.BeforeCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(LanguageORMWithBeforeCreate_); ok { + if db, err = hook.BeforeCreate_(ctx, db); err != nil { return nil, err } } if err = db.Create(&ormObj).Error; err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(LanguageORMWithAfterCreate); ok { - if err = hook.AfterCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(LanguageORMWithAfterCreate_); ok { + if err = hook.AfterCreate_(ctx, db); err != nil { return nil, err } } @@ -2043,11 +2043,11 @@ func DefaultCreateLanguage(ctx context.Context, in *Language, db *gorm1.DB) (*La return &pbResponse, err } -type LanguageORMWithBeforeCreate interface { - BeforeCreate(context.Context, *gorm1.DB) (*gorm1.DB, error) +type LanguageORMWithBeforeCreate_ interface { + BeforeCreate_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type LanguageORMWithAfterCreate interface { - AfterCreate(context.Context, *gorm1.DB) error +type LanguageORMWithAfterCreate_ interface { + AfterCreate_(context.Context, *gorm1.DB) error } // DefaultReadLanguage executes a basic gorm read call @@ -2109,8 +2109,8 @@ func DefaultDeleteLanguage(ctx context.Context, in *Language, db *gorm1.DB) erro if ormObj.Id == 0 { return errors.New("A non-zero ID value is required for a delete call") } - if hook, ok := interface{}(&ormObj).(LanguageORMWithBeforeDelete); ok { - if db, err = hook.BeforeDelete(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(LanguageORMWithBeforeDelete_); ok { + if db, err = hook.BeforeDelete_(ctx, db); err != nil { return err } } @@ -2118,17 +2118,17 @@ func DefaultDeleteLanguage(ctx context.Context, in *Language, db *gorm1.DB) erro if err != nil { return err } - if hook, ok := interface{}(&ormObj).(LanguageORMWithAfterDelete); ok { - err = hook.AfterDelete(ctx, db) + if hook, ok := interface{}(&ormObj).(LanguageORMWithAfterDelete_); ok { + err = hook.AfterDelete_(ctx, db) } return err } -type LanguageORMWithBeforeDelete interface { - BeforeDelete(context.Context, *gorm1.DB) (*gorm1.DB, error) +type LanguageORMWithBeforeDelete_ interface { + BeforeDelete_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type LanguageORMWithAfterDelete interface { - AfterDelete(context.Context, *gorm1.DB) error +type LanguageORMWithAfterDelete_ interface { + AfterDelete_(context.Context, *gorm1.DB) error } func DefaultDeleteLanguageSet(ctx context.Context, in []*Language, db *gorm1.DB) error { @@ -2371,16 +2371,16 @@ func DefaultCreateCreditCard(ctx context.Context, in *CreditCard, db *gorm1.DB) if err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(CreditCardORMWithBeforeCreate); ok { - if db, err = hook.BeforeCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(CreditCardORMWithBeforeCreate_); ok { + if db, err = hook.BeforeCreate_(ctx, db); err != nil { return nil, err } } if err = db.Create(&ormObj).Error; err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(CreditCardORMWithAfterCreate); ok { - if err = hook.AfterCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(CreditCardORMWithAfterCreate_); ok { + if err = hook.AfterCreate_(ctx, db); err != nil { return nil, err } } @@ -2388,11 +2388,11 @@ func DefaultCreateCreditCard(ctx context.Context, in *CreditCard, db *gorm1.DB) return &pbResponse, err } -type CreditCardORMWithBeforeCreate interface { - BeforeCreate(context.Context, *gorm1.DB) (*gorm1.DB, error) +type CreditCardORMWithBeforeCreate_ interface { + BeforeCreate_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type CreditCardORMWithAfterCreate interface { - AfterCreate(context.Context, *gorm1.DB) error +type CreditCardORMWithAfterCreate_ interface { + AfterCreate_(context.Context, *gorm1.DB) error } // DefaultReadCreditCard executes a basic gorm read call @@ -2454,8 +2454,8 @@ func DefaultDeleteCreditCard(ctx context.Context, in *CreditCard, db *gorm1.DB) if ormObj.Id == 0 { return errors.New("A non-zero ID value is required for a delete call") } - if hook, ok := interface{}(&ormObj).(CreditCardORMWithBeforeDelete); ok { - if db, err = hook.BeforeDelete(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(CreditCardORMWithBeforeDelete_); ok { + if db, err = hook.BeforeDelete_(ctx, db); err != nil { return err } } @@ -2463,17 +2463,17 @@ func DefaultDeleteCreditCard(ctx context.Context, in *CreditCard, db *gorm1.DB) if err != nil { return err } - if hook, ok := interface{}(&ormObj).(CreditCardORMWithAfterDelete); ok { - err = hook.AfterDelete(ctx, db) + if hook, ok := interface{}(&ormObj).(CreditCardORMWithAfterDelete_); ok { + err = hook.AfterDelete_(ctx, db) } return err } -type CreditCardORMWithBeforeDelete interface { - BeforeDelete(context.Context, *gorm1.DB) (*gorm1.DB, error) +type CreditCardORMWithBeforeDelete_ interface { + BeforeDelete_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type CreditCardORMWithAfterDelete interface { - AfterDelete(context.Context, *gorm1.DB) error +type CreditCardORMWithAfterDelete_ interface { + AfterDelete_(context.Context, *gorm1.DB) error } func DefaultDeleteCreditCardSet(ctx context.Context, in []*CreditCard, db *gorm1.DB) error { @@ -2720,16 +2720,16 @@ func DefaultCreateTask(ctx context.Context, in *Task, db *gorm1.DB) (*Task, erro if err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(TaskORMWithBeforeCreate); ok { - if db, err = hook.BeforeCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(TaskORMWithBeforeCreate_); ok { + if db, err = hook.BeforeCreate_(ctx, db); err != nil { return nil, err } } if err = db.Create(&ormObj).Error; err != nil { return nil, err } - if hook, ok := interface{}(&ormObj).(TaskORMWithAfterCreate); ok { - if err = hook.AfterCreate(ctx, db); err != nil { + if hook, ok := interface{}(&ormObj).(TaskORMWithAfterCreate_); ok { + if err = hook.AfterCreate_(ctx, db); err != nil { return nil, err } } @@ -2737,11 +2737,11 @@ func DefaultCreateTask(ctx context.Context, in *Task, db *gorm1.DB) (*Task, erro return &pbResponse, err } -type TaskORMWithBeforeCreate interface { - BeforeCreate(context.Context, *gorm1.DB) (*gorm1.DB, error) +type TaskORMWithBeforeCreate_ interface { + BeforeCreate_(context.Context, *gorm1.DB) (*gorm1.DB, error) } -type TaskORMWithAfterCreate interface { - AfterCreate(context.Context, *gorm1.DB) error +type TaskORMWithAfterCreate_ interface { + AfterCreate_(context.Context, *gorm1.DB) error } // DefaultApplyFieldMaskTask patches an pbObject with patcher according to a field mask. diff --git a/plugin/handlergen.go b/plugin/handlergen.go index 1de6bca0..1b669540 100644 --- a/plugin/handlergen.go +++ b/plugin/handlergen.go @@ -78,16 +78,17 @@ func (p *OrmPlugin) generateCreateHandler(message *generator.Descriptor) { p.P(`if err != nil {`) p.P(`return nil, err`) p.P(`}`) - p.generateBeforeHookCall(orm, "Create") + create := "Create_" + p.generateBeforeHookCall(orm, create) p.P(`if err = db.Create(&ormObj).Error; err != nil {`) p.P(`return nil, err`) p.P(`}`) - p.generateAfterHookCall(orm, "Create") + p.generateAfterHookCall(orm, create) p.P(`pbResponse, err := ormObj.ToPB(ctx)`) p.P(`return &pbResponse, err`) p.P(`}`) - p.generateBeforeHookDef(orm, "Create") - p.generateAfterHookDef(orm, "Create") + p.generateBeforeHookDef(orm, create) + p.generateAfterHookDef(orm, create) } func (p *OrmPlugin) generateReadHandler(message *generator.Descriptor) { @@ -422,21 +423,22 @@ func (p *OrmPlugin) generateDeleteHandler(message *generator.Descriptor) { p.generateAfterDeleteHookCall(ormable) p.P(`return err`) p.P(`}`) - p.generateBeforeHookDef(ormable, "Delete") - p.generateAfterHookDef(ormable, "Delete") + delete := "Delete_" + p.generateBeforeHookDef(ormable, delete) + p.generateAfterHookDef(ormable, delete) } func (p *OrmPlugin) generateBeforeDeleteHookCall(orm *OrmableType) { - p.P(`if hook, ok := interface{}(&ormObj).(`, orm.Name, `WithBeforeDelete); ok {`) - p.P(`if db, err = hook.BeforeDelete(ctx, db); err != nil {`) + p.P(`if hook, ok := interface{}(&ormObj).(`, orm.Name, `WithBeforeDelete_); ok {`) + p.P(`if db, err = hook.BeforeDelete_(ctx, db); err != nil {`) p.P(`return err`) p.P(`}`) p.P(`}`) } func (p *OrmPlugin) generateAfterDeleteHookCall(orm *OrmableType) { - p.P(`if hook, ok := interface{}(&ormObj).(`, orm.Name, `WithAfterDelete); ok {`) - p.P(`err = hook.AfterDelete(ctx, db)`) + p.P(`if hook, ok := interface{}(&ormObj).(`, orm.Name, `WithAfterDelete_); ok {`) + p.P(`err = hook.AfterDelete_(ctx, db)`) p.P(`}`) }