Why does my redis cache return only part of the data

This function checks implements Postgres with Redis Cache
when I make the get request, with the first result all the data is returned, but when I make the next one certain fields of the data is missing

func (usr *UserImplementation) GetAllUsers(ctx context.Context) ([]models.User, error) {

	cachedUsers, err := databaseapi.Redis_CacheDB_Api()
	if err != nil {
		return nil, fmt.Errorf("error connecting to Redis cache: %v", err)
	}

	// pipe := cachedUsers.TxPipeline()

	cachedData, err := cachedUsers.Get(ctx, "users").Result()
	if err != nil && err != redis.Nil {
		return nil, fmt.Errorf("error retrieving cached data: %v", err)
	}

	if cachedData != "" {
		// Data found in the cache, return the cached data
		var cachedUsers []models.User
		err := json.Unmarshal([]byte(cachedData), &cachedUsers)
		if err != nil {
			return nil, fmt.Errorf("error unmarshaling cached data: %v", err)
		}
		return cachedUsers, nil
	}

	users, err := usr.pg.Postgres_DB_Api().DB.GetAllUsers(ctx)
	if err != nil {
		return nil, fmt.Errorf("error: %v", err.Error())
	}

	cacheData, err := json.Marshal(users)
	if err != nil {
		return nil, fmt.Errorf("error marshaling data for caching: %v", err)
	}

	expiration := time.Hour

	err = cachedUsers.Set(ctx, "users", string(cacheData), expiration).Err()
	if err != nil {
		return nil, fmt.Errorf("error caching data: %v", err)
	}

	return models.DatabaseUsersToUsers(users), nil

}

This is my User Struct: type User struct {
ID uuid.UUID json:"id"
FirstName string json:"first_name"
LastName string json:"last_name"
OtherName string json:"other_name"
Username string json:"user_name"
Password string json:"password"
Email string json:"email"
ProfileImage string json:"profile_image"
Status string json:"status"
IsAdmin bool json:"is_admin"
Role string json:"role"
Gender string json:"gender"
PhoneNumber string json:"phone_number"
CreatedAt time.Time json:"created_at"
UpdatedAt time.Time json:"updated_at"
}

I put together a small example to try to help you. As a premise, I simplified your example just to provide what matters here. As some parts of the program haven't been shared, I had to do some guesses. If the example is not useful, just let me know what's missing and I'll update my answer. Let's start with the commands I used to run Postgres/Redis locally with Docker.

The setup

The commands I used were:

1. docker run -d -p 54322:5432 -e POSTGRES_PASSWORD=postgres postgres
2. docker run -d --name redis-stack -p 6379:6379 -p 8001:8001 redis/redis-stack:latest

Now, let's switch to the code.

The program

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"time"

	"github.com/redis/go-redis/v9"
	"gorm.io/driver/postgres"
	"gorm.io/gorm"
)

type user struct {
	ID        int    `json:"id"`
	FirstName string `json:"first_name"`
	LastName  string `json:"last_name"`
}

func main() {
	// 1. instantiate clients
	dsn := "host=localhost port=54322 user=postgres password=postgres"
	db, err := gorm.Open(postgres.Open(dsn))
	if err != nil {
		panic(err)
	}
	redisClient := redis.NewClient(&redis.Options{
		Addr:     ":6379",
		Password: "",
		DB:       0,
	})

	// 2. automigrate objects & seed dummy data
	db.AutoMigrate(&user{})
	db.Create(&user{ID: 1, FirstName: "John", LastName: "Doe"})
	db.Create(&user{ID: 2, FirstName: "Suzy", LastName: "White"})

	// 3. attempt to retrieve from cache
	var users []user
	cachedUsers, err := redisClient.Get(context.Background(), "users").Result()
	if err != nil && err != redis.Nil {
		panic(fmt.Errorf("err retrieving cached data: %v", err))
	}
	if cachedUsers != "" {
		if err := json.Unmarshal([]byte(cachedUsers), &users); err != nil {
			panic(fmt.Errorf("err while unmarshaling data: %v", err))
		}
		fmt.Println("users taken from Redis")
		for _, v := range users {
			fmt.Println(v)
		}
		return
	}

	// 4. retrieve from the DB
	if err := db.Model(&user{}).Find(&users).Error; err != nil {
		panic(fmt.Errorf("err while retrieving from DB: %v", err))
	}

	// 5. set the key within the cache
	rawUsers, err := json.Marshal(users)
	if err != nil {
		panic(fmt.Errorf("err while marshaling users: %v", err))
	}
	if err := redisClient.Set(context.Background(), "users", rawUsers, time.Minute*15).Err(); err != nil {
		panic(fmt.Errorf("err while setting key in cache: %v", err))
	}
	fmt.Println("users taken from DB")
	for _, v := range users {
		fmt.Println(v)
	}
}

Let's take a closer look at each section (divided by numbered comments):

1. In the client initialization there isn't much to say. We initialized clients pointing toward our local instances
2. Then, we set the DB up with some dummy data
3. We try to get data from the Redis instance. If we find them, we print them out and we terminate the program
4. If no data are found in the cache, then we get them from the DB
5. Finally, if we get from the DB, it's safe to assume that we should put them into the cache as well

In both cases, we get the same amount of data with the same fields. So if you stick to this example and adjust it to your models and kind of project (mine is not a web project) you should be good. In case you still face issues, let me know. Thanks!