feat: add expand option to currency list api (#4771)

Author: chrisgacsal

openmeter/currencies/adapter/currencies.go

@@ -168,6 +168,12 @@ func (a *adapter) ListCustomCurrencies(ctx context.Context, params currencies.Li
 			q = filter.ApplyToQuery(q, params.Code, customcurrency.FieldCode)
 		}
 
+		now := clock.Now()
+
+		if params.CurrencyExpandOptions.CostBasis {
+			q = WithCostBasis(q, now)
+		}
+
 		order := entutils.GetOrdering(sortx.OrderDefault)
 		if !params.Order.IsDefaultValue() {
 			order = entutils.GetOrdering(params.Order)
@@ -327,7 +333,7 @@ func (a *adapter) GetCurrency(ctx context.Context, params currencies.GetCurrency
 	return entutils.TransactingRepo(ctx, a, func(ctx context.Context, tx *adapter) (currencies.Currency, error) {
 		at := clock.Now()
 
-		qetQuery := tx.db.CustomCurrency.Query().
+		q := tx.db.CustomCurrency.Query().
 			Where(
 				customcurrency.Namespace(params.Namespace),
 				customcurrency.ID(params.ID),
@@ -337,7 +343,11 @@ func (a *adapter) GetCurrency(ctx context.Context, params currencies.GetCurrency
 				),
 			)
 
-		c, err := qetQuery.First(ctx)
+		if params.CostBasis {
+			q = WithCostBasis(q, at)
+		}
+
+		c, err := q.First(ctx)
 		if err != nil {
 			if entdb.IsNotFound(err) {
 				return currencies.Currency{}, models.NewGenericNotFoundError(
@@ -353,42 +363,42 @@ func (a *adapter) GetCurrency(ctx context.Context, params currencies.GetCurrency
 			return currencies.Currency{}, fmt.Errorf("failed to map currency from database: %w", err)
 		}
 
-		if params.CostBasis {
-			if c.DeletedAt != nil {
-				at = *c.DeletedAt
-			}
+		return curr, nil
+	})
+}
 
-			costBasisQuery := tx.db.CurrencyCostBasis.Query().
-				Where(
-					currencycostbasis.Namespace(params.Namespace),
-					currencycostbasis.CurrencyID(params.ID),
-					currencycostbasis.EffectiveFromLTE(at),
-					currencycostbasis.Or(
-						currencycostbasis.EffectiveToIsNil(),
-						currencycostbasis.EffectiveToGT(at),
+func WithCostBasis(q *entdb.CustomCurrencyQuery, at time.Time) *entdb.CustomCurrencyQuery {
+	return q.WithCostBasisHistory(func(query *entdb.CurrencyCostBasisQuery) {
+		query.Where(func(s *sql.Selector) {
+			ct := sql.Table(customcurrency.Table)
+
+			s.Join(ct).On(ct.C(customcurrency.FieldID), s.C(currencycostbasis.FieldCurrencyID))
+
+			s.Where(
+				sql.Or(
+					sql.And(
+						sql.NotNull(ct.C(customcurrency.FieldDeletedAt)),
+						sql.ColumnsEQ(s.C(currencycostbasis.FieldDeletedAt), ct.C(currencycostbasis.FieldDeletedAt)),
+						sql.ColumnsLTE(s.C(currencycostbasis.FieldEffectiveFrom), ct.C(customcurrency.FieldDeletedAt)),
+						sql.Or(
+							sql.IsNull(s.C(currencycostbasis.FieldEffectiveTo)),
+							sql.ColumnsGT(s.C(currencycostbasis.FieldEffectiveTo), ct.C(customcurrency.FieldDeletedAt)),
+						),
+					),
+					sql.And(
+						sql.IsNull(ct.C(customcurrency.FieldDeletedAt)),
+						sql.Or(
+							sql.IsNull(s.C(currencycostbasis.FieldDeletedAt)),
+							sql.GT(s.C(currencycostbasis.FieldDeletedAt), at),
+						),
+						sql.LTE(s.C(currencycostbasis.FieldEffectiveFrom), at),
+						sql.Or(
+							sql.IsNull(s.C(currencycostbasis.FieldEffectiveTo)),
+							sql.GT(s.C(currencycostbasis.FieldEffectiveTo), at),
+						),
 					),
-				)
-
-			cbs, err := costBasisQuery.All(ctx)
-			if err != nil {
-				if entdb.IsNotFound(err) {
-					return currencies.Currency{}, models.NewGenericNotFoundError(
-						fmt.Errorf("currency with id %s not found", params.ID),
-					)
-				}
-
-				return currencies.Currency{}, fmt.Errorf("failed to get currency: %w", err)
-			}
-
-			curr.CostBasis = lo.ToPtr(
-				lo.Map[*entdb.CurrencyCostBasis, currencies.CostBasis](cbs,
-					func(item *entdb.CurrencyCostBasis, _ int) currencies.CostBasis {
-						return mapCostBasisFromDB(item)
-					},
 				),
 			)
-		}
-
-		return curr, nil
+		})
 	})
 }

openmeter/currencies/currencyresolver/resolver.go

@@ -118,6 +118,9 @@ func (r *resolver) BatchResolveCurrencies(ctx context.Context, namespace string,
 			FilteringOptions: currencies.FilteringOptions{
 				Union: true,
 			},
+			CurrencyExpandOptions: currencies.CurrencyExpandOptions{
+				CostBasis: true,
+			},
 			Namespace: namespace,
 			ID:        idFilter,
 			Code:      codeFilter,

openmeter/currencies/service.go

@@ -61,6 +61,7 @@ type FilteringOptions struct {
 type ListCurrenciesInput struct {
 	pagination.Page
 	FilteringOptions
+	CurrencyExpandOptions
 
 	Namespace string `json:"namespace"`
 

openmeter/currencies/service/service_test.go

@@ -190,6 +190,72 @@ func TestCurrenciesService(t *testing.T) {
 					})
 				})
 
+				t.Run("ListWithCostBasis", func(t *testing.T) {
+					// given:
+					// - a custom currency with an active USD cost basis
+					testCases := []struct {
+						name             string
+						currencyType     *currencies.CurrencyType
+						expectedTotal    int
+						expectFiatResult bool
+					}{
+						{
+							name:          "custom currencies",
+							currencyType:  lo.ToPtr(currencies.CurrencyTypeCustom),
+							expectedTotal: 1,
+						},
+						{
+							name:             "custom and fiat currencies",
+							expectedTotal:    2,
+							expectFiatResult: true,
+						},
+					}
+
+					for _, testCase := range testCases {
+						t.Run(testCase.name, func(t *testing.T) {
+							// when:
+							// - currencies are listed with cost-basis data expanded
+							result, err := env.Service.ListCurrencies(t.Context(), currencies.ListCurrenciesInput{
+								Page:         pagination.NewPage(1, 10),
+								Namespace:    namespace,
+								CurrencyType: testCase.currencyType,
+								Code: &filter.FilterString{
+									In: lo.ToPtr([]string{"TOKENS", "USD"}),
+								},
+								CurrencyExpandOptions: currencies.CurrencyExpandOptions{
+									CostBasis: true,
+								},
+							})
+
+							// then:
+							// - custom currencies include active cost-basis data while fiat currencies do not
+							require.NoError(t, err)
+							require.Equal(t, testCase.expectedTotal, result.TotalCount)
+							require.Len(t, result.Items, testCase.expectedTotal)
+
+							customCurrencies := lo.Filter(result.Items, func(item currencies.Currency, _ int) bool {
+								return item.Type() == currencyx.CurrencyTypeCustom
+							})
+							require.Len(t, customCurrencies, 1)
+							assert.Equal(t, createdCurrency.ID, customCurrencies[0].ID)
+							require.NotNil(t, customCurrencies[0].CostBasis)
+							require.Len(t, *customCurrencies[0].CostBasis, 1)
+							assert.Equal(t, usd.ID, (*customCurrencies[0].CostBasis)[0].ID)
+
+							fiatCurrencies := lo.Filter(result.Items, func(item currencies.Currency, _ int) bool {
+								return item.Type() == currencyx.CurrencyTypeFiat
+							})
+							if testCase.expectFiatResult {
+								require.Len(t, fiatCurrencies, 1)
+								assert.Equal(t, currencyx.Code("USD"), fiatCurrencies[0].Details().Code)
+								assert.Nil(t, fiatCurrencies[0].CostBasis)
+							} else {
+								assert.Empty(t, fiatCurrencies)
+							}
+						})
+					}
+				})
+
 				t.Run("Multiple", func(t *testing.T) {
 					// given:
 					// - a custom currency with an active USD cost basis
@@ -318,6 +384,94 @@ func TestCurrenciesService(t *testing.T) {
 			})
 		})
 
+		t.Run("ListDeletedCurrencyWithCostBasis", func(t *testing.T) {
+			// given:
+			// - a deleted custom currency whose cost-basis history contains entries that were expired, active, and future at deletion
+			deletedNamespace := currenciestestutils.NewTestNamespace(t)
+			deletedCurrency, err := env.Service.CreateCurrency(t.Context(), currencies.CreateCurrencyInput{
+				Namespace: deletedNamespace,
+				CurrencyDetails: currencyx.CurrencyDetails{
+					Code:               "CREDITS",
+					Name:               "Credits",
+					Symbol:             "C",
+					Precision:          2,
+					DecimalMark:        ".",
+					ThousandsSeparator: ",",
+				},
+			})
+			require.NoError(t, err)
+
+			deletedAt := now.Add(-24 * time.Hour)
+			costBasisFixtures := []struct {
+				fiatCode      currencyx.Code
+				effectiveFrom time.Time
+				effectiveTo   *time.Time
+				active        bool
+			}{
+				{
+					fiatCode:      "EUR",
+					effectiveFrom: deletedAt.Add(-48 * time.Hour),
+					effectiveTo:   lo.ToPtr(deletedAt.Add(-time.Hour)),
+				},
+				{
+					fiatCode:      "USD",
+					effectiveFrom: deletedAt.Add(-time.Hour),
+					effectiveTo:   lo.ToPtr(deletedAt.Add(time.Hour)),
+					active:        true,
+				},
+				{
+					fiatCode:      "GBP",
+					effectiveFrom: deletedAt.Add(time.Hour),
+				},
+			}
+
+			var activeCostBasisID string
+			for _, fixture := range costBasisFixtures {
+				costBasis, err := env.Client.CurrencyCostBasis.Create().
+					SetNamespace(deletedNamespace).
+					SetCurrencyID(deletedCurrency.ID).
+					SetFiatCode(fixture.fiatCode).
+					SetRate(alpacadecimal.RequireFromString("1")).
+					SetEffectiveFrom(fixture.effectiveFrom).
+					SetNillableEffectiveTo(fixture.effectiveTo).
+					SetDeletedAt(deletedAt).
+					Save(t.Context())
+				require.NoError(t, err)
+
+				if fixture.active {
+					activeCostBasisID = costBasis.ID
+				}
+			}
+			require.NotEmpty(t, activeCostBasisID)
+
+			_, err = env.Client.CustomCurrency.UpdateOneID(deletedCurrency.ID).
+				SetDeletedAt(deletedAt).
+				Save(t.Context())
+			require.NoError(t, err)
+
+			// when:
+			// - the deleted currency is listed with cost-basis data expanded
+			result, err := env.Service.ListCurrencies(t.Context(), currencies.ListCurrenciesInput{
+				Page:         pagination.NewPage(1, 10),
+				Namespace:    deletedNamespace,
+				CurrencyType: lo.ToPtr(currencies.CurrencyTypeCustom),
+				Code: &filter.FilterString{
+					In: lo.ToPtr([]string{"CREDITS"}),
+				},
+				CurrencyExpandOptions: currencies.CurrencyExpandOptions{
+					CostBasis: true,
+				},
+			})
+
+			// then:
+			// - only the cost basis effective at the currency's deletion time is returned
+			require.NoError(t, err)
+			require.Len(t, result.Items, 1)
+			require.NotNil(t, result.Items[0].CostBasis)
+			require.Len(t, *result.Items[0].CostBasis, 1)
+			assert.Equal(t, activeCostBasisID, (*result.Items[0].CostBasis)[0].ID)
+		})
+
 		t.Run("List", func(t *testing.T) {
 			// given:
 			// - independently persisted custom currencies