quotation bff

api/payments/orchestrator/storage/mongo/repository.go

@@ -18,6 +18,7 @@ type Store struct {
 	ping   func(context.Context) error
 
 	payments storage.PaymentsStore
+	quotes   storage.QuotesStore
 }
 
 // New constructs a Mongo-backed payments repository from a Mongo connection.
@@ -25,28 +26,37 @@ func New(logger mlogger.Logger, conn *db.MongoConnection) (*Store, error) {
 	if conn == nil {
 		return nil, merrors.InvalidArgument("payments.storage.mongo: connection is nil")
 	}
-	repo := repository.CreateMongoRepository(conn.Database(), (&model.Payment{}).Collection())
-	return NewWithRepository(logger, conn.Ping, repo)
+	paymentsRepo := repository.CreateMongoRepository(conn.Database(), (&model.Payment{}).Collection())
+	quotesRepo := repository.CreateMongoRepository(conn.Database(), (&model.PaymentQuoteRecord{}).Collection())
+	return NewWithRepository(logger, conn.Ping, paymentsRepo, quotesRepo)
 }
 
 // NewWithRepository constructs a payments repository using the provided primitives.
-func NewWithRepository(logger mlogger.Logger, ping func(context.Context) error, paymentsRepo repository.Repository) (*Store, error) {
+func NewWithRepository(logger mlogger.Logger, ping func(context.Context) error, paymentsRepo repository.Repository, quotesRepo repository.Repository) (*Store, error) {
 	if ping == nil {
 		return nil, merrors.InvalidArgument("payments.storage.mongo: ping func is nil")
 	}
 	if paymentsRepo == nil {
 		return nil, merrors.InvalidArgument("payments.storage.mongo: payments repository is nil")
 	}
+	if quotesRepo == nil {
+		return nil, merrors.InvalidArgument("payments.storage.mongo: quotes repository is nil")
+	}
 
 	childLogger := logger.Named("storage").Named("mongo")
 	paymentsStore, err := store.NewPayments(childLogger, paymentsRepo)
 	if err != nil {
 		return nil, err
 	}
+	quotesStore, err := store.NewQuotes(childLogger, quotesRepo)
+	if err != nil {
+		return nil, err
+	}
 	result := &Store{
 		logger:   childLogger,
 		ping:     ping,
 		payments: paymentsStore,
+		quotes:   quotesStore,
 	}
 
 	return result, nil
@@ -65,4 +75,9 @@ func (s *Store) Payments() storage.PaymentsStore {
 	return s.payments
 }
 
+// Quotes returns the quotes store.
+func (s *Store) Quotes() storage.QuotesStore {
+	return s.quotes
+}
+
 var _ storage.Repository = (*Store)(nil)

api/payments/orchestrator/storage/mongo/store/quotes.go

@@ -0,0 +1,113 @@
+package store
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"time"
+
+	"github.com/tech/sendico/payments/orchestrator/storage"
+	"github.com/tech/sendico/payments/orchestrator/storage/model"
+	"github.com/tech/sendico/pkg/db/repository"
+	ri "github.com/tech/sendico/pkg/db/repository/index"
+	"github.com/tech/sendico/pkg/merrors"
+	"github.com/tech/sendico/pkg/mlogger"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.uber.org/zap"
+)
+
+type Quotes struct {
+	logger mlogger.Logger
+	repo   repository.Repository
+}
+
+// NewQuotes constructs a Mongo-backed quotes store.
+func NewQuotes(logger mlogger.Logger, repo repository.Repository) (*Quotes, error) {
+	if repo == nil {
+		return nil, merrors.InvalidArgument("quotesStore: repository is nil")
+	}
+
+	indexes := []*ri.Definition{
+		{
+			Keys:   []ri.Key{{Field: "quoteRef", Sort: ri.Asc}},
+			Unique: true,
+		},
+		{
+			Keys: []ri.Key{{Field: "organizationRef", Sort: ri.Asc}},
+		},
+		{
+			Keys:               []ri.Key{{Field: "expiresAt", Sort: ri.Asc}},
+			ExpireAfterSeconds: 0,
+		},
+	}
+
+	for _, def := range indexes {
+		if err := repo.CreateIndex(def); err != nil {
+			logger.Error("failed to ensure quotes index", zap.Error(err), zap.String("collection", repo.Collection()))
+			return nil, err
+		}
+	}
+
+	return &Quotes{
+		logger: logger.Named("quotes"),
+		repo:   repo,
+	}, nil
+}
+
+func (q *Quotes) Create(ctx context.Context, quote *model.PaymentQuoteRecord) error {
+	if quote == nil {
+		return merrors.InvalidArgument("quotesStore: nil quote")
+	}
+	quote.QuoteRef = strings.TrimSpace(quote.QuoteRef)
+	if quote.QuoteRef == "" {
+		return merrors.InvalidArgument("quotesStore: empty quoteRef")
+	}
+	if quote.OrganizationRef == primitive.NilObjectID {
+		return merrors.InvalidArgument("quotesStore: organization_ref is required")
+	}
+	if quote.ExpiresAt.IsZero() {
+		return merrors.InvalidArgument("quotesStore: expires_at is required")
+	}
+	if quote.Intent.Attributes != nil {
+		for k, v := range quote.Intent.Attributes {
+			quote.Intent.Attributes[k] = strings.TrimSpace(v)
+		}
+	}
+	quote.Update()
+
+	filter := repository.OrgFilter(quote.OrganizationRef).And(
+		repository.Filter("quoteRef", quote.QuoteRef),
+	)
+
+	if err := q.repo.Insert(ctx, quote, filter); err != nil {
+		if errors.Is(err, merrors.ErrDataConflict) {
+			return storage.ErrDuplicateQuote
+		}
+		return err
+	}
+	return nil
+}
+
+func (q *Quotes) GetByRef(ctx context.Context, orgRef primitive.ObjectID, quoteRef string) (*model.PaymentQuoteRecord, error) {
+	quoteRef = strings.TrimSpace(quoteRef)
+	if quoteRef == "" {
+		return nil, merrors.InvalidArgument("quotesStore: empty quoteRef")
+	}
+	if orgRef == primitive.NilObjectID {
+		return nil, merrors.InvalidArgument("quotesStore: organization_ref is required")
+	}
+	entity := &model.PaymentQuoteRecord{}
+	query := repository.OrgFilter(orgRef).And(repository.Filter("quoteRef", quoteRef))
+	if err := q.repo.FindOneByFilter(ctx, query, entity); err != nil {
+		if errors.Is(err, merrors.ErrNoData) {
+			return nil, storage.ErrQuoteNotFound
+		}
+		return nil, err
+	}
+	if !entity.ExpiresAt.IsZero() && time.Now().After(entity.ExpiresAt) {
+		return nil, storage.ErrQuoteNotFound
+	}
+	return entity, nil
+}
+
+var _ storage.QuotesStore = (*Quotes)(nil)