Loop over collections in mongodb and decode to various go structs

I have a series of collections in a mongodb instance where I want to pull all the collections and decode all documents in the collections so I can mutate them as I go.

I am using go to list the collection names:

...
collections, err := db.ListCollectionNames(context.TODO(), bson.M{})
if err != nil {
	log.Fatalf("Failed to get coll names: %v", err)
}

for _, coll := range collections {
	collection := db.Collection(coll)
...

This works flawlessly and the next step would be to open a cursor to each collection and loop over the cursor and call decode on each object to its corresponding type.

I have defined all the types in a types package:

type Announcements struct {
	Id            string    `bson:"_id"`
	Content       string    `bson:"content"`
	Title         string    `bson:"title"`
	DateModified  time.Time `bson:"dateModified,omitempty"`
	ModifiedBy    string    `bson:"modifiedBy,omitempty"`
}

The issue is that I cant define the variable to be used for decoding dynamically.

This code would need to be repeated for every single collection

var obj Announcements // This would need to be dynamic

for cursor.Next(context.Background()) {
	err := cursor.Decode(&obj)
	if err != nil {
		log.Fatal(err)
	}

	log.Printf("%#v\n", obj)
}

Is there a way to do this without repeating this many times? I realize a dynamically typed language would be better for this. Wanted to ask before I migrate the work to a scripting language.

I have tried using the reflect package and switch statements to instantiate the variable dynamnically and using the interface{} type but that force the decode to use bson types and not my defined structs.

-- edit --

I have tried to use a map to link collection names to types but to no avail.

var Collections = map[string]interface{}{
	"announcements":          Announcements{},
	"badges":                 Badges{},
	"betaUser":               BetaUser{},
	"bonusLearningItems":     BonusLearningItems{},
	"books":                  Books{},
...
}

So that when I use the obj var I tried an assignment like:

var obj types.Collections[coll]

hoping that would give me a variable of type Announcement if I was had looped to the announcements collection. but when I call decode it returns bson types.

I need to dynamically define the obj variable type.

There are many ways you can do this. One of them is by using a callback function:

func Process(cursor *mongo.Cursor, cb func(), out interface{}) {
  for cursor.Next(context.Background()) {
     err := cursor.Decode(out)
     if err != nil {
         log.Fatal(err)
     }
     cb()
     log.Printf("%#v\n", obj)
  }
}

Then define a map:

type collHandler struct {
   New func() interface{}
   Process func(interface{})
}


var collections=map[string]func() interface{} {
   "announcements":   collHandler{
     New: func() interface {} {return &Announcement{}},
     Process: func(data interface{}) {
        processAnnouncements(data.(*Announcement))
     },
   },
   ...
}

And then you can:

handler:=collections[collectionName]
obj:=handler.New()
process(cursor,func() {
   handler.Process(obj)
  },
  &obj)

This way, you can place the iteration into a common function, and use closures to deal with type specific logic.