feat(taxcode): prevent deletion of add-on-referenced tax codes

Author: borbelyr-kong

app/common/taxcode.go

@@ -11,6 +11,7 @@ import (
 	"github.com/openmeterio/openmeter/app/config"
 	"github.com/openmeterio/openmeter/openmeter/app"
 	entdb "github.com/openmeterio/openmeter/openmeter/ent/db"
+	"github.com/openmeterio/openmeter/openmeter/productcatalog/addon"
 	"github.com/openmeterio/openmeter/openmeter/productcatalog/plan"
 	"github.com/openmeterio/openmeter/openmeter/taxcode"
 	taxcodeadapter "github.com/openmeterio/openmeter/openmeter/taxcode/adapter"
@@ -67,6 +68,28 @@ func NewTaxCodePlanValidatorServiceHook(
 	return h, nil
 }
 
+// TaxCodeAddonHook prevents deleting tax codes that are still referenced by add-ons.
+type TaxCodeAddonHook taxcodehooks.AddonHook
+
+// NewTaxCodeAddonServiceHook builds the add-on-reference hook and registers it
+// on the tax code service. It depends on both the add-on and tax code services so wire constructs
+// it only after both exist, avoiding a construction cycle (add-on already depends on tax code).
+func NewTaxCodeAddonServiceHook(
+	addonService addon.Service,
+	taxCodeService taxcode.Service,
+) (TaxCodeAddonHook, error) {
+	h, err := taxcodehooks.NewAddonHook(taxcodehooks.AddonHookConfig{
+		AddonService: addonService,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to create tax code add-on hook: %w", err)
+	}
+
+	taxCodeService.RegisterHooks(h)
+
+	return h, nil
+}
+
 func NewTaxCodeNamespaceHandler(
 	logger *slog.Logger,
 	service taxcode.Service,

cmd/server/wire.go

@@ -100,6 +100,7 @@ type Application struct {
 	TaxCodeNamespaceHandler          *taxcode.NamespaceHandler
 	TaxCodeService                   taxcode.Service
 	TaxCodePlanValidatorHook         common.TaxCodePlanValidatorHook
+	TaxCodeAddonHook                 common.TaxCodeAddonHook
 	TelemetryServer                  common.TelemetryServer
 	TerminationChecker               *common.TerminationChecker
 	RuntimeMetricsCollector          common.RuntimeMetricsCollector
@@ -150,6 +151,7 @@ func initializeApplication(ctx context.Context, conf config.Configuration) (Appl
 		common.TaxCode,
 		common.TaxCodeNamespaceHandler,
 		common.NewTaxCodePlanValidatorServiceHook,
+		common.NewTaxCodeAddonServiceHook,
 		common.Subscription,
 		common.Lockr,
 		common.Secret,

cmd/server/wire_gen.go

@@ -10,11 +10,14 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
+	"github.com/openmeterio/openmeter/openmeter/app"
 	"github.com/openmeterio/openmeter/openmeter/meter"
 	"github.com/openmeterio/openmeter/openmeter/productcatalog"
 	"github.com/openmeterio/openmeter/openmeter/productcatalog/addon"
 	"github.com/openmeterio/openmeter/openmeter/productcatalog/feature"
 	pctestutils "github.com/openmeterio/openmeter/openmeter/productcatalog/testutils"
+	"github.com/openmeterio/openmeter/openmeter/taxcode"
+	tctestutils "github.com/openmeterio/openmeter/openmeter/taxcode/testutils"
 	"github.com/openmeterio/openmeter/openmeter/testutils"
 	"github.com/openmeterio/openmeter/pkg/clock"
 	"github.com/openmeterio/openmeter/pkg/datetime"
@@ -438,5 +441,108 @@ func TestPostgresAdapter(t *testing.T) {
 				})
 			}
 		})
+
+		t.Run("ListTaxCodeFilter", func(t *testing.T) {
+			testListAddonTaxCodeFilter(t, env)
+		})
+	})
+}
+
+func testListAddonTaxCodeFilter(t *testing.T, env *pctestutils.TestEnv) {
+	t.Helper()
+
+	ns := pctestutils.NewTestNamespace(t)
+
+	// Create two tax codes with distinct Stripe app mappings so the add-on service
+	// can resolve them and populate the rate-card tax_code_id FK.
+	tcEnv := tctestutils.NewTestEnvFromClient(t, env.Client, env.Logger)
+
+	taxA := tcEnv.CreateTaxCode(t, ns, taxcode.CreateTaxCodeInput{
+		Key:  "tax-a",
+		Name: "Tax A",
+		AppMappings: taxcode.TaxCodeAppMappings{
+			{AppType: app.AppTypeStripe, TaxCode: "txcd_20000001"},
+		},
+	})
+
+	taxB := tcEnv.CreateTaxCode(t, ns, taxcode.CreateTaxCodeInput{
+		Key:  "tax-b",
+		Name: "Tax B",
+		AppMappings: taxcode.TaxCodeAppMappings{
+			{AppType: app.AppTypeStripe, TaxCode: "txcd_20000002"},
+		},
+	})
+
+	// Helper: build a minimal add-on input with a FlatFeeRateCard referencing the given taxCodeID.
+	makeAddonInput := func(key string, taxCodeID string) addon.CreateAddonInput {
+		input := pctestutils.NewTestAddon(t, ns,
+			&productcatalog.FlatFeeRateCard{
+				RateCardMeta: productcatalog.RateCardMeta{
+					Key:  "rc-1",
+					Name: "RC 1",
+					TaxConfig: &productcatalog.TaxConfig{
+						TaxCodeID: lo.ToPtr(taxCodeID),
+					},
+				},
+			},
+		)
+		input.Addon.AddonMeta.Key = key
+		return input
+	}
+
+	// given: two add-ons each referencing a different tax code
+	addonA, err := env.Addon.CreateAddon(t.Context(), makeAddonInput("addon-a", taxA.ID))
+	require.NoError(t, err, "creating addonA must not fail")
+
+	addonB, err := env.Addon.CreateAddon(t.Context(), makeAddonInput("addon-b", taxB.ID))
+	require.NoError(t, err, "creating addonB must not fail")
+
+	t.Run("filter by taxA returns only addonA", func(t *testing.T) {
+		// when: listing add-ons filtered by taxA
+		result, err := env.AddonRepository.ListAddons(t.Context(), addon.ListAddonsInput{
+			Namespaces: []string{ns},
+			TaxCodes:   &filter.FilterString{In: lo.ToPtr([]string{taxA.ID})},
+			Page:       pagination.Page{PageSize: 100, PageNumber: 1},
+		})
+
+		// then: only addonA is returned
+		require.NoError(t, err)
+		ids := addonIDs(result)
+		require.ElementsMatch(t, []string{addonA.ID}, ids)
+	})
+
+	t.Run("filter by taxB returns only addonB", func(t *testing.T) {
+		// when: listing add-ons filtered by taxB
+		result, err := env.AddonRepository.ListAddons(t.Context(), addon.ListAddonsInput{
+			Namespaces: []string{ns},
+			TaxCodes:   &filter.FilterString{In: lo.ToPtr([]string{taxB.ID})},
+			Page:       pagination.Page{PageSize: 100, PageNumber: 1},
+		})
+
+		// then: only addonB is returned
+		require.NoError(t, err)
+		ids := addonIDs(result)
+		require.ElementsMatch(t, []string{addonB.ID}, ids)
 	})
+
+	t.Run("filter by nonexistent tax code returns empty", func(t *testing.T) {
+		// when: listing add-ons filtered by a tax code id that doesn't exist
+		result, err := env.AddonRepository.ListAddons(t.Context(), addon.ListAddonsInput{
+			Namespaces: []string{ns},
+			TaxCodes:   &filter.FilterString{In: lo.ToPtr([]string{"01000000000000000000000000"})},
+			Page:       pagination.Page{PageSize: 100, PageNumber: 1},
+		})
+
+		// then: no add-ons are returned
+		require.NoError(t, err)
+		require.Empty(t, result.Items)
+	})
+}
+
+func addonIDs(result pagination.Result[addon.Addon]) []string {
+	ids := make([]string, 0, len(result.Items))
+	for _, a := range result.Items {
+		ids = append(ids, a.ID)
+	}
+	return ids
 }

