fix: recurring period calculation fix (#3224)

Author: turip

Makefile

@@ -140,6 +140,12 @@ test: ## Run tests
 	PGPASSWORD=postgres psql -h 127.0.0.1 -U postgres postgres -c "SELECT version();" || (echo "!!! Postgres is not running. Please start it with 'docker compose up -d postgres' !!!" && false)
 	go test ${GO_TEST_FLAGS} ./...
 
+.PHONY: test-nocache
+test-nocache: ## Run tests without cache
+	$(call print-target)
+	PGPASSWORD=postgres psql -h 127.0.0.1 -U postgres postgres -c "SELECT version();" || (echo "!!! Postgres is not running. Please start it with 'docker compose up -d postgres' !!!" && false)
+	go test ${GO_TEST_FLAGS} -count=1 ./...
+
 .PHONY: test-all
 test-all: ## Run tests with svix dependencies, bypassing the test cache
 	$(call print-target)

openmeter/credit/engine/engine.go

@@ -61,10 +61,3 @@ type engine struct {
 
 // Ensure engine implements Engine
 var _ Engine = (*engine)(nil)
-
-func later(t1 time.Time, t2 time.Time) time.Time {
-	if t1.After(t2) {
-		return t1
-	}
-	return t2
-}

openmeter/credit/engine/grant.go

@@ -75,17 +75,20 @@ func (e *engine) getGrantRecurrenceTimes(grants []grant.Grant, period timeutil.C
 	}
 
 	for _, grant := range grantsWithRecurrence {
-		i, err := grant.Recurrence.NextAfter(later(grant.EffectiveAt, period.From))
+		it, err := grant.Recurrence.IterateFromNextAfter(
+			timeutil.Later(grant.EffectiveAt, period.From),
+			timeutil.Inclusive,
+		)
 		if err != nil {
 			return nil, err
 		}
 		// writing all reccurence times until grant is active or period ends
-		for i.Before(period.To) && grant.ActiveAt(i) {
+		for it.At.Before(period.To) && grant.ActiveAt(it.At) {
 			times = append(times, struct {
 				time    time.Time
 				grantID string
-			}{time: i, grantID: grant.ID})
-			i, err = grant.Recurrence.Next(i)
+			}{time: it.At, grantID: grant.ID})
+			it, err = it.Next()
 			if err != nil {
 				return nil, err
 			}

openmeter/entitlement/entitlement.go

@@ -206,7 +206,7 @@ func (c CreateEntitlementInputs) Validate() error {
 
 	// Let's validate the Usage Period
 	if c.UsagePeriod != nil {
-		if per, err := c.UsagePeriod.GetValue().Interval.ISODuration.Subtract(datetime.NewISODuration(0, 0, 0, 0, 1, 0, 0)); err == nil && per.Sign() == -1 {
+		if per, err := c.UsagePeriod.GetValue().Interval.ISODuration.Subtract(datetime.DurationHour); err == nil && per.Sign() == -1 {
 			return fmt.Errorf("UsagePeriod must be at least 1 hour")
 		}
 	}

openmeter/entitlement/metered/entitlement_grant.go

@@ -12,6 +12,7 @@ import (
 	"github.com/openmeterio/openmeter/pkg/clock"
 	"github.com/openmeterio/openmeter/pkg/convert"
 	"github.com/openmeterio/openmeter/pkg/models"
+	"github.com/openmeterio/openmeter/pkg/timeutil"
 )
 
 // CreateGrant creates a grant for a given entitlement
@@ -109,7 +110,7 @@ type EntitlementGrant struct {
 func GrantFromCreditGrant(grant grant.Grant) (*EntitlementGrant, error) {
 	g := &EntitlementGrant{}
 	if grant.Recurrence != nil {
-		next, err := grant.Recurrence.NextAfter(clock.Now())
+		next, err := grant.Recurrence.NextAfter(clock.Now(), timeutil.Inclusive)
 		if err != nil {
 			return nil, err
 		}

openmeter/subscription/subscriptionspec.go

@@ -253,7 +253,7 @@ func (s *SubscriptionSpec) GetAlignedBillingPeriodAt(at time.Time) (timeutil.Clo
 	// TODO(galexi, OM-1418): implement reanchoring
 
 	// We will use the subscription billing anchor as the cadence anchor
-	billingRecurrence, err := timeutil.RecurrenceFromISODuration(lo.ToPtr(s.BillingCadence), s.BillingAnchor)
+	billingRecurrence, err := timeutil.NewRecurrenceFromISODuration(s.BillingCadence, s.BillingAnchor)
 	if err != nil {
 		return def, fmt.Errorf("failed to get billing recurrence for phase %s: %w", phase.PhaseKey, err)
 	}
@@ -815,7 +815,7 @@ func (s SubscriptionItemSpec) GetFullServicePeriodAt(
 		}, nil
 	}
 
-	rec, err := timeutil.RecurrenceFromISODuration(billingCadence, alignedBillingAnchor)
+	rec, err := timeutil.NewRecurrenceFromISODuration(*billingCadence, alignedBillingAnchor)
 	if err != nil {
 		return timeutil.ClosedPeriod{}, fmt.Errorf("failed to get recurrence from ISO duration: %w", err)
 	}
@@ -922,7 +922,7 @@ func (s SubscriptionItemSpec) ToScheduleSubscriptionEntitlementInput(
 		scheduleInput.IssueAfterReset = tpl.IssueAfterReset
 		scheduleInput.IssueAfterResetPriority = tpl.IssueAfterResetPriority
 		scheduleInput.PreserveOverageAtReset = tpl.PreserveOverageAtReset
-		rec, err := timeutil.RecurrenceFromISODuration(&tpl.UsagePeriod, truncatedAnchorTime)
+		rec, err := timeutil.NewRecurrenceFromISODuration(tpl.UsagePeriod, truncatedAnchorTime)
 		if err != nil {
 			return def, true, fmt.Errorf("failed to get recurrence from ISO duration: %w", err)
 		}

openmeter/subscription/workflow/service/subscription.go

@@ -52,26 +52,16 @@ func (s *service) CreateFromPlan(ctx context.Context, inp subscriptionworkflow.C
 		// Let's normalize the billing anchor to the closest iteration based on the cadence
 		billingAnchor := lo.FromPtrOr(inp.BillingAnchor, activeFrom).UTC()
 
-		billingRecurrence, err := timeutil.RecurrenceFromISODuration(lo.ToPtr(plan.ToCreateSubscriptionPlanInput().BillingCadence), billingAnchor)
+		billingRecurrence, err := timeutil.NewRecurrenceFromISODuration(plan.ToCreateSubscriptionPlanInput().BillingCadence, billingAnchor)
 		if err != nil {
 			return def, fmt.Errorf("failed to get billing recurrence: %w", err)
 		}
 
-		billingAnchor, err = billingRecurrence.PrevBefore(activeFrom)
+		billingAnchor, err = billingRecurrence.PrevBefore(activeFrom, timeutil.Inclusive)
 		if err != nil {
 			return def, fmt.Errorf("failed to get billing anchor: %w", err)
 		}
 
-		// When anchor = beforeTime (or falls on iteration boundary), PrevBefore will return an iteration early.
-		oneBefore, err := billingRecurrence.Prev(activeFrom)
-		if err != nil {
-			return def, fmt.Errorf("failed to get one iteration before billing anchor: %w", err)
-		}
-
-		if oneBefore.Equal(billingAnchor) {
-			billingAnchor = activeFrom
-		}
-
 		// Let's create the new Spec
 		spec, err := subscription.NewSpecFromPlan(plan, subscription.CreateSubscriptionCustomerInput{
 			CustomerId:    cust.ID,

openmeter/subscription/workflow/service/subscription_test.go

@@ -104,12 +104,12 @@ func TestCreateFromPlan(t *testing.T) {
 
 				billingAnchor := activeFrom.Add(time.Hour)
 
-				cadRec, err := timeutil.RecurrenceFromISODuration(lo.ToPtr(cad), billingAnchor)
+				cadRec, err := timeutil.NewRecurrenceFromISODuration(cad, billingAnchor)
 				require.Nil(t, err)
 
 				// Let's set an anchor one hour after the activeFrom, which will then be set to one iteration before
 
-				expectedBillingAnchor, err := cadRec.Prev(billingAnchor)
+				expectedBillingAnchor, err := cadRec.Iterator().Prev()
 				require.Nil(t, err)
 
 				subView, err := deps.WorkflowService.CreateFromPlan(ctx, subscriptionworkflow.CreateSubscriptionWorkflowInput{

pkg/datetime/duration.go

@@ -165,42 +165,85 @@ func (d ISODuration) DivisibleBy(smaller ISODuration) (bool, error) {
 	return true, nil
 }
 
+func (p ISODuration) Mul(n int) (ISODuration, error) {
+	nDecimal, err := decimal.NewFromInt64(int64(n), 0, 0)
+	if err != nil {
+		return ISODuration{}, err
+	}
+
+	per, err := p.Period.Mul(nDecimal)
+	if err != nil {
+		return ISODuration{}, err
+	}
+	return ISODuration{per}, nil
+}
+
 // convertPeriodToSeconds converts a period to total seconds using decimal precision
 func convertPeriodToSeconds(p period.Period, daysInMonth int, hoursInDays int) (decimal.Decimal, error) {
-	zero := decimal.MustNew(0, 0)
+	zero := decimal.Zero
+
+	yearsMul, err := decimal.New(int64(daysInMonth*12*hoursInDays*3600), 0)
+	if err != nil {
+		return zero, err
+	}
 
 	// Convert years to seconds: years * (daysInMonth * 12) * hoursInDays * 3600
-	years, err := p.YearsDecimal().Mul(decimal.MustNew(int64(daysInMonth*12*hoursInDays*3600), 0))
+	years, err := p.YearsDecimal().Mul(yearsMul)
+	if err != nil {
+		return zero, err
+	}
+
+	monthsMul, err := decimal.New(int64(daysInMonth*hoursInDays*3600), 0)
 	if err != nil {
 		return zero, err
 	}
 
 	// Convert months to seconds: months * daysInMonth * hoursInDays * 3600
-	months, err := p.MonthsDecimal().Mul(decimal.MustNew(int64(daysInMonth*hoursInDays*3600), 0))
+	months, err := p.MonthsDecimal().Mul(monthsMul)
+	if err != nil {
+		return zero, err
+	}
+
+	weeksMul, err := decimal.New(int64(7*hoursInDays*3600), 0)
 	if err != nil {
 		return zero, err
 	}
 
 	// Convert weeks to seconds: weeks * 7 * hoursInDays * 3600
-	weeks, err := p.WeeksDecimal().Mul(decimal.MustNew(int64(7*hoursInDays*3600), 0))
+	weeks, err := p.WeeksDecimal().Mul(weeksMul)
 	if err != nil {
 		return zero, err
 	}
 
 	// Convert days to seconds: days * hoursInDays * 3600
-	days, err := p.DaysDecimal().Mul(decimal.MustNew(int64(hoursInDays*3600), 0))
+	daysMul, err := decimal.New(int64(hoursInDays*3600), 0)
+	if err != nil {
+		return zero, err
+	}
+
+	days, err := p.DaysDecimal().Mul(daysMul)
 	if err != nil {
 		return zero, err
 	}
 
 	// Convert hours to seconds: hours * 3600
-	hours, err := p.HoursDecimal().Mul(decimal.MustNew(3600, 0))
+	hoursMul, err := decimal.New(int64(3600), 0)
+	if err != nil {
+		return zero, err
+	}
+
+	hours, err := p.HoursDecimal().Mul(hoursMul)
 	if err != nil {
 		return zero, err
 	}
 
 	// Convert minutes to seconds: minutes * 60
-	minutes, err := p.MinutesDecimal().Mul(decimal.MustNew(60, 0))
+	minutesMul, err := decimal.New(int64(60), 0)
+	if err != nil {
+		return zero, err
+	}
+
+	minutes, err := p.MinutesDecimal().Mul(minutesMul)
 	if err != nil {
 		return zero, err
 	}

pkg/datetime/interval.go

@@ -0,0 +1,11 @@
+package datetime
+
+var (
+	DurationSecond ISODuration = NewISODuration(0, 0, 0, 0, 0, 0, 1)
+	DurationMinute ISODuration = NewISODuration(0, 0, 0, 0, 0, 1, 0)
+	DurationHour   ISODuration = NewISODuration(0, 0, 0, 0, 1, 0, 0)
+	DurationDay    ISODuration = NewISODuration(0, 0, 0, 1, 0, 0, 0)
+	DurationWeek   ISODuration = NewISODuration(0, 0, 1, 0, 0, 0, 0)
+	DurationMonth  ISODuration = NewISODuration(0, 1, 0, 0, 0, 0, 0)
+	DurationYear   ISODuration = NewISODuration(1, 0, 0, 0, 0, 0, 0)
+)