133 lines
3.1 KiB
Go
133 lines
3.1 KiB
Go
package mongo
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
"github.com/tech/sendico/ledger/storage"
|
|
"github.com/tech/sendico/ledger/storage/mongo/store"
|
|
"github.com/tech/sendico/pkg/db"
|
|
"github.com/tech/sendico/pkg/db/transaction"
|
|
"github.com/tech/sendico/pkg/merrors"
|
|
"github.com/tech/sendico/pkg/mlogger"
|
|
"go.mongodb.org/mongo-driver/mongo"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
type Store struct {
|
|
logger mlogger.Logger
|
|
conn *db.MongoConnection
|
|
db *mongo.Database
|
|
txFactory transaction.Factory
|
|
|
|
accounts storage.AccountsStore
|
|
journalEntries storage.JournalEntriesStore
|
|
postingLines storage.PostingLinesStore
|
|
balances storage.BalancesStore
|
|
outbox storage.OutboxStore
|
|
}
|
|
|
|
func New(logger mlogger.Logger, conn *db.MongoConnection) (*Store, error) {
|
|
if conn == nil {
|
|
return nil, merrors.InvalidArgument("mongo connection is nil")
|
|
}
|
|
|
|
client := conn.Client()
|
|
if client == nil {
|
|
return nil, merrors.Internal("mongo client not initialised")
|
|
}
|
|
|
|
db := conn.Database()
|
|
txFactory := newMongoTransactionFactory(client)
|
|
|
|
s := &Store{
|
|
logger: logger.Named("storage").Named("mongo"),
|
|
conn: conn,
|
|
db: db,
|
|
txFactory: txFactory,
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
|
|
defer cancel()
|
|
|
|
if err := s.Ping(ctx); err != nil {
|
|
s.logger.Error("mongo ping failed during store init", zap.Error(err))
|
|
return nil, err
|
|
}
|
|
|
|
// Initialize stores
|
|
accountsStore, err := store.NewAccounts(s.logger, db)
|
|
if err != nil {
|
|
s.logger.Error("failed to initialize accounts store", zap.Error(err))
|
|
return nil, err
|
|
}
|
|
|
|
journalEntriesStore, err := store.NewJournalEntries(s.logger, db)
|
|
if err != nil {
|
|
s.logger.Error("failed to initialize journal entries store", zap.Error(err))
|
|
return nil, err
|
|
}
|
|
|
|
postingLinesStore, err := store.NewPostingLines(s.logger, db)
|
|
if err != nil {
|
|
s.logger.Error("failed to initialize posting lines store", zap.Error(err))
|
|
return nil, err
|
|
}
|
|
|
|
balancesStore, err := store.NewBalances(s.logger, db)
|
|
if err != nil {
|
|
s.logger.Error("failed to initialize balances store", zap.Error(err))
|
|
return nil, err
|
|
}
|
|
|
|
outboxStore, err := store.NewOutbox(s.logger, db)
|
|
if err != nil {
|
|
s.logger.Error("failed to initialize outbox store", zap.Error(err))
|
|
return nil, err
|
|
}
|
|
|
|
s.accounts = accountsStore
|
|
s.journalEntries = journalEntriesStore
|
|
s.postingLines = postingLinesStore
|
|
s.balances = balancesStore
|
|
s.outbox = outboxStore
|
|
|
|
s.logger.Info("Ledger MongoDB storage initialized")
|
|
|
|
return s, nil
|
|
}
|
|
|
|
func (s *Store) Ping(ctx context.Context) error {
|
|
return s.conn.Ping(ctx)
|
|
}
|
|
|
|
func (s *Store) Accounts() storage.AccountsStore {
|
|
return s.accounts
|
|
}
|
|
|
|
func (s *Store) JournalEntries() storage.JournalEntriesStore {
|
|
return s.journalEntries
|
|
}
|
|
|
|
func (s *Store) PostingLines() storage.PostingLinesStore {
|
|
return s.postingLines
|
|
}
|
|
|
|
func (s *Store) Balances() storage.BalancesStore {
|
|
return s.balances
|
|
}
|
|
|
|
func (s *Store) Outbox() storage.OutboxStore {
|
|
return s.outbox
|
|
}
|
|
|
|
func (s *Store) Database() *mongo.Database {
|
|
return s.db
|
|
}
|
|
|
|
func (s *Store) TransactionFactory() transaction.Factory {
|
|
return s.txFactory
|
|
}
|
|
|
|
var _ storage.Repository = (*Store)(nil)
|