openmeter/productcatalog/addon/adapter/adapter_test.go

@@ -50,6 +50,15 @@ func (a *adapter) ListAddons(ctx context.Context, params addon.ListAddonsInput)
 		query = filter.ApplyToQuery(query, params.Name, addondb.FieldName)
 		query = filter.ApplyToQuery(query, params.Currency, addondb.FieldCurrency)
 
+		if params.TaxCodes != nil {
+			if p := filter.SelectPredicate[predicate.AddonRateCard](filter.Filter(*params.TaxCodes), addonratecarddb.FieldTaxCodeID); p != nil {
+				query = query.Where(addondb.HasRatecardsWith(
+					*p,
+					addonratecarddb.DeletedAtIsNil(),
+				))
+			}
+		}
+
 		if !params.IncludeDeleted {
 			query = query.Where(addondb.DeletedAtIsNil())
 		}

openmeter/productcatalog/addon/adapter/addon.go

@@ -95,6 +95,8 @@ type ListAddonsInput struct {
 	Key      *filter.FilterString
 	Name     *filter.FilterString
 	Currency *filter.FilterString
+	// TaxCodes filters add-ons by the tax code IDs referenced on their rate cards.
+	TaxCodes *filter.FilterString
 }
 
 func (i ListAddonsInput) Validate() error {
@@ -120,6 +122,11 @@ func (i ListAddonsInput) Validate() error {
 			errs = append(errs, err)
 		}
 	}
