Allow existing models in eager/flat create

associations/association.go

@@ -68,6 +68,7 @@ type AssociationBeforeCreatable interface {
 type AssociationAfterCreatable interface {
 	AfterInterface() interface{}
 	AfterSetup() error
+	AfterProcess() AssociationStatement
 	Association
 }
 
@@ -85,6 +86,11 @@ type AssociationStatement struct {
 	Args      []interface{}
 }
 
+// Empty is true if the containing Statement is empty.
+func (as AssociationStatement) Empty() bool {
+	return as.Statement == ""
+}
+
 // Associations a group of model associations.
 type Associations []Association
 
@@ -153,3 +159,8 @@ func isZero(i interface{}) bool {
 	v := reflect.ValueOf(i)
 	return v.Interface() == reflect.Zero(v.Type()).Interface()
 }
+
+// IsZeroOfUnderlyingType will check if the value of anything is the equal to the Zero value of that type.
+func IsZeroOfUnderlyingType(x interface{}) bool {
+	return reflect.DeepEqual(x, reflect.Zero(reflect.TypeOf(x)).Interface())
+}

associations/belongs_to_association.go

@@ -112,9 +112,7 @@ func (b *belongsToAssociation) BeforeInterface() interface{} {
 		return b.ownerModel.Interface()
 	}
 
-	currentVal := b.ownerModel.Interface()
-	zeroVal := reflect.Zero(b.ownerModel.Type()).Interface()
-	if reflect.DeepEqual(zeroVal, currentVal) {
+	if IsZeroOfUnderlyingType(b.ownerModel.Interface()) {
 		return nil
 	}
 

associations/belongs_to_association_test.go

@@ -4,11 +4,9 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/stretchr/testify/require"
-
 	"github.com/gobuffalo/pop/associations"
-
 	"github.com/gobuffalo/uuid"
+	"github.com/stretchr/testify/require"
 )
 
 type fooBelongsTo struct {
@@ -38,4 +36,17 @@ func Test_Belongs_To_Association(t *testing.T) {
 	where, args := as[0].Constraint()
 	a.Equal("id = ?", where)
 	a.Equal(id, args[0].(uuid.UUID))
+
+	bar2 := barBelongsTo{FooID: uuid.Nil}
+	as, err = associations.ForStruct(&bar2, "Foo")
+
+	a.NoError(err)
+	a.Equal(len(as), 1)
+	a.Equal(reflect.Struct, as[0].Kind())
+
+	before := as.AssociationsBeforeCreatable()
+
+	for index := range before {
+		a.Equal(nil, before[index].BeforeInterface())
+	}
 }

associations/has_many_association.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/gobuffalo/flect"
 	"github.com/gobuffalo/pop/nulls"
+	"github.com/jmoiron/sqlx"
 )
 
 // hasManyAssociation is the implementation for the has_many
@@ -119,3 +120,51 @@ func (a *hasManyAssociation) AfterSetup() error {
 	}
 	return nil
 }
+
+func (a *hasManyAssociation) AfterProcess() AssociationStatement {
+	v := a.value
+	if v.Kind() == reflect.Ptr {
+		v = v.Elem()
+	}
+
+	belongingIDFieldName := "ID"
+
+	ownerIDFieldName := "ID"
+	ownerID := reflect.Indirect(reflect.ValueOf(a.owner)).FieldByName(ownerIDFieldName).Interface()
+
+	ids := []interface{}{}
+
+	for i := 0; i < v.Len(); i++ {
+		id := v.Index(i).FieldByName(belongingIDFieldName).Interface()
+		if !IsZeroOfUnderlyingType(id) {
+			ids = append(ids, id)
+		}
+	}
+	if len(ids) == 0 {
+		return AssociationStatement{
+			Statement: "",
+			Args:      []interface{}{},
+		}
+	}
+
+	fk := a.fkID
+	if fk == "" {
+		fk = flect.Underscore(a.ownerName) + "_id"
+	}
+
+	// This will be used to update all of our owned models' foreign keys to our ID.
+	ret := fmt.Sprintf("UPDATE %s SET %s = ? WHERE %s in (?);", a.tableName, fk, belongingIDFieldName)
+
+	update, args, err := sqlx.In(ret, ownerID, ids)
+	if err != nil {
+		return AssociationStatement{
+			Statement: "",
+			Args:      []interface{}{},
+		}
+	}
+
+	return AssociationStatement{
+		Statement: update,
+		Args:      args,
+	}
+}

associations/has_one_association.go

