Introduce table reference support. (#16)

Author: fr33r

Makefile

@@ -9,5 +9,8 @@ bins:
 tests: bins
 	go test -v -race -covermode=atomic -coverprofile=morph.coverprofile
 
+coverage: tests
+	go tool cover -html=morph.coverprofile
+
 benchmarks: bins
 	go test -C internal -run XXX -bench=.

column.go

@@ -82,3 +82,14 @@ func (c *Column) FieldType() string {
 func (c *Column) SetFieldType(fieldType string) {
 	c.fieldType = strings.TrimSpace(fieldType)
 }
+
+// equal checks if two columns are equal.
+func (c Column) equals(other Column) bool {
+	sameName := c.Name() == other.Name()
+	sameField := c.Field() == other.Field()
+	sameFieldType := c.FieldType() == other.FieldType()
+	sameFieldStrategy := c.Strategy() == other.Strategy()
+	samePrimaryKey := c.PrimaryKey() == other.PrimaryKey()
+
+	return sameName && sameField && sameFieldType && sameFieldStrategy && samePrimaryKey
+}

configuration.go

@@ -9,34 +9,92 @@ type Configuration struct {
 // AsMetadata converts the configuration to metadata mappings.
 func (c Configuration) AsMetadata() []Table {
 	var tables []Table
+
+	references := map[string][]ReferenceConfiguration{}
+	tablesByName := map[string]*Table{}
+	columnsByName := map[string]*Column{}
+
 	for _, t := range c.Tables {
-		var table Table
-		table.SetTypeName(t.TypeName)
-		table.SetName(t.Name)
-		table.SetAlias(t.Alias)
-		for _, c := range t.Columns {
-			var column Column
-			column.SetField(c.Field)
-			column.SetName(c.Name)
-			column.SetFieldType(c.FieldType)
-			column.SetStrategy(c.FieldStrategy)
-			column.SetPrimaryKey(c.PrimaryKey)
-			if err := table.AddColumn(column); err != nil {
+		table := t.AsTable()
+		for _, column := range table.Columns() {
+			columnsByName[column.Name()] = &column
+		}
+		tablesByName[table.Name()] = &table
+
+		if len(t.References) > 0 {
+			if _, ok := references[table.Name()]; !ok {
+				references[table.Name()] = []ReferenceConfiguration{}
+			}
+			references[table.Name()] = append(references[table.Name()], t.References...)
+		}
+	}
+
+	for childTableName, refs := range references {
+		child, ok := tablesByName[childTableName]
+		if !ok {
+			continue
+		}
+		for _, ref := range refs {
+			parent, ok := tablesByName[ref.TableName]
+			if !ok {
+				continue
+			}
+			key := []Column{}
+			for _, fk := range ref.ForeignKey {
+				if column, ok := columnsByName[fk.ColumnName]; ok {
+					key = append(key, *column)
+				}
+			}
+			if _, err := child.References(parent, key); err != nil {
 				continue
 			}
 		}
-		tables = append(tables, table)
 	}
+
+	for _, table := range tablesByName {
+		tables = append(tables, *table)
+	}
+
 	return tables
 }
 
 // TableConfiguration represents the configuration used to construct
 // a single table mapping.
 type TableConfiguration struct {
-	TypeName string                `json:"typeName" yaml:"typeName"`
-	Name     string                `json:"name" yaml:"name"`
-	Alias    string                `json:"alias" yaml:"alias"`
-	Columns  []ColumnConfiguration `json:"columns" yaml:"columns"`
+	TypeName   string                   `json:"typeName" yaml:"typeName"`
+	Name       string                   `json:"name" yaml:"name"`
+	Alias      string                   `json:"alias" yaml:"alias"`
+	Columns    []ColumnConfiguration    `json:"columns" yaml:"columns"`
+	References []ReferenceConfiguration `json:"references" yaml:"references"`
+}
+
+// AsTable converts the configuration to a table mapping.
+func (t TableConfiguration) AsTable() Table {
+	var table Table
+	table.SetTypeName(t.TypeName)
+	table.SetName(t.Name)
+	table.SetAlias(t.Alias)
+
+	for _, c := range t.Columns {
+		if err := table.AddColumn(c.AsColumn()); err != nil {
+			continue
+		}
+	}
+
+	return table
+}
+
+// ReferenceConfiguration represents the configuration used to construct
+// a single reference between two tables.
+type ReferenceConfiguration struct {
+	TableName  string                    `json:"tableName" yaml:"tableName"`
+	ForeignKey []ForeignKeyConfiguration `json:"foreignKey" yaml:"foreignKey"`
+}
+
+// ForeignKeyConfiguration represents the configuration used to communicate
+// which columns comprise the foreign key for a reference.
+type ForeignKeyConfiguration struct {
+	ColumnName string `json:"columnName" yaml:"columnName"`
 }
 
 // ColumnConfiguration represents the configuration used to construct
@@ -48,3 +106,14 @@ type ColumnConfiguration struct {
 	FieldStrategy FieldStrategy `json:"fieldStrategy" yaml:"fieldStrategy"`
 	PrimaryKey    bool          `json:"primaryKey" yaml:"primaryKey"`
 }
+
+// AsColumn converts the configuration to a column mapping.
+func (c ColumnConfiguration) AsColumn() Column {
+	var column Column
+	column.SetField(c.Field)
+	column.SetName(c.Name)
+	column.SetFieldType(c.FieldType)
+	column.SetStrategy(c.FieldStrategy)
+	column.SetPrimaryKey(c.PrimaryKey)
+	return column
+}