api: expose current period start and end (#282)

api/api.go

@@ -322,11 +322,12 @@ func (h *Handler) serveWhoAmI(w http.ResponseWriter, r *http.Request) error {
 
 func (h *Handler) servePhase(w http.ResponseWriter, r *http.Request) error {
 	org := r.FormValue("org")
-	ps, err := h.c.LookupPhases(r.Context(), org)
+	s, err := h.c.LookupPhases(r.Context(), org)
 	if err != nil {
 		return err
 	}
 
+	ps := s.Phases
 	h.Logf("lookup phases: %# v", pretty.Formatter(ps))
 
 	for i, p := range ps {
@@ -345,6 +346,7 @@ func (h *Handler) servePhase(w http.ResponseWriter, r *http.Request) error {
 				Tax: apitypes.Taxation{
 					Automatic: p.AutomaticTax,
 				},
+				Current: apitypes.Period(s.Current),
 			})
 		}
 	}

api/api_test.go

@@ -196,7 +196,7 @@ func TestAPISubscribe(t *testing.T) {
 		if got.Effective.IsZero() {
 			t.Error("unexpected zero effective time")
 		}
-		ignore := diff.ZeroFields[apitypes.PhaseResponse]("Effective")
+		ignore := diff.ZeroFields[apitypes.PhaseResponse]("Effective", "Current")
 		diff.Test(t, t.Errorf, got, want, ignore)
 	}
 
@@ -472,6 +472,20 @@ func TestPhase(t *testing.T) {
 			if err != nil {
 				t.Fatal(err)
 			}
+
+			c := got.Current
+
+			if c.Effective.IsZero() {
+				t.Errorf("got zero effective time, want non-zero")
+			}
+			if c.End.IsZero() {
+				t.Errorf("got zero end time, want non-zero")
+			}
+			if !c.End.After(c.Effective) {
+				t.Errorf("unexpected effective time %s after end time %s", c.Effective, c.End)
+			}
+
+			got.Current = apitypes.Period{}
 			diff.Test(t, t.Errorf, got, tt.want)
 		})
 	}
@@ -517,7 +531,7 @@ func TestPhaseFragments(t *testing.T) {
 	if got.Effective.IsZero() {
 		t.Error("unexpected zero effective time")
 	}
-	ignore := diff.ZeroFields[apitypes.PhaseResponse]("Effective")
+	ignore := diff.ZeroFields[apitypes.PhaseResponse]("Effective", "Current")
 	diff.Test(t, t.Errorf, got, want, ignore)
 }
 

api/apitypes/apitypes.go

@@ -30,6 +30,15 @@ type Taxation struct {
 	Automatic bool `json:"automatic,omitempty"`
 }
 
