Understanding Interface Types in mgo Models

In the context of MongoDB and Go, modeling data with interfaces can present challenges due to the dynamic nature of interfaces. Here's a concise explanation of the issue you've encountered and a suggested solution.

The Problem with Interface Types

MongoDB's document-based data model doesn't provide type information for embedded documents. When using mgo to unmarshal MongoDB documents containing interface types into Go structs, mgo cannot determine the specific type of each embedded document. This results in the error "value of type bson.M is not assignable to type Node."

Solution: Wrapping Interface Types

To address this limitation, one approach is to wrap the interface type in a custom struct that provides type information. This allows mgo to identify the embedded document's specific type during unmarshalling.

Consider the following example:

type NodeWithType struct {
   Node Node `bson:"-"`
   Type string
}

type Workflow struct {
   CreatedAt time.Time
   StartedAt time.Time
   CreatedBy string
   Nodes []NodeWithType
}

Implementing SetBSON Function

To complete this solution, you need to implement the SetBSON function for the NodeWithType type. This function will decode the type string, create an instance of the corresponding type, and unmarshal it.

func (nt *NodeWithType) SetBSON(r bson.Raw) error {
   // Decode the "Type" field and determine the Node type
   var typeStr string
   if err := r.Unmarshal(&typeStr); err != nil {
      return err
   }

   // Create a new instance of the Node type based on the type string
   node, ok := reflect.New(reflect.TypeOf(Node).Elem()).Interface().(Node)
   if !ok {
      return errors.New("invalid Node type")
   }

   // Unmarshal the remaining data into the Node instance
   if err := r.Unmarshal(node); err != nil {
      return err
   }

   // Assign the Node instance to the NodeWithType struct
   nt.Node = node
   return nil
}

Conclusion

Utilizing this pattern enables you to effectively utilize interfaces while maintaining the ability to unmarshal embedded documents of different types. By providing explicit type information, mgo can seamlessly decode these documents into the desired Go structs.