fix: feature delete (#3522)

Author: chrisgacsal

openmeter/productcatalog/adapter/feature.go

@@ -20,7 +20,6 @@ import (
 	subscriptionrepo "github.com/openmeterio/openmeter/openmeter/subscription/repo"
 	"github.com/openmeterio/openmeter/pkg/clock"
 	"github.com/openmeterio/openmeter/pkg/framework/entutils"
-	"github.com/openmeterio/openmeter/pkg/models"
 	"github.com/openmeterio/openmeter/pkg/pagination"
 )
 
@@ -86,19 +85,28 @@ func (c *featureDBAdapter) GetByIdOrKey(ctx context.Context, namespace string, i
 	return &res, nil
 }
 
-func (c *featureDBAdapter) ArchiveFeature(ctx context.Context, featureID models.NamespacedID) error {
-	f, err := c.GetByIdOrKey(ctx, featureID.Namespace, featureID.ID, true)
+func (c *featureDBAdapter) ArchiveFeature(ctx context.Context, params feature.ArchiveFeatureInput) error {
+	f, err := c.GetByIdOrKey(ctx, params.Namespace, params.ID, true)
 	if err != nil {
 		return err
 	}
 
+	archivedAt := clock.Now()
+	if params.At != nil {
+		if params.At.Before(f.UpdatedAt) {
+			return &feature.ForbiddenError{Msg: "cannot archive feature at a time before it was last updated", ID: f.ID}
+		}
+
+		archivedAt = *params.At
+	}
+
 	// FIXME: (OM-1055) we should marry productcatalog/plan with feature so we can do this check outside the db layer
 	planReferencesIt, err := c.db.Plan.Query().
 		WithPhases(func(qp *db.PlanPhaseQuery) {
 			qp.WithRatecards()
 		}).
 		Where(
-			dbplan.Namespace(featureID.Namespace),
+			dbplan.Namespace(params.Namespace),
 			dbplan.EffectiveFromNotNil(),
 			dbplan.Or(dbplan.EffectiveToGT(clock.Now()), dbplan.EffectiveToIsNil()),
 			dbplan.HasPhasesWith(dbplanphase.HasRatecardsWith(
@@ -118,7 +126,7 @@ func (c *featureDBAdapter) ArchiveFeature(ctx context.Context, featureID models.
 			subscriptionrepo.SubscriptionActiveAfter(clock.Now())...,
 		).
 		Where(
-			dbsub.Namespace(featureID.Namespace),
+			dbsub.Namespace(params.Namespace),
 			dbsub.HasPhasesWith(dbsubphase.HasItemsWith(dbsubitem.FeatureKey(f.Key))),
 		).
 		Exist(ctx)
@@ -137,9 +145,9 @@ func (c *featureDBAdapter) ArchiveFeature(ctx context.Context, featureID models.
 	}
 
 	err = c.db.Feature.Update().
-		SetArchivedAt(clock.Now()).
-		Where(db_feature.ID(featureID.ID)).
-		Where(db_feature.Namespace(featureID.Namespace)).
+		SetArchivedAt(archivedAt).
+		Where(db_feature.ID(params.ID)).
+		Where(db_feature.Namespace(params.Namespace)).
 		Exec(ctx)
 	if err != nil {
 		return fmt.Errorf("failed to archive feature: %w", err)

openmeter/productcatalog/adapter/feature_test.go

@@ -94,15 +94,15 @@ func TestCreateFeature(t *testing.T) {
 				assert.NoError(t, err)
 
 				// archives the feature
-				err = connector.ArchiveFeature(ctx, models.NamespacedID{
+				err = connector.ArchiveFeature(ctx, feature.ArchiveFeatureInput{
 					Namespace: featureIn.Namespace,
 					ID:        createFeatureOut.ID,
 				})
 				assert.NoError(t, err)
 
 				// errors on a feature that doesn't exist
 				fakeID := ulid.Make().String()
-				err = connector.ArchiveFeature(ctx, models.NamespacedID{
+				err = connector.ArchiveFeature(ctx, feature.ArchiveFeatureInput{
 					Namespace: featureIn.Namespace,
 					ID:        fakeID,
 				})
@@ -160,7 +160,7 @@ func TestCreateFeature(t *testing.T) {
 				assert.Len(t, features.Items, 1)
 				assert.Equal(t, "feature-2", features.Items[0].Name)
 
-				err = connector.ArchiveFeature(ctx, models.NamespacedID{
+				err = connector.ArchiveFeature(ctx, feature.ArchiveFeatureInput{
 					Namespace: namespace,
 					ID:        features.Items[0].ID,
 				})
@@ -206,7 +206,7 @@ func TestCreateFeature(t *testing.T) {
 
 				assert.Equal(t, "feature-1", foundFeature.Name)
 
-				err = connector.ArchiveFeature(ctx, models.NamespacedID{
+				err = connector.ArchiveFeature(ctx, feature.ArchiveFeatureInput{
 					Namespace: namespace,
 					ID:        foundFeature.ID,
 				})
@@ -358,7 +358,7 @@ func TestArchiveFeature(t *testing.T) {
 		createFeatureOut, err := connector.CreateFeature(ctx, featureIn)
 		assert.NoError(t, err)
 
-		err = connector.ArchiveFeature(ctx, models.NamespacedID{
+		err = connector.ArchiveFeature(ctx, feature.ArchiveFeatureInput{
 			Namespace: createFeatureOut.Namespace,
 			ID:        createFeatureOut.ID,
 		})
@@ -416,7 +416,7 @@ func TestFetchingArchivedFeature(t *testing.T) {
 		createFeatureOutArchived, err := connector.CreateFeature(ctx, featureIn)
 		assert.NoError(t, err)
 
-		err = connector.ArchiveFeature(ctx, models.NamespacedID{
+		err = connector.ArchiveFeature(ctx, feature.ArchiveFeatureInput{
 			Namespace: createFeatureOutArchived.Namespace,
 			ID:        createFeatureOutArchived.ID,
 		})

openmeter/productcatalog/feature/connector.go

@@ -6,9 +6,11 @@ import (
 	"slices"
 
 	"github.com/oklog/ulid/v2"
+	"github.com/samber/lo"
 
 	meterpkg "github.com/openmeterio/openmeter/openmeter/meter"
 	"github.com/openmeterio/openmeter/openmeter/watermill/eventbus"
+	"github.com/openmeterio/openmeter/pkg/clock"
 	"github.com/openmeterio/openmeter/pkg/models"
 	"github.com/openmeterio/openmeter/pkg/pagination"
 	"github.com/openmeterio/openmeter/pkg/sortx"
@@ -163,25 +165,27 @@ func (c *featureConnector) CreateFeature(ctx context.Context, feature CreateFeat
 // ArchiveFeature archives a feature
 func (c *featureConnector) ArchiveFeature(ctx context.Context, featureID models.NamespacedID) error {
 	// Get the feature
-	_, err := c.GetFeature(ctx, featureID.Namespace, featureID.ID, false)
+	feat, err := c.GetFeature(ctx, featureID.Namespace, featureID.ID, false)
 	if err != nil {
 		return err
 	}
 
+	archivedAt := lo.ToPtr(clock.Now())
+
 	// Archive the feature
-	err = c.featureRepo.ArchiveFeature(ctx, featureID)
+	err = c.featureRepo.ArchiveFeature(ctx, ArchiveFeatureInput{
+		Namespace: feat.Namespace,
+		ID:        feat.ID,
+		At:        archivedAt,
+	})
 	if err != nil {
 		return err
 	}
 
-	// Get the archived feature
-	archivedFeature, err := c.GetFeature(ctx, featureID.Namespace, featureID.ID, true)
-	if err != nil {
-		return err
-	}
+	feat.ArchivedAt = archivedAt
 
 	// Publish the feature archived event
-	featureArchivedEvent := NewFeatureArchiveEvent(ctx, archivedFeature)
+	featureArchivedEvent := NewFeatureArchiveEvent(ctx, feat)
 	if err := c.publisher.Publish(ctx, featureArchivedEvent); err != nil {
 		return fmt.Errorf("failed to publish feature archived event: %w", err)
 	}

openmeter/productcatalog/feature/repository.go

@@ -2,15 +2,41 @@ package feature
 
 import (
 	"context"
+	"errors"
+	"time"
 
 	"github.com/openmeterio/openmeter/pkg/framework/entutils"
 	"github.com/openmeterio/openmeter/pkg/models"
 	"github.com/openmeterio/openmeter/pkg/pagination"
 )
 
+type ArchiveFeatureInput struct {
+	Namespace string
+	ID        string
+	At        *time.Time
+}
+
+func (i ArchiveFeatureInput) Validate() error {
+	var errs []error
+
+	if i.Namespace == "" {
+		errs = append(errs, errors.New("namespace is required"))
+	}
+
+	if i.ID == "" {
+		errs = append(errs, errors.New("id is required"))
+	}
+
+	if i.At != nil && i.At.IsZero() {
+		errs = append(errs, errors.New("at must not be zero"))
+	}
+
+	return models.NewNillableGenericValidationError(errors.Join(errs...))
+}
+
 type FeatureRepo interface {
 	CreateFeature(ctx context.Context, feature CreateFeatureInputs) (Feature, error)
-	ArchiveFeature(ctx context.Context, featureID models.NamespacedID) error
+	ArchiveFeature(ctx context.Context, params ArchiveFeatureInput) error
 	ListFeatures(ctx context.Context, params ListFeaturesParams) (pagination.Result[Feature], error)
 	HasActiveFeatureForMeter(ctx context.Context, namespace string, meterSlug string) (bool, error)