282 lines
8.1 KiB
Go
282 lines
8.1 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"strings"
|
|
|
|
"github.com/tech/sendico/payments/storage"
|
|
"github.com/tech/sendico/payments/storage/model"
|
|
"github.com/tech/sendico/pkg/db/repository"
|
|
"github.com/tech/sendico/pkg/db/repository/builder"
|
|
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/v2/bson"
|
|
"go.mongodb.org/mongo-driver/v2/mongo"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
const (
|
|
defaultPaymentPageSize int64 = 50
|
|
maxPaymentPageSize int64 = 200
|
|
)
|
|
|
|
type Payments struct {
|
|
logger mlogger.Logger
|
|
repo repository.Repository
|
|
}
|
|
|
|
// NewPayments constructs a Mongo-backed payments store.
|
|
func NewPayments(logger mlogger.Logger, repo repository.Repository) (*Payments, error) {
|
|
if repo == nil {
|
|
return nil, merrors.InvalidArgument("paymentsStore: repository is nil")
|
|
}
|
|
|
|
indexes := []*ri.Definition{
|
|
{
|
|
Keys: []ri.Key{{Field: "paymentRef", Sort: ri.Asc}},
|
|
Unique: true,
|
|
},
|
|
{
|
|
Keys: []ri.Key{{Field: "idempotencyKey", Sort: ri.Asc}, {Field: "organizationRef", Sort: ri.Asc}},
|
|
Unique: true,
|
|
},
|
|
{
|
|
Keys: []ri.Key{{Field: "state", Sort: ri.Asc}},
|
|
},
|
|
{
|
|
Keys: []ri.Key{{Field: "intent.source.managedWallet.managedWalletRef", Sort: ri.Asc}},
|
|
},
|
|
{
|
|
Keys: []ri.Key{{Field: "intent.destination.managedWallet.managedWalletRef", Sort: ri.Asc}},
|
|
},
|
|
{
|
|
Keys: []ri.Key{{Field: "execution.chainTransferRef", Sort: ri.Asc}},
|
|
},
|
|
{
|
|
Keys: []ri.Key{{Field: "executionPlan.steps.transferRef", Sort: ri.Asc}},
|
|
},
|
|
}
|
|
|
|
for _, def := range indexes {
|
|
if err := repo.CreateIndex(def); err != nil {
|
|
logger.Error("Failed to ensure payments index", zap.Error(err), zap.String("collection", repo.Collection()))
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
childLogger := logger.Named("payments")
|
|
childLogger.Debug("Payments store initialised")
|
|
|
|
return &Payments{
|
|
logger: childLogger,
|
|
repo: repo,
|
|
}, nil
|
|
}
|
|
|
|
func (p *Payments) Create(ctx context.Context, payment *model.Payment) error {
|
|
if payment == nil {
|
|
return merrors.InvalidArgument("paymentsStore: nil payment")
|
|
}
|
|
payment.Normalize()
|
|
if payment.PaymentRef == "" {
|
|
return merrors.InvalidArgument("paymentsStore: empty paymentRef")
|
|
}
|
|
if strings.TrimSpace(payment.IdempotencyKey) == "" {
|
|
return merrors.InvalidArgument("paymentsStore: empty idempotencyKey")
|
|
}
|
|
if payment.OrganizationRef == bson.NilObjectID {
|
|
return merrors.InvalidArgument("paymentsStore: organization_ref is required")
|
|
}
|
|
|
|
payment.Update()
|
|
filter := repository.OrgFilter(payment.OrganizationRef).And(
|
|
repository.Filter("idempotencyKey", payment.IdempotencyKey),
|
|
)
|
|
|
|
if err := p.repo.Insert(ctx, payment, filter); err != nil {
|
|
if errors.Is(err, merrors.ErrDataConflict) {
|
|
return storage.ErrDuplicatePayment
|
|
}
|
|
return err
|
|
}
|
|
p.logger.Debug("Payment created", zap.String("payment_ref", payment.PaymentRef))
|
|
return nil
|
|
}
|
|
|
|
func (p *Payments) Update(ctx context.Context, payment *model.Payment) error {
|
|
if payment == nil {
|
|
return merrors.InvalidArgument("paymentsStore: nil payment")
|
|
}
|
|
if payment.ID.IsZero() {
|
|
return merrors.InvalidArgument("paymentsStore: missing payment id")
|
|
}
|
|
payment.Normalize()
|
|
payment.Update()
|
|
if err := p.repo.Update(ctx, payment); err != nil {
|
|
if errors.Is(err, merrors.ErrNoData) {
|
|
return storage.ErrPaymentNotFound
|
|
}
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *Payments) GetByPaymentRef(ctx context.Context, paymentRef string) (*model.Payment, error) {
|
|
paymentRef = strings.TrimSpace(paymentRef)
|
|
if paymentRef == "" {
|
|
return nil, merrors.InvalidArgument("paymentsStore: empty paymentRef")
|
|
}
|
|
entity := &model.Payment{}
|
|
if err := p.repo.FindOneByFilter(ctx, repository.Filter("paymentRef", paymentRef), entity); err != nil {
|
|
if errors.Is(err, merrors.ErrNoData) {
|
|
return nil, storage.ErrPaymentNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
return entity, nil
|
|
}
|
|
|
|
func (p *Payments) GetByIdempotencyKey(ctx context.Context, orgRef bson.ObjectID, idempotencyKey string) (*model.Payment, error) {
|
|
idempotencyKey = strings.TrimSpace(idempotencyKey)
|
|
if orgRef == bson.NilObjectID {
|
|
return nil, merrors.InvalidArgument("paymentsStore: organization_ref is required")
|
|
}
|
|
if idempotencyKey == "" {
|
|
return nil, merrors.InvalidArgument("paymentsStore: empty idempotencyKey")
|
|
}
|
|
entity := &model.Payment{}
|
|
query := repository.OrgFilter(orgRef).And(repository.Filter("idempotencyKey", idempotencyKey))
|
|
if err := p.repo.FindOneByFilter(ctx, query, entity); err != nil {
|
|
if errors.Is(err, merrors.ErrNoData) {
|
|
return nil, storage.ErrPaymentNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
return entity, nil
|
|
}
|
|
|
|
func (p *Payments) GetByChainTransferRef(ctx context.Context, transferRef string) (*model.Payment, error) {
|
|
transferRef = strings.TrimSpace(transferRef)
|
|
if transferRef == "" {
|
|
return nil, merrors.InvalidArgument("paymentsStore: empty chain transfer reference")
|
|
}
|
|
entity := &model.Payment{}
|
|
query := repository.Query().Or(
|
|
repository.Filter("execution.chainTransferRef", transferRef),
|
|
repository.Filter("executionPlan.steps.transferRef", transferRef),
|
|
)
|
|
if err := p.repo.FindOneByFilter(ctx, query, entity); err != nil {
|
|
if errors.Is(err, merrors.ErrNoData) {
|
|
return nil, storage.ErrPaymentNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
return entity, nil
|
|
}
|
|
|
|
func (p *Payments) List(ctx context.Context, filter *model.PaymentFilter) (*model.PaymentList, error) {
|
|
if filter == nil {
|
|
filter = &model.PaymentFilter{}
|
|
}
|
|
|
|
query := repository.Query()
|
|
|
|
if len(filter.States) > 0 {
|
|
states := make([]string, 0, len(filter.States))
|
|
for _, state := range filter.States {
|
|
if trimmed := strings.TrimSpace(string(state)); trimmed != "" {
|
|
states = append(states, trimmed)
|
|
}
|
|
}
|
|
if len(states) > 0 {
|
|
query = query.Comparison(repository.Field("state"), builder.In, states)
|
|
}
|
|
}
|
|
|
|
if ref := strings.TrimSpace(filter.SourceRef); ref != "" {
|
|
if endpointFilter := endpointQuery("intent.source", ref); endpointFilter != nil {
|
|
query = query.And(endpointFilter)
|
|
}
|
|
}
|
|
if orgRef, err := bson.ObjectIDFromHex(strings.TrimSpace(filter.OrganizationRef)); err != nil {
|
|
p.logger.Warn("Failed to decode organization reference", zap.Error(err),
|
|
zap.String("provided_org_ref", filter.OrganizationRef))
|
|
return nil, err
|
|
} else {
|
|
query.And(repository.OrgFilter(orgRef))
|
|
}
|
|
|
|
if ref := strings.TrimSpace(filter.DestinationRef); ref != "" {
|
|
if endpointFilter := endpointQuery("intent.destination", ref); endpointFilter != nil {
|
|
query = query.And(endpointFilter)
|
|
}
|
|
}
|
|
|
|
if cursor := strings.TrimSpace(filter.Cursor); cursor != "" {
|
|
if oid, err := bson.ObjectIDFromHex(cursor); err == nil {
|
|
query = query.Comparison(repository.IDField(), builder.Gt, oid)
|
|
} else {
|
|
p.logger.Warn("Ignoring invalid payments cursor", zap.String("cursor", cursor), zap.Error(err))
|
|
}
|
|
}
|
|
|
|
limit := sanitizePaymentLimit(filter.Limit)
|
|
fetchLimit := limit + 1
|
|
query = query.Sort(repository.IDField(), true).Limit(&fetchLimit)
|
|
|
|
payments := make([]*model.Payment, 0, fetchLimit)
|
|
decoder := func(cur *mongo.Cursor) error {
|
|
item := &model.Payment{}
|
|
if err := cur.Decode(item); err != nil {
|
|
p.logger.Warn("Failed to decode item", zap.Error(err))
|
|
return err
|
|
}
|
|
payments = append(payments, item)
|
|
return nil
|
|
}
|
|
|
|
if err := p.repo.FindManyByFilter(ctx, query, decoder); err != nil && !errors.Is(err, merrors.ErrNoData) {
|
|
return nil, err
|
|
}
|
|
|
|
nextCursor := ""
|
|
if int64(len(payments)) == fetchLimit {
|
|
last := payments[len(payments)-1]
|
|
nextCursor = last.ID.Hex()
|
|
payments = payments[:len(payments)-1]
|
|
}
|
|
|
|
return &model.PaymentList{
|
|
Items: payments,
|
|
NextCursor: nextCursor,
|
|
}, nil
|
|
}
|
|
|
|
func endpointQuery(prefix, ref string) builder.Query {
|
|
trimmed := strings.TrimSpace(ref)
|
|
if trimmed == "" {
|
|
return nil
|
|
}
|
|
|
|
lower := strings.ToLower(trimmed)
|
|
filters := []builder.Query{
|
|
repository.Filter(prefix+".ledger.ledgerAccountRef", trimmed),
|
|
repository.Filter(prefix+".managedWallet.managedWalletRef", trimmed),
|
|
repository.Filter(prefix+".externalChain.address", lower),
|
|
}
|
|
|
|
return repository.Query().Or(filters...)
|
|
}
|
|
|
|
func sanitizePaymentLimit(requested int32) int64 {
|
|
if requested <= 0 {
|
|
return defaultPaymentPageSize
|
|
}
|
|
if requested > int32(maxPaymentPageSize) {
|
|
return maxPaymentPageSize
|
|
}
|
|
return int64(requested)
|
|
}
|