feat: support line deletion

Author: turip

openmeter/billing/adapter/invoice.go

@@ -44,7 +44,7 @@ func (a *adapter) GetInvoiceById(ctx context.Context, in billing.GetInvoiceByIdI
 			WithBillingWorkflowConfig()
 
 		if in.Expand.Lines {
-			query = tx.expandInvoiceLineItems(query)
+			query = tx.expandInvoiceLineItems(query, in.Expand.DeletedLines)
 		}
 
 		invoice, err := query.Only(ctx)
@@ -64,13 +64,17 @@ func (a *adapter) GetInvoiceById(ctx context.Context, in billing.GetInvoiceByIdI
 	})
 }
 
-func (a *adapter) expandInvoiceLineItems(query *db.BillingInvoiceQuery) *db.BillingInvoiceQuery {
+func (a *adapter) expandInvoiceLineItems(query *db.BillingInvoiceQuery, includeDeleted bool) *db.BillingInvoiceQuery {
 	return query.WithBillingInvoiceLines(func(q *db.BillingInvoiceLineQuery) {
+		if !includeDeleted {
+			q = q.Where(billinginvoiceline.DeletedAtIsNil())
+		}
+
 		q = q.Where(
-			billinginvoiceline.DeletedAtIsNil(),
 			// Detailed lines are sub-lines of a line and should not be included in the top-level invoice
 			billinginvoiceline.StatusIn(billingentity.InvoiceLineStatusValid),
 		)
+
 		a.expandLineItems(q)
 	})
 }
@@ -184,7 +188,7 @@ func (a *adapter) ListInvoices(ctx context.Context, input billing.ListInvoicesIn
 		}
 
 		if input.Expand.Lines {
-			query = tx.expandInvoiceLineItems(query)
+			query = tx.expandInvoiceLineItems(query, input.Expand.DeletedLines)
 		}
 
 		switch input.OrderBy {

openmeter/billing/adapter/invoicelinediff.go

@@ -177,12 +177,11 @@ func diffInvoiceLines(lines []*billingentity.Line) (*invoiceLineDiff, error) {
 
 	diff.AffectedLineIDs = set.Subtract(
 		set.Union(diff.AffectedLineIDs, diff.ChildrenDiff.AffectedLineIDs),
-		set.New(lo.Map(diff.LineBase.ToUpdate, func(l *billingentity.Line, _ int) string {
-			return l.ID
-		})...),
-		set.New(lo.Map(diff.ChildrenDiff.LineBase.ToUpdate, func(l *billingentity.Line, _ int) string {
-			return l.ID
-		})...),
+		lineIDsAsSet(diff.LineBase.ToUpdate),
+		lineIDsAsSet(diff.ChildrenDiff.LineBase.ToUpdate),
+
+		lineIDsAsSet(diff.LineBase.ToDelete),
+		lineIDsAsSet(diff.ChildrenDiff.LineBase.ToDelete),
 	)
 
 	// Let's make sure we are not leaking any in-progress calculation details
@@ -192,6 +191,12 @@ func diffInvoiceLines(lines []*billingentity.Line) (*invoiceLineDiff, error) {
 	return &diff, nil
 }
 
+func lineIDsAsSet(lines []*billingentity.Line) *set.Set[string] {
+	return set.New(lo.Map(lines, func(l *billingentity.Line, _ int) string {
+		return l.ID
+	})...)
+}
+
 func diffLineBaseEntities(line *billingentity.Line, out *invoiceLineDiff) error {
 	if line.DBState.ID == "" {
 		// This should not happen, as we fill the DBState after the DB fetch, it's more
@@ -205,7 +210,36 @@ func diffLineBaseEntities(line *billingentity.Line, out *invoiceLineDiff) error
 
 	baseNeedsUpdate := false
 	if !line.DBState.LineBase.Equal(line.LineBase) {
-		baseNeedsUpdate = true
+		switch {
+		case (line.DBState.LineBase.DeletedAt == nil) && (line.LineBase.DeletedAt != nil):
+			// The line got deleted
+			out.LineBase.NeedsDelete(line)
+			out.AffectedLineIDs.Add(lineParentIDs(line, lineIDExcludeSelf)...)
+
+			if line.Children.IsPresent() {
+				// We need to delete the children as well
+				if err := deleteLineChildren(line, out); err != nil {
+					return err
+				}
+			}
+
+			if err := handleLineDependantEntities(line, operationDelete, out); err != nil {
+				return err
+			}
+
+			return nil
+		case (line.DBState.LineBase.DeletedAt != nil) && (line.LineBase.DeletedAt == nil):
+			// The line got undeleted
+
+			// Warning: it's up to the caller to make sure that child objects are properly updated too
+			baseNeedsUpdate = true
+
+		case line.DBState.LineBase.DeletedAt != nil && line.LineBase.DeletedAt != nil:
+			// The line is deleted, we don't need to update anything
+			return nil
+		default:
+			baseNeedsUpdate = true
+		}
 	}
 
 	switch line.Type {
@@ -289,6 +323,20 @@ func getChildrenActions(dbSave []*billingentity.Line, current []*billingentity.L
 	return nil
 }
 
+func deleteLineChildren(line *billingentity.Line, out *invoiceLineDiff) error {
+	for _, child := range line.DBState.Children.OrEmpty() {
+		out.ChildrenDiff.LineBase.NeedsDelete(child)
+
+		if err := handleLineDependantEntities(child, operationDelete, out.ChildrenDiff); err != nil {
+			return err
+		}
+
+		out.ChildrenDiff.AffectedLineIDs.Add(lineParentIDs(child, lineIDExcludeSelf)...)
+	}
+
+	return nil
+}
+
 func handleLineDependantEntities(line *billingentity.Line, lineOperation operation, out *invoiceLineDiff) error {
 	return handleLineDiscounts(line, lineOperation, out)
 }

openmeter/billing/adapter/invoicelinediff_test.go

@@ -8,6 +8,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	billingentity "github.com/openmeterio/openmeter/openmeter/billing/entity"
+	"github.com/openmeterio/openmeter/pkg/clock"
 )
 
 type idDiff = diff[string]
@@ -263,6 +264,105 @@ func TestInvoiceLineDiffing(t *testing.T) {
 			},
 		}, lineDiff)
 	})
+
+	// DeletedAt handling
+	t.Run("support for detailed lines being deleted using deletedAt", func(t *testing.T) {
+		base := cloneLines(template)
+		snapshotAsDBState(base)
+
+		base[1].Children.GetByID("2.1").DeletedAt = lo.ToPtr(clock.Now())
+
+		lineDiff, err := diffInvoiceLines(base)
+		require.NoError(t, err)
+
+		requireDiff(t, lineDiffExpectation{
+			AffectedLineIDs: []string{"2"},
+			ChildrenDiff: &lineDiffExpectation{
+				LineBase: idDiff{
+					ToDelete: []string{"2.1"},
+				},
+				Discounts: idDiff{
+					ToDelete: []string{"D2.1.1"},
+				},
+			},
+		}, lineDiff)
+	})
+
+	t.Run("support for parent lines with children being deleted using deletedAt", func(t *testing.T) {
+		base := cloneLines(template)
+		snapshotAsDBState(base)
+
+		base[1].DeletedAt = lo.ToPtr(clock.Now())
+
+		lineDiff, err := diffInvoiceLines(base)
+		require.NoError(t, err)
+
+		requireDiff(t, lineDiffExpectation{
+			LineBase: idDiff{
+				ToDelete: []string{"2"},
+			},
+			ChildrenDiff: &lineDiffExpectation{
+				LineBase: idDiff{
+					ToDelete: []string{"2.1", "2.2"},
+				},
+				Discounts: idDiff{
+					ToDelete: []string{"D2.1.1"},
+				},
+			},
+		}, lineDiff)
+	})
+
+	t.Run("support for parent lines without children being deleted using deletedAt", func(t *testing.T) {
+		base := cloneLines(template)
+		snapshotAsDBState(base)
+
+		base[0].DeletedAt = lo.ToPtr(clock.Now())
+
+		lineDiff, err := diffInvoiceLines(base)
+		require.NoError(t, err)
+
+		requireDiff(t, lineDiffExpectation{
+			LineBase: idDiff{
+				ToDelete: []string{"1"},
+			},
+		}, lineDiff)
+	})
+
+	t.Run("deleted, changed lines are not triggering updates", func(t *testing.T) {
+		base := cloneLines(template)
+		base[0].DeletedAt = lo.ToPtr(clock.Now())
+		snapshotAsDBState(base)
+		base[0].Description = lo.ToPtr("test")
+
+		lineDiff, err := diffInvoiceLines(base)
+		require.NoError(t, err)
+
+		requireDiff(t, lineDiffExpectation{}, lineDiff)
+	})
+
+	t.Run("deleted, changed lines are not triggering updates", func(t *testing.T) {
+		base := cloneLines(template)
+		base[1].DeletedAt = lo.ToPtr(clock.Now())
+		base[1].Children.GetByID("2.1").DeletedAt = lo.ToPtr(clock.Now())
+
+		snapshotAsDBState(base)
+		base[1].DeletedAt = nil
+		base[1].Children.GetByID("2.1").DeletedAt = nil
+
+		lineDiff, err := diffInvoiceLines(base)
+		require.NoError(t, err)
+
+		requireDiff(t, lineDiffExpectation{
+			LineBase: idDiff{
+				ToUpdate: []string{"2"},
+			},
+			ChildrenDiff: &lineDiffExpectation{
+				LineBase: idDiff{
+					ToUpdate: []string{"2.1"},
+				},
+			},
+		}, lineDiff)
+	})
 }
 
 func mapLinesToIDs(lines []*billingentity.Line) []string {

openmeter/billing/entity/errors.go

@@ -37,6 +37,7 @@ var (
 	ErrInvoiceLineVolumeSplitNotSupported        = NewValidationError("invoice_line_graduated_split_not_supported", "graduated tiered pricing is not supported for split periods")
 	ErrInvoiceLineNoTiers                        = NewValidationError("invoice_line_no_tiers", "usage based invoice line: no tiers found")
 	ErrInvoiceLineMissingOpenEndedTier           = NewValidationError("invoice_line_missing_open_ended_tier", "usage based invoice line: missing open ended tier")
+	ErrInvoiceLineDeleteInvalidStatus            = NewValidationError("invoice_line_delete_invalid_status", "invoice line cannot be deleted in the current state (only valid lines can be deleted)")
 	ErrInvoiceCreateNoLines                      = NewValidationError("invoice_create_no_lines", "the new invoice would have no lines")
 	ErrInvoiceCreateUBPLineCustomerHasNoSubjects = NewValidationError("invoice_create_ubp_line_customer_has_no_subjects", "creating an usage based line: customer has no subjects")
 	ErrInvoiceCreateUBPLinePeriodIsEmpty         = NewValidationError("invoice_create_ubp_line_period_is_empty", "creating an usage based line: truncated period is empty")

openmeter/billing/entity/invoice.go

@@ -118,12 +118,14 @@ type InvoiceExpand struct {
 	Preceding    bool
 	WorkflowApps bool
 	Lines        bool
+	DeletedLines bool
 }
 
 var InvoiceExpandAll = InvoiceExpand{
 	Preceding:    true,
 	WorkflowApps: true,
 	Lines:        true,
+	DeletedLines: false,
 }
 
 func (e InvoiceExpand) Validate() error {
@@ -135,6 +137,11 @@ func (e InvoiceExpand) SetLines(v bool) InvoiceExpand {
 	return e
 }
 
+func (e InvoiceExpand) SetDeletedLines(v bool) InvoiceExpand {
+	e.DeletedLines = v
+	return e
+}
+
 type InvoiceBase struct {
 	Namespace string `json:"namespace"`
 	ID        string `json:"id"`

openmeter/billing/entity/invoiceline.go

@@ -232,6 +232,13 @@ type Line struct {
 	DBState *Line
 }
 
+func (i Line) LineID() LineID {
+	return LineID{
+		Namespace: i.Namespace,
+		ID:        i.ID,
+	}
+}
+
 // CloneWithoutDependencies returns a clone of the line without any external dependencies. Could be used
 // for creating a new line without any references to the parent or children (or config IDs).
 func (i Line) CloneWithoutDependencies() *Line {

openmeter/billing/invoiceline.go

@@ -338,3 +338,5 @@ func (v ValidateLineOwnershipInput) Validate() error {
 
 	return nil
 }
+
+type DeleteInvoiceLineInput = billingentity.LineID

openmeter/billing/service.go

@@ -35,6 +35,7 @@ type InvoiceLineService interface {
 	CreateInvoiceLines(ctx context.Context, input CreateInvoiceLinesInput) ([]*billingentity.Line, error)
 	GetInvoiceLine(ctx context.Context, input GetInvoiceLineInput) (*billingentity.Line, error)
 	UpdateInvoiceLine(ctx context.Context, input UpdateInvoiceLineInput) (*billingentity.Line, error)
+	DeleteInvoiceLine(ctx context.Context, input DeleteInvoiceLineInput) error
 
 	ValidateLineOwnership(ctx context.Context, input ValidateLineOwnershipInput) error
 }

openmeter/billing/service/invoicecalc/details.go

@@ -22,6 +22,10 @@ func RecalculateDetailedLinesAndTotals(invoice *billingentity.Invoice, deps Calc
 	var outErr error
 
 	for _, line := range lines {
+		if line.IsDeleted() {
+			continue
+		}
+
 		if err := line.CalculateDetailedLines(); err != nil {
 			outErr = errors.Join(outErr,
 				billingentity.ValidationWithFieldPrefix(fmt.Sprintf("line[%s]", line.ID()),
@@ -41,6 +45,11 @@ func RecalculateDetailedLinesAndTotals(invoice *billingentity.Invoice, deps Calc
 	totals := billingentity.Totals{}
 
 	totals = totals.Add(lo.Map(invoice.Lines.OrEmpty(), func(line *billingentity.Line, _ int) billingentity.Totals {
+		// Deleted lines are not contributing to the totals
+		if line.DeletedAt != nil {
+			return billingentity.Totals{}
+		}
+
 		return line.Totals
 	})...)
 

openmeter/billing/service/invoiceline.go

@@ -12,6 +12,7 @@ import (
 	billingentity "github.com/openmeterio/openmeter/openmeter/billing/entity"
 	lineservice "github.com/openmeterio/openmeter/openmeter/billing/service/lineservice"
 	customerentity "github.com/openmeterio/openmeter/openmeter/customer/entity"
+	"github.com/openmeterio/openmeter/pkg/clock"
 	"github.com/openmeterio/openmeter/pkg/currencyx"
 	"github.com/openmeterio/openmeter/pkg/framework/transaction"
 	"github.com/openmeterio/openmeter/pkg/pagination"
@@ -370,3 +371,48 @@ func (s *Service) UpdateInvoiceLine(ctx context.Context, input billing.UpdateInv
 
 	return updatedLine, nil
 }
+
+func (s *Service) DeleteInvoiceLine(ctx context.Context, input billing.DeleteInvoiceLineInput) error {
+	if err := input.Validate(); err != nil {
+		return billingentity.ValidationError{
+			Err: err,
+		}
+	}
+
+	existingLine, err := s.adapter.GetInvoiceLine(ctx, input)
+	if err != nil {
+		return err
+	}
+
+	if existingLine.Status != billingentity.InvoiceLineStatusValid {
+		return billingentity.ValidationError{
+			Err: fmt.Errorf("line[%s]: %w", existingLine.ID, billingentity.ErrInvoiceLineDeleteInvalidStatus),
+		}
+	}
+
+	return transaction.RunWithNoValue(ctx, s.adapter, func(ctx context.Context) error {
+		_, err := s.executeTriggerOnInvoice(
+			ctx,
+			billingentity.InvoiceID{
+				ID:        existingLine.InvoiceID,
+				Namespace: existingLine.Namespace,
+			},
+			triggerUpdated,
+			ExecuteTriggerWithAllowInStates(billingentity.InvoiceStatusDraftUpdating),
+			ExecuteTriggerWithEditCallback(func(sm *InvoiceStateMachine) error {
+				line := sm.Invoice.Lines.GetByID(existingLine.ID)
+				if line == nil || line.DeletedAt != nil {
+					return billingentity.NotFoundError{
+						Err: fmt.Errorf("line[%s]: not found in invoice", existingLine.ID),
+					}
+				}
+
+				line.DeletedAt = lo.ToPtr(clock.Now())
+
+				return nil
+			}),
+		)
+
+		return err
+	})
+}