Auto type assertion not working when fetching data

[voidhofer]

I switched from go-mgo/mgo.v2 to this as it was advised by many but I found an odd problem.
While in go-mgo's version it was possible to fetch results to a struct object with this package it is not possible.

Every time I use "c.Find(nil).One(&result)" to fetch data into a struct I get an empty struct.
I have to manually marshal and unmarshal the data to get it into a struct otherwise it will not work.

Example:

type Menu struct {
    ID       bson.ObjectId 'json:"_id" bson:"_id"'
    Value string                'json:"val" bson:"val"'
}

func GetData() (Menu, error) {
        var err error
        var result interface{}
        var resultMenu Menu
        if database.CheckConnection() {
		session := database.Mongo.Copy()
		defer session.Close()
		c := session.DB(database.ReadConfig().MongoDB.Database).C("menus")
		err = c.FindId(bson.ObjectIdHex("5b6d851c9d8c2119e3667a99")).One(&result) // using resultMenu instead of result will return an empty Menu object
	} else {
		err = ErrUnavailable
	}
	bsonBytes, _ := bson.Marshal(result)         // have to manually marshal and unmarshal data
	bson.Unmarshal(bsonBytes, &resultMenu)
	return resultMenu, standardizeError(err)
}

[ljluestc]

package main

import (
	"context"
	"errors"
	"time"

	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

// Menu represents the structure of the menu document in MongoDB
type Menu struct {
	ID    primitive.ObjectId `json:"_id" bson:"_id"`
	Value string             `json:"val" bson:"val"`
}

// DatabaseConfig holds MongoDB configuration
type DatabaseConfig struct {
	URI      string
	Database string
}

// Database holds the MongoDB client and configuration
type Database struct {
	Client *mongo.Client
	Config *DatabaseConfig
}

// ErrUnavailable is returned when the database connection is not available
var ErrUnavailable = errors.New("database connection unavailable")

// Connect initializes the MongoDB connection
func (d *Database) Connect() error {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	client, err := mongo.Connect(ctx, options.Client().ApplyURI(d.Config.URI))
	if err != nil {
		return err
	}
	d.Client = client
	return nil
}

// CheckConnection verifies if the database connection is active
func (d *Database) CheckConnection() bool {
	if d.Client == nil {
		return false
	}
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()
	return d.Client.Ping(ctx, nil) == nil
}

// Close terminates the MongoDB connection
func (d *Database) Close() error {
	if d.Client == nil {
		return nil
	}
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	return d.Client.Disconnect(ctx)
}

// GetData retrieves a Menu document by ID
func GetData(id string) (Menu, error) {
	var resultMenu Menu
	var err error

	database := &Database{
		Config: &DatabaseConfig{
			URI:      "mongodb://localhost:27017", // Replace with your MongoDB URI
			Database: "your_database_name",        // Replace with your database name
		},
	}

	// Connect to the database
	if err = database.Connect(); err != nil {
		return Menu{}, standardizeError(err)
	}
	defer database.Close()

	// Check connection
	if !database.CheckConnection() {
		return Menu{}, ErrUnavailable
	}

	// Convert string ID to ObjectID
	objID, err := primitive.ObjectIDFromHex(id)
	if err != nil {
		return Menu{}, standardizeError(err)
	}

	// Query the database
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	collection := database.Client.Database(database.Config.Database).Collection("menus")
	err = collection.FindOne(ctx, bson.M{"_id": objID}).Decode(&resultMenu)
	if err != nil {
		return Menu{}, standardizeError(err)
	}

	return resultMenu, nil
}

// standardizeError normalizes errors for consistent handling
func standardizeError(err error) error {
	if err == mongo.ErrNoDocuments {
		return errors.New("no document found")
	}
	return err
}

func main() {
	// Example usage
	menu, err := GetData("5b6d851c9d8c2119e3667a99")
	if err != nil {
		panic(err)
	}
	// Print the result
	// fmt.Printf("Menu: %+v\n", menu)
}