feat: convert package and dynamic price to unitconfig translation

Author: rolosp

api/spec/packages/aip/src/productcatalog/ratecard.tsp

@@ -3,6 +3,7 @@ import "../billing/tax.tsp";
 import "../features/index.tsp";
 import "../tax/codes.tsp";
 import "./price.tsp";
+import "./unitconfig.tsp";
 
 namespace ProductCatalog;
 
@@ -52,6 +53,18 @@ model RateCard {
   @summary("Price")
   price: Price;
 
+  /**
+   * Unit conversion configuration for the rate card.
+   *
+   * Synthesized on read for plans authored with v1 dynamic or package prices:
+   * dynamic prices map to a unit price with a multiply unit config, and
+   * package prices map to a unit price with a divide unit config.
+   * Not yet accepted on create or update.
+   */
+  @visibility(Lifecycle.Read)
+  @summary("Unit config")
+  unit_config?: UnitConfig;
+
   /**
    * The payment term of the rate card.
    * In advance payment term can only be used for flat prices.

api/v3/api.gen.go

@@ -16,28 +16,6 @@ import (
 	"github.com/openmeterio/openmeter/pkg/models"
 )
 
-var unsupportedV3PriceTypes = map[productcatalog.PriceType]struct{}{
-	productcatalog.DynamicPriceType: {},
-	productcatalog.PackagePriceType: {},
-}
-
-func hasUnsupportedV3Price(p plan.Plan) bool {
-	for _, phase := range p.Phases {
-		for _, rc := range phase.RateCards {
-			price := rc.AsMeta().Price
-			if price == nil {
-				continue
-			}
-
-			if _, unsupported := unsupportedV3PriceTypes[price.Type()]; unsupported {
-				return true
-			}
-		}
-	}
-
-	return false
-}
-
 func ToAPIBillingPlan(p plan.Plan) (api.BillingPlan, error) {
 	validationIssues, _ := p.AsProductCatalogPlan().ValidationErrors()
 
@@ -163,9 +141,54 @@ func ToAPIBillingRateCard(rc productcatalog.RateCard) (api.BillingRateCard, erro
 
 	result.Price = price
 
+	unitConfig, err := ToAPIBillingRateCardUnitConfig(meta.Price)
+	if err != nil {
+		return result, fmt.Errorf("failed to convert unit config: %w", err)
+	}
+
+	result.UnitConfig = unitConfig
+
 	return result, nil
 }
 
+// ToAPIBillingRateCardUnitConfig synthesizes a v3 unit config from a v1 dynamic
+// or package price. v3 does not surface dynamic or package prices directly;
+// instead they are rendered as a unit price paired with a unit config that
+// describes the conversion that v1 applied implicitly.
+func ToAPIBillingRateCardUnitConfig(p *productcatalog.Price) (*api.BillingUnitConfig, error) {
+	if p == nil {
+		return nil, nil
+	}
+
+	switch p.Type() {
+	case productcatalog.DynamicPriceType:
+		dynamic, err := p.AsDynamic()
+		if err != nil {
+			return nil, fmt.Errorf("failed to read dynamic price: %w", err)
+		}
+
+		return &api.BillingUnitConfig{
+			Operation:        api.BillingUnitConfigOperationMultiply,
+			ConversionFactor: dynamic.Multiplier.String(),
+		}, nil
+
+	case productcatalog.PackagePriceType:
+		pkg, err := p.AsPackage()
+		if err != nil {
+			return nil, fmt.Errorf("failed to read package price: %w", err)
+		}
+
+		return &api.BillingUnitConfig{
+			Operation:        api.BillingUnitConfigOperationDivide,
+			ConversionFactor: pkg.QuantityPerPackage.String(),
+			Rounding:         lo.ToPtr(api.BillingUnitConfigRoundingModeCeiling),
+		}, nil
+
+	default:
+		return nil, nil
+	}
+}
+
 func ToAPIBillingPrice(p *productcatalog.Price) (api.BillingPrice, error) {
 	var result api.BillingPrice
 
@@ -236,10 +259,29 @@ func ToAPIBillingPrice(p *productcatalog.Price) (api.BillingPrice, error) {
 		}
 
 	case productcatalog.DynamicPriceType:
-		return result, models.NewGenericConflictError(fmt.Errorf("dynamic price is not supported in v3 API"))
+		// Dynamic prices are surfaced in v3 as a unit price of amount 1; the
+		// multiplier is carried separately on the rate card's unit config.
+		if err := result.FromBillingPriceUnit(api.BillingPriceUnit{
+			Amount: "1",
+			Type:   api.BillingPriceUnitType("unit"),
+		}); err != nil {
+			return result, fmt.Errorf("failed to set unit price for dynamic price: %w", err)
+		}
 
 	case productcatalog.PackagePriceType:
-		return result, models.NewGenericConflictError(fmt.Errorf("package price is not supported in v3 API"))
+		// Package prices are surfaced in v3 as a unit price; the package size
+		// is carried separately on the rate card's unit config.
+		pkg, err := p.AsPackage()
+		if err != nil {
+			return result, fmt.Errorf("failed to read package price: %w", err)
+		}
+
+		if err = result.FromBillingPriceUnit(api.BillingPriceUnit{
+			Amount: pkg.Amount.String(),
+			Type:   api.BillingPriceUnitType("unit"),
+		}); err != nil {
+			return result, fmt.Errorf("failed to set unit price for package price: %w", err)
+		}
 
 	default:
 		return result, fmt.Errorf("unknown price type: %s", p.Type())

api/v3/handlers/plans/convert.go

@@ -529,25 +529,199 @@ func TestFromBillingPrice(t *testing.T) {
 		assert.Equal(t, "volume", disc)
 	})
 
-	t.Run("dynamic price returns conflict error", func(t *testing.T) {
-		p := productcatalog.NewPriceFrom(productcatalog.DynamicPrice{})
+	t.Run("dynamic price translates to unit price of amount 1", func(t *testing.T) {
+		p := productcatalog.NewPriceFrom(productcatalog.DynamicPrice{
+			Multiplier: decimal.NewFromFloat(1.2),
+		})
 
-		_, err := ToAPIBillingPrice(p)
-		require.Error(t, err)
-		assert.True(t, models.IsGenericConflictError(err))
-		assert.Contains(t, err.Error(), "dynamic price is not supported in v3 API")
+		result, err := ToAPIBillingPrice(p)
+		require.NoError(t, err)
+
+		disc, err := result.Discriminator()
+		require.NoError(t, err)
+		assert.Equal(t, "unit", disc)
+
+		unit, err := result.AsBillingPriceUnit()
+		require.NoError(t, err)
+		assert.Equal(t, api.Numeric("1"), unit.Amount)
+	})
+
+	t.Run("package price translates to unit price with package amount", func(t *testing.T) {
+		p := productcatalog.NewPriceFrom(productcatalog.PackagePrice{
+			Amount:             decimal.NewFromFloat(0.5),
+			QuantityPerPackage: decimal.NewFromInt(1000),
+		})
+
+		result, err := ToAPIBillingPrice(p)
+		require.NoError(t, err)
+
+		disc, err := result.Discriminator()
+		require.NoError(t, err)
+		assert.Equal(t, "unit", disc)
+
+		unit, err := result.AsBillingPriceUnit()
+		require.NoError(t, err)
+		assert.Equal(t, api.Numeric("0.5"), unit.Amount)
+	})
+}
+
+func TestToAPIBillingRateCardUnitConfig(t *testing.T) {
+	t.Run("nil price has no unit config", func(t *testing.T) {
+		result, err := ToAPIBillingRateCardUnitConfig(nil)
+		require.NoError(t, err)
+		assert.Nil(t, result)
+	})
+
+	t.Run("flat price has no unit config", func(t *testing.T) {
+		p := productcatalog.NewPriceFrom(productcatalog.FlatPrice{Amount: decimal.NewFromFloat(5)})
+
+		result, err := ToAPIBillingRateCardUnitConfig(p)
+		require.NoError(t, err)
+		assert.Nil(t, result)
+	})
+
+	t.Run("unit price has no unit config", func(t *testing.T) {
+		p := productcatalog.NewPriceFrom(productcatalog.UnitPrice{Amount: decimal.NewFromFloat(0.05)})
+
+		result, err := ToAPIBillingRateCardUnitConfig(p)
+		require.NoError(t, err)
+		assert.Nil(t, result)
 	})
 
-	t.Run("package price returns conflict error", func(t *testing.T) {
+	t.Run("dynamic price produces multiply unit config", func(t *testing.T) {
+		p := productcatalog.NewPriceFrom(productcatalog.DynamicPrice{
+			Multiplier: decimal.NewFromFloat(1.2),
+		})
+
+		result, err := ToAPIBillingRateCardUnitConfig(p)
+		require.NoError(t, err)
+		require.NotNil(t, result)
+		assert.Equal(t, api.BillingUnitConfigOperationMultiply, result.Operation)
+		assert.Equal(t, api.Numeric("1.2"), result.ConversionFactor)
+		assert.Nil(t, result.Rounding)
+		assert.Nil(t, result.Precision)
+		assert.Nil(t, result.DisplayUnit)
+	})
+
+	t.Run("package price produces divide unit config with ceiling rounding", func(t *testing.T) {
 		p := productcatalog.NewPriceFrom(productcatalog.PackagePrice{
 			Amount:             decimal.NewFromFloat(10),
-			QuantityPerPackage: decimal.NewFromInt(100),
+			QuantityPerPackage: decimal.NewFromInt(1000),
 		})
 
-		_, err := ToAPIBillingPrice(p)
-		require.Error(t, err)
-		assert.True(t, models.IsGenericConflictError(err))
-		assert.Contains(t, err.Error(), "package price is not supported in v3 API")
+		result, err := ToAPIBillingRateCardUnitConfig(p)
+		require.NoError(t, err)
+		require.NotNil(t, result)
+		assert.Equal(t, api.BillingUnitConfigOperationDivide, result.Operation)
+		assert.Equal(t, api.Numeric("1000"), result.ConversionFactor)
+		require.NotNil(t, result.Rounding)
+		assert.Equal(t, api.BillingUnitConfigRoundingModeCeiling, *result.Rounding)
+	})
+}
+
+func TestFromRateCard_DynamicAndPackagePrices(t *testing.T) {
+	cadence, err := datetime.ISODurationString("P1M").Parse()
+	require.NoError(t, err)
+
+	t.Run("dynamic price renders as unit price plus multiply unit config and preserves commitments", func(t *testing.T) {
+		minAmt := decimal.NewFromFloat(10)
+		maxAmt := decimal.NewFromFloat(100)
+		price := productcatalog.NewPriceFrom(productcatalog.DynamicPrice{
+			Multiplier: decimal.NewFromFloat(1.2),
+			Commitments: productcatalog.Commitments{
+				MinimumAmount: &minAmt,
+				MaximumAmount: &maxAmt,
+			},
+		})
+
+		rc := &productcatalog.UsageBasedRateCard{
+			RateCardMeta: productcatalog.RateCardMeta{
+				Key:   "tokens",
+				Name:  "Tokens",
+				Price: price,
+			},
+			BillingCadence: cadence,
+		}
+
+		result, err := ToAPIBillingRateCard(rc)
+		require.NoError(t, err)
+
+		disc, err := result.Price.Discriminator()
+		require.NoError(t, err)
+		assert.Equal(t, "unit", disc)
+
+		unit, err := result.Price.AsBillingPriceUnit()
+		require.NoError(t, err)
+		assert.Equal(t, api.Numeric("1"), unit.Amount)
+
+		require.NotNil(t, result.UnitConfig)
+		assert.Equal(t, api.BillingUnitConfigOperationMultiply, result.UnitConfig.Operation)
+		assert.Equal(t, api.Numeric("1.2"), result.UnitConfig.ConversionFactor)
+		assert.Nil(t, result.UnitConfig.Rounding)
+
+		require.NotNil(t, result.Commitments)
+		assert.Equal(t, lo.ToPtr(api.Numeric("10")), result.Commitments.MinimumAmount)
+		assert.Equal(t, lo.ToPtr(api.Numeric("100")), result.Commitments.MaximumAmount)
+	})
+
+	t.Run("package price renders as unit price plus divide unit config and preserves commitments", func(t *testing.T) {
+		minAmt := decimal.NewFromFloat(5)
+		price := productcatalog.NewPriceFrom(productcatalog.PackagePrice{
+			Amount:             decimal.NewFromFloat(0.5),
+			QuantityPerPackage: decimal.NewFromInt(1000),
+			Commitments: productcatalog.Commitments{
+				MinimumAmount: &minAmt,
+			},
+		})
+
+		rc := &productcatalog.UsageBasedRateCard{
+			RateCardMeta: productcatalog.RateCardMeta{
+				Key:   "api-calls",
+				Name:  "API Calls",
+				Price: price,
+			},
+			BillingCadence: cadence,
+		}
+
+		result, err := ToAPIBillingRateCard(rc)
+		require.NoError(t, err)
+
+		disc, err := result.Price.Discriminator()
+		require.NoError(t, err)
+		assert.Equal(t, "unit", disc)
+
+		unit, err := result.Price.AsBillingPriceUnit()
+		require.NoError(t, err)
+		assert.Equal(t, api.Numeric("0.5"), unit.Amount)
+
+		require.NotNil(t, result.UnitConfig)
+		assert.Equal(t, api.BillingUnitConfigOperationDivide, result.UnitConfig.Operation)
+		assert.Equal(t, api.Numeric("1000"), result.UnitConfig.ConversionFactor)
+		require.NotNil(t, result.UnitConfig.Rounding)
+		assert.Equal(t, api.BillingUnitConfigRoundingModeCeiling, *result.UnitConfig.Rounding)
+
+		require.NotNil(t, result.Commitments)
+		assert.Equal(t, lo.ToPtr(api.Numeric("5")), result.Commitments.MinimumAmount)
+		assert.Nil(t, result.Commitments.MaximumAmount)
+	})
+
+	t.Run("unit price has no unit config on rate card", func(t *testing.T) {
+		price := productcatalog.NewPriceFrom(productcatalog.UnitPrice{
+			Amount: decimal.NewFromFloat(0.05),
+		})
+
+		rc := &productcatalog.UsageBasedRateCard{
+			RateCardMeta: productcatalog.RateCardMeta{
+				Key:   "api-calls",
+				Name:  "API Calls",
+				Price: price,
+			},
+			BillingCadence: cadence,
+		}
+
+		result, err := ToAPIBillingRateCard(rc)
+		require.NoError(t, err)
+		assert.Nil(t, result.UnitConfig)
 	})
 }
 

api/v3/handlers/plans/convert_test.go

@@ -111,11 +111,6 @@ func (h *handler) ListPlans() ListPlansHandler {
 
 			items := make([]api.BillingPlan, 0, len(result.Items))
 			for _, p := range result.Items {
-				// FIXME: For now we skip plans containing price types not representable in v3 (e.g., package, dynamic). We'll add full bidirectional transform later on.
-				if hasUnsupportedV3Price(p) {
-					continue
-				}
-
 				billingPlan, err := ToAPIBillingPlan(p)
 				if err != nil {
 					return ListPlansResponse{}, err