+	if i.TaxCodes != nil {
+		if err := i.TaxCodes.Validate(); err != nil {
+			errs = append(errs, err)
+		}
+	}
 
 	if i.OrderBy != "" {
 		if err := i.OrderBy.Validate(); err != nil {

openmeter/productcatalog/addon/service.go

@@ -176,3 +176,23 @@ func IsTaxCodeReferencedByPlanError(err error) bool {
 	var vi models.ValidationIssue
 	return errors.As(err, &vi) && vi.Code() == ErrCodeTaxCodeReferencedByPlan
 }
+
+const ErrCodeTaxCodeReferencedByAddon models.ErrorCode = "tax_code_referenced_by_addon"
+
+var ErrTaxCodeReferencedByAddon = models.NewValidationIssue(
+	ErrCodeTaxCodeReferencedByAddon,
+	"tax code cannot be deleted as it is referenced by one or more add-ons",
+	models.WithCriticalSeverity(),
+	commonhttp.WithHTTPStatusCodeAttribute(http.StatusConflict),
+)
+
+func NewTaxCodeReferencedByAddonError(taxCodeID string, addonIDs []string) error {
+	return ErrTaxCodeReferencedByAddon.
+		WithAttr("id", taxCodeID).
+		WithAttr("addon_ids", addonIDs)
+}
+
+func IsTaxCodeReferencedByAddonError(err error) bool {
+	var vi models.ValidationIssue
+	return errors.As(err, &vi) && vi.Code() == ErrCodeTaxCodeReferencedByAddon
+}

openmeter/taxcode/errors.go

@@ -0,0 +1,82 @@
+package hooks
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/samber/lo"
+
+	"github.com/openmeterio/openmeter/openmeter/productcatalog"
+	"github.com/openmeterio/openmeter/openmeter/productcatalog/addon"
+	"github.com/openmeterio/openmeter/openmeter/taxcode"
+	"github.com/openmeterio/openmeter/pkg/filter"
+	"github.com/openmeterio/openmeter/pkg/models"
+	"github.com/openmeterio/openmeter/pkg/pagination"
+)
+
+type (
+	AddonHook     = models.ServiceHook[taxcode.TaxCode]
+	NoopAddonHook = models.NoopServiceHook[taxcode.TaxCode]
+)
+
+type AddonHookConfig struct {
+	AddonService addon.Service
+}
+
+func (e AddonHookConfig) Validate() error {
+	if e.AddonService == nil {
+		return fmt.Errorf("addon service is required")
+	}
+
+	return nil
+}
+
+var _ models.ServiceHook[taxcode.TaxCode] = (*addonHook)(nil)
+
+type addonHook struct {
+	NoopAddonHook
+
+	addonService addon.Service
+}
+
+func NewAddonHook(config AddonHookConfig) (AddonHook, error) {
+	if err := config.Validate(); err != nil {
+		return nil, fmt.Errorf("invalid addon hook config: %w", err)
+	}
+
+	return &addonHook{
+		addonService: config.AddonService,
+	}, nil
+}
+
+func (e *addonHook) PreDelete(ctx context.Context, tc *taxcode.TaxCode) error {
+	affectedAddons, err := e.addonService.ListAddons(ctx, addon.ListAddonsInput{
+		Namespaces: []string{tc.Namespace},
+		Status: []productcatalog.AddonStatus{
+			productcatalog.AddonStatusActive,
+			productcatalog.AddonStatusDraft,
+			productcatalog.AddonStatusArchived,
+		},
+		TaxCodes: &filter.FilterString{
+			In: &[]string{
+				tc.ID,
+			},
+		},
+		Page: pagination.Page{
+			PageSize:   5,
+			PageNumber: 1,
+		},
+	})
+	if err != nil {
+		return fmt.Errorf("failed to list add-ons: %w", err)
+	}
+
+	if len(affectedAddons.Items) > 0 {
+		addonIDs := lo.Map(affectedAddons.Items, func(item addon.Addon, _ int) string {
+			return item.ID
+		})
+		return taxcode.NewTaxCodeReferencedByAddonError(tc.ID, addonIDs)
+	}
+
+	return nil
+}