@@ -9,12 +9,13 @@ import (
 )
 
 type hasOneAssociation struct {
-	ownedModel reflect.Value
-	ownedType  reflect.Type
-	ownerID    interface{}
-	ownerName  string
-	owner      interface{}
-	fkID       string
+	ownedTableName string
+	ownedModel     reflect.Value
+	ownedType      reflect.Type
+	ownerID        interface{}
+	ownerName      string
+	owner          interface{}
+	fkID           string
 	*associationSkipable
 	*associationComposite
 }
@@ -33,12 +34,13 @@ func hasOneAssociationBuilder(p associationParams) (Association, error) {
 
 	fval := p.modelValue.FieldByName(p.field.Name)
 	return &hasOneAssociation{
-		owner:      p.model,
-		ownedModel: fval,
-		ownedType:  fval.Type(),
-		ownerID:    ownerID.Interface(),
-		ownerName:  p.modelType.Name(),
-		fkID:       p.popTags.Find("fk_id").Value,
+		owner:          p.model,
+		ownedTableName: flect.Pluralize(p.popTags.Find("has_one").Value),
+		ownedModel:     fval,
+		ownedType:      fval.Type(),
+		ownerID:        ownerID.Interface(),
+		ownerName:      p.modelType.Name(),
+		fkID:           p.popTags.Find("fk_id").Value,
 		associationSkipable: &associationSkipable{
 			skipped: skipped,
 		},
@@ -76,9 +78,7 @@ func (h *hasOneAssociation) AfterInterface() interface{} {
 		return h.ownedModel.Interface()
 	}
 
-	currentVal := h.ownedModel.Interface()
-	zeroVal := reflect.Zero(h.ownedModel.Type()).Interface()
-	if reflect.DeepEqual(zeroVal, currentVal) {
+	if IsZeroOfUnderlyingType(h.ownedModel.Interface()) {
 		return nil
 	}
 
@@ -100,3 +100,33 @@ func (h *hasOneAssociation) AfterSetup() error {
 
 	return fmt.Errorf("could not set '%s' to '%s'", ownerID, fval)
 }
+
+func (h *hasOneAssociation) AfterProcess() AssociationStatement {
+	belongingIDFieldName := "ID"
+	id := h.ownedModel.FieldByName(belongingIDFieldName).Interface()
+
+	ownerIDFieldName := "ID"
+	ownerID := reflect.Indirect(reflect.ValueOf(h.owner)).FieldByName(ownerIDFieldName).Interface()
+
+	ids := []interface{}{ownerID}
+
+	if IsZeroOfUnderlyingType(id) {
+		return AssociationStatement{
+			Statement: "",
+			Args:      []interface{}{},
+		}
+	}
+	ids = append(ids, id)
+
+	fk := h.fkID
+	if fk == "" {
+		fk = flect.Underscore(h.ownerName) + "_id"
+	}
+
+	ret := fmt.Sprintf("UPDATE %s SET %s = ? WHERE %s = ?", h.ownedTableName, fk, belongingIDFieldName)
+
+	return AssociationStatement{
+		Statement: ret,
+		Args:      ids,
+	}
+}

associations/has_one_association_test.go

@@ -35,6 +35,14 @@ func Test_Has_One_Association(t *testing.T) {
 	where, args := as[0].Constraint()
 	a.Equal("foo_has_one_id = ?", where)
 	a.Equal(id, args[0].(uuid.UUID))
+
+	foo2 := FooHasOne{}
+
+	as, err = associations.ForStruct(&foo2)
+	after := as.AssociationsAfterCreatable()
+	for index := range after {
+		a.Equal(nil, after[index].AfterInterface())
+	}
 }
 
 func Test_Has_One_SetValue(t *testing.T) {

connection_details_test.go

@@ -164,8 +164,10 @@ func Test_ConnectionDetails_Finalize_SQLite_with_Dialect(t *testing.T) {
 	r.Equal("", cd.Port)
 	r.Equal("", cd.User)
 }
+
 func Test_ConnectionDetails_Finalize_SQLite_without_URL(t *testing.T) {
 	r := require.New(t)
+
 	cd := &ConnectionDetails{
 		Dialect:  "sqlite",
 		Database: "./foo.db",

dialect_cockroach.go

@@ -8,7 +8,7 @@ import (
 	"strings"
 	"sync"
 
-	_ "github.com/cockroachdb/cockroach-go/crdb" // Load CockroachdbQL/postgres Go driver. Also loads github.com/lib/pq
+	_ "github.com/cockroachdb/cockroach-go/crdb" // Load CockroachdbQL/postgres Go driver which also loads github.com/lib/pq
 	"github.com/gobuffalo/fizz"
 	"github.com/gobuffalo/fizz/translators"
 	"github.com/gobuffalo/pop/columns"
@@ -196,6 +196,7 @@ func (p *cockroach) Lock(fn func() error) error {
 
 func (p *cockroach) DumpSchema(w io.Writer) error {
 	cmd := exec.Command("cockroach", "dump", p.Details().Database, "--dump-mode=schema")
+
 	c := p.ConnectionDetails
 	if defaults.String(c.Options["sslmode"], "disable") == "disable" || strings.Contains(c.RawOptions, "sslmode=disable") {
 		cmd.Args = append(cmd.Args, "--insecure")

dialect_cockroach_test.go

@@ -18,8 +18,10 @@ func Test_Cockroach_URL_Raw(t *testing.T) {
 	r.Equal("scheme://user:pass@host:port/database?option1=value1", m.URL())
 	r.Equal("postgres://user:pass@host:port/?option1=value1", m.urlWithoutDb())
 }
+
 func Test_Cockroach_URL_Build(t *testing.T) {
 	r := require.New(t)
+
 	cd := &ConnectionDetails{
 		Dialect:  "cockroach",
 		Database: "database",

executors.go

@@ -1,8 +1,9 @@
 package pop
 
 import (
-	"fmt"
+	"reflect"
 
+	"github.com/gobuffalo/pop/associations"
 	"github.com/gobuffalo/pop/columns"
 	"github.com/gobuffalo/pop/logging"
 	"github.com/gobuffalo/uuid"
@@ -60,13 +61,21 @@ func (c *Connection) ValidateAndSave(model interface{}, excludeColumns ...string
 
 var emptyUUID = uuid.Nil.String()
 
+// IsZeroOfUnderlyingType will check if the value of anything is the equal to the Zero value of that type.
+func IsZeroOfUnderlyingType(x interface{}) bool {
+	return reflect.DeepEqual(x, reflect.Zero(reflect.TypeOf(x)).Interface())
+}
+
 // Save wraps the Create and Update methods. It executes a Create if no ID is provided with the entry;
 // or issues an Update otherwise.
 func (c *Connection) Save(model interface{}, excludeColumns ...string) error {
 	sm := &Model{Value: model}
 	return sm.iterate(func(m *Model) error {
-		id := m.ID()
-		if fmt.Sprint(id) == "0" || fmt.Sprint(id) == emptyUUID {
+		id, err := m.fieldByName("ID")
+		if err != nil {
+			return err
+		}
+		if IsZeroOfUnderlyingType(id.Interface()) {
 			return c.Create(m.Value, excludeColumns...)
 		}
 		return c.Update(m.Value, excludeColumns...)
@@ -101,7 +110,11 @@ func (c *Connection) Create(model interface{}, excludeColumns ...string) error {
 	sm := &Model{Value: model}
 	return sm.iterate(func(m *Model) error {
 		return c.timeFunc("Create", func() error {
-			var err error
+			asos, err := associations.ForStruct(m.Value)
+			if err != nil {
+				return err
+			}
+
 			if err = m.beforeSave(c); err != nil {
 				return err
 			}
@@ -110,6 +123,23 @@ func (c *Connection) Create(model interface{}, excludeColumns ...string) error {
 				return err
 			}
 
+			processAssoc := len(asos) > 0
+
+			if processAssoc {
+				before := asos.AssociationsBeforeCreatable()
+				for index := range before {
+					i := before[index].BeforeInterface()
+					if i == nil {
+						continue
+					}
+
+					err = before[index].BeforeSetup()
+					if err != nil {
+						return err
+					}
+				}
+			}
+
 			tn := m.TableName()
 			cols := columns.ForStructWithAlias(m.Value, tn, m.As)
 
@@ -124,6 +154,37 @@ func (c *Connection) Create(model interface{}, excludeColumns ...string) error {
 				return err
 			}
 
+			if processAssoc {
+				after := asos.AssociationsAfterCreatable()
+				for index := range after {
+					stm := after[index].AfterProcess()
+					if c.TX != nil && !stm.Empty() {
+						_, err := c.TX.Exec(c.Dialect.TranslateSQL(stm.Statement), stm.Args...)
+						if err != nil {
+							return err
+						}
+					}
+				}
+
+				stms := asos.AssociationsCreatableStatement()
+				for index := range stms {
+					statements := stms[index].Statements()
+					for _, stm := range statements {
+						if c.TX != nil {
+							_, err := c.TX.Exec(c.Dialect.TranslateSQL(stm.Statement), stm.Args...)
+							if err != nil {
+								return err
+							}
+							continue
+						}
+						_, err = c.Store.Exec(c.Dialect.TranslateSQL(stm.Statement), stm.Args...)
+						if err != nil {
+							return err
+						}
+					}
+				}
+			}
+
 			if err = m.afterCreate(c); err != nil {
 				return err
 			}