feat: redefine how subject and customer lifecycles interact

Author: GAlexIHU

app/common/customer.go

@@ -88,27 +88,6 @@ func NewCustomerSubjectServiceHook(
 	return h, nil
 }
 
-type CustomerSubjectValidatorHook customerservicehooks.SubjectValidatorHook
-
-func NewCustomerSubjectValidatorServiceHook(
-	logger *slog.Logger,
-	subjectService subject.Service,
-	customerService customer.Service,
-) (CustomerSubjectValidatorHook, error) {
-	// Initialize the customer subject validator hook and register it for Subject service
-	h, err := customerservicehooks.NewSubjectValidatorHook(customerservicehooks.SubjectValidatorHookConfig{
-		Customer: customerService,
-		Logger:   logger,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("failed to create customer subject validator hook: %w", err)
-	}
-
-	subjectService.RegisterHooks(h)
-
-	return h, nil
-}
-
 type CustomerEntitlementValidatorHook customerservicehooks.EntitlementValidatorHook
 
 func NewCustomerEntitlementValidatorServiceHook(

app/common/subject.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/openmeterio/openmeter/openmeter/customer"
 	entdb "github.com/openmeterio/openmeter/openmeter/ent/db"
-	"github.com/openmeterio/openmeter/openmeter/registry"
 	"github.com/openmeterio/openmeter/openmeter/subject"
 	"github.com/openmeterio/openmeter/openmeter/subject/adapter"
 	"github.com/openmeterio/openmeter/openmeter/subject/service"
@@ -52,20 +51,3 @@ func NewSubjectCustomerHook(
 
 	return h, nil
 }
-
-func NewSubjectEntitlementValidatorHook(
-	logger *slog.Logger,
-	entitlementRegistry *registry.Entitlement,
-	subjectService subject.Service,
-) (subjecthooks.EntitlementValidatorHook, error) {
-	h, err := subjecthooks.NewEntitlementValidatorHook(subjecthooks.EntitlementValidatorHookConfig{
-		EntitlementService: entitlementRegistry.Entitlement,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("failed to create subject entitlement validator hook: %w", err)
-	}
-
-	subjectService.RegisterHooks(h)
-
-	return h, nil
-}

cmd/server/wire.go

@@ -48,7 +48,6 @@ type Application struct {
 	AppRegistry                      common.AppRegistry
 	Customer                         customer.Service
 	CustomerSubjectHook              common.CustomerSubjectHook
-	CustomerSubjectValidatorHook     common.CustomerSubjectValidatorHook
 	CustomerEntitlementValidatorHook common.CustomerEntitlementValidatorHook
 	Billing                          billing.Service
 	EntClient                        *db.Client
@@ -77,7 +76,6 @@ type Application struct {
 	Secret                           secret.Service
 	SubjectService                   subject.Service
 	SubjectCustomerHook              subjecthooks.CustomerSubjectHook
-	SubjectEntitlementValidatorHook  subjecthooks.EntitlementValidatorHook
 	Subscription                     common.SubscriptionServiceWithWorkflow
 	StreamingConnector               streaming.Connector
 	TelemetryServer                  common.TelemetryServer
@@ -95,7 +93,6 @@ func initializeApplication(ctx context.Context, conf config.Configuration) (Appl
 		common.Config,
 		common.Customer,
 		common.NewCustomerSubjectServiceHook,
-		common.NewCustomerSubjectValidatorServiceHook,
 		common.NewCustomerEntitlementValidatorServiceHook,
 		common.Database,
 		common.Entitlement,
@@ -125,7 +122,6 @@ func initializeApplication(ctx context.Context, conf config.Configuration) (Appl
 		common.ServerProvisionTopics,
 		common.Subject,
 		common.NewSubjectCustomerHook,
-		common.NewSubjectEntitlementValidatorHook,
 		common.Telemetry,
 		common.TelemetryLoggerNoAdditionalMiddlewares,
 		common.NewTerminationChecker,

cmd/server/wire_gen.go

@@ -52,6 +52,21 @@ type Customer struct {
 	ActiveSubscriptionIDs mo.Option[[]string]
 }
 
+// AsCustomerMutate returns a CustomerMutate from the Customer
+func (c Customer) AsCustomerMutate() CustomerMutate {
+	return CustomerMutate{
+		Key:              c.Key,
+		Name:             c.Name,
+		Description:      c.Description,
+		UsageAttribution: c.UsageAttribution,
+		PrimaryEmail:     c.PrimaryEmail,
+		Currency:         c.Currency,
+		BillingAddress:   c.BillingAddress,
+		Metadata:         c.Metadata,
+		Annotation:       c.Annotation,
+	}
+}
+
 // GetUsageAttribution returns the customer usage attribution
 // implementing the streaming.CustomerUsageAttribution interface
 func (c Customer) GetUsageAttribution() streaming.CustomerUsageAttribution {

openmeter/customer/customer.go

@@ -10,6 +10,7 @@ import (
 	"slices"
 	"strconv"
 	"strings"
+	"time"
 
 	"github.com/samber/lo"
 	"go.opentelemetry.io/otel/attribute"
@@ -22,6 +23,7 @@ import (
 	"github.com/openmeterio/openmeter/openmeter/customer"
 	"github.com/openmeterio/openmeter/openmeter/subject"
 	subjectservicehooks "github.com/openmeterio/openmeter/openmeter/subject/service/hooks"
+	"github.com/openmeterio/openmeter/pkg/clock"
 	"github.com/openmeterio/openmeter/pkg/models"
 )
 
@@ -57,6 +59,79 @@ func (s subjectCustomerHook) provision(ctx context.Context, sub *subject.Subject
 	return nil
 }
 
+func (s subjectCustomerHook) PostDelete(ctx context.Context, sub *subject.Subject) error {
+	ctx, span := s.tracer.Start(ctx, "subject_customer_hook.post_delete", trace.WithAttributes(
+		attribute.String("subject.id", sub.Id),
+		attribute.String("subject.key", sub.Key),
+	))
+	defer span.End()
+
+	// Let's get the customer by usage attribution
+	cus, err := s.provisioner.customer.GetCustomerByUsageAttribution(ctx, customer.GetCustomerByUsageAttributionInput{
+		Namespace:  sub.Namespace,
+		SubjectKey: sub.Key,
+	})
+	if err != nil {
+		if models.IsGenericNotFoundError(err) {
+			span.AddEvent("customer not found by usage attribution", trace.WithAttributes(
+				attribute.String("error", err.Error()),
+			))
+
+			return nil
+		}
+
+		return err
+	}
+
+	if cus == nil {
+		span.AddEvent("customer not found by usage attribution")
+
+		return nil
+	}
+
+	if cus.DeletedAt != nil && cus.DeletedAt.Before(clock.Now()) {
+		span.AddEvent("customer is deleted", trace.WithAttributes(
+			attribute.String("customer.id", cus.ID),
+			attribute.String("customer.deleted_at", cus.DeletedAt.Format(time.RFC3339)),
+		))
+
+		return nil
+	}
+
+	// Let's update the customer usage attribution
+	cus, err = s.provisioner.customer.UpdateCustomer(ctx, customer.UpdateCustomerInput{
+		CustomerID: customer.CustomerID{
+			Namespace: cus.Namespace,
+			ID:        cus.ID,
+		},
+		CustomerMutate: func() customer.CustomerMutate {
+			mut := cus.AsCustomerMutate()
+
+			mut.UsageAttribution.SubjectKeys = lo.Filter(mut.UsageAttribution.SubjectKeys, func(key string, _ int) bool {
+				return key != sub.Key
+			})
+
+			return mut
+		}(),
+	})
+
+	if cus != nil {
+		span.AddEvent("updated customer usage attribution", trace.WithAttributes(
+			attribute.String("customer.usage_attribution.subject_keys", strings.Join(cus.UsageAttribution.SubjectKeys, ", ")),
+		))
+	}
+
+	if err != nil {
+		span.AddEvent("failed to update customer usage attribution", trace.WithAttributes(
+			attribute.String("error", err.Error()),
+		))
+
+		return err
+	}
+
+	return nil
+}
+
 func (s subjectCustomerHook) PostCreate(ctx context.Context, sub *subject.Subject) error {
 	ctx, span := s.tracer.Start(ctx, "subject_customer_hook.post_create")
 	defer span.End()