chore: prior run values

Author: turip

openmeter/billing/charges/usagebased/service/creditheninvoice.go

@@ -11,7 +11,6 @@ import (
 	"github.com/openmeterio/openmeter/openmeter/billing"
 	"github.com/openmeterio/openmeter/openmeter/billing/charges/meta"
 	"github.com/openmeterio/openmeter/openmeter/billing/charges/usagebased"
-	usagebasedrating "github.com/openmeterio/openmeter/openmeter/billing/charges/usagebased/service/rating"
 	usagebasedrun "github.com/openmeterio/openmeter/openmeter/billing/charges/usagebased/service/run"
 	"github.com/openmeterio/openmeter/openmeter/productcatalog"
 	"github.com/openmeterio/openmeter/pkg/statelessx"
@@ -248,16 +247,15 @@ func (s *CreditThenInvoiceStateMachine) startInvoiceCreatedRun(
 	}
 
 	result, err := s.Runs.CreateRatedRun(ctx, usagebasedrun.CreateRatedRunInput{
-		Charge:                  s.Charge,
-		CustomerOverride:        s.CustomerOverride,
-		FeatureMeter:            s.FeatureMeter,
-		Type:                    runType,
-		StoredAtLT:              storedAtLT,
-		ServicePeriodTo:         servicePeriodTo,
-		LineID:                  lo.ToPtr(input.LineID),
-		IgnoreMinimumCommitment: ignoreMinimumCommitmentForRunType(runType),
-		CreditAllocation:        usagebasedrun.CreditAllocationAvailable,
-		CurrencyCalculator:      s.CurrencyCalculator,
+		Charge:             s.Charge,
+		CustomerOverride:   s.CustomerOverride,
+		FeatureMeter:       s.FeatureMeter,
+		Type:               runType,
+		StoredAtLT:         storedAtLT,
+		ServicePeriodTo:    servicePeriodTo,
+		LineID:             lo.ToPtr(input.LineID),
+		CreditAllocation:   usagebasedrun.CreditAllocationAvailable,
+		CurrencyCalculator: s.CurrencyCalculator,
 	})
 	if err != nil {
 		return err
@@ -275,12 +273,6 @@ func (s *CreditThenInvoiceStateMachine) StartFinalInvoiceRun(ctx context.Context
 	return s.startInvoiceCreatedRun(ctx, input, usagebased.RealizationRunTypeFinalRealization)
 }
 
-func ignoreMinimumCommitmentForRunType(runType usagebased.RealizationRunType) bool {
-	// Partial invoice runs are interim cumulative checkpoints. Minimum commitment is billed only on the
-	// final realization, so partial runs must suppress it during both creation and later snapshotting.
-	return runType == usagebased.RealizationRunTypePartialInvoice
-}
-
 func resolveInvoiceCreatedTrigger(charge usagebased.Charge, billedPeriod timeutil.ClosedPeriod) meta.Trigger {
 	if meta.NormalizeTimestamp(billedPeriod.To).Equal(meta.NormalizeTimestamp(charge.Intent.ServicePeriod.To)) {
 		return meta.TriggerFinalInvoiceCreated
@@ -309,18 +301,18 @@ func (s *CreditThenInvoiceStateMachine) SnapshotInvoiceUsage(ctx context.Context
 
 	storedAtLT := meta.NormalizeTimestamp(currentRun.StoredAtLT)
 
-	ratingResult, err := s.Rater.GetDetailedLinesForUsage(ctx, usagebasedrating.GetDetailedLinesForUsageInput{
-		Charge:                  s.Charge,
-		PriorRuns:               s.Charge.Realizations.Without(currentRun.ID),
-		Customer:                s.CustomerOverride,
-		FeatureMeter:            s.FeatureMeter,
-		ServicePeriodTo:         currentRun.ServicePeriodTo,
-		StoredAtLT:              storedAtLT,
-		IgnoreMinimumCommitment: ignoreMinimumCommitmentForRunType(currentRun.Type),
+	snapshot, err := s.Runs.SnapshotRunUsage(ctx, usagebasedrun.SnapshotRunUsageInput{
+		Charge:           s.Charge,
+		CurrentRunID:     currentRun.ID,
+		StoredAtLT:       storedAtLT,
+		ServicePeriodTo:  currentRun.ServicePeriodTo,
+		CustomerOverride: s.CustomerOverride,
+		FeatureMeter:     s.FeatureMeter,
 	})
 	if err != nil {
-		return fmt.Errorf("get rating for usage: %w", err)
+		return fmt.Errorf("snapshot run usage: %w", err)
 	}
+	ratingResult := snapshot.Rating
 
 	currentTotals := ratingResult.Totals.RoundToPrecision(s.CurrencyCalculator)
 

openmeter/billing/charges/usagebased/service/creditheninvoice_test.go

@@ -58,13 +58,3 @@ func TestResolveInvoiceCreatedTrigger(t *testing.T) {
 		require.Equal(t, meta.TriggerFinalInvoiceCreated, trigger)
 	})
 }
-
-func TestIgnoreMinimumCommitmentForRunType(t *testing.T) {
-	t.Run("partial invoice run", func(t *testing.T) {
-		require.True(t, ignoreMinimumCommitmentForRunType(usagebased.RealizationRunTypePartialInvoice))
-	})
-
-	t.Run("final realization run", func(t *testing.T) {
-		require.False(t, ignoreMinimumCommitmentForRunType(usagebased.RealizationRunTypeFinalRealization))
-	})
-}

openmeter/billing/charges/usagebased/service/creditsonly.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/openmeterio/openmeter/openmeter/billing/charges/meta"
 	"github.com/openmeterio/openmeter/openmeter/billing/charges/usagebased"
-	usagebasedrating "github.com/openmeterio/openmeter/openmeter/billing/charges/usagebased/service/rating"
 	usagebasedrun "github.com/openmeterio/openmeter/openmeter/billing/charges/usagebased/service/run"
 	"github.com/openmeterio/openmeter/openmeter/productcatalog"
 	"github.com/openmeterio/openmeter/pkg/clock"
@@ -184,17 +183,18 @@ func (s *CreditsOnlyStateMachine) FinalizeRealizationRun(ctx context.Context) er
 
 	storedAtLT := meta.NormalizeTimestamp(currentRun.StoredAtLT)
 
-	ratingResult, err := s.Rater.GetDetailedLinesForUsage(ctx, usagebasedrating.GetDetailedLinesForUsageInput{
-		Charge:          s.Charge,
-		PriorRuns:       s.Charge.Realizations.Without(currentRun.ID),
-		Customer:        s.CustomerOverride,
-		FeatureMeter:    s.FeatureMeter,
-		ServicePeriodTo: currentRun.ServicePeriodTo,
-		StoredAtLT:      storedAtLT,
+	snapshot, err := s.Runs.SnapshotRunUsage(ctx, usagebasedrun.SnapshotRunUsageInput{
+		Charge:           s.Charge,
+		CurrentRunID:     currentRun.ID,
+		StoredAtLT:       storedAtLT,
+		ServicePeriodTo:  currentRun.ServicePeriodTo,
+		CustomerOverride: s.CustomerOverride,
+		FeatureMeter:     s.FeatureMeter,
 	})
 	if err != nil {
-		return fmt.Errorf("get rating for usage: %w", err)
+		return fmt.Errorf("snapshot run usage: %w", err)
 	}
+	ratingResult := snapshot.Rating
 
 	currentTotals := ratingResult.Totals.RoundToPrecision(s.CurrencyCalculator)
 	targetCreditsTotal := currentTotals.Total
@@ -219,12 +219,18 @@ func (s *CreditsOnlyStateMachine) FinalizeRealizationRun(ctx context.Context) er
 	}
 	currentRun.DetailedLines = mo.Some(runDetailedLines)
 
-	if _, err := s.Adapter.UpdateRealizationRun(ctx, usagebased.UpdateRealizationRunInput{
+	currentRunBase, err := s.Adapter.UpdateRealizationRun(ctx, usagebased.UpdateRealizationRunInput{
 		ID:              currentRun.ID,
 		StoredAtLT:      mo.Some(storedAtLT),
 		MeteredQuantity: mo.Some(ratingResult.Quantity),
 		Totals:          mo.Some(currentTotals),
-	}); err != nil {
+	})
+	if err != nil {
+		return fmt.Errorf("update realization run: %w", err)
+	}
+	currentRun.RealizationRunBase = currentRunBase
+
+	if err := s.Charge.Realizations.SetRealizationRun(currentRun); err != nil {
 		return fmt.Errorf("update realization run: %w", err)
 	}
 

openmeter/billing/charges/usagebased/service/rating/details.go

@@ -13,18 +13,26 @@ import (
 	"github.com/openmeterio/openmeter/openmeter/productcatalog/feature"
 )
 
-type GetDetailedLinesForUsageInput struct {
-	Charge          usagebased.Charge
-	PriorRuns       usagebased.RealizationRuns
-	Customer        billing.CustomerOverrideWithDetails
-	FeatureMeter    feature.FeatureMeter
+type GetDetailedRatingForUsageInput struct {
+	// Charge general data
+
+	// Charge contains the charge intent and the prior runs with detailed lines expanded.
+	Charge usagebased.Charge
+
+	// Current run's data
+
+	// ServicePeriodTo defines the rated event-time upper bound for the current run.
 	ServicePeriodTo time.Time
-	StoredAtLT      time.Time
-	// IgnoreMinimumCommitment suppresses minimum commitment while still applying the rest of the billing mutators.
-	IgnoreMinimumCommitment bool
+	// StoredAtLT defines the stored-at cutoff for current and prior snapshots.
+	StoredAtLT time.Time
+
+	// Metering values
+
+	Customer     billing.CustomerOverrideWithDetails
+	FeatureMeter feature.FeatureMeter
 }
 
-func (i GetDetailedLinesForUsageInput) Validate() error {
+func (i GetDetailedRatingForUsageInput) Validate() error {
 	if err := i.Charge.Validate(); err != nil {
 		return fmt.Errorf("charge: %w", err)
 	}
@@ -37,11 +45,11 @@ func (i GetDetailedLinesForUsageInput) Validate() error {
 		return fmt.Errorf("feature meter is required")
 	}
 
+	period := i.Charge.Intent.ServicePeriod
 	if i.ServicePeriodTo.IsZero() {
 		return fmt.Errorf("service period to is required")
 	}
 
-	period := i.Charge.Intent.ServicePeriod
 	if !i.ServicePeriodTo.After(period.From) {
 		return fmt.Errorf("service period to must be after charge service period from")
 	}
@@ -54,46 +62,43 @@ func (i GetDetailedLinesForUsageInput) Validate() error {
 		return fmt.Errorf("stored at lt is required")
 	}
 
-	if err := i.PriorRuns.Validate(); err != nil {
-		return fmt.Errorf("prior runs: %w", err)
-	}
-
-	for idx, run := range i.PriorRuns {
-		if !run.DetailedLines.IsPresent() {
+	for idx, run := range i.Charge.Realizations {
+		if run.ServicePeriodTo.Before(i.ServicePeriodTo) && !run.DetailedLines.IsPresent() {
 			return fmt.Errorf("prior runs[%d]: detailed lines must be expanded", idx)
 		}
 	}
 
 	return nil
 }
 
-type GetRatingForUsageResult struct {
+type GetDetailedRatingForUsageResult struct {
 	billingrating.GenerateDetailedLinesResult
+	// Quantity is the current run's meter value between [Charge.Intent.ServicePeriod.From, ServicePeriodTo)
+	// capped at StoredAtLT.
 	Quantity alpacadecimal.Decimal
 }
 
-// GetDetailedLinesForUsage returns the rated detailed lines together with the metered quantity snapshot
-// used to compute them. Prefer GetTotalsForUsage when only totals are needed because it is faster.
-func (s *service) GetDetailedLinesForUsage(ctx context.Context, in GetDetailedLinesForUsageInput) (GetRatingForUsageResult, error) {
+func (s *service) GetDetailedRatingForUsage(ctx context.Context, in GetDetailedRatingForUsageInput) (GetDetailedRatingForUsageResult, error) {
 	if err := in.Validate(); err != nil {
-		return GetRatingForUsageResult{}, err
+		return GetDetailedRatingForUsageResult{}, err
 	}
 
-	servicePeriod := in.Charge.Intent.ServicePeriod
-	servicePeriod.To = in.ServicePeriodTo
-
-	snapshotQuantity, err := s.snapshotQuantity(ctx, snapshotQuantityInput{
-		Customer:      in.Customer.Customer,
-		FeatureMeter:  in.FeatureMeter,
-		ServicePeriod: servicePeriod,
-		StoredAtLT:    in.StoredAtLT,
+	currentQuantity, err := s.getQuantityForUsage(ctx, getQuantityForUsageInput{
+		Charge:          in.Charge,
+		Customer:        in.Customer,
+		FeatureMeter:    in.FeatureMeter,
+		ServicePeriodTo: in.ServicePeriodTo,
+		StoredAtLT:      in.StoredAtLT,
 	})
 	if err != nil {
-		return GetRatingForUsageResult{}, fmt.Errorf("get snapshot quantity: %w", err)
+		return GetDetailedRatingForUsageResult{}, fmt.Errorf("get current quantity: %w", err)
 	}
 
+	servicePeriod := in.Charge.Intent.ServicePeriod
+	servicePeriod.To = in.ServicePeriodTo
+
 	var opts []billingrating.GenerateDetailedLinesOption
-	if in.IgnoreMinimumCommitment {
+	if in.ServicePeriodTo.Before(in.Charge.Intent.ServicePeriod.To) {
 		opts = append(opts, billingrating.WithMinimumCommitmentIgnored())
 	}
 
@@ -102,19 +107,19 @@ func (s *service) GetDetailedLinesForUsage(ctx context.Context, in GetDetailedLi
 
 	ratingResult, err := s.ratingService.GenerateDetailedLines(usagebased.RateableIntent{
 		Intent:     intent,
-		MeterValue: snapshotQuantity,
+		MeterValue: currentQuantity,
 	}, opts...)
 	if err != nil {
-		return GetRatingForUsageResult{}, fmt.Errorf("rating: %w", err)
+		return GetDetailedRatingForUsageResult{}, fmt.Errorf("rating: %w", err)
 	}
 
 	ratingResult.DetailedLines = withServicePeriodInDetailedLineChildUniqueReferenceIDs(
 		ratingResult.DetailedLines,
 		servicePeriod,
 	)
 
-	return GetRatingForUsageResult{
+	return GetDetailedRatingForUsageResult{
 		GenerateDetailedLinesResult: ratingResult,
-		Quantity:                    snapshotQuantity,
+		Quantity:                    currentQuantity,
 	}, nil
 }

openmeter/billing/charges/usagebased/service/rating/quantity.go

@@ -0,0 +1,70 @@
+package rating
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/alpacahq/alpacadecimal"
+
+	"github.com/openmeterio/openmeter/openmeter/billing"
+	"github.com/openmeterio/openmeter/openmeter/billing/charges/usagebased"
+	"github.com/openmeterio/openmeter/openmeter/productcatalog/feature"
+)
+
+type getQuantityForUsageInput struct {
+	Charge          usagebased.Charge
+	Customer        billing.CustomerOverrideWithDetails
+	FeatureMeter    feature.FeatureMeter
+	ServicePeriodTo time.Time
+	StoredAtLT      time.Time
+}
+
+func (i getQuantityForUsageInput) Validate() error {
+	if err := i.Charge.Validate(); err != nil {
+		return fmt.Errorf("charge: %w", err)
+	}
+
+	if i.Customer.Customer == nil {
+		return fmt.Errorf("customer is required")
+	}
+
+	if i.FeatureMeter.Meter == nil {
+		return fmt.Errorf("feature meter is required")
+	}
+
+	if i.ServicePeriodTo.IsZero() {
+		return fmt.Errorf("service period to is required")
+	}
+
+	period := i.Charge.Intent.ServicePeriod
+	if !i.ServicePeriodTo.After(period.From) {
+		return fmt.Errorf("service period to must be after charge service period from")
+	}
+
+	if i.ServicePeriodTo.After(period.To) {
+		return fmt.Errorf("service period to must not be after charge service period to")
+	}
+
+	if i.StoredAtLT.IsZero() {
+		return fmt.Errorf("stored at lt is required")
+	}
+
+	return nil
+}
+
+func (s *service) getQuantityForUsage(ctx context.Context, in getQuantityForUsageInput) (alpacadecimal.Decimal, error) {
+	if err := in.Validate(); err != nil {
+		return alpacadecimal.Zero, err
+	}
+
+	servicePeriod := in.Charge.Intent.ServicePeriod
+	servicePeriod.To = in.ServicePeriodTo
+
+	return s.snapshotQuantity(ctx, snapshotQuantityInput{
+		Customer:      in.Customer.Customer,
+		FeatureMeter:  in.FeatureMeter,
+		ServicePeriod: servicePeriod,
+		StoredAtLT:    in.StoredAtLT,
+	})
+}

openmeter/billing/charges/usagebased/service/rating/service.go

@@ -32,9 +32,9 @@ type Service interface {
 	// GetTotalsForUsage returns charge totals for a usage snapshot without generating detailed lines.
 	// Prefer this when only totals are required because it is faster than generating detailed lines.
 	GetTotalsForUsage(ctx context.Context, in GetTotalsForUsageInput) (totals.Totals, error)
-	// GetDetailedLinesForUsage returns rated detailed lines and the metered quantity snapshot used to compute them.
+	// GetDetailedRatingForUsage returns rated detailed lines and the metered quantity snapshot used to compute them.
 	// Prefer GetTotalsForUsage when only totals are required because it is faster.
-	GetDetailedLinesForUsage(ctx context.Context, in GetDetailedLinesForUsageInput) (GetRatingForUsageResult, error)
+	GetDetailedRatingForUsage(ctx context.Context, in GetDetailedRatingForUsageInput) (GetDetailedRatingForUsageResult, error)
 }
 
 type service struct {