feat(billing): move plan writes to AdminService and add ListAllPlans

Makefile

@@ -4,7 +4,7 @@ TAG := $(shell git rev-list --tags --max-count=1)
 VERSION := $(shell git describe --tags ${TAG})
 .PHONY: build check fmt lint test test-race vet test-cover-html help install proto admin-app compose-up-dev
 .DEFAULT_GOAL := build
-PROTON_COMMIT := "91eaffcdc8435ee129f9f93b43ad957c32efee62"
+PROTON_COMMIT := "0a5d4207bcefc231021c032cd166fd07440f11a5"
 
 admin-app:
 	@echo " > generating admin build"

billing/checkout/checkout.go

@@ -26,6 +26,7 @@ var (
 	ErrInvalidDetail     = errors.New("invalid checkout detail")
 	ErrKycCompleted      = errors.New("organization kyc completed")
 	ErrAlreadySubscribed = errors.New("already subscribed to the plan")
+	ErrPlanInactive      = errors.New("plan is inactive and cannot be subscribed to")
 )
 
 type Checkout struct {

billing/checkout/service.go

@@ -251,6 +251,11 @@ func (s *Service) Create(ctx context.Context, ch Checkout) (Checkout, error) {
 			return Checkout{}, ErrAlreadySubscribed
 		}
 
+		// a retired (inactive) plan is closed to new subscriptions
+		if plan.IsInactive() {
+			return Checkout{}, fmt.Errorf("plan %q is inactive and cannot be subscribed to: %w", plan.Name, ErrPlanInactive)
+		}
+
 		// create subscription items
 		var subsItems []*stripe.CheckoutSessionLineItemParams
 

billing/plan/plan.go

@@ -16,6 +16,20 @@ var (
 	ErrInvalidDetail = errors.New("invalid plan detail")
 )
 
+const (
+	StateActive   = "active"
+	StateInactive = "inactive"
+	// StateAll is a Filter.State sentinel that matches plans in any state. An
+	// empty Filter.State defaults to active, so this is the way to list every plan.
+	StateAll = "all"
+)
+
+// IsInactive reports whether the plan is retired: hidden from ListPlans and
+// closed to new subscriptions. Existing subscriptions on it keep working.
+func (p Plan) IsInactive() bool {
+	return p.State == StateInactive
+}
+
 // Plan is a collection of products
 // it is a logical grouping of products and doesn't have
 // a corresponding billing engine entity

billing/plan/plan_test.go

@@ -42,3 +42,22 @@ func TestPlan_IsFree(t *testing.T) {
 		})
 	}
 }