+type Period struct {
+	Effective time.Time `json:"effective,omitempty"`
+	End       time.Time `json:"end,omitempty"`
+}
+
+func (p *Period) IsZero() bool {
+	return p.Effective.IsZero() && p.End.IsZero()
+}
+
 type PhaseResponse struct {
 	Effective time.Time          `json:"effective,omitempty"`
 	End       time.Time          `json:"end,omitempty"`
@@ -38,26 +47,24 @@ type PhaseResponse struct {
 	Fragments []refs.FeaturePlan `json:"fragments,omitempty"`
 	Trial     bool               `json:"trial,omitempty"`
 	Tax       Taxation           `json:"tax,omitempty"`
+	Current   Period             `json:"current,omitempty"`
 }
 
 func (pr PhaseResponse) MarshalJSON() ([]byte, error) {
 	type Alias PhaseResponse
-	if pr.End.IsZero() {
-		return json.Marshal(&struct {
-			*Alias
-			End byte `json:"end,omitempty"`
-		}{
-			Alias: (*Alias)(&pr),
-		})
-	} else {
-		return json.Marshal(&struct {
-			*Alias
-			End time.Time `json:"end"`
-		}{
-			Alias: (*Alias)(&pr),
-			End:   pr.End,
-		})
-	}
+	return json.Marshal(&struct {
+		*Alias
+		Effective any `json:"effective,omitempty"`
+		End       any `json:"end,omitempty"`
+		Current   any `json:"current,omitempty"`
+		Tax       any `json:"tax,omitempty"`
+	}{
+		Alias:     (*Alias)(&pr),
+		Effective: nilIfZero(pr.Effective),
+		End:       nilIfZero(pr.End),
+		Current:   nilIfZero(pr.Current),
+		Tax:       nilIfZero(pr.Tax),
+	})
 }
 
 type PaymentMethodsResponse struct {
@@ -166,3 +173,14 @@ type ClockResponse struct {
 	Present time.Time `json:"present"`
 	Status  string    `json:"status"`
 }
+
+func nilIfZero[T comparable](v T) any {
+	if z, ok := any(v).(interface{ IsZero() bool }); ok && z.IsZero() {
+		return nil
+	}
+	var zero T
+	if v == zero {
+		return nil
+	}
+	return v
+}

api/apitypes/json_test.go

@@ -13,13 +13,13 @@ func TestPhaseResponseJSON(t *testing.T) {
 	}{
 		{
 			pr:   PhaseResponse{},
-			want: `{"effective":"0001-01-01T00:00:00Z","tax":{}}`,
+			want: `{}`,
 		},
 		{
 			pr: PhaseResponse{
 				End: time.Date(2018, 1, 1, 0, 0, 0, 0, time.UTC),
 			},
-			want: `{"effective":"0001-01-01T00:00:00Z","tax":{},"end":"2018-01-01T00:00:00Z"}`,
+			want: `{"end":"2018-01-01T00:00:00Z"}`,
 		},
 	}
 

control/schedule.go

@@ -117,7 +117,8 @@ type subscription struct {
 	EndDate      time.Time
 	CanceledAt   time.Time
 	Features     []Feature
-	AutomaticTax bool
+	AutomaticTax bool // TODO(bmizerany): cheange to tax.Applied
+	Current      Period
 }
 
 func (c *Client) lookupSubscription(ctx context.Context, org, name string) (sub subscription, err error) {
@@ -153,6 +154,8 @@ func (c *Client) lookupSubscription(ctx context.Context, org, name string) (sub
 		AutomaticTax struct {
 			Enabled bool
 		} `json:"automatic_tax"`
+		CurrentPeriodStart int64 `json:"current_period_start"`
+		CurrentPeriodEnd   int64 `json:"current_period_end"`
 	}
 
 	// TODO(bmizerany): cache the subscription ID and looked it up
@@ -190,6 +193,10 @@ func (c *Client) lookupSubscription(ctx context.Context, org, name string) (sub
 		Status:       v.Status,
 		Features:     fs,
 		AutomaticTax: v.AutomaticTax.Enabled,
+		Current: Period{
+			Effective: timeUnix(v.CurrentPeriodStart),
+			End:       timeUnix(v.CurrentPeriodEnd),
+		},
 	}
 	if v.TrialEnd > 0 {
 		s.TrialEnd = time.Unix(v.TrialEnd, 0)
@@ -701,16 +708,29 @@ func (c *Client) LookupStatus(ctx context.Context, org string) (string, error) {
 	return s.Status, nil
 }
 
-func (c *Client) LookupPhases(ctx context.Context, org string) (ps []Phase, err error) {
+type Schedule struct {
+	Current Period
+	Phases  []Phase
+}
+
+func (c *Client) LookupPhases(ctx context.Context, org string) (ps *Schedule, err error) {
 	s, err := c.lookupSubscription(ctx, org, defaultScheduleName)
 	if errors.Is(err, errSubscriptionNotFound) {
-		return nil, nil
+		return &Schedule{}, nil
 	}
 	if err != nil {
 		return nil, err
 	}
+
 	_, all, err := c.lookupPhases(ctx, org, s, defaultScheduleName)
-	return all, err
+	if err != nil {
+		return nil, err
+	}
+	cs := &Schedule{
+		Current: s.Current,
+		Phases:  all,
+	}
+	return cs, nil
 }
 
 // LookupPaymentMethods returns the payment methods for the given org.
@@ -1046,3 +1066,11 @@ func numFeaturesInPlan(fs []refs.FeaturePlan, plan refs.Plan) (n int) {
 	}
 	return n
 }
+
+// timeUnix is like time.Unix, but returns the zero time if n is zero.
+func timeUnix(n int64) time.Time {
+	if n == 0 {
+		return time.Time{}
+	}
+	return time.Unix(n, 0)
+}

control/schedule_test.go

@@ -44,6 +44,8 @@ var ignoreProviderIDs = diff.OptionList(
 	diff.ZeroFields[Org]("ProviderID"),
 )
 
+var ignoreScheduleTimes = diff.ZeroFields[Schedule]("Current")
+
 func TestSchedule(t *testing.T) {
 	ciOnly(t)
 
@@ -81,7 +83,8 @@ func TestSchedule(t *testing.T) {
 			t.Fatal(err)
 		}
 		t.Logf("got phases %# v", pretty.Formatter(got))
-		diff.Test(t, t.Errorf, got, want, ignoreProviderIDs)
+		w := &Schedule{Phases: want}
+		diff.Test(t, t.Errorf, got, w, ignoreProviderIDs, ignoreScheduleTimes)
 	}
 
 	s.schedule("org:example", 0, "", planFree...)
@@ -268,7 +271,8 @@ func (s *scheduleTester) checkPhases(org string, want []Phase) {
 		s.t.Fatal(err)
 	}
 	s.t.Logf("got phases %# v", pretty.Formatter(got))
-	diff.Test(s.t, s.t.Errorf, got, want, ignoreProviderIDs)
+	w := &Schedule{Phases: want}
+	diff.Test(s.t, s.t.Errorf, got, w, ignoreProviderIDs, ignoreScheduleTimes)
 }
 
 func (s *scheduleTester) report(org, name string, n int) {
@@ -589,13 +593,16 @@ func TestScheduleMinMaxItems(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	want := []Phase{{
+	want := &Schedule{Phases: []Phase{{
 		Org:      "org:example",
 		Features: wantFeatures,
 		Current:  true,
 		Plans:    nil, // fragments only
-	}}
-	diff.Test(t, t.Errorf, got, want, diff.ZeroFields[Phase]("Effective"))
+	}}}
+	diff.Test(t, t.Errorf, got, want,
+		diff.ZeroFields[Phase]("Effective"),
+		ignoreScheduleTimes,
+	)
 }
 
 func TestSchedulePaymentMethod(t *testing.T) {
@@ -768,16 +775,16 @@ func TestLookupPhasesWithTiersRoundTrip(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	want := []Phase{{
+	want := &Schedule{Phases: []Phase{{
 		Org:       "org:example",
 		Effective: t0,
 		Current:   true,
 		Features:  fps,
 
 		Plans: plans("plan:test@0"),
-	}}
+	}}}
 
-	diff.Test(t, t.Errorf, got, want, ignoreProviderIDs)
+	diff.Test(t, t.Errorf, got, want, ignoreProviderIDs, ignoreScheduleTimes)
 }
 
 func TestSubscribeToPlan(t *testing.T) {
@@ -807,16 +814,16 @@ func TestSubscribeToPlan(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	want := []Phase{{
+	want := &Schedule{Phases: []Phase{{
 		Org:       "org:example",
 		Current:   true,
 		Effective: t0,
 		Features:  FeaturePlans(fs),
 
 		Plans: plans("plan:pro@0"),
-	}}
+	}}}
 
-	diff.Test(t, t.Errorf, got, want, ignoreProviderIDs)
+	diff.Test(t, t.Errorf, got, want, ignoreProviderIDs, ignoreScheduleTimes)
 }
 
 func TestDedupCustomer(t *testing.T) {
@@ -870,15 +877,15 @@ func TestLookupPhases(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	want := []Phase{{
+	want := &Schedule{Phases: []Phase{{
 		Org:       "org:example",
 		Current:   true,
 		Effective: t0,
 		Features:  FeaturePlans(fs0),
 
 		Plans: plans("plan:test@0"),
-	}}
-	diff.Test(t, t.Errorf, got, want, ignoreProviderIDs)
+	}}}
+	diff.Test(t, t.Errorf, got, want, ignoreProviderIDs, ignoreScheduleTimes)
 
 	fs1 := []Feature{
 		{
@@ -902,22 +909,22 @@ func TestLookupPhases(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	for i, p := range got {
+	for i, p := range got.Phases {
 		p.Features = slices.Clone(p.Features)
 		refs.SortGroupedByVersion(p.Features)
-		got[i] = p
+		got.Phases[i] = p
 	}
 
-	want = []Phase{{
+	want = &Schedule{Phases: []Phase{{
 		Org:       "org:example",
 		Current:   true,
 		Effective: t0,
 		Features:  fpsFrag,
 
 		Plans: plans("plan:test@0"),
-	}}
+	}}}
 
-	diff.Test(t, t.Errorf, got, want, ignoreProviderIDs)
+	diff.Test(t, t.Errorf, got, want, ignoreProviderIDs, ignoreScheduleTimes)
 }
 
 func TestLookupPaymentMethods(t *testing.T) {
@@ -1189,7 +1196,10 @@ func TestLookupPhasesNoSchedule(t *testing.T) {
 				t.Fatal(err)
 			}
 
-			diff.Test(t, t.Errorf, got, tt.want)
+			want := &Schedule{
+				Phases: tt.want,
+			}
+			diff.Test(t, t.Errorf, got, want, ignoreScheduleTimes)
 		})
 	}
 }