How to return nested entities after creating a new object?

Question

Model Account contains nested structures - Currency and User

When I create a new instance of Account in DB, and then return it in my response, nested entities are empty:

type Account struct {
    BaseModel
    Name       string          `gorm:"size:64;not null" json:"name"`
    Balance    decimal.Decimal `gorm:"type:decimal(16, 2);default:0;not null;" json:"balance"`
    UserID     int             `gorm:"not null" json:"-"`
    User       User            `gorm:"foreignKey:UserID" json:"user"`
    CurrencyID int             `gorm:"not null" json:"-"`
    Currency   Currency        `gorm:"foreignKey:CurrencyID" json:"currency"`
}

type CreateAccountBody struct {
    Name       string          `json:"name" binding:"required"`
    Balance    decimal.Decimal `json:"balance"`
    CurrencyID int             `json:"currency_id" binding:"required"`
}

func CreateAccount(ctx *gin.Context) {
    body := CreateAccountBody{}

    if err := ctx.Bind(&body); err != nil {
        log.Println("Error while binding body:", err)
        ctx.JSON(
            http.StatusBadRequest,
            gin.H{"error": "Wrong request parameters"},
        )
        return
    }

    account := Account {
        Name:       body.Name,
        Balance:    body.Balance,
        CurrencyID: body.CurrencyID,
        UserID:     1,
    }
    
    if result := db.DB.Create(&account); result.Error != nil {
        log.Println("Unable to create an account:", result.Error)
    }    

    ctx.JSON(http.StatusCreated, gin.H{"data": account})
}

To avoid this problem, I refresh account variable with separate query:

db.DB.Create(&account)
db.DB.Preload("User").Preload("Currency").Find(&account, account.ID)
ctx.JSON(http.StatusCreated, gin.H{"data": account})

Is this the most effective and correct way to achieve the desired result?

Answer 1

I'm gonna share you how usually I managed this scenario. First, let me share the code.

main.go file

package main

import (
    "context"

    "gogindemo/handlers"

    "github.com/gin-gonic/gin"
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
)

var (
    db  *gorm.DB
    ctx *gin.Context
)

func init() {
    dsn := "host=localhost user=postgres password=postgres dbname=postgres port=5432 sslmode=disable"
    var err error
    db, err = gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        panic(err)
    }

    db.AutoMigrate(&handlers.Currency{})
    db.AutoMigrate(&handlers.User{})
    db.AutoMigrate(&handlers.Account{})
}

func AddDb() gin.HandlerFunc {
    return func(ctx *gin.Context) {
        ctx.Request = ctx.Request.WithContext(context.WithValue(ctx.Request.Context(), "DB", db))
        ctx.Next()
    }
}

func main() {
    db.Create(&handlers.User{Id: 1, Name: "john doe"})
    db.Create(&handlers.User{Id: 2, Name: "mary hut"})
    db.Create(&handlers.Currency{Id: 1, Name: "EUR"})
    db.Create(&handlers.Currency{Id: 2, Name: "USD"})

    r := gin.Default()
    r.POST("/account", AddDb(), handlers.CreateAccount)

    r.Run()
}

Here, I've just added the code for bootstrapping the database objects and add some dummy data to it.

handlers/handlers.go file

package handlers

import (
    "net/http"

    "github.com/gin-gonic/gin"
    "github.com/shopspring/decimal"
    "gorm.io/gorm"
)

type User struct {
    Id   int
    Name string
}

type Currency struct {
    Id   int
    Name string
}

type Account struct {
    Id         int
    Name       string          `gorm:"size:64;not null" json:"name"`
    Balance    decimal.Decimal `gorm:"type:decimal(16, 2);default:0;not null;" json:"balance"`
    UserID     int             `gorm:"not null" json:"-"`
    User       User            `gorm:"foreignKey:UserID" json:"user"`
    CurrencyID int             `gorm:"not null" json:"-"`
    Currency   Currency        `gorm:"foreignKey:CurrencyID" json:"currency"`
}

type CreateAccountBody struct {
    Name       string          `json:"name" binding:"required"`
    Balance    decimal.Decimal `json:"balance"`
    CurrencyID int             `json:"currency_id" binding:"required"`
}

func CreateAccount(c *gin.Context) {
    db, ok := c.Request.Context().Value("DB").(*gorm.DB)
    if !ok {
        c.JSON(http.StatusInternalServerError, gin.H{"error": "internal server error"})
        return
    }
    var accountReq CreateAccountBody
    if err := c.BindJSON(&accountReq); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": "wrong request body payload"})
        return
    }

    // create Account & update the "account" variable
    account := Account{Name: accountReq.Name, Balance: accountReq.Balance, CurrencyID: accountReq.CurrencyID, UserID: 1}
    db.Create(&account).Preload("Currency").Preload("User").Find(&account, account.Id)

    c.IndentedJSON(http.StatusCreated, account)
}

Within this file, I actually talk with the database through the DB passed in the context. Now, back to your question.
If the relationship between the Currency/Account and User/Account is of type 1:1, then, you should rely on the Preload clause. This will load the related entity in a separate query instead of adding it in an INNER JOIN clause.

Let me know if this solves your issue, thanks!