+
+func TestPlan_IsInactive(t *testing.T) {
+	tests := []struct {
+		name  string
+		state string
+		want  bool
+	}{
+		{name: "inactive is inactive", state: "inactive", want: true},
+		{name: "active is not inactive", state: "active", want: false},
+		{name: "empty state is not inactive", state: "", want: false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := (plan.Plan{State: tt.state}).IsInactive(); got != tt.want {
+				t.Errorf("IsInactive() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

billing/plan/service.go

@@ -73,6 +73,26 @@ func (s Service) Create(ctx context.Context, p Plan) (Plan, error) {
 	return s.planRepository.Create(ctx, p)
 }
 
+// UpdatePlan updates a plan's own fields: title, description, credits, trial
+// days, state, and metadata. A plan's products are managed through UpsertPlans,
+// so they are left untouched here. The plan is looked up by id or name.
+func (s Service) UpdatePlan(ctx context.Context, p Plan) (Plan, error) {
+	existing, err := s.GetByID(ctx, p.ID)
+	if err != nil {
+		return Plan{}, err
+	}
+	existing.Title = p.Title
+	existing.Description = p.Description
+	existing.OnStartCredits = p.OnStartCredits
+	existing.TrialDays = p.TrialDays
+	existing.State = p.State
+	existing.Metadata = p.Metadata
+	if _, err := s.planRepository.UpdateByName(ctx, existing); err != nil {
+		return Plan{}, err
+	}
+	return s.GetByID(ctx, existing.ID)
+}
+
 func (s Service) GetByID(ctx context.Context, id string) (Plan, error) {
 	var fetchedPlan Plan
 	var err error
@@ -280,7 +300,12 @@ func (s Service) UpsertPlans(ctx context.Context, planFile File) error {
 		} else if err != nil {
 			return err
 		} else {
-			// update plan
+			// update plan; the plan file may omit state on this seed path, so
+			// keep the existing plan's state rather than blanking it
+			state := planToCreate.State
+			if state == "" {
+				state = planOb.State
+			}
 			if _, err = s.planRepository.UpdateByName(ctx, Plan{
 				ID:             planOb.ID,
 				Name:           planToCreate.Name,
@@ -289,7 +314,7 @@ func (s Service) UpsertPlans(ctx context.Context, planFile File) error {
 				Description:    planToCreate.Description,
 				TrialDays:      planToCreate.TrialDays,
 				Metadata:       planToCreate.Metadata,
-				State:          planToCreate.State,
+				State:          state,
 			}); err != nil {
 				return err
 			}

billing/subscription/service.go

@@ -634,6 +634,11 @@ func (s *Service) ChangePlan(ctx context.Context, id string, changeRequest Chang
 		return change, ErrAlreadyOnSamePlan
 	}
 
+	// cannot move a subscription onto a retired (inactive) plan; moving off one is allowed
+	if planObj.IsInactive() {
+		return change, fmt.Errorf("plan %q is inactive and cannot be subscribed to: %w", planObj.Name, ErrPlanInactive)
+	}
+
 	// check if schedule exists
 	stripeSubscription, stripeSchedule, err := s.createOrGetSchedule(ctx, sub)
 	if err != nil {
@@ -1004,6 +1009,9 @@ func (s *Service) findPlanByStripeSubscription(ctx context.Context, stripeSubscr
 	plans, err := s.planService.List(ctx, plan.Filter{
 		IDs:      productPlanIDs,
 		Interval: interval,
+		// resolve an existing subscription's plan regardless of state; an
+		// inactive (retired) plan must still resolve for its current subscribers
+		State: plan.StateAll,
 	})
 	if err != nil {
 		return plan.Plan{}, err
@@ -1040,6 +1048,9 @@ func (s *Service) findPlanByStripePhase(ctx context.Context, stripePhase *stripe
 	plans, err := s.planService.List(ctx, plan.Filter{
 		IDs:      productPlanIDs,
 		Interval: interval,
+		// resolve an existing subscription's plan regardless of state; an
+		// inactive (retired) plan must still resolve for its current subscribers
+		State: plan.StateAll,
 	})
 	if err != nil {
 		return plan.Plan{}, err

billing/subscription/service_test.go

@@ -226,6 +226,23 @@ func TestService_ChangePlan(t *testing.T) {
 			},
 			wantErr: errors.New("plan not found"),
 		},
+		{
+			name: "should return error if the target plan is inactive",
+			id:   "test-id",
+			change: subscription.ChangeRequest{
+				PlanID:    "new-plan",
+				Immediate: true,
+			},
+			setup: func(r *mocks.Repository, p *mocks.PlanService, c *mocks.CustomerService, o *mocks.OrganizationService) {
+				r.EXPECT().GetByID(mock.Anything, "test-id").Return(subscription.Subscription{
+					ID:     "test-id",
+					PlanID: "old-plan",
+					State:  subscription.StateActive.String(),
+				}, nil)
+				p.EXPECT().GetByID(mock.Anything, "new-plan").Return(plan.Plan{ID: "new-plan", State: "inactive"}, nil)
+			},
+			wantErr: subscription.ErrPlanInactive,
+		},
 	}
 
 	for _, tt := range tests {

billing/subscription/subscription.go

@@ -13,6 +13,7 @@ var (
 	ErrInvalidID                      = fmt.Errorf("invalid subscription id")
 	ErrInvalidDetail                  = fmt.Errorf("invalid subscription detail")
 	ErrAlreadyOnSamePlan              = fmt.Errorf("already on the same plan")
+	ErrPlanInactive                   = fmt.Errorf("plan is inactive and cannot be subscribed to")
 	ErrNoPhaseActive                  = fmt.Errorf("no phase active")
 	ErrPhaseIsUpdating                = fmt.Errorf("phase is in the middle of a change, please try again later")
 	ErrSubscriptionOnProviderNotFound = fmt.Errorf("failed to get subscription from billing provider")

internal/api/v1beta1connect/billing_errors.go

@@ -72,6 +72,8 @@ func mapBillingErrorCode(err error) *connect.Error {
 		return connect.NewError(connect.CodeNotFound, ErrCustomerNotFound)
 	case errors.Is(err, checkout.ErrAlreadySubscribed):
 		return connect.NewError(connect.CodeAlreadyExists, checkout.ErrAlreadySubscribed)
+	case errors.Is(err, checkout.ErrPlanInactive), errors.Is(err, subscription.ErrPlanInactive):
+		return connect.NewError(connect.CodeFailedPrecondition, ErrPlanInactive)
 	case errors.Is(err, product.ErrProductNotFound):
 		return connect.NewError(connect.CodeNotFound, product.ErrProductNotFound)
 	case errors.Is(err, product.ErrFeatureNotFound):

internal/api/v1beta1connect/billing_plan.go

@@ -2,6 +2,7 @@ package v1beta1connect
 
 import (
 	"context"
+	"errors"
 	"fmt"
 
 	"connectrpc.com/connect"
@@ -71,6 +72,7 @@ func (h *ConnectHandler) CreatePlan(ctx context.Context, request *connect.Reques
 		Products:       products,
 		OnStartCredits: request.Msg.GetBody().GetOnStartCredits(),
 		TrialDays:      request.Msg.GetBody().GetTrialDays(),
+		State:          request.Msg.GetBody().GetState(),
 		Metadata:       metaDataMap,
 	}
 
@@ -95,6 +97,39 @@ func (h *ConnectHandler) CreatePlan(ctx context.Context, request *connect.Reques
 	return connect.NewResponse(&frontierv1beta1.CreatePlanResponse{Plan: planPB}), nil
 }
 
+func (h *ConnectHandler) UpdatePlan(ctx context.Context, request *connect.Request[frontierv1beta1.UpdatePlanRequest]) (*connect.Response[frontierv1beta1.UpdatePlanResponse], error) {
+	body := request.Msg.GetBody()
+	// UpdatePlan changes a plan's own fields (title, description, credits, trial
+	// days, state, metadata). A plan's products are managed through CreatePlan's
+	// upsert, not here, so they are not read from the request.
+	updatedPlan, err := h.planService.UpdatePlan(ctx, plan.Plan{
+		ID:             request.Msg.GetId(),
+		Title:          body.GetTitle(),
+		Description:    body.GetDescription(),
+		OnStartCredits: body.GetOnStartCredits(),
+		TrialDays:      body.GetTrialDays(),
+		State:          body.GetState(),
+		Metadata:       metadata.Build(body.GetMetadata().AsMap()),
+	})
+	if err != nil {
+		switch {
+		case errors.Is(err, plan.ErrNotFound):
+			return nil, connect.NewError(connect.CodeNotFound, ErrNotFound)
+		case errors.Is(err, plan.ErrInvalidName), errors.Is(err, plan.ErrInvalidUUID):
+			return nil, connect.NewError(connect.CodeInvalidArgument, ErrBadRequest)
+		default:
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("UpdatePlan.UpdatePlan: plan_id=%s: %w", request.Msg.GetId(), err))
+		}
+	}
+
+	planPB, err := transformPlanToPB(updatedPlan)
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("UpdatePlan: plan_id=%s: %w", updatedPlan.ID, err))
+	}
+
+	return connect.NewResponse(&frontierv1beta1.UpdatePlanResponse{Plan: planPB}), nil
+}
+
 func (h *ConnectHandler) ListPlans(ctx context.Context, request *connect.Request[frontierv1beta1.ListPlansRequest]) (*connect.Response[frontierv1beta1.ListPlansResponse], error) {
 	var plans []*frontierv1beta1.Plan
 	planList, err := h.planService.List(ctx, plan.Filter{})
@@ -112,6 +147,29 @@ func (h *ConnectHandler) ListPlans(ctx context.Context, request *connect.Request
 	return connect.NewResponse(&frontierv1beta1.ListPlansResponse{Plans: plans}), nil
 }
 
+func (h *ConnectHandler) ListAllPlans(ctx context.Context, request *connect.Request[frontierv1beta1.ListAllPlansRequest]) (*connect.Response[frontierv1beta1.ListAllPlansResponse], error) {
+	// ListPlans lists active plans only. ListAllPlans lists every plan: an empty
+	// state means all states, and a set state filters to that state.
+	state := request.Msg.GetState()
+	if state == "" {
+		state = plan.StateAll
+	}
+	var plans []*frontierv1beta1.Plan
+	planList, err := h.planService.List(ctx, plan.Filter{State: state})
+	if err != nil {
+		return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("ListAllPlans.List: %w", err))
+	}
+	for _, v := range planList {
+		planPB, err := transformPlanToPB(v)
+		if err != nil {
+			return nil, connect.NewError(connect.CodeInternal, fmt.Errorf("ListAllPlans: plan_id=%s: %w", v.ID, err))
+		}
+		plans = append(plans, planPB)
+	}
+
+	return connect.NewResponse(&frontierv1beta1.ListAllPlansResponse{Plans: plans}), nil
+}
+
 func (h *ConnectHandler) GetPlan(ctx context.Context, request *connect.Request[frontierv1beta1.GetPlanRequest]) (*connect.Response[frontierv1beta1.GetPlanResponse], error) {
 	planOb, err := h.planService.GetByID(ctx, request.Msg.GetId())
 	if err != nil {
@@ -153,6 +211,7 @@ func transformPlanToPB(p plan.Plan) (*frontierv1beta1.Plan, error) {
 		OnStartCredits: p.OnStartCredits,
 		Products:       products,
 		TrialDays:      p.TrialDays,
+		State:          p.State,
 		Metadata:       metaData,
 		CreatedAt:      timestamppb.New(p.CreatedAt),
 		UpdatedAt:      timestamppb.New(p.UpdatedAt),