Files
mtusi2026lab4/internal/storage/postgres/store.go
T
2026-10-21 21:22:42 +03:00

97 lines
2.3 KiB
Go

package postgres
import (
"context"
"fmt"
"time"
"github.com/jackc/pgx/v5/pgxpool"
"mtusi-messenger/internal/config"
"mtusi-messenger/internal/storage/postgres/internal/sqlcgen"
)
type Store struct {
pool *pgxpool.Pool
queries *sqlcgen.Queries
queryTimeout time.Duration
idempotencyTTL time.Duration
users *UserRepository
chats *ChatRepository
messages *MessageRepository
sessions *SessionRepository
}
func New(ctx context.Context, cfg config.Postgres, idempotencyTTL time.Duration) (*Store, error) {
cfg, err := normalize(cfg)
if err != nil {
return nil, fmt.Errorf("normalize database config: %w", err)
}
poolCfg, err := pgxpool.ParseConfig(cfg.DSN())
if err != nil {
return nil, fmt.Errorf("parse database dsn: %w", err)
}
poolCfg.MaxConns = cfg.MaxConns
poolCfg.MinConns = cfg.MinConns
poolCfg.MaxConnLifetime = cfg.MaxConnLifetime
poolCfg.MaxConnIdleTime = cfg.MaxConnIdleTime
poolCfg.ConnConfig.ConnectTimeout = cfg.ConnectTimeout
pool, err := pgxpool.NewWithConfig(ctx, poolCfg)
if err != nil {
return nil, fmt.Errorf("create pool: %w", err)
}
pingCtx, cancel := context.WithTimeout(ctx, cfg.ConnectTimeout)
defer cancel()
if err := pool.Ping(pingCtx); err != nil {
pool.Close()
return nil, fmt.Errorf("ping database: %w", err)
}
store := &Store{
pool: pool,
queries: sqlcgen.New(pool),
queryTimeout: cfg.QueryTimeout,
idempotencyTTL: idempotencyTTL,
}
store.users = &UserRepository{store: store}
store.chats = &ChatRepository{store: store}
store.messages = &MessageRepository{store: store}
store.sessions = &SessionRepository{store: store}
return store, nil
}
func (s *Store) Users() *UserRepository { return s.users }
func (s *Store) Chats() *ChatRepository { return s.chats }
func (s *Store) Messages() *MessageRepository { return s.messages }
func (s *Store) Sessions() *SessionRepository { return s.sessions }
func (s *Store) Ping(ctx context.Context) error {
if err := s.pool.Ping(ctx); err != nil {
return fmt.Errorf("ping database: %w", err)
}
return nil
}
func (s *Store) Close() { s.pool.Close() }
func (s *Store) timeout(ctx context.Context) (context.Context, context.CancelFunc) {
if s.queryTimeout <= 0 {
return context.WithCancel(ctx)
}
return context.WithTimeout(ctx, s.queryTimeout)
}