Add before/after select/delete to hooks generation

* Add tests for all hooks

boil/hooks.go

@@ -6,9 +6,13 @@ type HookPoint int
 // the hook point constants
 const (
 	HookAfterInsert HookPoint = iota + 1
+	HookAfterSelect
 	HookAfterUpdate
+	HookAfterDelete
 	HookAfterUpsert
 	HookBeforeInsert
+	HookBeforeSelect
 	HookBeforeUpdate
+	HookBeforeDelete
 	HookBeforeUpsert
 )

templates/02_hooks.tpl

@@ -2,10 +2,15 @@
 {{- $tableNameSingular := .Table.Name | singular | titleCase -}}
 {{- $varNameSingular := .Table.Name | singular | camelCase -}}
 var {{$varNameSingular}}BeforeInsertHooks []{{$tableNameSingular}}Hook
+var {{$varNameSingular}}BeforeSelectHooks []{{$tableNameSingular}}Hook
 var {{$varNameSingular}}BeforeUpdateHooks []{{$tableNameSingular}}Hook
+var {{$varNameSingular}}BeforeDeleteHooks []{{$tableNameSingular}}Hook
 var {{$varNameSingular}}BeforeUpsertHooks []{{$tableNameSingular}}Hook
+
 var {{$varNameSingular}}AfterInsertHooks []{{$tableNameSingular}}Hook
+var {{$varNameSingular}}AfterSelectHooks []{{$tableNameSingular}}Hook
 var {{$varNameSingular}}AfterUpdateHooks []{{$tableNameSingular}}Hook
+var {{$varNameSingular}}AfterDeleteHooks []{{$tableNameSingular}}Hook
 var {{$varNameSingular}}AfterUpsertHooks []{{$tableNameSingular}}Hook
 
 // doBeforeInsertHooks executes all "before insert" hooks.
@@ -19,6 +24,17 @@ func (o *{{$tableNameSingular}}) doBeforeInsertHooks() (err error) {
   return nil
 }
 
