connect/repositories/repositories.go

package repositories

import (
	"context"

	"github.com/redis/go-redis/v9"
	"github.com/rotisserie/eris"
	"gorm.io/gorm"
	"sikey.com/websocket/models"
)

type TransactionFun func(ctx context.Context, repos *Repositories) error

type Repositories struct {
	source *gorm.DB
	rdb    *redis.Client

	//SessionRepository         SessionRepository
	OnlineRepository               OnlineRepository
	FirebaseMessageRepository      FirebaseMessageRepository
	MessageRepository              MessageRepository
	NotifyRepository               NotifyRepository
	SessionGroupRepository         SessionGroupRepository
	SessionSingleRepository        SessionSingleRepository
	FirebaseMessageQueueRepository FirebaseMessageQueueRepository
}

func NewRepositories(source *gorm.DB, rdb *redis.Client) *Repositories {
	return &Repositories{
		source: source,
		rdb:    rdb,

		//SessionRepository:         NewSessionRepository(source),
		OnlineRepository:               NewOnlineRepository(rdb),
		FirebaseMessageRepository:      NewFirebaseMessageRepository(source),
		MessageRepository:              NewMessageRepository(source),
		NotifyRepository:               NewNotifyRepository(source),
		SessionGroupRepository:         NewSessionGroupRepository(source),
		SessionSingleRepository:        NewSessionSingleRepository(source),
		FirebaseMessageQueueRepository: NewFirebaseMessageQueueRepository(source),
	}
}

func (repos *Repositories) Transaction(ctx context.Context, fn TransactionFun) error {
	return repos.source.Transaction(func(tx *gorm.DB) error {
		return fn(ctx, repos)
	})
}

func resultSlice[T any](mods []T, err error) ([]T, error) {
	switch {
	case err == nil:
		return mods, nil
	case eris.Is(err, models.ErrRecordNotFound):
		return make([]T, 0), nil
	default:
		return nil, err
	}
}

func result[T any](mod T, err error) (*T, error) {
	switch {
	case err == nil:
		return &mod, nil
	case eris.Is(err, models.ErrRecordNotFound):
		return nil, nil
	default:
		return nil, err
	}
}