+// doBeforeSelectHooks executes all "before Select" hooks.
+func (o *{{$tableNameSingular}}) doBeforeSelectHooks() (err error) {
+  for _, hook := range {{$varNameSingular}}BeforeSelectHooks {
+    if err := hook(o); err != nil {
+      return err
+    }
+  }
+
+  return nil
+}
+
 // doBeforeUpdateHooks executes all "before Update" hooks.
 func (o *{{$tableNameSingular}}) doBeforeUpdateHooks() (err error) {
   for _, hook := range {{$varNameSingular}}BeforeUpdateHooks {
@@ -30,6 +46,17 @@ func (o *{{$tableNameSingular}}) doBeforeUpdateHooks() (err error) {
   return nil
 }
 
+// doBeforeDeleteHooks executes all "before Delete" hooks.
+func (o *{{$tableNameSingular}}) doBeforeDeleteHooks() (err error) {
+  for _, hook := range {{$varNameSingular}}BeforeDeleteHooks {
+    if err := hook(o); err != nil {
+      return err
+    }
+  }
+
+  return nil
+}
+
 // doBeforeUpsertHooks executes all "before Upsert" hooks.
 func (o *{{$tableNameSingular}}) doBeforeUpsertHooks() (err error) {
   for _, hook := range {{$varNameSingular}}BeforeUpsertHooks {
@@ -52,6 +79,17 @@ func (o *{{$tableNameSingular}}) doAfterInsertHooks() (err error) {
   return nil
 }
 
+// doAfterSelectHooks executes all "after Select" hooks.
+func (o *{{$tableNameSingular}}) doAfterSelectHooks() (err error) {
+  for _, hook := range {{$varNameSingular}}AfterSelectHooks {
+    if err := hook(o); err != nil {
+      return err
+    }
+  }
+
+  return nil
+}
+
 // doAfterUpdateHooks executes all "after Update" hooks.
 func (o *{{$tableNameSingular}}) doAfterUpdateHooks() (err error) {
   for _, hook := range {{$varNameSingular}}AfterUpdateHooks {
@@ -63,6 +101,17 @@ func (o *{{$tableNameSingular}}) doAfterUpdateHooks() (err error) {
   return nil
 }
 
+// doAfterDeleteHooks executes all "after Delete" hooks.
+func (o *{{$tableNameSingular}}) doAfterDeleteHooks() (err error) {
+  for _, hook := range {{$varNameSingular}}AfterDeleteHooks {
+    if err := hook(o); err != nil {
+      return err
+    }
+  }
+
+  return nil
+}
+
 // doAfterUpsertHooks executes all "after Upsert" hooks.
 func (o *{{$tableNameSingular}}) doAfterUpsertHooks() (err error) {
   for _, hook := range {{$varNameSingular}}AfterUpsertHooks {
@@ -78,14 +127,22 @@ func {{$tableNameSingular}}AddHook(hookPoint boil.HookPoint, {{$varNameSingular}
   switch hookPoint {
     case boil.HookBeforeInsert:
       {{$varNameSingular}}BeforeInsertHooks = append({{$varNameSingular}}BeforeInsertHooks, {{$varNameSingular}}Hook)
+    case boil.HookBeforeSelect:
+      {{$varNameSingular}}BeforeSelectHooks = append({{$varNameSingular}}BeforeSelectHooks, {{$varNameSingular}}Hook)
     case boil.HookBeforeUpdate:
       {{$varNameSingular}}BeforeUpdateHooks = append({{$varNameSingular}}BeforeUpdateHooks, {{$varNameSingular}}Hook)
+    case boil.HookBeforeDelete:
+      {{$varNameSingular}}BeforeDeleteHooks = append({{$varNameSingular}}BeforeDeleteHooks, {{$varNameSingular}}Hook)
     case boil.HookBeforeUpsert:
       {{$varNameSingular}}BeforeUpsertHooks = append({{$varNameSingular}}BeforeUpsertHooks, {{$varNameSingular}}Hook)
     case boil.HookAfterInsert:
       {{$varNameSingular}}AfterInsertHooks = append({{$varNameSingular}}AfterInsertHooks, {{$varNameSingular}}Hook)
+    case boil.HookAfterSelect:
+      {{$varNameSingular}}AfterSelectHooks = append({{$varNameSingular}}AfterSelectHooks, {{$varNameSingular}}Hook)
     case boil.HookAfterUpdate:
       {{$varNameSingular}}AfterUpdateHooks = append({{$varNameSingular}}AfterUpdateHooks, {{$varNameSingular}}Hook)
+    case boil.HookAfterDelete:
+      {{$varNameSingular}}AfterDeleteHooks = append({{$varNameSingular}}AfterDeleteHooks, {{$varNameSingular}}Hook)
     case boil.HookAfterUpsert:
       {{$varNameSingular}}AfterUpsertHooks = append({{$varNameSingular}}AfterUpsertHooks, {{$varNameSingular}}Hook)
   }

templates_test/hooks.tpl

@@ -13,6 +13,16 @@ func {{$varNameSingular}}AfterInsertHook(o *{{$tableNameSingular}}) error {
   return nil
 }
 
+func {{$varNameSingular}}BeforeSelectHook(o *{{$tableNameSingular}}) error {
+  *o = {{$tableNameSingular}}{}
+  return nil
+}
+
+func {{$varNameSingular}}AfterSelectHook(o *{{$tableNameSingular}}) error {
+  *o = {{$tableNameSingular}}{}
+  return nil
+}
+
 func {{$varNameSingular}}BeforeUpdateHook(o *{{$tableNameSingular}}) error {
   *o = {{$tableNameSingular}}{}
   return nil
@@ -23,6 +33,26 @@ func {{$varNameSingular}}AfterUpdateHook(o *{{$tableNameSingular}}) error {
   return nil
 }
 
+func {{$varNameSingular}}BeforeDeleteHook(o *{{$tableNameSingular}}) error {
+  *o = {{$tableNameSingular}}{}
+  return nil
+}
+
+func {{$varNameSingular}}AfterDeleteHook(o *{{$tableNameSingular}}) error {
+  *o = {{$tableNameSingular}}{}
+  return nil
+}
+
+func {{$varNameSingular}}BeforeUpsertHook(o *{{$tableNameSingular}}) error {
+  *o = {{$tableNameSingular}}{}
+  return nil
+}
+
+func {{$varNameSingular}}AfterUpsertHook(o *{{$tableNameSingular}}) error {
+  *o = {{$tableNameSingular}}{}
+  return nil
+}
+
 func test{{$tableNamePlural}}Hooks(t *testing.T) {
   t.Parallel()
 
@@ -43,7 +73,87 @@ func test{{$tableNamePlural}}Hooks(t *testing.T) {
   if !reflect.DeepEqual(o, empty) {
     t.Errorf("Expected BeforeInsertHook function to empty object, but got: %#v", o)
   }
-
   {{$varNameSingular}}BeforeInsertHooks = []{{$tableNameSingular}}Hook{}
+
+  {{$tableNameSingular}}AddHook(boil.HookAfterInsert, {{$varNameSingular}}AfterInsertHook)
+  if err = o.doAfterInsertHooks(); err != nil {
+    t.Errorf("Unable to execute doAfterInsertHooks: %s", err)
+  }
+  if !reflect.DeepEqual(o, empty) {
+    t.Errorf("Expected AfterInsertHook function to empty object, but got: %#v", o)
+  }
+  {{$varNameSingular}}AfterInsertHooks = []{{$tableNameSingular}}Hook{}
+
+  {{$tableNameSingular}}AddHook(boil.HookBeforeSelect, {{$varNameSingular}}BeforeSelectHook)
+  if err = o.doBeforeSelectHooks(); err != nil {
+    t.Errorf("Unable to execute doBeforeSelectHooks: %s", err)
+  }
+  if !reflect.DeepEqual(o, empty) {
+    t.Errorf("Expected BeforeSelectHook function to empty object, but got: %#v", o)
+  }
+  {{$varNameSingular}}BeforeSelectHooks = []{{$tableNameSingular}}Hook{}
+
+  {{$tableNameSingular}}AddHook(boil.HookAfterSelect, {{$varNameSingular}}AfterSelectHook)
+  if err = o.doAfterSelectHooks(); err != nil {
+    t.Errorf("Unable to execute doAfterSelectHooks: %s", err)
+  }
+  if !reflect.DeepEqual(o, empty) {
+    t.Errorf("Expected AfterSelectHook function to empty object, but got: %#v", o)
+  }
+  {{$varNameSingular}}AfterSelectHooks = []{{$tableNameSingular}}Hook{}
+
+  {{$tableNameSingular}}AddHook(boil.HookBeforeUpdate, {{$varNameSingular}}BeforeUpdateHook)
+  if err = o.doBeforeUpdateHooks(); err != nil {
+    t.Errorf("Unable to execute doBeforeUpdateHooks: %s", err)
+  }
+  if !reflect.DeepEqual(o, empty) {
+    t.Errorf("Expected BeforeUpdateHook function to empty object, but got: %#v", o)
+  }
+  {{$varNameSingular}}BeforeUpdateHooks = []{{$tableNameSingular}}Hook{}
+
+  {{$tableNameSingular}}AddHook(boil.HookAfterUpdate, {{$varNameSingular}}AfterUpdateHook)
+  if err = o.doAfterUpdateHooks(); err != nil {
+    t.Errorf("Unable to execute doAfterUpdateHooks: %s", err)
+  }
+  if !reflect.DeepEqual(o, empty) {
+    t.Errorf("Expected AfterUpdateHook function to empty object, but got: %#v", o)
+  }
+  {{$varNameSingular}}AfterUpdateHooks = []{{$tableNameSingular}}Hook{}
+
+  {{$tableNameSingular}}AddHook(boil.HookBeforeDelete, {{$varNameSingular}}BeforeDeleteHook)
+  if err = o.doBeforeDeleteHooks(); err != nil {
+    t.Errorf("Unable to execute doBeforeDeleteHooks: %s", err)
+  }
+  if !reflect.DeepEqual(o, empty) {
+    t.Errorf("Expected BeforeDeleteHook function to empty object, but got: %#v", o)
+  }
+  {{$varNameSingular}}BeforeDeleteHooks = []{{$tableNameSingular}}Hook{}
+
+  {{$tableNameSingular}}AddHook(boil.HookAfterDelete, {{$varNameSingular}}AfterDeleteHook)
+  if err = o.doAfterDeleteHooks(); err != nil {
+    t.Errorf("Unable to execute doAfterDeleteHooks: %s", err)
+  }
+  if !reflect.DeepEqual(o, empty) {
+    t.Errorf("Expected AfterDeleteHook function to empty object, but got: %#v", o)
+  }
+  {{$varNameSingular}}AfterDeleteHooks = []{{$tableNameSingular}}Hook{}
+
+  {{$tableNameSingular}}AddHook(boil.HookBeforeUpsert, {{$varNameSingular}}BeforeUpsertHook)
+  if err = o.doBeforeUpsertHooks(); err != nil {
+    t.Errorf("Unable to execute doBeforeUpsertHooks: %s", err)
+  }
+  if !reflect.DeepEqual(o, empty) {
+    t.Errorf("Expected BeforeUpsertHook function to empty object, but got: %#v", o)
+  }
+  {{$varNameSingular}}BeforeUpsertHooks = []{{$tableNameSingular}}Hook{}
+
+  {{$tableNameSingular}}AddHook(boil.HookAfterUpsert, {{$varNameSingular}}AfterUpsertHook)
+  if err = o.doAfterUpsertHooks(); err != nil {
+    t.Errorf("Unable to execute doAfterUpsertHooks: %s", err)
+  }
+  if !reflect.DeepEqual(o, empty) {
+    t.Errorf("Expected AfterUpsertHook function to empty object, but got: %#v", o)
+  }
+  {{$varNameSingular}}AfterUpsertHooks = []{{$tableNameSingular}}Hook{}
 }
 {{- end}}