Upload folder using huggingface_hub

apiconverter/cursor.go

@@ -0,0 +1,18 @@
+package apiconverter
+
+import (
+	"github.com/openmeterio/openmeter/api"
+	"github.com/openmeterio/openmeter/pkg/pagination/v2"
+)
+
+func ConvertCursor(s api.CursorPaginationCursor) (*pagination.Cursor, error) {
+	return pagination.DecodeCursor(s)
+}
+
+func ConvertCursorPtr(s *api.CursorPaginationCursor) (*pagination.Cursor, error) {
+	if s == nil {
+		return nil, nil
+	}
+
+	return ConvertCursor(*s)
+}

apiconverter/filter.gen.go

@@ -0,0 +1,266 @@
+// Code generated by github.com/jmattheis/goverter, DO NOT EDIT.
+//go:build !goverter
+
+package apiconverter
+
+import (
+	api "github.com/openmeterio/openmeter/api"
+	filter "github.com/openmeterio/openmeter/pkg/filter"
+)
+
+func init() {
+	ConvertBoolean = func(source api.FilterBoolean) filter.FilterBoolean {
+		var filterFilterBoolean filter.FilterBoolean
+		filterFilterBoolean.Eq = source.Eq
+		return filterFilterBoolean
+	}
+	ConvertBooleanPtr = func(source *api.FilterBoolean) *filter.FilterBoolean {
+		var pFilterFilterBoolean *filter.FilterBoolean
+		if source != nil {
+			filterFilterBoolean := ConvertBoolean((*source))
+			pFilterFilterBoolean = &filterFilterBoolean
+		}
+		return pFilterFilterBoolean
+	}
+	ConvertFloat = func(source api.FilterFloat) filter.FilterFloat {
+		var filterFilterFloat filter.FilterFloat
+		filterFilterFloat.Eq = source.Eq
+		filterFilterFloat.Ne = source.Ne
+		filterFilterFloat.Gt = source.Gt
+		filterFilterFloat.Gte = source.Gte
+		filterFilterFloat.Lt = source.Lt
+		filterFilterFloat.Lte = source.Lte
+		if source.And != nil {
+			var filterFilterFloatList []filter.FilterFloat
+			if (*source.And) != nil {
+				filterFilterFloatList = make([]filter.FilterFloat, len((*source.And)))
+				for i := 0; i < len((*source.And)); i++ {
+					filterFilterFloatList[i] = ConvertFloat((*source.And)[i])
+				}
+			}
+			filterFilterFloat.And = &filterFilterFloatList
+		}
+		if source.Or != nil {
+			var filterFilterFloatList2 []filter.FilterFloat
+			if (*source.Or) != nil {
+				filterFilterFloatList2 = make([]filter.FilterFloat, len((*source.Or)))
+				for j := 0; j < len((*source.Or)); j++ {
+					filterFilterFloatList2[j] = ConvertFloat((*source.Or)[j])
+				}
+			}
+			filterFilterFloat.Or = &filterFilterFloatList2
+		}
+		return filterFilterFloat
+	}
+	ConvertFloatPtr = func(source *api.FilterFloat) *filter.FilterFloat {
+		var pFilterFilterFloat *filter.FilterFloat
+		if source != nil {
+			filterFilterFloat := ConvertFloat((*source))
+			pFilterFilterFloat = &filterFilterFloat
+		}
+		return pFilterFilterFloat
+	}
+	ConvertIDExact = func(source api.FilterIDExact) filter.FilterString {
+		var filterFilterString filter.FilterString
+		filterFilterString.In = source.In
+		return filterFilterString
+	}
+	ConvertIDExactPtr = func(source *api.FilterIDExact) *filter.FilterString {
+		var pFilterFilterString *filter.FilterString
+		if source != nil {
+			filterFilterString := ConvertIDExact((*source))
+			pFilterFilterString = &filterFilterString
+		}
+		return pFilterFilterString
+	}
+	ConvertInt = func(source api.FilterInteger) filter.FilterInteger {
+		var filterFilterInteger filter.FilterInteger
+		filterFilterInteger.Eq = source.Eq
+		filterFilterInteger.Ne = source.Ne
+		filterFilterInteger.Gt = source.Gt
+		filterFilterInteger.Gte = source.Gte
+		filterFilterInteger.Lt = source.Lt
+		filterFilterInteger.Lte = source.Lte
+		if source.And != nil {
+			var filterFilterIntegerList []filter.FilterInteger
+			if (*source.And) != nil {
+				filterFilterIntegerList = make([]filter.FilterInteger, len((*source.And)))
+				for i := 0; i < len((*source.And)); i++ {
+					filterFilterIntegerList[i] = ConvertInt((*source.And)[i])
+				}
+			}
+			filterFilterInteger.And = &filterFilterIntegerList
+		}
+		if source.Or != nil {
+			var filterFilterIntegerList2 []filter.FilterInteger
+			if (*source.Or) != nil {
+				filterFilterIntegerList2 = make([]filter.FilterInteger, len((*source.Or)))
+				for j := 0; j < len((*source.Or)); j++ {
+					filterFilterIntegerList2[j] = ConvertInt((*source.Or)[j])
+				}
+			}
+			filterFilterInteger.Or = &filterFilterIntegerList2
+		}
+		return filterFilterInteger
+	}
+	ConvertIntPtr = func(source *api.FilterInteger) *filter.FilterInteger {
+		var pFilterFilterInteger *filter.FilterInteger
+		if source != nil {
+			filterFilterInteger := ConvertInt((*source))
+			pFilterFilterInteger = &filterFilterInteger
+		}
+		return pFilterFilterInteger
+	}
+	ConvertString = func(source api.FilterString) filter.FilterString {
+		var filterFilterString filter.FilterString
+		filterFilterString.Eq = source.Eq
+		filterFilterString.Ne = source.Ne
+		filterFilterString.In = source.In
+		filterFilterString.Nin = source.Nin
+		filterFilterString.Like = source.Like
+		filterFilterString.Nlike = source.Nlike
+		filterFilterString.Ilike = source.Ilike
+		filterFilterString.Nilike = source.Nilike
+		filterFilterString.Gt = source.Gt
+		filterFilterString.Gte = source.Gte
+		filterFilterString.Lt = source.Lt
+		filterFilterString.Lte = source.Lte
+		if source.And != nil {
+			var filterFilterStringList []filter.FilterString
+			if (*source.And) != nil {
+				filterFilterStringList = make([]filter.FilterString, len((*source.And)))
+				for i := 0; i < len((*source.And)); i++ {
+					filterFilterStringList[i] = ConvertString((*source.And)[i])
+				}
+			}
+			filterFilterString.And = &filterFilterStringList
+		}
+		if source.Or != nil {
+			var filterFilterStringList2 []filter.FilterString
+			if (*source.Or) != nil {
+				filterFilterStringList2 = make([]filter.FilterString, len((*source.Or)))
+				for j := 0; j < len((*source.Or)); j++ {
+					filterFilterStringList2[j] = ConvertString((*source.Or)[j])
+				}
+			}
+			filterFilterString.Or = &filterFilterStringList2
+		}
+		return filterFilterString
+	}
+	ConvertStringMap = func(source map[string]api.FilterString) map[string]filter.FilterString {
+		var mapStringFilterFilterString map[string]filter.FilterString
+		if source != nil {
+			mapStringFilterFilterString = make(map[string]filter.FilterString, len(source))
+			for key, value := range source {
+				mapStringFilterFilterString[key] = ConvertString(value)
+			}
+		}
+		return mapStringFilterFilterString
+	}
+	ConvertStringMapPtr = func(source *map[string]api.FilterString) *map[string]filter.FilterString {
+		var pMapStringFilterFilterString *map[string]filter.FilterString
+		if source != nil {
+			mapStringFilterFilterString := ConvertStringMap((*source))
+			pMapStringFilterFilterString = &mapStringFilterFilterString
+		}
+		return pMapStringFilterFilterString
+	}
+	ConvertStringMapToAPIPtr = func(source map[string]filter.FilterString) map[string]api.FilterString {
+		var mapStringApiFilterString map[string]api.FilterString
+		if source != nil {
+			mapStringApiFilterString = make(map[string]api.FilterString, len(source))
+			for key, value := range source {
+				mapStringApiFilterString[key] = filterFilterStringToApiFilterString(value)
+			}
+		}
+		return mapStringApiFilterString
+	}
+	ConvertStringPtr = func(source *api.FilterString) *filter.FilterString {
+		var pFilterFilterString *filter.FilterString
+		if source != nil {
+			filterFilterString := ConvertString((*source))
+			pFilterFilterString = &filterFilterString
+		}
+		return pFilterFilterString
+	}
+	ConvertStringToAPI = func(source *filter.FilterString) *api.FilterString {
+		var pApiFilterString *api.FilterString
+		if source != nil {
+			apiFilterString := filterFilterStringToApiFilterString((*source))
+			pApiFilterString = &apiFilterString
+		}
+		return pApiFilterString
+	}
+	ConvertTime = func(source api.FilterTime) filter.FilterTime {
+		var filterFilterTime filter.FilterTime
+		filterFilterTime.Gt = source.Gt
+		filterFilterTime.Gte = source.Gte
+		filterFilterTime.Lt = source.Lt
+		filterFilterTime.Lte = source.Lte
+		if source.And != nil {
+			var filterFilterTimeList []filter.FilterTime
+			if (*source.And) != nil {
+				filterFilterTimeList = make([]filter.FilterTime, len((*source.And)))
+				for i := 0; i < len((*source.And)); i++ {
+					filterFilterTimeList[i] = ConvertTime((*source.And)[i])
+				}
+			}
+			filterFilterTime.And = &filterFilterTimeList
+		}
+		if source.Or != nil {
+			var filterFilterTimeList2 []filter.FilterTime
+			if (*source.Or) != nil {
+				filterFilterTimeList2 = make([]filter.FilterTime, len((*source.Or)))
+				for j := 0; j < len((*source.Or)); j++ {
+					filterFilterTimeList2[j] = ConvertTime((*source.Or)[j])
+				}
+			}
+			filterFilterTime.Or = &filterFilterTimeList2
+		}
+		return filterFilterTime
+	}
+	ConvertTimePtr = func(source *api.FilterTime) *filter.FilterTime {
+		var pFilterFilterTime *filter.FilterTime
+		if source != nil {
+			filterFilterTime := ConvertTime((*source))
+			pFilterFilterTime = &filterFilterTime
+		}
+		return pFilterFilterTime
+	}
+}
+func filterFilterStringToApiFilterString(source filter.FilterString) api.FilterString {
+	var apiFilterString api.FilterString
+	if source.And != nil {
+		var apiFilterStringList []api.FilterString
+		if (*source.And) != nil {
+			apiFilterStringList = make([]api.FilterString, len((*source.And)))
+			for i := 0; i < len((*source.And)); i++ {
+				apiFilterStringList[i] = filterFilterStringToApiFilterString((*source.And)[i])
+			}
+		}
+		apiFilterString.And = &apiFilterStringList
+	}
+	apiFilterString.Eq = source.Eq
+	apiFilterString.Gt = source.Gt
+	apiFilterString.Gte = source.Gte
+	apiFilterString.Ilike = source.Ilike
+	apiFilterString.In = source.In
+	apiFilterString.Like = source.Like
+	apiFilterString.Lt = source.Lt
+	apiFilterString.Lte = source.Lte
+	apiFilterString.Ne = source.Ne
+	apiFilterString.Nilike = source.Nilike
+	apiFilterString.Nin = source.Nin
+	apiFilterString.Nlike = source.Nlike
+	if source.Or != nil {
+		var apiFilterStringList2 []api.FilterString
+		if (*source.Or) != nil {
+			apiFilterStringList2 = make([]api.FilterString, len((*source.Or)))
+			for j := 0; j < len((*source.Or)); j++ {
+				apiFilterStringList2[j] = filterFilterStringToApiFilterString((*source.Or)[j])
+			}
+		}
+		apiFilterString.Or = &apiFilterStringList2
+	}
+	return apiFilterString
+}

apiconverter/filter.go

@@ -0,0 +1,43 @@
+//go:generate go tool github.com/jmattheis/goverter/cmd/goverter gen ./
+package apiconverter
+
+import (
+	"github.com/openmeterio/openmeter/api"
+	"github.com/openmeterio/openmeter/pkg/filter"
+)
+
+// goverter:variables
+// goverter:skipCopySameType
+// goverter:output:file ./filter.gen.go
+//
+// The `goverter:ignore` directives below silence field-mismatch errors for
+// fields that exist on the internal filter types but not on the v1 API types.
+// If the v1 API (api/api.gen.go) is ever extended to expose those operators,
+// remove the corresponding ignore entry so the generated converter copies
+// them through — otherwise they will be silently dropped at the boundary.
+var (
+	// Exists/Contains/Ncontains are internal-only; the v1 FilterString has no
+	// equivalent fields. Remove entries from the ignore list when v1 grows them.
+	// goverter:ignore Exists Contains Ncontains
+	ConvertString       func(api.FilterString) filter.FilterString
+	ConvertStringPtr    func(*api.FilterString) *filter.FilterString
+	ConvertStringMap    func(map[string]api.FilterString) map[string]filter.FilterString
+	ConvertStringMapPtr func(*map[string]api.FilterString) *map[string]filter.FilterString
+	// goverter:ignoreMissing
+	ConvertIDExact    func(api.FilterIDExact) filter.FilterString
+	ConvertIDExactPtr func(*api.FilterIDExact) *filter.FilterString
+	ConvertInt        func(api.FilterInteger) filter.FilterInteger
+	ConvertIntPtr     func(*api.FilterInteger) *filter.FilterInteger
+	ConvertFloat      func(api.FilterFloat) filter.FilterFloat
+	ConvertFloatPtr   func(*api.FilterFloat) *filter.FilterFloat
+	// FilterTime.Eq is new on the internal type; v1 api.FilterTime does not
+	// expose it. Remove this ignore when v1 grows an Eq field.
+	// goverter:ignore Eq
+	// goverter:ignore Exists
+	ConvertTime              func(api.FilterTime) filter.FilterTime
+	ConvertTimePtr           func(*api.FilterTime) *filter.FilterTime
+	ConvertBoolean           func(api.FilterBoolean) filter.FilterBoolean
+	ConvertBooleanPtr        func(*api.FilterBoolean) *filter.FilterBoolean
+	ConvertStringToAPI       func(*filter.FilterString) *api.FilterString
+	ConvertStringMapToAPIPtr func(map[string]filter.FilterString) map[string]api.FilterString
+)

app/adapter.go

@@ -0,0 +1,37 @@
+package app
+
+import (
+	"context"
+
+	"github.com/openmeterio/openmeter/pkg/framework/entutils"
+	"github.com/openmeterio/openmeter/pkg/pagination"
+)
+
+type Adapter interface {
+	AppAdapter
+
+	entutils.TxCreator
+}
+type AppAdapter interface {
+	// Marketplace
+	RegisterMarketplaceListing(input RegisterMarketplaceListingInput) error
+	GetMarketplaceListing(ctx context.Context, input MarketplaceGetInput) (RegistryItem, error)
+	ListMarketplaceListings(ctx context.Context, input MarketplaceListInput) (pagination.Result[RegistryItem], error)
+	InstallMarketplaceListingWithAPIKey(ctx context.Context, input InstallAppWithAPIKeyInput) (App, error)
+	InstallMarketplaceListing(ctx context.Context, input InstallAppInput) (App, error)
+	GetMarketplaceListingOauth2InstallURL(ctx context.Context, input GetOauth2InstallURLInput) (GetOauth2InstallURLOutput, error)
+	AuthorizeMarketplaceListingOauth2Install(ctx context.Context, input AuthorizeOauth2InstallInput) error
+
+	// Installed app
+	CreateApp(ctx context.Context, input CreateAppInput) (AppBase, error)
+	GetApp(ctx context.Context, input GetAppInput) (App, error)
+	UpdateApp(ctx context.Context, input UpdateAppInput) (App, error)
+	ListApps(ctx context.Context, input ListAppInput) (pagination.Result[App], error)
+	UninstallApp(ctx context.Context, input UninstallAppInput) (*AppBase, error)
+	UpdateAppStatus(ctx context.Context, input UpdateAppStatusInput) error
+
+	// Customer data
+	ListCustomerData(ctx context.Context, input ListCustomerInput) (pagination.Result[CustomerApp], error)
+	EnsureCustomer(ctx context.Context, input EnsureCustomerInput) error
+	DeleteCustomer(ctx context.Context, input DeleteCustomerInput) error
+}

app/adapter/adapter.go

@@ -0,0 +1,68 @@
+package appadapter
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+
+	"github.com/openmeterio/openmeter/openmeter/app"
+	entdb "github.com/openmeterio/openmeter/openmeter/ent/db"
+	"github.com/openmeterio/openmeter/pkg/framework/entutils"
+	"github.com/openmeterio/openmeter/pkg/framework/transaction"
+)
+
+type Config struct {
+	Client *entdb.Client
+}
+
+func (c Config) Validate() error {
+	if c.Client == nil {
+		return errors.New("ent client is required")
+	}
+
+	return nil
+}
+
+func New(config Config) (app.Adapter, error) {
+	if err := config.Validate(); err != nil {
+		return nil, err
+	}
+
+	adapter := &adapter{
+		db:       config.Client,
+		registry: map[app.AppType]app.RegistryItem{},
+	}
+
+	return adapter, nil
+}
+
+var _ app.Adapter = (*adapter)(nil)
+
+type adapter struct {
+	db       *entdb.Client
+	registry map[app.AppType]app.RegistryItem
+}
+
+// Tx implements entutils.TxCreator interface
+func (a *adapter) Tx(ctx context.Context) (context.Context, transaction.Driver, error) {
+	txCtx, rawConfig, eDriver, err := a.db.HijackTx(ctx, &sql.TxOptions{
+		ReadOnly: false,
+	})
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to hijack transaction: %w", err)
+	}
+	return txCtx, entutils.NewTxDriver(eDriver, rawConfig), nil
+}
+
+func (a *adapter) WithTx(ctx context.Context, tx *entutils.TxDriver) *adapter {
+	txClient := entdb.NewTxClientFromRawConfig(ctx, *tx.GetConfig())
+	return &adapter{
+		db:       txClient.Client(),
+		registry: a.registry,
+	}
+}
+
+func (a *adapter) Self() *adapter {
+	return a
+}

app/adapter/app.go

@@ -0,0 +1,283 @@
+package appadapter
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/samber/lo"
+
+	"github.com/openmeterio/openmeter/openmeter/app"
+	"github.com/openmeterio/openmeter/openmeter/ent/db"
+	appdb "github.com/openmeterio/openmeter/openmeter/ent/db/app"
+	appcustomerdb "github.com/openmeterio/openmeter/openmeter/ent/db/appcustomer"
+	"github.com/openmeterio/openmeter/pkg/framework/entutils"
+	"github.com/openmeterio/openmeter/pkg/framework/transaction"
+	"github.com/openmeterio/openmeter/pkg/models"
+	"github.com/openmeterio/openmeter/pkg/pagination"
+)
+
+var _ app.AppAdapter = (*adapter)(nil)
+
+// CreateApp creates an app
+func (a *adapter) CreateApp(ctx context.Context, input app.CreateAppInput) (app.AppBase, error) {
+	return transaction.Run(ctx, a, func(ctx context.Context) (app.AppBase, error) {
+		return entutils.TransactingRepo(
+			ctx,
+			a,
+			func(ctx context.Context, repo *adapter) (app.AppBase, error) {
+				appCreateQuery := repo.db.App.Create().
+					SetNamespace(input.Namespace).
+					SetName(input.Name).
+					SetDescription(input.Description).
+					SetType(input.Type).
+					SetStatus(app.AppStatusReady)
+
+				// Set ID if provided by the input
+				if input.ID != nil {
+					appCreateQuery = appCreateQuery.SetID(input.ID.ID)
+				}
+
+				dbApp, err := appCreateQuery.Save(ctx)
+				if err != nil {
+					return app.AppBase{}, fmt.Errorf("failed to create app: %w", err)
+				}
+
+				// Get registry item
+				registryItem, err := repo.GetMarketplaceListing(ctx, app.MarketplaceGetInput{
+					Type: dbApp.Type,
+				})
+				if err != nil {
+					return app.AppBase{}, fmt.Errorf("failed to get listing for app %s: %w", dbApp.ID, err)
+				}
+
+				// Map app base from db
+				return mapAppBaseFromDB(dbApp, registryItem), nil
+			})
+	})
+}
+
+// UpdateAppStatus updates an app status
+func (a *adapter) UpdateAppStatus(ctx context.Context, input app.UpdateAppStatusInput) error {
+	_, err := a.db.App.Update().
+		Where(appdb.Namespace(input.ID.Namespace)).
+		Where(appdb.ID(input.ID.ID)).
+		SetStatus(input.Status).
+		Save(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to update app status: %w", err)
+	}
+
+	return nil
+}
+
+// ListApps lists apps
+func (a *adapter) ListApps(ctx context.Context, params app.ListAppInput) (pagination.Result[app.App], error) {
+	return entutils.TransactingRepo(
+		ctx,
+		a,
+		func(ctx context.Context, repo *adapter) (pagination.Result[app.App], error) {
+			query := repo.db.App.
+				Query().
+				Where(appdb.Namespace(params.Namespace))
+
+			if params.Type != nil {
+				query = query.Where(appdb.Type(*params.Type))
+			}
+
+			// Do not return deleted apps by default
+			if !params.IncludeDeleted {
+				query = query.Where(appdb.DeletedAtIsNil())
+			}
+
+			// Only list apps that has customer data for the given customer
+			if params.CustomerID != nil {
+				query = query.Where(appdb.HasCustomerAppsWith(
+					appcustomerdb.CustomerID(params.CustomerID.ID),
+					appcustomerdb.DeletedAtIsNil(),
+				))
+			}
+
+			// Only list apps that has the given app IDs
+			if len(params.AppIDs) > 0 {
+				appIDs := lo.Map(params.AppIDs, func(appID app.AppID, _ int) string {
+					return appID.ID
+				})
+
+				query = query.Where(appdb.IDIn(appIDs...))
+			}
+
+			response := pagination.Result[app.App]{
+				Page: params.Page,
+			}
+
+			paged, err := query.Paginate(ctx, params.Page)
+			if err != nil {
+				return response, err
+			}
+
+			result := make([]app.App, 0, len(paged.Items))
+			for _, dbApp := range paged.Items {
+				registryItem, err := repo.GetMarketplaceListing(ctx, app.MarketplaceGetInput{
+					Type: dbApp.Type,
+				})
+				if err != nil {
+					return response, fmt.Errorf("failed to get listing for app %s: %w", dbApp.ID, err)
+				}
+
+				app, err := mapAppFromDB(ctx, dbApp, registryItem)
+				if err != nil {
+					return response, fmt.Errorf("failed to map app %s from db: %w", dbApp.ID, err)
+				}
+
+				result = append(result, app)
+			}
+
+			response.TotalCount = paged.TotalCount
+			response.Items = result
+
+			return response, nil
+		},
+	)
+}
+
+// GetApp gets an app
+func (a *adapter) GetApp(ctx context.Context, input app.GetAppInput) (app.App, error) {
+	return entutils.TransactingRepo(
+		ctx,
+		a,
+		func(ctx context.Context, repo *adapter) (app.App, error) {
+			dbApp, err := repo.db.App.Query().
+				Where(appdb.Namespace(input.Namespace)).
+				Where(appdb.ID(input.ID)).
+				First(ctx)
+			if err != nil {
+				if db.IsNotFound(err) {
+					return nil, app.NewAppNotFoundError(input)
+				}
+
+				return nil, err
+			}
+
+			// Get registry item
+			registryItem, err := repo.GetMarketplaceListing(ctx, app.MarketplaceGetInput{
+				Type: dbApp.Type,
+			})
+			if err != nil {
+				return nil, fmt.Errorf("failed to get listing for app %s: %w", dbApp.ID, err)
+			}
+
+			// Map app from db
+			app, err := mapAppFromDB(ctx, dbApp, registryItem)
+			if err != nil {
+				return nil, fmt.Errorf("failed to map app from db: %w", err)
+			}
+
+			return app, nil
+		},
+	)
+}
+
+// UpdateApp updates an app
+func (a *adapter) UpdateApp(ctx context.Context, input app.UpdateAppInput) (app.App, error) {
+	return transaction.Run(ctx, a, func(ctx context.Context) (app.App, error) {
+		return entutils.TransactingRepo(
+			ctx,
+			a,
+			func(ctx context.Context, repo *adapter) (app.App, error) {
+				// Update the app
+				_, err := repo.db.App.Update().
+					Where(appdb.Namespace(input.AppID.Namespace)).
+					Where(appdb.ID(input.AppID.ID)).
+					SetName(input.Name).
+					SetOrClearDescription(input.Description).
+					SetOrClearMetadata(input.Metadata).
+					Save(ctx)
+				if err != nil {
+					return nil, fmt.Errorf("failed to update the app with id %s: %w", input.AppID.ID, err)
+				}
+
+				// Get the updated app
+				app, err := a.GetApp(ctx, input.AppID)
+				if err != nil {
+					return nil, fmt.Errorf("failed to get updated app: %s: %w", input.AppID.ID, err)
+				}
+
+				return app, nil
+			})
+	})
+}
+
+// UninstallApp uninstalls an app
+func (a *adapter) UninstallApp(ctx context.Context, input app.UninstallAppInput) (*app.AppBase, error) {
+	return transaction.Run(ctx, a, func(ctx context.Context) (*app.AppBase, error) {
+		return entutils.TransactingRepo(ctx, a, func(ctx context.Context, repo *adapter) (*app.AppBase, error) {
+			installedApp, err := repo.GetApp(ctx, input)
+			if err != nil {
+				return nil, fmt.Errorf("failed to get app: %w", err)
+			}
+
+			// Get app factory through registry
+			registryItem, err := repo.GetMarketplaceListing(ctx, app.MarketplaceGetInput{
+				Type: installedApp.GetType(),
+			})
+			if err != nil {
+				return nil, fmt.Errorf("failed to get listing for app: %w", err)
+			}
+
+			// Uninstall app through factory
+			err = registryItem.Factory.UninstallApp(ctx, installedApp.GetID())
+			if err != nil {
+				return nil, fmt.Errorf("failed to uninstall app: %w", err)
+			}
+
+			deletedAt := time.Now()
+
+			// Delete app from database
+			_, err = repo.db.App.Update().
+				Where(appdb.Namespace(input.Namespace)).
+				Where(appdb.ID(input.ID)).
+				SetDeletedAt(time.Now()).
+				Save(ctx)
+			if err != nil {
+				return nil, fmt.Errorf("failed to delete app from database: %w", err)
+			}
+
+			appBase := installedApp.GetAppBase()
+			appBase.DeletedAt = &deletedAt
+
+			return &appBase, nil
+		})
+	})
+}
+
+// mapAppBaseFromDB maps an app base from the database
+func mapAppBaseFromDB(dbApp *db.App, registryItem app.RegistryItem) app.AppBase {
+	return app.AppBase{
+		ManagedResource: models.NewManagedResource(models.ManagedResourceInput{
+			ID:          dbApp.ID,
+			Namespace:   dbApp.Namespace,
+			CreatedAt:   dbApp.CreatedAt,
+			UpdatedAt:   dbApp.UpdatedAt,
+			DeletedAt:   dbApp.DeletedAt,
+			Name:        dbApp.Name,
+			Description: dbApp.Description,
+		}),
+		Type:     dbApp.Type,
+		Status:   dbApp.Status,
+		Listing:  registryItem.Listing,
+		Metadata: dbApp.Metadata,
+	}
+}
+
+// mapAppFromDB maps an app from the database
+func mapAppFromDB(ctx context.Context, dbApp *db.App, registryItem app.RegistryItem) (app.App, error) {
+	appBase := mapAppBaseFromDB(dbApp, registryItem)
+
+	app, err := registryItem.Factory.NewApp(ctx, appBase)
+	if err != nil {
+		return app, fmt.Errorf("failed to create app with %s factory: %w", appBase.Type, err)
+	}
+
+	return app, nil
+}

app/adapter/customer.go

@@ -0,0 +1,178 @@
+package appadapter
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+
+	"github.com/openmeterio/openmeter/openmeter/app"
+	"github.com/openmeterio/openmeter/openmeter/ent/db"
+	appcustomerdb "github.com/openmeterio/openmeter/openmeter/ent/db/appcustomer"
+	"github.com/openmeterio/openmeter/pkg/framework/entutils"
+	"github.com/openmeterio/openmeter/pkg/framework/transaction"
+	"github.com/openmeterio/openmeter/pkg/models"
+	"github.com/openmeterio/openmeter/pkg/pagination"
+)
+
+var _ app.AppAdapter = (*adapter)(nil)
+
+// ListCustomerData lists app customer data
+func (a *adapter) ListCustomerData(ctx context.Context, input app.ListCustomerInput) (pagination.Result[app.CustomerApp], error) {
+	if err := input.Validate(); err != nil {
+		return pagination.Result[app.CustomerApp]{}, models.NewGenericValidationError(
+			fmt.Errorf("error listing customer data: %w", err),
+		)
+	}
+
+	listInput := app.ListAppInput{
+		Page:       input.Page,
+		Namespace:  input.CustomerID.Namespace,
+		CustomerID: &input.CustomerID,
+		Type:       input.Type,
+	}
+
+	if input.AppID != nil {
+		listInput.AppIDs = []app.AppID{*input.AppID}
+	}
+
+	apps, err := a.ListApps(ctx, listInput)
+	if err != nil {
+		return pagination.Result[app.CustomerApp]{}, fmt.Errorf("failed to list apps: %w", err)
+	}
+
+	response := pagination.Result[app.CustomerApp]{
+		Page:       input.Page,
+		TotalCount: apps.TotalCount,
+		Items:      make([]app.CustomerApp, 0, len(apps.Items)),
+	}
+
+	for _, customerApp := range apps.Items {
+		customerData, err := customerApp.GetCustomerData(ctx, app.GetAppInstanceCustomerDataInput{
+			CustomerID: input.CustomerID,
+		})
+		if err != nil {
+			return pagination.Result[app.CustomerApp]{}, fmt.Errorf("failed to get customer data for app %s: %w", customerApp.GetID().ID, err)
+		}
+
+		response.Items = append(response.Items, app.CustomerApp{
+			App:          customerApp,
+			CustomerData: customerData,
+		})
+	}
+
+	return response, nil
+}
+
+// EnsureCustomer upserts app customer relationship:
+// If the app or customer does not exist, an error is returned
+// If the app customer relationship already exists, nothing is done
+// If the app customer relationship is deleted, it is restored
+func (a *adapter) EnsureCustomer(ctx context.Context, input app.EnsureCustomerInput) error {
+	return transaction.RunWithNoValue(ctx, a, func(ctx context.Context) error {
+		if err := input.Validate(); err != nil {
+			return models.NewGenericValidationError(
+				err,
+			)
+		}
+
+		_, err := entutils.TransactingRepo(
+			ctx,
+			a,
+			func(ctx context.Context, repo *adapter) (any, error) {
+				// Upsert customer data for the app
+				err := repo.db.AppCustomer.
+					Create().
+					SetNamespace(input.AppID.Namespace).
+					SetAppID(input.AppID.ID).
+					SetCustomerID(input.CustomerID.ID).
+					SetNillableDeletedAt(nil).
+					// Upsert
+					OnConflict(
+						sql.ConflictColumns(
+							appcustomerdb.FieldNamespace,
+							appcustomerdb.FieldAppID,
+							appcustomerdb.FieldCustomerID,
+						),
+						sql.ConflictWhere(sql.IsNull(appcustomerdb.FieldDeletedAt)),
+					).
+					UpdateDeletedAt().
+					Exec(ctx)
+				if err != nil {
+					// TODO: differentiate between app or customer not found
+					// When the constraint error is returned, it means that the app or customer does not exist.
+					if db.IsConstraintError(err) {
+						return nil, app.NewAppNotFoundError(input.AppID)
+					}
+
+					// TODO (pmarton): This is a workaround for the issue where DoNothing() returns an error when no rows are affected.
+					// See: https://github.com/ent/ent/issues/1821
+					if err.Error() == "sql: no rows in result set" {
+						return nil, nil
+					}
+
+					return nil, fmt.Errorf("failed to upsert app customer: %w", err)
+				}
+
+				return nil, nil
+			},
+		)
+
+		return err
+	})
+}
+
+// DeleteCustomer deletes app customer
+func (a *adapter) DeleteCustomer(ctx context.Context, input app.DeleteCustomerInput) error {
+	return transaction.RunWithNoValue(ctx, a, func(ctx context.Context) error {
+		if err := input.Validate(); err != nil {
+			return models.NewGenericValidationError(
+				fmt.Errorf("error delete customer: %w", err),
+			)
+		}
+
+		// Determine namespace
+		var namespace string
+
+		if input.AppID != nil {
+			namespace = input.AppID.Namespace
+		}
+
+		if input.CustomerID != nil {
+			namespace = input.CustomerID.Namespace
+		}
+
+		if namespace == "" {
+			return models.NewGenericValidationError(
+				fmt.Errorf("error delete customer: namespace is empty"),
+			)
+		}
+
+		_, err := entutils.TransactingRepo(ctx, a, func(ctx context.Context, repo *adapter) (any, error) {
+			// Delete app customer
+			query := repo.db.AppCustomer.
+				Update().
+				SetDeletedAt(time.Now()).
+				Where(
+					appcustomerdb.Namespace(namespace),
+				)
+
+			if input.AppID != nil {
+				query = query.Where(appcustomerdb.AppID(input.AppID.ID))
+			}
+
+			if input.CustomerID != nil {
+				query = query.Where(appcustomerdb.CustomerID(input.CustomerID.ID))
+			}
+
+			_, err := query.Save(ctx)
+			if err != nil {
+				return nil, fmt.Errorf("failed to delete app customer: %w", err)
+			}
+
+			return nil, nil
+		})
+		return err
+	})
+}

app/adapter/marketplace.go

@@ -0,0 +1,132 @@
+package appadapter
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/samber/lo"
+
+	"github.com/openmeterio/openmeter/openmeter/app"
+	"github.com/openmeterio/openmeter/pkg/framework/transaction"
+	"github.com/openmeterio/openmeter/pkg/models"
+	"github.com/openmeterio/openmeter/pkg/pagination"
+)
+
+// ListMarketplaceListings lists marketplace listings
+func (a adapter) ListMarketplaceListings(ctx context.Context, input app.MarketplaceListInput) (pagination.Result[app.RegistryItem], error) {
+	items := lo.Values(a.registry)
+	items = lo.Subset(items, (input.PageNumber-1)*input.PageSize, uint(input.PageSize))
+
+	response := pagination.Result[app.RegistryItem]{
+		Page:       input.Page,
+		Items:      items,
+		TotalCount: len(a.registry),
+	}
+
+	return response, nil
+}
+
+// GetMarketplaceListing gets a marketplace listing
+func (a adapter) GetMarketplaceListing(ctx context.Context, input app.MarketplaceGetInput) (app.RegistryItem, error) {
+	if _, ok := a.registry[input.Type]; !ok {
+		return app.RegistryItem{}, models.NewGenericNotFoundError(
+			fmt.Errorf("listing with type not found: %s", input.Type),
+		)
+	}
+
+	return a.registry[input.Type], nil
+}
+
+// InstallMarketplaceListingWithAPIKey installs an app with an API key
+func (a *adapter) InstallMarketplaceListingWithAPIKey(ctx context.Context, input app.InstallAppWithAPIKeyInput) (app.App, error) {
+	return transaction.Run(ctx, a, func(ctx context.Context) (app.App, error) {
+		// Get registry item
+		registryItem, err := a.GetMarketplaceListing(ctx, app.MarketplaceGetInput{
+			Type: input.Type,
+		})
+		if err != nil {
+			return nil, fmt.Errorf("failed to get listing for app %s: %w", input.Type, err)
+		}
+
+		name, ok := lo.Coalesce(input.Name, registryItem.Listing.Name)
+		if !ok {
+			return nil, fmt.Errorf("name is required, listing doesn't have a name either")
+		}
+
+		installer, ok := registryItem.Factory.(app.AppFactoryInstallWithAPIKey)
+		if !ok {
+			return nil, models.NewGenericValidationError(fmt.Errorf("app does not support this installation method. Supported methods: %v", registryItem.Listing.InstallMethods))
+		}
+
+		// Install app
+		app, err := installer.InstallAppWithAPIKey(ctx, app.AppFactoryInstallAppWithAPIKeyInput{
+			Namespace: input.Namespace,
+			APIKey:    input.APIKey,
+			Name:      name,
+		})
+		if err != nil {
+			return nil, fmt.Errorf("failed to install app: %w", err)
+		}
+
+		return app, nil
+	})
+}
+
+// InstallMarketplaceListing installs an app
+func (a *adapter) InstallMarketplaceListing(ctx context.Context, input app.InstallAppInput) (app.App, error) {
+	return transaction.Run(ctx, a, func(ctx context.Context) (app.App, error) {
+		// Get registry item
+		registryItem, err := a.GetMarketplaceListing(ctx, app.MarketplaceGetInput{
+			Type: input.Type,
+		})
+		if err != nil {
+			return nil, fmt.Errorf("failed to get listing for app %s: %w", input.Type, err)
+		}
+
+		name, ok := lo.Coalesce(input.Name, registryItem.Listing.Name)
+		if !ok {
+			return nil, fmt.Errorf("name is required, listing doesn't have a name either")
+		}
+
+		installer, ok := registryItem.Factory.(app.AppFactoryInstall)
+		if !ok {
+			return nil, models.NewGenericValidationError(fmt.Errorf("app does not support this installation method. Supported methods: %v", registryItem.Listing.InstallMethods))
+		}
+
+		// Install app
+		app, err := installer.InstallApp(ctx, app.AppFactoryInstallAppInput{
+			Namespace: input.Namespace,
+			Name:      name,
+		})
+		if err != nil {
+			return nil, fmt.Errorf("failed to install app: %w", err)
+		}
+
+		return app, nil
+	})
+}
+
+// GetMarketplaceListingOauth2InstallURL gets an OAuth2 install URL
+func (a adapter) GetMarketplaceListingOauth2InstallURL(ctx context.Context, input app.GetOauth2InstallURLInput) (app.GetOauth2InstallURLOutput, error) {
+	return app.GetOauth2InstallURLOutput{}, fmt.Errorf("not implemented")
+}
+
+// AuthorizeOauth2Install authorizes an OAuth2 install
+func (a adapter) AuthorizeMarketplaceListingOauth2Install(ctx context.Context, input app.AuthorizeOauth2InstallInput) error {
+	return fmt.Errorf("not implemented")
+}
+
+// RegisterMarketplaceListing registers an app type
+func (a adapter) RegisterMarketplaceListing(input app.RegisterMarketplaceListingInput) error {
+	if _, ok := a.registry[input.Listing.Type]; ok {
+		return fmt.Errorf("marketplace listing with key %s already exists", input.Listing.Type)
+	}
+
+	if err := input.Listing.Validate(); err != nil {
+		return fmt.Errorf("marketplace listing with key %s is invalid: %w", input.Listing.Type, err)
+	}
+
+	a.registry[input.Listing.Type] = input
+
+	return nil
+}

app/app.go

@@ -0,0 +1,218 @@
+package app
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/openmeterio/openmeter/openmeter/customer"
+	"github.com/openmeterio/openmeter/pkg/models"
+	"github.com/openmeterio/openmeter/pkg/pagination"
+)
+
+// App represents an installed app
+type App interface {
+	GetAppBase() AppBase
+	GetID() AppID
+	GetType() AppType
+	GetName() string
+	GetDescription() *string
+	GetStatus() AppStatus
+	GetMetadata() models.Metadata
+	GetListing() MarketplaceListing
+
+	GetEventAppData() (EventAppData, error)
+
+	UpdateAppConfig(ctx context.Context, input AppConfigUpdate) error
+
+	// ValidateCapabilities validates if the app can run for the given capabilities
+	ValidateCapabilities(capabilities ...CapabilityType) error
+
+	// Customer data
+	GetCustomerData(ctx context.Context, input GetAppInstanceCustomerDataInput) (CustomerData, error)
+	UpsertCustomerData(ctx context.Context, input UpsertAppInstanceCustomerDataInput) error
+	DeleteCustomerData(ctx context.Context, input DeleteAppInstanceCustomerDataInput) error
+}
+
+type GetAppInstanceCustomerDataInput struct {
+	CustomerID customer.CustomerID
+}
+
+func (i GetAppInstanceCustomerDataInput) Validate() error {
+	if err := i.CustomerID.Validate(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+type UpsertAppInstanceCustomerDataInput struct {
+	CustomerID customer.CustomerID
+	Data       CustomerData
+}
+
+func (i UpsertAppInstanceCustomerDataInput) Validate() error {
+	if err := i.CustomerID.Validate(); err != nil {
+		return err
+	}
+
+	if err := i.Data.Validate(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+type DeleteAppInstanceCustomerDataInput struct {
+	CustomerID customer.CustomerID
+}
+
+func (i DeleteAppInstanceCustomerDataInput) Validate() error {
+	if err := i.CustomerID.Validate(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// GetAppInput is the input for getting an installed app
+type GetAppInput = AppID
+
+type AppConfigUpdate interface {
+	models.Validator
+}
+
+// UpdateAppInput is the input for setting an app as default for a type
+type UpdateAppInput struct {
+	AppID           AppID
+	Name            string
+	Description     *string
+	Default         bool
+	Metadata        *map[string]string
+	AppConfigUpdate AppConfigUpdate
+}
+
+func (i UpdateAppInput) Validate() error {
+	if err := i.AppID.Validate(); err != nil {
+		return fmt.Errorf("error validating app ID: %w", err)
+	}
+
+	// Required fields
+	if i.Name == "" {
+		return errors.New("name is required")
+	}
+
+	if i.Metadata != nil {
+		for k, v := range *i.Metadata {
+			if k == "" {
+				return errors.New("metadata key is required")
+			}
+
+			if v == "" {
+				return errors.New("metadata value is required")
+			}
+		}
+	}
+
+	if i.AppConfigUpdate != nil {
+		if err := i.AppConfigUpdate.Validate(); err != nil {
+			return fmt.Errorf("error validating app entity update: %w", err)
+		}
+	}
+
+	return nil
+}
+
+// CreateAppInput is the input for creating an app
+type CreateAppInput struct {
+	// AppID is optional. If not provided, a new AppID will be generated by the database
+	ID          *AppID
+	Namespace   string
+	Name        string
+	Description string
+	Type        AppType
+}
+
+func (i CreateAppInput) Validate() error {
+	if i.Namespace == "" {
+		return errors.New("namespace is required")
+	}
+
+	if i.Name == "" {
+		return errors.New("name is required")
+	}
+
+	return nil
+}
+
+// ListAppInput is the input for listing installed apps
+type ListAppInput struct {
+	Namespace string
+	pagination.Page
+
+	AppIDs         []AppID
+	Type           *AppType
+	IncludeDeleted bool
+	// Only list apps that has data for the given customer
+	CustomerID *customer.CustomerID
+}
+
+func (i ListAppInput) Validate() error {
+	var errs []error
+
+	if i.Namespace == "" {
+		errs = append(errs, models.NewGenericValidationError(
+			errors.New("namespace is required"),
+		))
+	}
+
+	if i.CustomerID != nil {
+		if err := i.CustomerID.Validate(); err != nil {
+			errs = append(errs, models.NewGenericValidationError(
+				fmt.Errorf("error validating customer id: %w", err),
+			))
+		}
+
+		if i.CustomerID.Namespace != i.Namespace {
+			errs = append(errs, models.NewGenericValidationError(
+				fmt.Errorf("customer id namespace %s does not match app namespace %s", i.CustomerID.Namespace, i.Namespace),
+			))
+		}
+	}
+
+	if len(i.AppIDs) > 0 {
+		for _, appID := range i.AppIDs {
+			if appID.Namespace != i.Namespace {
+				errs = append(errs, models.NewGenericValidationError(
+					fmt.Errorf("app id namespace %s does not match app namespace %s", appID.Namespace, i.Namespace),
+				))
+			}
+
+			if err := appID.Validate(); err != nil {
+				errs = append(errs, models.NewGenericValidationError(
+					fmt.Errorf("error validating app id: %w", err),
+				))
+			}
+		}
+	}
+
+	return errors.Join(errs...)
+}
+
+// UpdateAppStatusInput is the input for updating an app status
+type UpdateAppStatusInput struct {
+	ID     AppID
+	Status AppStatus
+}
+
+func (i UpdateAppStatusInput) Validate() error {
+	if err := i.ID.Validate(); err != nil {
+		return err
+	}
+
+	if i.Status == "" {
+		return errors.New("status is required")
+	}
+
+	return nil
+}

app/appbase.go

@@ -0,0 +1,161 @@
+package app
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/openmeterio/openmeter/pkg/models"
+)
+
+// AppType represents the type of an app
+type AppType string
+
+const (
+	AppTypeStripe          AppType = "stripe"
+	AppTypeSandbox         AppType = "sandbox"
+	AppTypeCustomInvoicing AppType = "custom_invoicing"
+)
+
+func (t AppType) Validate() error {
+	switch t {
+	case AppTypeStripe, AppTypeSandbox, AppTypeCustomInvoicing:
+		return nil
+	default:
+		return models.NewGenericValidationError(fmt.Errorf("invalid app type: %s", t))
+	}
+}
+
+// AppStatus represents the status of an app
+type AppStatus string
+
+const (
+	AppStatusReady        AppStatus = "ready"
+	AppStatusUnauthorized AppStatus = "unauthorized"
+)
+
+type CapabilityType string
+
+const (
+	CapabilityTypeReportUsage      CapabilityType = "reportUsage"
+	CapabilityTypeReportEvents     CapabilityType = "reportEvents"
+	CapabilityTypeCalculateTax     CapabilityType = "calculateTax"
+	CapabilityTypeInvoiceCustomers CapabilityType = "invoiceCustomers"
+	CapabilityTypeCollectPayments  CapabilityType = "collectPayments"
+)
+
+// AppBase represents an abstract with the base fields of an app
+type AppBase struct {
+	models.ManagedResource
+
+	Type     AppType            `json:"type"`
+	Status   AppStatus          `json:"status"`
+	Listing  MarketplaceListing `json:"listing"`
+	Metadata models.Metadata    `json:"metadata,omitempty"`
+}
+
+func (a AppBase) GetAppBase() AppBase {
+	return a
+}
+
+func (a AppBase) GetID() AppID {
+	return AppID{
+		Namespace: a.Namespace,
+		ID:        a.ID,
+	}
+}
+
+func (a AppBase) GetType() AppType {
+	return a.Type
+}
+
+func (a AppBase) GetName() string {
+	return a.Name
+}
+
+func (a AppBase) GetDescription() *string {
+	return a.Description
+}
+
+func (a AppBase) GetStatus() AppStatus {
+	return a.Status
+}
+
+func (a AppBase) GetListing() MarketplaceListing {
+	return a.Listing
+}
+
+func (a AppBase) GetMetadata() models.Metadata {
+	return a.Metadata
+}
+
+// ValidateCapabilities validates if the app can run for the given capabilities
+func (a AppBase) ValidateCapabilities(capabilities ...CapabilityType) error {
+	for _, capability := range capabilities {
+		found := false
+
+		for _, c := range a.Listing.Capabilities {
+			if c.Type == capability {
+				found = true
+				break
+			}
+		}
+
+		if !found {
+			return fmt.Errorf("capability %s is not supported by %s app type", capability, a.Type)
+		}
+	}
+
+	return nil
+}
+
+// ValidateCustomer validates if the app can run for the given customer
+// func (a AppBase) ValidateCustomer(c customerentity.Customer, capabilities []CapabilityType) error {
+// 	return fmt.Errorf("each app must implement its own ValidateCustomer method")
+// }
+
+// Validate validates the app base
+func (a AppBase) Validate() error {
+	if err := a.ManagedResource.Validate(); err != nil {
+		return fmt.Errorf("error validating managed resource: %w", err)
+	}
+
+	if a.ID == "" {
+		return errors.New("id is required")
+	}
+
+	if a.Namespace == "" {
+		return errors.New("namespace is required")
+	}
+
+	if a.Name == "" {
+		return errors.New("name is required")
+	}
+
+	if a.Status == "" {
+		return errors.New("status is required")
+	}
+
+	if err := a.Listing.Validate(); err != nil {
+		return fmt.Errorf("error validating listing: %w", err)
+	}
+
+	return nil
+}
+
+// AppID represents the unique identifier for an installed app
+type AppID struct {
+	Namespace string
+	ID        string
+}
+
+func (i AppID) Validate() error {
+	if i.Namespace == "" {
+		return errors.New("namespace is required")
+	}
+
+	if i.ID == "" {
+		return errors.New("id is required")
+	}
+
+	return nil
+}

app/customer.go

@@ -0,0 +1,10 @@
+package app
+
+type CustomerData interface {
+	Validate() error
+}
+
+type CustomerApp struct {
+	App          App
+	CustomerData CustomerData
+}

app/custominvoicing/adapter.go

@@ -0,0 +1,27 @@
+package appcustominvoicing
+
+import (
+	"context"
+
+	"github.com/openmeterio/openmeter/openmeter/app"
+	"github.com/openmeterio/openmeter/pkg/framework/entutils"
+)
+
+type Adapter interface {
+	CustomerDataAdapter
+	AppConfigAdapter
+
+	entutils.TxCreator
+}
+
+type CustomerDataAdapter interface {
+	GetCustomerData(ctx context.Context, input GetAppCustomerDataInput) (CustomerData, error)
+	UpsertCustomerData(ctx context.Context, input UpsertCustomerDataInput) error
+	DeleteCustomerData(ctx context.Context, input DeleteAppCustomerDataInput) error
+}
+
+type AppConfigAdapter interface {
+	GetAppConfiguration(ctx context.Context, input app.AppID) (Configuration, error)
+	UpsertAppConfiguration(ctx context.Context, input UpsertAppConfigurationInput) error
+	DeleteAppConfiguration(ctx context.Context, input app.AppID) error
+}

app/custominvoicing/adapter/adapter.go

@@ -0,0 +1,72 @@
+package adapter
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"log/slog"
+
+	appcustominvoicing "github.com/openmeterio/openmeter/openmeter/app/custominvoicing"
+	entdb "github.com/openmeterio/openmeter/openmeter/ent/db"
+	"github.com/openmeterio/openmeter/pkg/framework/entutils"
+	"github.com/openmeterio/openmeter/pkg/framework/transaction"
+)
+
+type Config struct {
+	Client *entdb.Client
+	Logger *slog.Logger
+}
+
+func (c Config) Validate() error {
+	if c.Client == nil {
+		return errors.New("ent client is required")
+	}
+
+	if c.Logger == nil {
+		return errors.New("logger is required")
+	}
+
+	return nil
+}
+
+func New(config Config) (appcustominvoicing.Adapter, error) {
+	if err := config.Validate(); err != nil {
+		return nil, err
+	}
+
+	return &adapter{
+		db:     config.Client,
+		logger: config.Logger,
+	}, nil
+}
+
+var _ appcustominvoicing.Adapter = (*adapter)(nil)
+
+type adapter struct {
+	db     *entdb.Client
+	logger *slog.Logger
+}
+
+func (a *adapter) Tx(ctx context.Context) (context.Context, transaction.Driver, error) {
+	txCtx, rawConfig, eDriver, err := a.db.HijackTx(ctx, &sql.TxOptions{
+		ReadOnly: false,
+	})
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to hijack transaction: %w", err)
+	}
+	return txCtx, entutils.NewTxDriver(eDriver, rawConfig), nil
+}
+
+func (a *adapter) WithTx(ctx context.Context, tx *entutils.TxDriver) *adapter {
+	txDb := entdb.NewTxClientFromRawConfig(ctx, *tx.GetConfig())
+
+	return &adapter{
+		db:     txDb.Client(),
+		logger: a.logger,
+	}
+}
+
+func (a *adapter) Self() *adapter {
+	return a
+}

app/custominvoicing/adapter/appconfig.go

@@ -0,0 +1,70 @@
+package adapter
+
+import (
+	"context"
+	"time"
+
+	"github.com/openmeterio/openmeter/openmeter/app"
+	custominvoicing "github.com/openmeterio/openmeter/openmeter/app/custominvoicing"
+	"github.com/openmeterio/openmeter/openmeter/ent/db"
+	"github.com/openmeterio/openmeter/openmeter/ent/db/appcustominvoicing"
+	"github.com/openmeterio/openmeter/pkg/framework/entutils"
+)
+
+var _ custominvoicing.AppConfigAdapter = (*adapter)(nil)
+
+func (a *adapter) GetAppConfiguration(ctx context.Context, input app.AppID) (custominvoicing.Configuration, error) {
+	return entutils.TransactingRepo(ctx, a, func(ctx context.Context, tx *adapter) (custominvoicing.Configuration, error) {
+		appConfig, err := tx.db.AppCustomInvoicing.Query().
+			Where(
+				appcustominvoicing.ID(input.ID),
+				appcustominvoicing.Namespace(input.Namespace),
+				appcustominvoicing.DeletedAtIsNil(),
+			).
+			First(ctx)
+		if err != nil {
+			if db.IsNotFound(err) {
+				return custominvoicing.Configuration{}, nil
+			}
+
+			return custominvoicing.Configuration{}, err
+		}
+
+		return mapDBToAppConfiguration(appConfig), nil
+	})
+}
+
+func (a *adapter) UpsertAppConfiguration(ctx context.Context, input custominvoicing.UpsertAppConfigurationInput) error {
+	return entutils.TransactingRepoWithNoValue(ctx, a, func(ctx context.Context, tx *adapter) error {
+		return tx.db.AppCustomInvoicing.Create().
+			SetID(input.AppID.ID).
+			SetNamespace(input.AppID.Namespace).
+			SetEnableDraftSyncHook(input.Configuration.EnableDraftSyncHook).
+			SetEnableIssuingSyncHook(input.Configuration.EnableIssuingSyncHook).
+
+			// Upsert
+			OnConflictColumns(appcustominvoicing.FieldID, appcustominvoicing.FieldNamespace).
+			UpdateNewValues().
+			Exec(ctx)
+	})
+}
+
+func (a *adapter) DeleteAppConfiguration(ctx context.Context, input app.AppID) error {
+	return entutils.TransactingRepoWithNoValue(ctx, a, func(ctx context.Context, tx *adapter) error {
+		return tx.db.AppCustomInvoicing.Update().
+			Where(
+				appcustominvoicing.ID(input.ID),
+				appcustominvoicing.Namespace(input.Namespace),
+				appcustominvoicing.DeletedAtIsNil(),
+			).
+			SetDeletedAt(time.Now()).
+			Exec(ctx)
+	})
+}
+
+func mapDBToAppConfiguration(appConfig *db.AppCustomInvoicing) custominvoicing.Configuration {
+	return custominvoicing.Configuration{
+		EnableDraftSyncHook:   appConfig.EnableDraftSyncHook,
+		EnableIssuingSyncHook: appConfig.EnableIssuingSyncHook,
+	}
+}

app/custominvoicing/adapter/customerdata.go

@@ -0,0 +1,89 @@
+package adapter
+
+import (
+	"context"
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+
+	appcustominvoicing "github.com/openmeterio/openmeter/openmeter/app/custominvoicing"
+	"github.com/openmeterio/openmeter/openmeter/ent/db"
+	"github.com/openmeterio/openmeter/openmeter/ent/db/appcustominvoicingcustomer"
+	"github.com/openmeterio/openmeter/pkg/framework/entutils"
+)
+
+func (a *adapter) GetCustomerData(ctx context.Context, input appcustominvoicing.GetAppCustomerDataInput) (appcustominvoicing.CustomerData, error) {
+	if err := input.Validate(); err != nil {
+		return appcustominvoicing.CustomerData{}, err
+	}
+
+	return entutils.TransactingRepo(ctx, a, func(ctx context.Context, tx *adapter) (appcustominvoicing.CustomerData, error) {
+		line, err := tx.db.AppCustomInvoicingCustomer.Query().
+			Where(
+				appcustominvoicingcustomer.CustomerID(input.CustomerID),
+				appcustominvoicingcustomer.Namespace(input.Namespace),
+				appcustominvoicingcustomer.AppID(input.AppID),
+				appcustominvoicingcustomer.DeletedAtIsNil(),
+			).
+			First(ctx)
+		if err != nil {
+			if db.IsNotFound(err) {
+				return appcustominvoicing.CustomerData{}, nil
+			}
+
+			return appcustominvoicing.CustomerData{}, err
+		}
+
+		return mapDBToCustomerData(line), nil
+	})
+}
+
+func (a *adapter) UpsertCustomerData(ctx context.Context, input appcustominvoicing.UpsertCustomerDataInput) error {
+	if err := input.Validate(); err != nil {
+		return err
+	}
+
+	return entutils.TransactingRepoWithNoValue(ctx, a, func(ctx context.Context, tx *adapter) error {
+		return tx.db.AppCustomInvoicingCustomer.Create().
+			SetMetadata(input.Data.Metadata).
+			SetCustomerID(input.CustomerDataID.CustomerID).
+			SetNamespace(input.CustomerDataID.Namespace).
+			SetAppID(input.CustomerDataID.AppID).
+			// Upsert
+			OnConflict(
+				sql.ConflictColumns(
+					appcustominvoicingcustomer.FieldCustomerID,
+					appcustominvoicingcustomer.FieldNamespace,
+					appcustominvoicingcustomer.FieldAppID,
+				),
+				sql.ConflictWhere(sql.IsNull(appcustominvoicingcustomer.FieldDeletedAt)),
+			).
+			UpdateMetadata().
+			UpdateDeletedAt().
+			Exec(ctx)
+	})
+}
+
+func (a *adapter) DeleteCustomerData(ctx context.Context, input appcustominvoicing.DeleteAppCustomerDataInput) error {
+	if err := input.Validate(); err != nil {
+		return err
+	}
+
+	return entutils.TransactingRepoWithNoValue(ctx, a, func(ctx context.Context, tx *adapter) error {
+		return tx.db.AppCustomInvoicingCustomer.Update().
+			SetDeletedAt(time.Now()).
+			Where(
+				appcustominvoicingcustomer.CustomerID(input.CustomerID),
+				appcustominvoicingcustomer.Namespace(input.Namespace),
+				appcustominvoicingcustomer.AppID(input.AppID),
+				appcustominvoicingcustomer.DeletedAtIsNil(),
+			).
+			Exec(ctx)
+	})
+}
+
+func mapDBToCustomerData(line *db.AppCustomInvoicingCustomer) appcustominvoicing.CustomerData {
+	return appcustominvoicing.CustomerData{
+		Metadata: line.Metadata,
+	}
+}

app/custominvoicing/app.go

@@ -0,0 +1,170 @@
+package appcustominvoicing
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/openmeterio/openmeter/openmeter/app"
+	"github.com/openmeterio/openmeter/openmeter/billing"
+	"github.com/openmeterio/openmeter/openmeter/billing/sequence"
+	"github.com/openmeterio/openmeter/openmeter/customer"
+	customerapp "github.com/openmeterio/openmeter/openmeter/customer/app"
+)
+
+var (
+	_ customerapp.App                 = (*App)(nil)
+	_ billing.InvoicingApp            = (*App)(nil)
+	_ billing.InvoicingAppAsyncSyncer = (*App)(nil)
+)
+
+var DefaultInvoiceSequenceNumber = sequence.Definition{
+	Prefix:         "INV",
+	SuffixTemplate: "{{.CustomerPrefix}}-{{.NextSequenceNumber}}",
+	Scope:          "invoices/custom-invoicing",
+	CommitMode:     sequence.CommitModeWithCaller,
+}
+
+type Configuration struct {
+	EnableDraftSyncHook   bool `json:"enable_draft_sync_hook"`
+	EnableIssuingSyncHook bool `json:"enable_issuing_sync_hook"`
+}
+
+const (
+	MetadataKeyDraftSyncedAt = "openmeter.io/custominvoicing/draft-synced-at"
+	MetadataKeyFinalizedAt   = "openmeter.io/custominvoicing/finalized-at"
+)
+
+func (c Configuration) Validate() error {
+	return nil
+}
+
+type Meta struct {
+	app.AppBase
+	Configuration
+}
+
+var _ app.EventAppParser = (*Meta)(nil)
+
+func (m *Meta) FromEventAppData(event app.EventApp) error {
+	m.AppBase = event.AppBase
+
+	if err := event.AppData.ParseInto(&m.Configuration); err != nil {
+		return fmt.Errorf("error parsing app data: %w", err)
+	}
+
+	return nil
+}
+
+type App struct {
+	Meta
+
+	customInvoicingService Service
+	sequenceService        sequence.Service
+}
+
+func (a App) ValidateCustomer(ctx context.Context, customer *customer.Customer, capabilities []app.CapabilityType) error {
+	return nil
+}
+
+func (a App) UpdateAppConfig(ctx context.Context, input app.AppConfigUpdate) error {
+	cfg, ok := input.(Configuration)
+	if !ok {
+		return fmt.Errorf("invalid configuration")
+	}
+
+	if err := cfg.Validate(); err != nil {
+		return err
+	}
+
+	return a.customInvoicingService.UpsertAppConfiguration(ctx, UpsertAppConfigurationInput{
+		AppID:         a.GetID(),
+		Configuration: cfg,
+	})
+}
+
+func (a App) GetEventAppData() (app.EventAppData, error) {
+	return app.NewEventAppData(a.Configuration)
+}
+
+// InvoicingApp
+// These are no-ops as whatever is meaningful, is handled via the http driver of the custominvoicing app.
+
+// ValidateStandardInvoice is a no-op as any validation issues are published via the draft.syncing and finalizations syncing
+// flow.
+func (a App) ValidateStandardInvoice(ctx context.Context, invoice billing.StandardInvoice) error {
+	return nil
+}
+
+func (a App) UpsertStandardInvoice(ctx context.Context, invoice billing.StandardInvoice) (*billing.UpsertStandardInvoiceResult, error) {
+	return nil, nil
+}
+
+func (a App) FinalizeStandardInvoice(ctx context.Context, invoice billing.StandardInvoice) (*billing.FinalizeStandardInvoiceResult, error) {
+	canAdvance, err := a.CanIssuingSyncAdvance(invoice)
+	if err != nil {
+		return nil, err
+	}
+
+	res := billing.NewFinalizeStandardInvoiceResult()
+
+	// If we are done with the hook work, let's make sure that the invoice has a non-draft invoice number
+	if canAdvance {
+		// If the invoice still has a draft invoice number, let's generate a non-draft one
+		if sequence.DraftInvoiceSequenceNumber.PrefixMatches(invoice.Number) {
+			invoiceNumber, err := a.sequenceService.GenerateInvoiceSequenceNumber(ctx,
+				sequence.GenerationInput{
+					Namespace:    invoice.Namespace,
+					CustomerName: invoice.Customer.Name,
+					Currency:     invoice.Currency,
+				},
+				DefaultInvoiceSequenceNumber,
+			)
+			if err != nil {
+				return nil, fmt.Errorf("generating invoice number: %w", err)
+			}
+
+			res.SetInvoiceNumber(invoiceNumber)
+		}
+	}
+
+	return res, nil
+}
+
+// DeleteStandardInvoice is a no-op as this should happen via the notifications webhook
+func (a App) DeleteStandardInvoice(ctx context.Context, invoice billing.StandardInvoice) error {
+	return nil
+}
+
+// InvoicingAppAsyncSyncer
+
+func (a App) CanDraftSyncAdvance(invoice billing.StandardInvoice) (bool, error) {
+	if !a.Configuration.EnableDraftSyncHook {
+		return true, nil
+	}
+
+	if invoice.Metadata == nil {
+		return false, nil
+	}
+
+	if _, ok := invoice.Metadata[MetadataKeyDraftSyncedAt]; ok {
+		return true, nil
+	}
+
+	return false, nil
+}
+
+func (a App) CanIssuingSyncAdvance(invoice billing.StandardInvoice) (bool, error) {
+	if !a.Configuration.EnableIssuingSyncHook {
+		return true, nil
+	}
+
+	if invoice.Metadata == nil {
+		return false, nil
+	}
+
+	if _, ok := invoice.Metadata[MetadataKeyFinalizedAt]; ok {
+		return true, nil
+	}
+
+	return false, nil
+}

app/custominvoicing/customerdata.go

@@ -0,0 +1,100 @@
+package appcustominvoicing
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/openmeterio/openmeter/openmeter/app"
+	"github.com/openmeterio/openmeter/pkg/models"
+)
+
+var _ app.CustomerData = (*CustomerData)(nil)
+
+type CustomerData struct {
+	Metadata models.Metadata `json:"metadata,omitempty"`
+}
+
+func (c CustomerData) Validate() error {
+	return nil
+}
+
+// Customer Specific App Data Handling
+
+func (a App) GetCustomerData(ctx context.Context, input app.GetAppInstanceCustomerDataInput) (app.CustomerData, error) {
+	return a.customInvoicingService.GetCustomerData(ctx, GetAppCustomerDataInput{
+		Namespace:  a.Namespace,
+		AppID:      a.ID,
+		CustomerID: input.CustomerID.ID,
+	})
+}
+
+func (a App) UpsertCustomerData(ctx context.Context, input app.UpsertAppInstanceCustomerDataInput) error {
+	data, ok := input.Data.(CustomerData)
+	if !ok {
+		return fmt.Errorf("invalid customer data: %v", input.Data)
+	}
+
+	return a.customInvoicingService.UpsertCustomerData(ctx, UpsertCustomerDataInput{
+		CustomerDataID: CustomerDataID{
+			Namespace:  a.Namespace,
+			AppID:      a.ID,
+			CustomerID: input.CustomerID.ID,
+		},
+		Data: data,
+	})
+}
+
+func (a App) DeleteCustomerData(ctx context.Context, input app.DeleteAppInstanceCustomerDataInput) error {
+	return a.customInvoicingService.DeleteCustomerData(ctx, DeleteAppCustomerDataInput{
+		Namespace:  a.Namespace,
+		AppID:      a.ID,
+		CustomerID: input.CustomerID.ID,
+	})
+}
+
+// Service types
+
+type UpsertCustomerDataInput struct {
+	CustomerDataID
+	Data CustomerData
+}
+
+func (i UpsertCustomerDataInput) Validate() error {
+	if err := i.CustomerDataID.Validate(); err != nil {
+		return err
+	}
+
+	if err := i.Data.Validate(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+type CustomerDataID struct {
+	Namespace  string
+	AppID      string
+	CustomerID string
+}
+
+func (i CustomerDataID) Validate() error {
+	if i.Namespace == "" {
+		return errors.New("namespace is required")
+	}
+
+	if i.CustomerID == "" {
+		return errors.New("customer id is required")
+	}
+
+	if i.AppID == "" {
+		return errors.New("app id is required")
+	}
+
+	return nil
+}
+
+type (
+	GetAppCustomerDataInput    = CustomerDataID
+	DeleteAppCustomerDataInput = CustomerDataID
+)

app/custominvoicing/factory.go

@@ -0,0 +1,159 @@
+package appcustominvoicing
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/openmeterio/openmeter/openmeter/app"
+	"github.com/openmeterio/openmeter/openmeter/billing/sequence"
+)
+
+var (
+	MarketplaceListing = app.MarketplaceListing{
+		Type:        app.AppTypeCustomInvoicing,
+		Name:        "Custom Invoicing",
+		Description: "Custom Invoicing can be used to interface with third party invoicing and payment systems",
+		Capabilities: []app.Capability{
+			CollectPaymentCapability,
+			CalculateTaxCapability,
+			InvoiceCustomerCapability,
+		},
+		InstallMethods: []app.InstallMethod{
+			app.InstallMethodNoCredentials,
+		},
+	}
+
+	CollectPaymentCapability = app.Capability{
+		Type:        app.CapabilityTypeCollectPayments,
+		Key:         "custom_invoicing_collect_payment",
+		Name:        "Payment",
+		Description: "Process payments",
+	}
+
+	CalculateTaxCapability = app.Capability{
+		Type:        app.CapabilityTypeCalculateTax,
+		Key:         "custom_invoicing_calculate_tax",
+		Name:        "Calculate Tax",
+		Description: "Calculate tax for a payment",
+	}
+
+	InvoiceCustomerCapability = app.Capability{
+		Type:        app.CapabilityTypeInvoiceCustomers,
+		Key:         "custom_invoicing_invoice_customer",
+		Name:        "Invoice Customer",
+		Description: "Invoice a customer",
+	}
+)
+
+type Factory struct {
+	appService             app.Service
+	customInvoicingService Service
+	sequenceService        sequence.Service
+}
+
+type FactoryConfig struct {
+	AppService             app.Service
+	CustomInvoicingService Service
+	SequenceService        sequence.Service
+}
+
+func (c FactoryConfig) Validate() error {
+	if c.AppService == nil {
+		return fmt.Errorf("app service is required")
+	}
+
+	if c.CustomInvoicingService == nil {
+		return fmt.Errorf("custom invoicing service is required")
+	}
+
+	if c.SequenceService == nil {
+		return fmt.Errorf("sequence service is required")
+	}
+
+	return nil
+}
+
+func NewFactory(config FactoryConfig) (*Factory, error) {
+	if err := config.Validate(); err != nil {
+		return nil, fmt.Errorf("failed to validate config: %w", err)
+	}
+
+	fact := &Factory{
+		appService:             config.AppService,
+		customInvoicingService: config.CustomInvoicingService,
+		sequenceService:        config.SequenceService,
+	}
+
+	err := config.AppService.RegisterMarketplaceListing(app.RegistryItem{
+		Listing: MarketplaceListing,
+		Factory: fact,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to register marketplace listing: %w", err)
+	}
+
+	return fact, nil
+}
+
+// Factory
+func (f *Factory) NewApp(ctx context.Context, appBase app.AppBase) (app.App, error) {
+	cfg, err := f.customInvoicingService.GetAppConfiguration(ctx, appBase.GetID())
+	if err != nil {
+		return nil, fmt.Errorf("failed to get app config: %w", err)
+	}
+
+	return App{
+		Meta: Meta{
+			AppBase:       appBase,
+			Configuration: cfg,
+		},
+		customInvoicingService: f.customInvoicingService,
+		sequenceService:        f.sequenceService,
+	}, nil
+}
+
+func (f *Factory) InstallApp(ctx context.Context, input app.AppFactoryInstallAppInput) (app.App, error) {
+	if err := input.Validate(); err != nil {
+		return nil, fmt.Errorf("invalid input: %w", err)
+	}
+
+	newApp, err := f.customInvoicingService.CreateApp(ctx, CreateAppInput{
+		Namespace: input.Namespace,
+		Name:      input.Name,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to create app: %w", err)
+	}
+
+	return f.NewApp(ctx, newApp.GetAppBase())
+}
+
+func (f *Factory) UninstallApp(ctx context.Context, input app.UninstallAppInput) error {
+	return f.customInvoicingService.DeleteApp(ctx, input)
+}
+
+// Service types
+
+type CreateAppInput struct {
+	Namespace string
+	Name      string
+
+	Config Configuration
+}
+
+func (i CreateAppInput) Validate() error {
+	if i.Namespace == "" {
+		return fmt.Errorf("namespace is required")
+	}
+
+	if i.Name == "" {
+		return fmt.Errorf("name is required")
+	}
+
+	return nil
+}
+
+type UpsertAppConfigurationInput struct {
+	AppID         app.AppID
+	Configuration Configuration
+}

app/custominvoicing/httpdriver/custominvoicing.go

@@ -0,0 +1,172 @@
+package httpdriver
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+
+	"github.com/openmeterio/openmeter/api"
+	appcustominvoicing "github.com/openmeterio/openmeter/openmeter/app/custominvoicing"
+	"github.com/openmeterio/openmeter/openmeter/billing"
+	billinghttpdriver "github.com/openmeterio/openmeter/openmeter/billing/httpdriver"
+	"github.com/openmeterio/openmeter/pkg/framework/commonhttp"
+	"github.com/openmeterio/openmeter/pkg/framework/transport/httptransport"
+)
+
+type (
+	DraftSyncronizedRequest  = appcustominvoicing.SyncDraftInvoiceInput
+	DraftSyncronizedResponse = api.Invoice
+	DraftSyncronizedParams   = struct {
+		InvoiceID string `json:"invoiceId"`
+	}
+	DraftSyncronizedHandler httptransport.HandlerWithArgs[DraftSyncronizedRequest, DraftSyncronizedResponse, DraftSyncronizedParams]
+)
+
+func (h *handler) DraftSyncronized() DraftSyncronizedHandler {
+	return httptransport.NewHandlerWithArgs(
+		func(ctx context.Context, r *http.Request, params DraftSyncronizedParams) (DraftSyncronizedRequest, error) {
+			namespace, err := h.resolveNamespace(ctx)
+			if err != nil {
+				return DraftSyncronizedRequest{}, fmt.Errorf("failed to resolve namespace: %w", err)
+			}
+
+			var body api.CustomInvoicingDraftSynchronizedRequest
+			if err := commonhttp.JSONRequestBodyDecoder(r, &body); err != nil {
+				return DraftSyncronizedRequest{}, fmt.Errorf("failed to decode draft synchronized request: %w", err)
+			}
+
+			return DraftSyncronizedRequest{
+				InvoiceID: billing.InvoiceID{
+					ID:        params.InvoiceID,
+					Namespace: namespace,
+				},
+				UpsertInvoiceResults: mapUpsertStandardInvoiceResultFromAPI(body.Invoicing),
+			}, nil
+		},
+		func(ctx context.Context, request DraftSyncronizedRequest) (DraftSyncronizedResponse, error) {
+			if err := request.Validate(); err != nil {
+				return DraftSyncronizedResponse{}, err
+			}
+
+			invoice, err := h.service.SyncDraftInvoice(ctx, request)
+			if err != nil {
+				return DraftSyncronizedResponse{}, err
+			}
+
+			return billinghttpdriver.MapStandardInvoiceToAPI(invoice)
+		},
+		commonhttp.JSONResponseEncoderWithStatus[DraftSyncronizedResponse](http.StatusOK),
+		httptransport.AppendOptions(
+			h.options,
+			httptransport.WithOperationName("DraftSyncronized"),
+			httptransport.WithErrorEncoder(errorEncoder()),
+		)...,
+	)
+}
+
+type (
+	IssuingSyncronizedRequest  = appcustominvoicing.SyncIssuingInvoiceInput
+	IssuingSyncronizedResponse = api.Invoice
+	IssuingSyncronizedParams   = struct {
+		InvoiceID string `json:"invoiceId"`
+	}
+	IssuingSyncronizedHandler httptransport.HandlerWithArgs[IssuingSyncronizedRequest, IssuingSyncronizedResponse, IssuingSyncronizedParams]
+)
+
+func (h *handler) IssuingSyncronized() IssuingSyncronizedHandler {
+	return httptransport.NewHandlerWithArgs(
+		func(ctx context.Context, r *http.Request, params IssuingSyncronizedParams) (IssuingSyncronizedRequest, error) {
+			namespace, err := h.resolveNamespace(ctx)
+			if err != nil {
+				return IssuingSyncronizedRequest{}, fmt.Errorf("failed to resolve namespace: %w", err)
+			}
+
+			var body api.CustomInvoicingFinalizedRequest
+			if err := commonhttp.JSONRequestBodyDecoder(r, &body); err != nil {
+				return IssuingSyncronizedRequest{}, fmt.Errorf("failed to decode issuing synchronized request: %w", err)
+			}
+
+			return IssuingSyncronizedRequest{
+				InvoiceID: billing.InvoiceID{
+					ID:        params.InvoiceID,
+					Namespace: namespace,
+				},
+				FinalizeInvoiceResult: mapFinalizeStandardInvoiceResultFromAPI(body),
+			}, nil
+		},
+		func(ctx context.Context, request IssuingSyncronizedRequest) (IssuingSyncronizedResponse, error) {
+			if err := request.Validate(); err != nil {
+				return IssuingSyncronizedResponse{}, err
+			}
+
+			invoice, err := h.service.SyncIssuingInvoice(ctx, request)
+			if err != nil {
+				return IssuingSyncronizedResponse{}, err
+			}
+
+			return billinghttpdriver.MapStandardInvoiceToAPI(invoice)
+		},
+		commonhttp.JSONResponseEncoderWithStatus[IssuingSyncronizedResponse](http.StatusOK),
+		httptransport.AppendOptions(
+			h.options,
+			httptransport.WithOperationName("IssuingSyncronized"),
+			httptransport.WithErrorEncoder(errorEncoder()),
+		)...,
+	)
+}
+
+type (
+	UpdatePaymentStatusRequest  = appcustominvoicing.HandlePaymentTriggerInput
+	UpdatePaymentStatusResponse = api.Invoice
+	UpdatePaymentStatusParams   = struct {
+		InvoiceID string `json:"invoiceId"`
+	}
+	UpdatePaymentStatusHandler httptransport.HandlerWithArgs[UpdatePaymentStatusRequest, UpdatePaymentStatusResponse, UpdatePaymentStatusParams]
+)
+
+func (h *handler) UpdatePaymentStatus() UpdatePaymentStatusHandler {
+	return httptransport.NewHandlerWithArgs(
+		func(ctx context.Context, r *http.Request, params UpdatePaymentStatusParams) (UpdatePaymentStatusRequest, error) {
+			namespace, err := h.resolveNamespace(ctx)
+			if err != nil {
+				return UpdatePaymentStatusRequest{}, fmt.Errorf("failed to resolve namespace: %w", err)
+			}
+
+			var body api.CustomInvoicingUpdatePaymentStatusRequest
+			if err := commonhttp.JSONRequestBodyDecoder(r, &body); err != nil {
+				return UpdatePaymentStatusRequest{}, fmt.Errorf("failed to decode handle payment trigger request: %w", err)
+			}
+
+			trigger, err := mapPaymentTriggerFromAPI(body.Trigger)
+			if err != nil {
+				return UpdatePaymentStatusRequest{}, fmt.Errorf("failed to map payment trigger: %w", err)
+			}
+
+			return UpdatePaymentStatusRequest{
+				InvoiceID: billing.InvoiceID{
+					ID:        params.InvoiceID,
+					Namespace: namespace,
+				},
+				Trigger: trigger,
+			}, nil
+		},
+		func(ctx context.Context, request UpdatePaymentStatusRequest) (UpdatePaymentStatusResponse, error) {
+			if err := request.Validate(); err != nil {
+				return UpdatePaymentStatusResponse{}, err
+			}
+
+			invoice, err := h.service.HandlePaymentTrigger(ctx, request)
+			if err != nil {
+				return UpdatePaymentStatusResponse{}, err
+			}
+
+			return billinghttpdriver.MapStandardInvoiceToAPI(invoice)
+		},
+		commonhttp.JSONResponseEncoderWithStatus[UpdatePaymentStatusResponse](http.StatusOK),
+		httptransport.AppendOptions(
+			h.options,
+			httptransport.WithOperationName("UpdatePaymentStatus"),
+			httptransport.WithErrorEncoder(errorEncoder()),
+		)...,
+	)
+}

app/custominvoicing/httpdriver/errors.go

@@ -0,0 +1,21 @@
+package httpdriver
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/openmeterio/openmeter/openmeter/billing"
+	"github.com/openmeterio/openmeter/pkg/framework/commonhttp"
+	"github.com/openmeterio/openmeter/pkg/framework/transport/httptransport/encoder"
+)
+
+func errorEncoder() encoder.ErrorEncoder {
+	return func(ctx context.Context, err error, w http.ResponseWriter, r *http.Request) bool {
+		return commonhttp.HandleErrorIfTypeMatches[billing.NotFoundError](ctx, http.StatusNotFound, err, w, billing.EncodeValidationIssues) ||
+			commonhttp.HandleErrorIfTypeMatches[billing.ValidationError](ctx, http.StatusBadRequest, err, w, billing.EncodeValidationIssues) ||
+			commonhttp.HandleErrorIfTypeMatches[billing.UpdateAfterDeleteError](ctx, http.StatusConflict, err, w, billing.EncodeValidationIssues) ||
+			commonhttp.HandleErrorIfTypeMatches[billing.ValidationIssue](ctx, http.StatusBadRequest, err, w, billing.EncodeValidationIssues) ||
+			// dependency: apps
+			commonhttp.HandleErrorIfTypeMatches[billing.AppError](ctx, http.StatusBadRequest, err, w)
+	}
+}

app/custominvoicing/httpdriver/handler.go

@@ -0,0 +1,52 @@
+package httpdriver
+
+import (
+	"context"
+	"errors"
+	"net/http"
+
+	appcustominvoicing "github.com/openmeterio/openmeter/openmeter/app/custominvoicing"
+	"github.com/openmeterio/openmeter/openmeter/namespace/namespacedriver"
+	"github.com/openmeterio/openmeter/pkg/framework/commonhttp"
+	"github.com/openmeterio/openmeter/pkg/framework/transport/httptransport"
+)
+
+type Handler interface {
+	AppHandler
+}
+
+type AppHandler interface {
+	DraftSyncronized() DraftSyncronizedHandler
+	IssuingSyncronized() IssuingSyncronizedHandler
+	UpdatePaymentStatus() UpdatePaymentStatusHandler
+}
+
+var _ Handler = (*handler)(nil)
+
+type handler struct {
+	service appcustominvoicing.SyncService
+
+	namespaceDecoder namespacedriver.NamespaceDecoder
+	options          []httptransport.HandlerOption
+}
+
+func (h *handler) resolveNamespace(ctx context.Context) (string, error) {
+	ns, ok := h.namespaceDecoder.GetNamespace(ctx)
+	if !ok {
+		return "", commonhttp.NewHTTPError(http.StatusInternalServerError, errors.New("internal server error"))
+	}
+
+	return ns, nil
+}
+
+func New(
+	service appcustominvoicing.SyncService,
+	namespaceDecoder namespacedriver.NamespaceDecoder,
+	options ...httptransport.HandlerOption,
+) Handler {
+	return &handler{
+		service:          service,
+		namespaceDecoder: namespaceDecoder,
+		options:          options,
+	}
+}

app/custominvoicing/httpdriver/mapper.go

@@ -0,0 +1,85 @@
+package httpdriver
+
+import (
+	"fmt"
+
+	"github.com/openmeterio/openmeter/api"
+	"github.com/openmeterio/openmeter/openmeter/billing"
+	"github.com/openmeterio/openmeter/pkg/models"
+)
+
+func mapUpsertStandardInvoiceResultFromAPI(in *api.CustomInvoicingSyncResult) *billing.UpsertStandardInvoiceResult {
+	if in == nil {
+		return nil
+	}
+
+	res := billing.NewUpsertStandardInvoiceResult()
+
+	if in.InvoiceNumber != nil {
+		res.SetInvoiceNumber(*in.InvoiceNumber)
+	}
+
+	if in.ExternalId != nil {
+		res.SetExternalID(*in.ExternalId)
+	}
+
+	if in.LineExternalIds != nil {
+		for _, line := range *in.LineExternalIds {
+			res.AddLineExternalID(line.LineId, line.ExternalId)
+		}
+	}
+
+	if in.LineDiscountExternalIds != nil {
+		for _, lineDiscount := range *in.LineDiscountExternalIds {
+			res.AddLineDiscountExternalID(lineDiscount.LineDiscountId, lineDiscount.ExternalId)
+		}
+	}
+
+	return res
+}
+
+func mapFinalizeStandardInvoiceResultFromAPI(in api.CustomInvoicingFinalizedRequest) *billing.FinalizeStandardInvoiceResult {
+	res := billing.NewFinalizeStandardInvoiceResult()
+
+	if in.Invoicing != nil {
+		if in.Invoicing.InvoiceNumber != nil {
+			res.SetInvoiceNumber(*in.Invoicing.InvoiceNumber)
+		}
+
+		if in.Invoicing.SentToCustomerAt != nil {
+			res.SetSentToCustomerAt(*in.Invoicing.SentToCustomerAt)
+		}
+	}
+
+	if in.Payment != nil {
+		if in.Payment.ExternalId != nil {
+			res.SetPaymentExternalID(*in.Payment.ExternalId)
+		}
+	}
+	return res
+}
+
+func mapPaymentTriggerFromAPI(in api.CustomInvoicingPaymentTrigger) (billing.InvoiceTrigger, error) {
+	if in == "" {
+		return "", models.NewGenericValidationError(fmt.Errorf("payment trigger is required"))
+	}
+
+	// Map API trigger names to internal state machine triggers
+	switch in {
+	case api.CustomInvoicingPaymentTriggerPaid:
+		return billing.TriggerPaid, nil
+	case api.CustomInvoicingPaymentTriggerPaymentFailed:
+		// Note: API uses "payment_failed" but internal trigger is "failed"
+		return billing.TriggerFailed, nil
+	case api.CustomInvoicingPaymentTriggerPaymentUncollectible:
+		return billing.TriggerPaymentUncollectible, nil
+	case api.CustomInvoicingPaymentTriggerPaymentOverdue:
+		return billing.TriggerPaymentOverdue, nil
+	case api.CustomInvoicingPaymentTriggerActionRequired:
+		return billing.TriggerActionRequired, nil
+	case api.CustomInvoicingPaymentTriggerVoid:
+		return billing.TriggerVoid, nil
+	default:
+		return "", models.NewGenericValidationError(fmt.Errorf("unknown payment trigger: %s", in))
+	}
+}

app/custominvoicing/service.go

@@ -0,0 +1,34 @@
+package appcustominvoicing
+
+import (
+	"context"
+
+	"github.com/openmeterio/openmeter/openmeter/app"
+	"github.com/openmeterio/openmeter/openmeter/billing"
+)
+
+type Service interface {
+	CustomerDataService
+	FactoryService
+	SyncService
+}
+
+type CustomerDataService interface {
+	GetCustomerData(ctx context.Context, input GetAppCustomerDataInput) (CustomerData, error)
+	UpsertCustomerData(ctx context.Context, input UpsertCustomerDataInput) error
+	DeleteCustomerData(ctx context.Context, input DeleteAppCustomerDataInput) error
+}
+
+type FactoryService interface {
+	CreateApp(ctx context.Context, input CreateAppInput) (app.AppBase, error)
+	DeleteApp(ctx context.Context, input app.UninstallAppInput) error
+	UpsertAppConfiguration(ctx context.Context, input UpsertAppConfigurationInput) error
+	GetAppConfiguration(ctx context.Context, appID app.AppID) (Configuration, error)
+}
+
+type SyncService interface {
+	SyncDraftInvoice(ctx context.Context, input SyncDraftInvoiceInput) (billing.StandardInvoice, error)
+	SyncIssuingInvoice(ctx context.Context, input SyncIssuingInvoiceInput) (billing.StandardInvoice, error)
+
+	HandlePaymentTrigger(ctx context.Context, input HandlePaymentTriggerInput) (billing.StandardInvoice, error)
+}

app/custominvoicing/service/customerdata.go

@@ -0,0 +1,26 @@
+package service
+
+import (
+	"context"
+
+	appcustominvoicing "github.com/openmeterio/openmeter/openmeter/app/custominvoicing"
+	"github.com/openmeterio/openmeter/pkg/framework/transaction"
+)
+
+func (s *Service) GetCustomerData(ctx context.Context, input appcustominvoicing.GetAppCustomerDataInput) (appcustominvoicing.CustomerData, error) {
+	return transaction.Run(ctx, s.adapter, func(ctx context.Context) (appcustominvoicing.CustomerData, error) {
+		return s.adapter.GetCustomerData(ctx, input)
+	})
+}
+
+func (s *Service) UpsertCustomerData(ctx context.Context, input appcustominvoicing.UpsertCustomerDataInput) error {
+	return transaction.RunWithNoValue(ctx, s.adapter, func(ctx context.Context) error {
+		return s.adapter.UpsertCustomerData(ctx, input)
+	})
+}
+
+func (s *Service) DeleteCustomerData(ctx context.Context, input appcustominvoicing.DeleteAppCustomerDataInput) error {
+	return transaction.RunWithNoValue(ctx, s.adapter, func(ctx context.Context) error {
+		return s.adapter.DeleteCustomerData(ctx, input)
+	})
+}

app/custominvoicing/service/factory.go

@@ -0,0 +1,57 @@
+package service
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/openmeterio/openmeter/openmeter/app"
+	appcustominvoicing "github.com/openmeterio/openmeter/openmeter/app/custominvoicing"
+	"github.com/openmeterio/openmeter/pkg/framework/transaction"
+)
+
+var _ appcustominvoicing.FactoryService = (*Service)(nil)
+
+func (s *Service) CreateApp(ctx context.Context, input appcustominvoicing.CreateAppInput) (app.AppBase, error) {
+	if err := input.Validate(); err != nil {
+		return app.AppBase{}, fmt.Errorf("invalid input: %w", err)
+	}
+
+	return transaction.Run(ctx, s.adapter, func(ctx context.Context) (app.AppBase, error) {
+		// Let's create the app first
+		appBase, err := s.appService.CreateApp(ctx, app.CreateAppInput{
+			Namespace: input.Namespace,
+			Name:      input.Name,
+			Type:      app.AppTypeCustomInvoicing,
+		})
+		if err != nil {
+			return app.AppBase{}, fmt.Errorf("failed to create app: %w", err)
+		}
+
+		// Let's create the app settings entity
+		err = s.adapter.UpsertAppConfiguration(ctx, appcustominvoicing.UpsertAppConfigurationInput{
+			AppID:         app.AppID{ID: appBase.ID, Namespace: appBase.Namespace},
+			Configuration: input.Config,
+		})
+		if err != nil {
+			return app.AppBase{}, fmt.Errorf("failed to create app settings: %w", err)
+		}
+
+		return appBase, nil
+	})
+}
+
+func (s *Service) DeleteApp(ctx context.Context, input app.UninstallAppInput) error {
+	return transaction.RunWithNoValue(ctx, s.adapter, func(ctx context.Context) error {
+		return s.adapter.DeleteAppConfiguration(ctx, input)
+	})
+}
+
+func (s *Service) UpsertAppConfiguration(ctx context.Context, input appcustominvoicing.UpsertAppConfigurationInput) error {
+	return transaction.RunWithNoValue(ctx, s.adapter, func(ctx context.Context) error {
+		return s.adapter.UpsertAppConfiguration(ctx, input)
+	})
+}
+
+func (s *Service) GetAppConfiguration(ctx context.Context, appID app.AppID) (appcustominvoicing.Configuration, error) {
+	return s.adapter.GetAppConfiguration(ctx, appID)
+}

app/custominvoicing/service/service.go

@@ -0,0 +1,62 @@
+package service
+
+import (
+	"errors"
+	"log/slog"
+
+	"github.com/openmeterio/openmeter/openmeter/app"
+	appcustominvoicing "github.com/openmeterio/openmeter/openmeter/app/custominvoicing"
+	"github.com/openmeterio/openmeter/openmeter/billing"
+)
+
+var _ appcustominvoicing.Service = (*Service)(nil)
+
+type Service struct {
+	adapter appcustominvoicing.Adapter
+	logger  *slog.Logger
+
+	// dependencies
+	appService     app.Service
+	billingService billing.Service
+}
+
+type Config struct {
+	Adapter appcustominvoicing.Adapter
+	Logger  *slog.Logger
+
+	AppService     app.Service
+	BillingService billing.Service
+}
+
+func (c Config) Validate() error {
+	if c.Adapter == nil {
+		return errors.New("adapter cannot be nil")
+	}
+
+	if c.Logger == nil {
+		return errors.New("logger cannot be nil")
+	}
+
+	if c.AppService == nil {
+		return errors.New("app service cannot be nil")
+	}
+
+	if c.BillingService == nil {
+		return errors.New("billing service cannot be nil")
+	}
+
+	return nil
+}
+
+func New(config Config) (*Service, error) {
+	if err := config.Validate(); err != nil {
+		return nil, err
+	}
+
+	return &Service{
+		adapter:        config.Adapter,
+		logger:         config.Logger,
+		appService:     config.AppService,
+		billingService: config.BillingService,
+	}, nil
+}

app/custominvoicing/service/sync.go

@@ -0,0 +1,117 @@
+package service
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/samber/lo"
+
+	"github.com/openmeterio/openmeter/openmeter/app"
+	appcustominvoicing "github.com/openmeterio/openmeter/openmeter/app/custominvoicing"
+	"github.com/openmeterio/openmeter/openmeter/billing"
+	"github.com/openmeterio/openmeter/pkg/clock"
+	"github.com/openmeterio/openmeter/pkg/framework/transaction"
+	"github.com/openmeterio/openmeter/pkg/models"
+)
+
+var _ appcustominvoicing.SyncService = (*Service)(nil)
+
+func (s *Service) SyncDraftInvoice(ctx context.Context, input appcustominvoicing.SyncDraftInvoiceInput) (billing.StandardInvoice, error) {
+	if err := input.Validate(); err != nil {
+		return billing.StandardInvoice{}, err
+	}
+
+	return s.billingService.SyncDraftInvoice(ctx, billing.SyncDraftStandardInvoiceInput{
+		InvoiceID:            input.InvoiceID,
+		UpsertInvoiceResults: input.UpsertInvoiceResults,
+		AdditionalMetadata: map[string]string{
+			appcustominvoicing.MetadataKeyDraftSyncedAt: clock.Now().Format(time.RFC3339),
+		},
+		InvoiceValidator: s.ValidateInvoiceApp,
+	})
+}
+
+func (s *Service) SyncIssuingInvoice(ctx context.Context, input appcustominvoicing.SyncIssuingInvoiceInput) (billing.StandardInvoice, error) {
+	if err := input.Validate(); err != nil {
+		return billing.StandardInvoice{}, err
+	}
+
+	return s.billingService.SyncIssuingInvoice(ctx, billing.SyncIssuingStandardInvoiceInput{
+		InvoiceID:             input.InvoiceID,
+		FinalizeInvoiceResult: input.FinalizeInvoiceResult,
+		AdditionalMetadata: map[string]string{
+			appcustominvoicing.MetadataKeyFinalizedAt: clock.Now().Format(time.RFC3339),
+		},
+		InvoiceValidator: s.ValidateInvoiceApp,
+	})
+}
+
+func (s *Service) ValidateInvoiceApp(invoice billing.StandardInvoice) error {
+	if invoice.Workflow.Apps == nil {
+		return models.NewGenericValidationError(fmt.Errorf("standard invoice %s has no apps", invoice.ID))
+	}
+
+	if invoice.Workflow.Apps.Invoicing == nil {
+		return models.NewGenericValidationError(fmt.Errorf("invoice %s has no invoicing app", invoice.ID))
+	}
+
+	if invoice.Workflow.Apps.Invoicing.GetType() != app.AppTypeCustomInvoicing {
+		return models.NewGenericValidationError(fmt.Errorf("invoice %s is not managed by the custom invoicing app", invoice.ID))
+	}
+
+	return nil
+}
+
+func (s *Service) HandlePaymentTrigger(ctx context.Context, input appcustominvoicing.HandlePaymentTriggerInput) (billing.StandardInvoice, error) {
+	if err := input.Validate(); err != nil {
+		return billing.StandardInvoice{}, err
+	}
+
+	return transaction.Run(ctx, s.adapter, func(ctx context.Context) (billing.StandardInvoice, error) {
+		invoice, err := s.billingService.GetStandardInvoiceById(ctx, billing.GetStandardInvoiceByIdInput{
+			Invoice: input.InvoiceID,
+		})
+		if err != nil {
+			return billing.StandardInvoice{}, err
+		}
+
+		if err := s.ValidateInvoiceApp(invoice); err != nil {
+			return billing.StandardInvoice{}, err
+		}
+
+		err = s.billingService.TriggerInvoice(ctx, billing.InvoiceTriggerServiceInput{
+			InvoiceTriggerInput: billing.InvoiceTriggerInput{
+				Invoice: input.InvoiceID,
+				Trigger: input.Trigger,
+			},
+			AppType:    app.AppTypeCustomInvoicing,
+			Capability: app.CapabilityTypeCollectPayments,
+		})
+		if err != nil {
+			return billing.StandardInvoice{}, err
+		}
+
+		invoice, err = s.billingService.GetStandardInvoiceById(ctx, billing.GetStandardInvoiceByIdInput{
+			Invoice: input.InvoiceID,
+		})
+		if err != nil {
+			return billing.StandardInvoice{}, err
+		}
+
+		if len(invoice.ValidationIssues) > 0 {
+			criticalIssues := lo.Filter(invoice.ValidationIssues, func(issue billing.ValidationIssue, _ int) bool {
+				return issue.Severity == billing.ValidationIssueSeverityCritical
+			})
+
+			if len(criticalIssues) > 0 {
+				// Warning: This causes a rollback of the transaction
+				return billing.StandardInvoice{}, billing.ValidationError{
+					Err: criticalIssues.AsError(),
+				}
+			}
+		}
+
+		return invoice, nil
+	})
+}

app/custominvoicing/sync.go

@@ -0,0 +1,66 @@
+package appcustominvoicing
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/openmeterio/openmeter/openmeter/billing"
+	"github.com/openmeterio/openmeter/pkg/models"
+)
+
+type SyncDraftInvoiceInput struct {
+	InvoiceID            billing.InvoiceID
+	UpsertInvoiceResults *billing.UpsertStandardInvoiceResult
+}
+
+func (i *SyncDraftInvoiceInput) Validate() error {
+	var errs []error
+
+	if err := i.InvoiceID.Validate(); err != nil {
+		errs = append(errs, err)
+	}
+
+	if i.UpsertInvoiceResults == nil {
+		errs = append(errs, fmt.Errorf("upsert invoice results are required"))
+	}
+
+	return models.NewNillableGenericValidationError(errors.Join(errs...))
+}
+
+type SyncIssuingInvoiceInput struct {
+	InvoiceID             billing.InvoiceID
+	FinalizeInvoiceResult *billing.FinalizeStandardInvoiceResult
+}
+
+func (i *SyncIssuingInvoiceInput) Validate() error {
+	var errs []error
+
+	if err := i.InvoiceID.Validate(); err != nil {
+		errs = append(errs, err)
+	}
+
+	if i.FinalizeInvoiceResult == nil {
+		errs = append(errs, fmt.Errorf("finalize invoice result is required"))
+	}
+
+	return models.NewNillableGenericValidationError(errors.Join(errs...))
+}
+
+type HandlePaymentTriggerInput struct {
+	InvoiceID billing.InvoiceID
+	Trigger   billing.InvoiceTrigger
+}
+
+func (i *HandlePaymentTriggerInput) Validate() error {
+	var errs []error
+
+	if err := i.InvoiceID.Validate(); err != nil {
+		errs = append(errs, err)
+	}
+
+	if i.Trigger == "" {
+		errs = append(errs, fmt.Errorf("trigger is required"))
+	}
+
+	return models.NewNillableGenericValidationError(errors.Join(errs...))
+}

app/defaults.go

@@ -0,0 +1,6 @@
+package app
+
+const (
+	DefaultPageNumber = 1
+	DefaultPageSize   = 100
+)

app/errors.go

@@ -0,0 +1,226 @@
+package app
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/openmeterio/openmeter/openmeter/customer"
+	"github.com/openmeterio/openmeter/pkg/models"
+)
+
+// AppNotFoundError
+func NewAppNotFoundError(appID AppID) *AppNotFoundError {
+	return &AppNotFoundError{
+		err: models.NewGenericNotFoundError(
+			fmt.Errorf("app with id %s not found in %s namespace", appID.ID, appID.Namespace),
+		),
+	}
+}
+
+var _ models.GenericError = AppNotFoundError{}
+
+type AppNotFoundError struct {
+	err error
+}
+
+func (e AppNotFoundError) Error() string {
+	return e.err.Error()
+}
+
+func (e AppNotFoundError) Unwrap() error {
+	return e.err
+}
+
+// IsAppNotFoundError returns true if the error is a AppNotFoundError.
+func IsAppNotFoundError(err error) bool {
+	if err == nil {
+		return false
+	}
+
+	var e *AppNotFoundError
+
+	return errors.As(err, &e)
+}
+
+// AppDefaultNotFoundError
+func NewAppDefaultNotFoundError(appType AppType, namespace string) *AppDefaultNotFoundError {
+	return &AppDefaultNotFoundError{
+		err: models.NewGenericNotFoundError(
+			fmt.Errorf("there is no default app for %s type in %s namespace", appType, namespace),
+		),
+	}
+}
+
+var _ models.GenericError = AppDefaultNotFoundError{}
+
+type AppDefaultNotFoundError struct {
+	err error
+}
+
+func (e AppDefaultNotFoundError) Error() string {
+	return e.err.Error()
+}
+
+func (e AppDefaultNotFoundError) Unwrap() error {
+	return e.err
+}
+
+func IsAppDefaultNotFoundError(err error) bool {
+	if err == nil {
+		return false
+	}
+
+	var e *AppDefaultNotFoundError
+
+	return errors.As(err, &e)
+}
+
+// AppProviderAuthenticationError
+func NewAppProviderAuthenticationError(appID *AppID, namespace string, providerError error) *AppProviderAuthenticationError {
+	var err error
+
+	if appID == nil {
+		err = fmt.Errorf("provider authentication error for app in %s namespace: %w", namespace, providerError)
+	} else {
+		err = fmt.Errorf("provider authentication error for app %s: %w", appID.ID, providerError)
+	}
+
+	return &AppProviderAuthenticationError{
+		err: models.NewGenericUnauthorizedError(err),
+	}
+}
+
+var _ models.GenericError = (*AppProviderAuthenticationError)(nil)
+
+type AppProviderAuthenticationError struct {
+	err error
+}
+
+func (e AppProviderAuthenticationError) Error() string {
+	return e.err.Error()
+}
+
+func (e AppProviderAuthenticationError) Unwrap() error {
+	return e.err
+}
+
+func IsAppProviderAuthenticationError(err error) bool {
+	if err == nil {
+		return false
+	}
+
+	var e *AppProviderAuthenticationError
+
+	return errors.As(err, &e)
+}
+
+// AppProviderError
+func NewAppProviderError(appID *AppID, namespace string, providerError error) *AppProviderError {
+	var err error
+
+	if appID == nil {
+		err = fmt.Errorf("provider error for app in %s namespace: %w", namespace, providerError)
+	} else {
+		err = fmt.Errorf("provider error for app %s: %w", appID.ID, providerError)
+	}
+
+	return &AppProviderError{
+		err: models.NewGenericPreConditionFailedError(err),
+	}
+}
+
+var _ models.GenericError = (*AppProviderError)(nil)
+
+type AppProviderError struct {
+	err error
+}
+
+func (e AppProviderError) Error() string {
+	return e.err.Error()
+}
+
+func (e AppProviderError) Unwrap() error {
+	return e.err
+}
+
+func IsAppProviderError(err error) bool {
+	if err == nil {
+		return false
+	}
+
+	var e *AppProviderError
+
+	return errors.As(err, &e)
+}
+
+// AppProviderPreConditionError
+var _ models.GenericError = (*AppProviderPreConditionError)(nil)
+
+func NewAppProviderPreConditionError(appID AppID, condition string) *AppProviderPreConditionError {
+	return &AppProviderPreConditionError{
+		err: models.NewGenericPreConditionFailedError(
+			fmt.Errorf("app does not meet condition for %s: %s", appID.ID, condition),
+		),
+	}
+}
+
+type AppProviderPreConditionError struct {
+	err error
+}
+
+func (e AppProviderPreConditionError) Error() string {
+	return e.err.Error()
+}
+
+func (e AppProviderPreConditionError) Unwrap() error {
+	return e.err
+}
+
+func IsAppProviderPreConditionError(err error) bool {
+	if err == nil {
+		return false
+	}
+
+	var e *AppProviderPreConditionError
+
+	return errors.As(err, &e)
+}
+
+// AppCustomerPreConditionError
+func NewAppCustomerPreConditionError(appID AppID, appType AppType, customerID *customer.CustomerID, condition string) *AppCustomerPreConditionError {
+	var err error
+
+	if customerID == nil {
+		err = fmt.Errorf("customer does not meet condition for %s app type with id %s in namespace %s: %s", appType, appID.ID, appID.Namespace, condition)
+	} else {
+		err = fmt.Errorf("customer with id %s does not meet condition %s for %s app type with id %s in namespace %s", customerID.ID, condition, appType, appID.ID, appID.Namespace)
+	}
+
+	return &AppCustomerPreConditionError{
+		err: models.NewGenericPreConditionFailedError(err),
+	}
+}
+
+var _ models.GenericError = (*AppCustomerPreConditionError)(nil)
+
+type AppCustomerPreConditionError struct {
+	err error
+}
+
+func (e AppCustomerPreConditionError) Error() string {
+	return e.err.Error()
+}
+
+func (e AppCustomerPreConditionError) Unwrap() error {
+	return e.err
+}
+
+func IsAppCustomerPreConditionError(err error) bool {
+	if err == nil {
+		return false
+	}
+
+	var e *AppCustomerPreConditionError
+
+	return errors.As(err, &e)
+}

app/event.go

@@ -0,0 +1,214 @@
+package app
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"reflect"
+
+	"github.com/oklog/ulid/v2"
+
+	"github.com/openmeterio/openmeter/openmeter/event/metadata"
+	"github.com/openmeterio/openmeter/openmeter/session"
+)
+
+// EventAppParser should be implemented by the app's meta contents to be parsable from an EventApp
+type EventAppParser interface {
+	FromEventAppData(EventApp) error
+}
+
+type EventAppData map[string]any
+
+// NewEventAppData creates a new EventAppData from a given value
+// TODO[later]: we need to refactor apps to be able to handle serialization more gracefully, e.g. having a proper
+// union type for app instead of the interface
+func NewEventAppData(v any) (EventAppData, error) {
+	jsonBytes, err := json.Marshal(v)
+	if err != nil {
+		return nil, err
+	}
+
+	var data EventAppData
+	if err := json.Unmarshal(jsonBytes, &data); err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}
+
+// ParseInto parses the EventAppData into a given value, the value must be a pointer
+func (e EventAppData) ParseInto(v any) error {
+	if rv := reflect.ValueOf(v); rv.Kind() != reflect.Pointer || rv.IsNil() {
+		return fmt.Errorf("target must be a non-nil pointer")
+	}
+
+	jsonBytes, err := json.Marshal(e)
+	if err != nil {
+		return err
+	}
+
+	if err := json.Unmarshal(jsonBytes, v); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+type EventApp struct {
+	AppBase
+	AppData EventAppData `json:"appData"`
+}
+
+func NewEventApp(app App) (EventApp, error) {
+	appBase := app.GetAppBase()
+
+	appData, err := app.GetEventAppData()
+	if err != nil {
+		return EventApp{}, err
+	}
+
+	return EventApp{
+		AppBase: appBase,
+		AppData: appData,
+	}, nil
+}
+
+const (
+	AppEventSubsystem  metadata.EventSubsystem = "app"
+	AppCreateEventName metadata.EventName      = "app.created"
+	AppUpdateEventName metadata.EventName      = "app.updated"
+	AppDeleteEventName metadata.EventName      = "app.deleted"
+)
+
+// NewAppCreateEvent creates a new app create event
+// TODO[later]: We should use eventApp instead of AppBase, but the creation flow is somewhat tricky to change as the flow
+// is that the app calls the AppCreate without having the configuration presisted.
+func NewAppCreateEvent(ctx context.Context, appBase AppBase) AppCreateEvent {
+	return AppCreateEvent{
+		AppBase: appBase,
+		UserID:  session.GetSessionUserID(ctx),
+	}
+}
+
+// AppCreateEvent is an event that is emitted when an app is created
+type AppCreateEvent struct {
+	AppBase
+	UserID *string `json:"userId,omitempty"`
+}
+
+func (e AppCreateEvent) EventName() string {
+	return metadata.GetEventName(metadata.EventType{
+		Subsystem: AppEventSubsystem,
+		Name:      AppCreateEventName,
+		Version:   "v1",
+	})
+}
+
+func (e AppCreateEvent) EventMetadata() metadata.EventMetadata {
+	resourcePath := metadata.ComposeResourcePath(e.AppBase.Namespace, metadata.EntityApp, e.AppBase.ID)
+
+	return metadata.EventMetadata{
+		ID:      ulid.Make().String(),
+		Source:  resourcePath,
+		Subject: resourcePath,
+		Time:    e.AppBase.CreatedAt,
+	}
+}
+
+func (e AppCreateEvent) Validate() error {
+	if e.AppBase.ID == "" {
+		return fmt.Errorf("app base is required")
+	}
+	return nil
+}
+
+// NewAppUpdateEvent creates a new app update event
+func NewAppUpdateEvent(ctx context.Context, app App) (AppUpdateEvent, error) {
+	eventApp, err := NewEventApp(app)
+	if err != nil {
+		return AppUpdateEvent{}, err
+	}
+
+	return AppUpdateEvent{
+		EventApp: eventApp,
+		UserID:   session.GetSessionUserID(ctx),
+	}, nil
+}
+
+// AppUpdateEvent is an event that is emitted when an app is updated
+type AppUpdateEvent struct {
+	EventApp
+	UserID *string `json:"userId,omitempty"`
+}
+
+func (e AppUpdateEvent) EventName() string {
+	return metadata.GetEventName(metadata.EventType{
+		Subsystem: AppEventSubsystem,
+		Name:      AppUpdateEventName,
+		Version:   "v2",
+	})
+}
+
+func (e AppUpdateEvent) EventMetadata() metadata.EventMetadata {
+	appBase := e.AppBase.GetAppBase()
+	resourcePath := metadata.ComposeResourcePath(appBase.Namespace, metadata.EntityApp, appBase.ID)
+
+	return metadata.EventMetadata{
+		ID:      ulid.Make().String(),
+		Source:  resourcePath,
+		Subject: resourcePath,
+		Time:    appBase.UpdatedAt,
+	}
+}
+
+func (e AppUpdateEvent) Validate() error {
+	if e.AppBase.ID == "" {
+		return fmt.Errorf("app base is required")
+	}
+
+	return nil
+}
+
+// NewAppDeleteEvent creates a new app delete event
+func NewAppDeleteEvent(ctx context.Context, app AppBase, appData EventAppData) AppDeleteEvent {
+	return AppDeleteEvent{
+		EventApp: EventApp{
+			AppBase: app,
+			AppData: appData,
+		},
+		UserID: session.GetSessionUserID(ctx),
+	}
+}
+
+// AppDeleteEvent is an event that is emitted when an app is deleted
+type AppDeleteEvent struct {
+	EventApp
+	UserID *string `json:"userId,omitempty"`
+}
+
+func (e AppDeleteEvent) EventName() string {
+	return metadata.GetEventName(metadata.EventType{
+		Subsystem: AppEventSubsystem,
+		Name:      AppDeleteEventName,
+		Version:   "v2",
+	})
+}
+
+func (e AppDeleteEvent) EventMetadata() metadata.EventMetadata {
+	resourcePath := metadata.ComposeResourcePath(e.AppBase.Namespace, metadata.EntityApp, e.AppBase.ID)
+
+	return metadata.EventMetadata{
+		ID:      ulid.Make().String(),
+		Source:  resourcePath,
+		Subject: resourcePath,
+		Time:    *e.AppBase.DeletedAt,
+	}
+}
+
+func (e AppDeleteEvent) Validate() error {
+	if e.AppBase.ID == "" {
+		return fmt.Errorf("app base is required")
+	}
+
+	return nil
+}

app/events.go

@@ -0,0 +1,70 @@
+package app
+
+import (
+	"fmt"
+
+	"github.com/openmeterio/openmeter/openmeter/customer"
+	"github.com/openmeterio/openmeter/openmeter/event/metadata"
+	"github.com/openmeterio/openmeter/openmeter/watermill/marshaler"
+)
+
+const (
+	EventSubsystemAppCustomer = "app_customer"
+)
+
+type PaymentSetupAppData interface {
+	Validate() error
+}
+
+type CustomerPaymentSetupResult struct {
+	Metadata map[string]string `json:"metadata,omitempty"`
+	// Add additional fields here as needed. Keep in mind that this event is app neutral, so please create abstractions on top of app specific data if needed.
+	// The consumer can always query the specific app data. (If this does not cut it on the long run, we need to have per app event types, which is an overkill)
+}
+
+func (r CustomerPaymentSetupResult) Validate() error {
+	return nil
+}
+
+type CustomerPaymentSetupSucceededEvent struct {
+	App      AppBase                    `json:"app"`
+	Customer customer.CustomerID        `json:"customer"`
+	Result   CustomerPaymentSetupResult `json:"result"`
+}
+
+var (
+	_ marshaler.Event = CustomerPaymentSetupSucceededEvent{}
+
+	appCustomerDefaultPaymentMethodChangedEventName = metadata.GetEventName(metadata.EventType{
+		Subsystem: EventSubsystemAppCustomer,
+		Name:      "payment_setup_succeeded",
+		Version:   "v2",
+	})
+)
+
+func (e CustomerPaymentSetupSucceededEvent) Validate() error {
+	if err := e.App.Validate(); err != nil {
+		return fmt.Errorf("app: %w", err)
+	}
+
+	if err := e.Customer.Validate(); err != nil {
+		return fmt.Errorf("customer: %w", err)
+	}
+
+	if err := e.Result.Validate(); err != nil {
+		return fmt.Errorf("result: %w", err)
+	}
+
+	return nil
+}
+
+func (e CustomerPaymentSetupSucceededEvent) EventName() string {
+	return appCustomerDefaultPaymentMethodChangedEventName
+}
+
+func (e CustomerPaymentSetupSucceededEvent) EventMetadata() metadata.EventMetadata {
+	return metadata.EventMetadata{
+		Source:  metadata.ComposeResourcePath(e.App.Namespace, metadata.EntityApp, e.App.ID),
+		Subject: metadata.ComposeResourcePath(e.Customer.Namespace, metadata.EntityCustomer, e.Customer.ID),
+	}
+}

app/httpdriver/app.go

@@ -0,0 +1,261 @@
+package httpdriver
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+
+	"github.com/samber/lo"
+
+	"github.com/openmeterio/openmeter/api"
+	"github.com/openmeterio/openmeter/openmeter/app"
+	appcustominvoicing "github.com/openmeterio/openmeter/openmeter/app/custominvoicing"
+	appsandbox "github.com/openmeterio/openmeter/openmeter/app/sandbox"
+	appstripe "github.com/openmeterio/openmeter/openmeter/app/stripe"
+	"github.com/openmeterio/openmeter/pkg/framework/commonhttp"
+	"github.com/openmeterio/openmeter/pkg/framework/transport/httptransport"
+	"github.com/openmeterio/openmeter/pkg/models"
+	"github.com/openmeterio/openmeter/pkg/pagination"
+)
+
+// ListAppsHandler is a handler for listing apps
+type (
+	ListAppsRequest  = app.ListAppInput
+	ListAppsResponse = api.AppPaginatedResponse
+	ListAppsParams   = api.ListAppsParams
+	ListAppsHandler  httptransport.HandlerWithArgs[ListAppsRequest, ListAppsResponse, ListAppsParams]
+)
+
+// ListApps returns a handler for listing apps
+func (h *handler) ListApps() ListAppsHandler {
+	return httptransport.NewHandlerWithArgs(
+		func(ctx context.Context, r *http.Request, params ListAppsParams) (ListAppsRequest, error) {
+			// Resolve namespace
+			namespace, err := h.resolveNamespace(ctx)
+			if err != nil {
+				return ListAppsRequest{}, fmt.Errorf("failed to resolve namespace: %w", err)
+			}
+
+			return ListAppsRequest{
+				Namespace: namespace,
+				Page: pagination.Page{
+					PageSize:   lo.FromPtrOr(params.PageSize, app.DefaultPageSize),
+					PageNumber: lo.FromPtrOr(params.Page, app.DefaultPageNumber),
+				},
+			}, nil
+		},
+		func(ctx context.Context, request ListAppsRequest) (ListAppsResponse, error) {
+			result, err := h.service.ListApps(ctx, request)
+			if err != nil {
+				return ListAppsResponse{}, fmt.Errorf("failed to list apps: %w", err)
+			}
+
+			items := make([]api.App, 0, len(result.Items))
+			for _, item := range result.Items {
+				app, err := MapAppToAPI(item)
+				if err != nil {
+					return ListAppsResponse{}, fmt.Errorf("failed to map app to api: %w", err)
+				}
+
+				items = append(items, app)
+			}
+
+			return ListAppsResponse{
+				Page:       result.Page.PageNumber,
+				PageSize:   result.Page.PageSize,
+				TotalCount: result.TotalCount,
+				Items:      items,
+			}, nil
+		},
+		commonhttp.JSONResponseEncoderWithStatus[ListAppsResponse](http.StatusOK),
+		httptransport.AppendOptions(
+			h.options,
+			httptransport.WithOperationName("listApps"),
+		)...,
+	)
+}
+
+// GetAppHandler is a handler to get an app by id
+type (
+	GetAppRequest  = app.GetAppInput
+	GetAppResponse = api.App
+	GetAppHandler  httptransport.HandlerWithArgs[GetAppRequest, GetAppResponse, string]
+)
+
+// GetApp returns an app handler
+func (h *handler) GetApp() GetAppHandler {
+	return httptransport.NewHandlerWithArgs(
+		func(ctx context.Context, r *http.Request, appId string) (GetAppRequest, error) {
+			// Resolve namespace
+			namespace, err := h.resolveNamespace(ctx)
+			if err != nil {
+				return GetAppRequest{}, fmt.Errorf("failed to resolve namespace: %w", err)
+			}
+
+			return GetAppRequest{
+				Namespace: namespace,
+				ID:        appId,
+			}, nil
+		},
+		func(ctx context.Context, request GetAppRequest) (GetAppResponse, error) {
+			app, err := h.service.GetApp(ctx, request)
+			if err != nil {
+				return GetAppResponse{}, fmt.Errorf("failed to get app: %w", err)
+			}
+
+			return MapAppToAPI(app)
+		},
+		commonhttp.JSONResponseEncoderWithStatus[GetAppResponse](http.StatusOK),
+		httptransport.AppendOptions(
+			h.options,
+			httptransport.WithOperationName("getApp"),
+		)...,
+	)
+}
+
+// UpdateAppHandler is a handler to update an app
+type (
+	UpdateAppRequest  = app.UpdateAppInput
+	UpdateAppResponse = api.App
+	UpdateAppHandler  httptransport.HandlerWithArgs[UpdateAppRequest, UpdateAppResponse, string]
+)
+
+// UpdateApp returns an app handler
+func (h *handler) UpdateApp() UpdateAppHandler {
+	return httptransport.NewHandlerWithArgs(
+		func(ctx context.Context, r *http.Request, appId string) (UpdateAppRequest, error) {
+			// Resolve namespace
+			namespace, err := h.resolveNamespace(ctx)
+			if err != nil {
+				return UpdateAppRequest{}, fmt.Errorf("failed to resolve namespace: %w", err)
+			}
+
+			var body api.UpdateAppJSONRequestBody
+			if err := commonhttp.JSONRequestBodyDecoder(r, &body); err != nil {
+				return UpdateAppRequest{}, fmt.Errorf("field to decode upsert customer data request: %w", err)
+			}
+
+			updateType, err := body.Discriminator()
+			if err != nil {
+				return UpdateAppRequest{}, models.NewGenericValidationError(fmt.Errorf("failed to get update type: %w", err))
+			}
+
+			switch updateType {
+			case string(app.AppTypeStripe):
+				payload, err := body.AsStripeAppReplaceUpdate()
+				if err != nil {
+					return UpdateAppRequest{}, fmt.Errorf("failed to get stripe app replace update: %w", err)
+				}
+
+				return UpdateAppRequest{
+					AppID: app.AppID{
+						ID:        appId,
+						Namespace: namespace,
+					},
+					Name:        payload.Name,
+					Description: payload.Description,
+					Metadata:    payload.Metadata,
+					AppConfigUpdate: appstripe.Configuration{
+						SecretAPIKey: payload.SecretAPIKey,
+					},
+				}, nil
+
+			case string(app.AppTypeSandbox):
+				payload, err := body.AsSandboxAppReplaceUpdate()
+				if err != nil {
+					return UpdateAppRequest{}, fmt.Errorf("failed to get sandbox app replace update: %w", err)
+				}
+
+				return UpdateAppRequest{
+					AppID: app.AppID{
+						ID:        appId,
+						Namespace: namespace,
+					},
+					Name:            payload.Name,
+					Description:     payload.Description,
+					Metadata:        payload.Metadata,
+					AppConfigUpdate: appsandbox.Configuration{},
+				}, nil
+			case string(app.AppTypeCustomInvoicing):
+				payload, err := body.AsCustomInvoicingAppReplaceUpdate()
+				if err != nil {
+					return UpdateAppRequest{}, fmt.Errorf("failed to get custom invoicing app replace update: %w", err)
+				}
+
+				return UpdateAppRequest{
+					AppID: app.AppID{
+						ID:        appId,
+						Namespace: namespace,
+					},
+					Name:        payload.Name,
+					Description: payload.Description,
+					Metadata:    payload.Metadata,
+					AppConfigUpdate: appcustominvoicing.Configuration{
+						EnableDraftSyncHook:   payload.EnableDraftSyncHook,
+						EnableIssuingSyncHook: payload.EnableIssuingSyncHook,
+					},
+				}, nil
+			default:
+				return UpdateAppRequest{}, models.NewGenericValidationError(fmt.Errorf("invalid app type: %s", updateType))
+			}
+		},
+		func(ctx context.Context, request UpdateAppRequest) (UpdateAppResponse, error) {
+			app, err := h.service.UpdateApp(ctx, request)
+			if err != nil {
+				return UpdateAppResponse{}, fmt.Errorf("failed to update app: %w", err)
+			}
+
+			return MapAppToAPI(app)
+		},
+		commonhttp.JSONResponseEncoderWithStatus[UpdateAppResponse](http.StatusOK),
+		httptransport.AppendOptions(
+			h.options,
+			httptransport.WithOperationName("updateApp"),
+		)...,
+	)
+}
+
+// UninstallAppHandler is a handler to uninstalls an app by id
+type (
+	UninstallAppRequest  = app.UninstallAppInput
+	UninstallAppResponse = interface{}
+	UninstallAppHandler  httptransport.HandlerWithArgs[UninstallAppRequest, UninstallAppResponse, string]
+)
+
+// UninstallApp uninstalls an app
+func (h *handler) UninstallApp() UninstallAppHandler {
+	return httptransport.NewHandlerWithArgs(
+		func(ctx context.Context, r *http.Request, appId string) (UninstallAppRequest, error) {
+			// Resolve namespace
+			namespace, err := h.resolveNamespace(ctx)
+			if err != nil {
+				return UninstallAppRequest{}, fmt.Errorf("failed to resolve namespace: %w", err)
+			}
+
+			return UninstallAppRequest{
+				Namespace: namespace,
+				ID:        appId,
+			}, nil
+		},
+		func(ctx context.Context, request UninstallAppRequest) (UninstallAppResponse, error) {
+			// Check if the app is not used by any billing profile
+
+			if err := h.billingService.IsAppUsed(ctx, request); err != nil {
+				return nil, err
+			}
+
+			// Uninstall app
+			err := h.service.UninstallApp(ctx, request)
+			if err != nil {
+				return nil, fmt.Errorf("failed to uninstall app: %w", err)
+			}
+
+			return nil, nil
+		},
+		commonhttp.EmptyResponseEncoder[UninstallAppResponse](http.StatusNoContent),
+		httptransport.AppendOptions(
+			h.options,
+			httptransport.WithOperationName("uninstallApp"),
+		)...,
+	)
+}

app/httpdriver/customer.go

@@ -0,0 +1,421 @@
+package httpdriver
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+
+	"github.com/samber/lo"
+
+	"github.com/openmeterio/openmeter/api"
+	"github.com/openmeterio/openmeter/openmeter/app"
+	appcustominvoicing "github.com/openmeterio/openmeter/openmeter/app/custominvoicing"
+	appsandbox "github.com/openmeterio/openmeter/openmeter/app/sandbox"
+	appstripe "github.com/openmeterio/openmeter/openmeter/app/stripe"
+	"github.com/openmeterio/openmeter/openmeter/billing"
+	"github.com/openmeterio/openmeter/openmeter/customer"
+	"github.com/openmeterio/openmeter/pkg/framework/commonhttp"
+	"github.com/openmeterio/openmeter/pkg/framework/transport/httptransport"
+	"github.com/openmeterio/openmeter/pkg/models"
+	"github.com/openmeterio/openmeter/pkg/pagination"
+)
+
+type (
+	ListCustomerDataRequest  = app.ListCustomerInput
+	ListCustomerDataResponse = api.CustomerAppDataPaginatedResponse
+	ListCustomerDataHandler  httptransport.HandlerWithArgs[ListCustomerDataRequest, ListCustomerDataResponse, ListCustomerDataParams]
+)
+
+type ListCustomerDataParams struct {
+	api.ListCustomerAppDataParams
+	CustomerIdOrKey string
+}
+
+// ListCustomerData returns a handler for listing customers app data.
+func (h *handler) ListCustomerData() ListCustomerDataHandler {
+	return httptransport.NewHandlerWithArgs(
+		func(ctx context.Context, r *http.Request, params ListCustomerDataParams) (ListCustomerDataRequest, error) {
+			ns, err := h.resolveNamespace(ctx)
+			if err != nil {
+				return ListCustomerDataRequest{}, err
+			}
+
+			// Get the customer
+			cus, err := h.customerService.GetCustomer(ctx, customer.GetCustomerInput{
+				CustomerIDOrKey: &customer.CustomerIDOrKey{
+					IDOrKey:   params.CustomerIdOrKey,
+					Namespace: ns,
+				},
+			})
+			if err != nil {
+				return ListCustomerDataRequest{}, err
+			}
+
+			if cus != nil && cus.IsDeleted() {
+				return ListCustomerDataRequest{},
+					models.NewGenericPreConditionFailedError(
+						fmt.Errorf("customer is deleted [namespace=%s customer.id=%s]", cus.Namespace, cus.ID),
+					)
+			}
+
+			req := ListCustomerDataRequest{
+				CustomerID: cus.GetID(),
+
+				// Pagination
+				Page: pagination.Page{
+					PageSize:   lo.FromPtrOr(params.PageSize, customer.DefaultPageSize),
+					PageNumber: lo.FromPtrOr(params.Page, customer.DefaultPageNumber),
+				},
+			}
+
+			if params.Type != nil {
+				req.Type = lo.ToPtr(app.AppType(*params.Type))
+			}
+
+			return req, nil
+		},
+		func(ctx context.Context, request ListCustomerDataRequest) (ListCustomerDataResponse, error) {
+			resp, err := h.service.ListCustomerData(ctx, request)
+			if err != nil {
+				return ListCustomerDataResponse{}, fmt.Errorf("failed to list customers: %w", err)
+			}
+
+			items := make([]api.CustomerAppData, 0, len(resp.Items))
+
+			for _, customerApp := range resp.Items {
+				item, err := h.toAPICustomerAppData(customerApp)
+				if err != nil {
+					return ListCustomerDataResponse{}, fmt.Errorf("failed to cast app customer data: %w", err)
+				}
+
+				items = append(items, item)
+			}
+
+			return ListCustomerDataResponse{
+				Items:      items,
+				Page:       resp.Page.PageNumber,
+				PageSize:   resp.Page.PageSize,
+				TotalCount: resp.TotalCount,
+			}, nil
+		},
+		commonhttp.JSONResponseEncoderWithStatus[ListCustomerDataResponse](http.StatusOK),
+		httptransport.AppendOptions(
+			h.options,
+			httptransport.WithOperationName("listCustomerData"),
+		)...,
+	)
+}
+
+type UpsertCustomerDataRequest struct {
+	CustomerId customer.CustomerID
+	Data       []api.CustomerAppData
+}
+
+type UpsertCustomerDataParams struct {
+	CustomerIdOrKey string
+}
+
+type (
+	UpsertCustomerDataResponse = interface{}
+	UpsertCustomerDataHandler  httptransport.HandlerWithArgs[UpsertCustomerDataRequest, UpsertCustomerDataResponse, UpsertCustomerDataParams]
+)
+
+// UpsertCustomerData returns a new httptransport.Handler for creating a customer.
+func (h *handler) UpsertCustomerData() UpsertCustomerDataHandler {
+	return httptransport.NewHandlerWithArgs(
+		func(ctx context.Context, r *http.Request, params UpsertCustomerDataParams) (UpsertCustomerDataRequest, error) {
+			ns, err := h.resolveNamespace(ctx)
+			if err != nil {
+				return UpsertCustomerDataRequest{}, err
+			}
+
+			// Get the customer and ensure we do not update customer data if the customer is already deleted
+			cus, err := h.customerService.GetCustomer(ctx, customer.GetCustomerInput{
+				CustomerIDOrKey: &customer.CustomerIDOrKey{
+					IDOrKey:   params.CustomerIdOrKey,
+					Namespace: ns,
+				},
+			})
+			if err != nil {
+				return UpsertCustomerDataRequest{}, err
+			}
+
+			if cus != nil && cus.IsDeleted() {
+				return UpsertCustomerDataRequest{},
+					models.NewGenericPreConditionFailedError(
+						fmt.Errorf("customer is deleted [namespace=%s customer.id=%s]", cus.Namespace, cus.ID),
+					)
+			}
+
+			var body []api.CustomerAppData
+
+			if err := commonhttp.JSONRequestBodyDecoder(r, &body); err != nil {
+				return UpsertCustomerDataRequest{},
+					fmt.Errorf("field to decode upsert customer data request: %w", err)
+			}
+
+			return UpsertCustomerDataRequest{
+				CustomerId: cus.GetID(),
+				Data:       body,
+			}, nil
+		},
+		func(ctx context.Context, req UpsertCustomerDataRequest) (UpsertCustomerDataResponse, error) {
+			for _, apiCustomerData := range req.Data {
+				customerApp, customerData, err := h.toCustomerData(ctx, req.CustomerId, apiCustomerData)
+				if err != nil {
+					return nil, err
+				}
+
+				err = customerApp.UpsertCustomerData(ctx, app.UpsertAppInstanceCustomerDataInput{
+					CustomerID: req.CustomerId,
+					Data:       customerData,
+				})
+				if err != nil {
+					return nil, err
+				}
+			}
+
+			return nil, nil
+		},
+		commonhttp.EmptyResponseEncoder[UpsertCustomerDataResponse](http.StatusOK),
+		httptransport.AppendOptions(
+			h.options,
+			httptransport.WithOperationName("upsertCustomerData"),
+		)...,
+	)
+}
+
+type DeleteCustomerDataParams struct {
+	CustomerIdOrKey string
+	AppId           string
+}
+
+type DeleteCustomerDataRequest struct {
+	AppID      app.AppID
+	CustomerID customer.CustomerID
+}
+
+type (
+	DeleteCustomerDataResponse = interface{}
+	DeleteCustomerDataHandler  httptransport.HandlerWithArgs[DeleteCustomerDataRequest, DeleteCustomerDataResponse, DeleteCustomerDataParams]
+)
+
+// DeleteCustomerData returns a handler for deleting a customer data.
+func (h *handler) DeleteCustomerData() DeleteCustomerDataHandler {
+	return httptransport.NewHandlerWithArgs(
+		func(ctx context.Context, r *http.Request, params DeleteCustomerDataParams) (DeleteCustomerDataRequest, error) {
+			ns, err := h.resolveNamespace(ctx)
+			if err != nil {
+				return DeleteCustomerDataRequest{}, err
+			}
+
+			// Get the customer
+			cus, err := h.customerService.GetCustomer(ctx, customer.GetCustomerInput{
+				CustomerIDOrKey: &customer.CustomerIDOrKey{
+					IDOrKey:   params.CustomerIdOrKey,
+					Namespace: ns,
+				},
+			})
+			if err != nil {
+				return DeleteCustomerDataRequest{}, err
+			}
+
+			if cus != nil && cus.IsDeleted() {
+				return DeleteCustomerDataRequest{},
+					models.NewGenericPreConditionFailedError(
+						fmt.Errorf("customer is deleted [namespace=%s customer.id=%s]", cus.Namespace, cus.ID),
+					)
+			}
+
+			return DeleteCustomerDataRequest{
+				CustomerID: cus.GetID(),
+				AppID: app.AppID{
+					Namespace: ns,
+					ID:        params.AppId,
+				},
+			}, nil
+		},
+		func(ctx context.Context, request DeleteCustomerDataRequest) (DeleteCustomerDataResponse, error) {
+			// Get app
+			existingApp, err := h.service.GetApp(ctx, request.AppID)
+			if err != nil {
+				return nil, err
+			}
+
+			// Delete customer data
+			err = existingApp.DeleteCustomerData(ctx, app.DeleteAppInstanceCustomerDataInput{
+				CustomerID: request.CustomerID,
+			})
+			if err != nil {
+				return nil, err
+			}
+
+			return nil, nil
+		},
+		commonhttp.EmptyResponseEncoder[DeleteCustomerDataResponse](http.StatusNoContent),
+		httptransport.AppendOptions(
+			h.options,
+			httptransport.WithOperationName("deleteCustomerData"),
+		)...,
+	)
+}
+
+// toCustomerData converts an API CustomerAppData to a CustomerData model
+func (h *handler) toCustomerData(ctx context.Context, customerID customer.CustomerID, apiApp api.CustomerAppData) (app.App, app.CustomerData, error) {
+	// Get app type
+	appType, err := apiApp.Discriminator()
+	if err != nil {
+		return nil, nil, fmt.Errorf("error getting app type: %w", err)
+	}
+
+	switch appType {
+	// Sandbox app
+	case string(app.AppTypeSandbox):
+		// Parse as sandbox app
+		apiSandboxCustomerData, err := apiApp.AsSandboxCustomerAppData()
+		if err != nil {
+			return nil, nil, fmt.Errorf("error converting to stripe app: %w", err)
+		}
+
+		// Resolve app
+		resolvedApp, err := h.resolveCustomerApp(ctx, customerID, app.AppTypeSandbox, apiSandboxCustomerData.Id)
+		if err != nil {
+			return nil, nil, fmt.Errorf("error resolving sandbox app: %w", err)
+		}
+
+		// Create customer data
+		sandboxCustomerData := appsandbox.CustomerData{}
+
+		return resolvedApp, sandboxCustomerData, nil
+
+	// Stripe app
+	case string(app.AppTypeStripe):
+		// Parse as stripe app
+		apiStripeCustomerData, err := apiApp.AsStripeCustomerAppData()
+		if err != nil {
+			return nil, nil, fmt.Errorf("error converting to stripe app: %w", err)
+		}
+
+		// Resolve app
+		resolvedApp, err := h.resolveCustomerApp(ctx, customerID, app.AppTypeStripe, apiStripeCustomerData.Id)
+		if err != nil {
+			return nil, nil, fmt.Errorf("error resolving stripe app: %w", err)
+		}
+
+		// Create customer data
+		stripeCustomerData := fromAPIAppStripeCustomerData(apiStripeCustomerData)
+
+		return resolvedApp, stripeCustomerData, nil
+	case string(app.AppTypeCustomInvoicing):
+		// Parse as custom invoicing app
+		apiCustomInvoicingCustomerData, err := apiApp.AsCustomInvoicingCustomerAppData()
+		if err != nil {
+			return nil, nil, fmt.Errorf("error converting to custom invoicing app: %w", err)
+		}
+
+		// Resolve app
+		resolvedApp, err := h.resolveCustomerApp(ctx, customerID, app.AppTypeCustomInvoicing, apiCustomInvoicingCustomerData.Id)
+		if err != nil {
+			return nil, nil, fmt.Errorf("error resolving custom invoicing app: %w", err)
+		}
+
+		// Create customer data
+		customInvoicingCustomerData := appcustominvoicing.CustomerData{
+			Metadata: lo.FromPtrOr(apiCustomInvoicingCustomerData.Metadata, map[string]string{}),
+		}
+
+		return resolvedApp, customInvoicingCustomerData, nil
+	}
+
+	return nil, nil, fmt.Errorf("unsupported app type: %s", appType)
+}
+
+// resolveCustomerApp resolves a customer app based on the app type or app ID.
+func (h *handler) resolveCustomerApp(ctx context.Context, customerID customer.CustomerID, appType app.AppType, appID *string) (app.App, error) {
+	var resolvedApp app.App
+	var err error
+
+	// Get app ID from API data or get default app for billing profile
+	if appID != nil {
+		return h.service.GetApp(ctx, app.GetAppInput{
+			Namespace: customerID.Namespace,
+			ID:        *appID,
+		})
+	}
+
+	// Get the customer app by type
+	resolvedApp, err = h.billingService.GetCustomerApp(ctx, billing.GetCustomerAppInput{
+		CustomerID: customerID,
+		AppType:    appType,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("error getting customer app: %w", err)
+	}
+
+	return resolvedApp, nil
+}
+
+// toAPICustomerAppData converts a CustomerApp to an API CustomerAppData
+func (h *handler) toAPICustomerAppData(a app.CustomerApp) (api.CustomerAppData, error) {
+	apiCustomerAppData := api.CustomerAppData{}
+	appId := a.App.GetID().ID
+
+	switch customerAppData := a.CustomerData.(type) {
+	case appstripe.CustomerData:
+		stripeApp, ok := a.App.(appstripe.App)
+		if !ok {
+			return apiCustomerAppData, fmt.Errorf("error casting app to stripe app")
+		}
+
+		// Convert to API stripe customer app data
+		apiStripeCustomerAppData := ToAPIStripeCustomerAppData(customerAppData, stripeApp)
+
+		// Convert to API customer app data
+		err := apiCustomerAppData.FromStripeCustomerAppData(apiStripeCustomerAppData)
+		if err != nil {
+			return apiCustomerAppData, fmt.Errorf("error converting to stripe customer app: %w", err)
+		}
+
+	case appsandbox.CustomerData:
+		sandboxApp, ok := a.App.(appsandbox.App)
+		if !ok {
+			return apiCustomerAppData, fmt.Errorf("error casting app to sandbox app")
+		}
+
+		apiApp := mapSandboxAppToAPI(sandboxApp.Meta)
+
+		apiSandboxCustomerAppData := api.SandboxCustomerAppData{
+			Id:   &appId,
+			Type: api.SandboxCustomerAppDataTypeSandbox,
+			App:  &apiApp,
+		}
+
+		err := apiCustomerAppData.FromSandboxCustomerAppData(apiSandboxCustomerAppData)
+		if err != nil {
+			return apiCustomerAppData, fmt.Errorf("error converting to sandbox customer app: %w", err)
+		}
+
+	case appcustominvoicing.CustomerData:
+		customInvoicingApp, ok := a.App.(appcustominvoicing.App)
+		if !ok {
+			return apiCustomerAppData, fmt.Errorf("error casting app to custom invoicing app")
+		}
+
+		apiApp := mapCustomInvoicingAppToAPI(customInvoicingApp.Meta)
+
+		apiCustomInvoicingCustomerAppData := api.CustomInvoicingCustomerAppData{
+			Id:   &appId,
+			Type: api.CustomInvoicingCustomerAppDataTypeCustomInvoicing,
+			App:  &apiApp,
+		}
+
+		err := apiCustomerAppData.FromCustomInvoicingCustomerAppData(apiCustomInvoicingCustomerAppData)
+		if err != nil {
+			return apiCustomerAppData, fmt.Errorf("error converting to custom invoicing customer app: %w", err)
+		}
+	default:
+		return apiCustomerAppData, fmt.Errorf("unsupported customer data for app: %s", appId)
+	}
+
+	return apiCustomerAppData, nil
+}

app/httpdriver/handler.go

@@ -0,0 +1,80 @@
+package httpdriver
+
+import (
+	"context"
+	"errors"
+	"log/slog"
+	"net/http"
+
+	"github.com/openmeterio/openmeter/openmeter/app"
+	stripeapp "github.com/openmeterio/openmeter/openmeter/app/stripe"
+	"github.com/openmeterio/openmeter/openmeter/billing"
+	"github.com/openmeterio/openmeter/openmeter/customer"
+	"github.com/openmeterio/openmeter/openmeter/namespace/namespacedriver"
+	"github.com/openmeterio/openmeter/pkg/framework/commonhttp"
+	"github.com/openmeterio/openmeter/pkg/framework/transport/httptransport"
+)
+
+type Handler interface {
+	AppHandler
+}
+
+type AppHandler interface {
+	// App handlers
+	ListApps() ListAppsHandler
+	GetApp() GetAppHandler
+	UninstallApp() UninstallAppHandler
+	UpdateApp() UpdateAppHandler
+
+	// Customer Data handlers
+	ListCustomerData() ListCustomerDataHandler
+	UpsertCustomerData() UpsertCustomerDataHandler
+	DeleteCustomerData() DeleteCustomerDataHandler
+
+	// Marketplace handlers
+	ListMarketplaceListings() ListMarketplaceListingsHandler
+	GetMarketplaceListing() GetMarketplaceListingHandler
+	MarketplaceAppAPIKeyInstall() MarketplaceAppAPIKeyInstallHandler
+	MarketplaceAppInstall() MarketplaceAppInstallHandler
+}
+
+var _ Handler = (*handler)(nil)
+
+type handler struct {
+	service app.Service
+
+	stripeAppService stripeapp.Service
+	billingService   billing.Service
+	customerService  customer.Service
+	namespaceDecoder namespacedriver.NamespaceDecoder
+	options          []httptransport.HandlerOption
+}
+
+func (h *handler) resolveNamespace(ctx context.Context) (string, error) {
+	ns, ok := h.namespaceDecoder.GetNamespace(ctx)
+	if !ok {
+		return "", commonhttp.NewHTTPError(http.StatusInternalServerError, errors.New("internal server error"))
+	}
+
+	return ns, nil
+}
+
+func New(
+	logger *slog.Logger,
+	namespaceDecoder namespacedriver.NamespaceDecoder,
+	appService app.Service,
+	appStripeService stripeapp.Service,
+	billingService billing.Service,
+	customerService customer.Service,
+
+	options ...httptransport.HandlerOption,
+) Handler {
+	return &handler{
+		service:          appService,
+		namespaceDecoder: namespaceDecoder,
+		stripeAppService: appStripeService,
+		billingService:   billingService,
+		customerService:  customerService,
+		options:          options,
+	}
+}

app/httpdriver/mapper.go

@@ -0,0 +1,177 @@
+package httpdriver
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/samber/lo"
+
+	"github.com/openmeterio/openmeter/api"
+	"github.com/openmeterio/openmeter/openmeter/app"
+	appcustominvoicing "github.com/openmeterio/openmeter/openmeter/app/custominvoicing"
+	appsandbox "github.com/openmeterio/openmeter/openmeter/app/sandbox"
+	appstripe "github.com/openmeterio/openmeter/openmeter/app/stripe"
+)
+
+// MapAppToAPI maps an app to an API app
+func MapAppToAPI(item app.App) (api.App, error) {
+	if item == nil {
+		return api.App{}, errors.New("invalid app: nil")
+	}
+
+	switch item.GetType() {
+	case app.AppTypeStripe:
+		stripeApp := item.(appstripe.App)
+
+		app := api.App{}
+		if err := app.FromStripeApp(mapStripeAppToAPI(stripeApp.Meta)); err != nil {
+			return app, err
+		}
+
+		return app, nil
+	case app.AppTypeSandbox:
+		sandboxApp := item.(appsandbox.App)
+
+		app := api.App{}
+		if err := app.FromSandboxApp(mapSandboxAppToAPI(sandboxApp.Meta)); err != nil {
+			return app, err
+		}
+
+		return app, nil
+	case app.AppTypeCustomInvoicing:
+		customInvoicingApp := item.(appcustominvoicing.App)
+
+		app := api.App{}
+		if err := app.FromCustomInvoicingApp(mapCustomInvoicingAppToAPI(customInvoicingApp.Meta)); err != nil {
+			return app, err
+		}
+
+		return app, nil
+	default:
+		return api.App{}, fmt.Errorf("unsupported app type: %s", item.GetType())
+	}
+}
+
+func mapSandboxAppToAPI(app appsandbox.Meta) api.SandboxApp {
+	return api.SandboxApp{
+		Id:        app.GetID().ID,
+		Type:      api.SandboxAppTypeSandbox,
+		Name:      app.GetName(),
+		Status:    api.AppStatus(app.GetStatus()),
+		Listing:   mapMarketplaceListing(app.GetListing()),
+		CreatedAt: app.CreatedAt,
+		UpdatedAt: app.UpdatedAt,
+		DeletedAt: app.DeletedAt,
+	}
+}
+
+func mapStripeAppToAPI(
+	stripeApp appstripe.Meta,
+) api.StripeApp {
+	apiStripeApp := api.StripeApp{
+		Id:              stripeApp.GetID().ID,
+		Type:            api.StripeAppType(stripeApp.GetType()),
+		Name:            stripeApp.Name,
+		Status:          api.AppStatus(stripeApp.GetStatus()),
+		Listing:         mapMarketplaceListing(stripeApp.GetListing()),
+		MaskedAPIKey:    stripeApp.MaskedAPIKey,
+		CreatedAt:       stripeApp.CreatedAt,
+		UpdatedAt:       stripeApp.UpdatedAt,
+		DeletedAt:       stripeApp.DeletedAt,
+		StripeAccountId: stripeApp.StripeAccountID,
+		Livemode:        stripeApp.Livemode,
+	}
+
+	apiStripeApp.Description = stripeApp.GetDescription()
+
+	if stripeApp.GetMetadata() != nil {
+		apiStripeApp.Metadata = lo.ToPtr(api.Metadata(stripeApp.GetMetadata()))
+	}
+
+	return apiStripeApp
+}
+
+func mapCustomInvoicingAppToAPI(app appcustominvoicing.Meta) api.CustomInvoicingApp {
+	return api.CustomInvoicingApp{
+		Id:          app.GetID().ID,
+		Type:        api.CustomInvoicingAppTypeCustomInvoicing,
+		Name:        app.GetName(),
+		Status:      api.AppStatus(app.GetStatus()),
+		Listing:     mapMarketplaceListing(app.GetListing()),
+		Metadata:    lo.EmptyableToPtr(api.Metadata(app.GetMetadata())),
+		Description: app.GetDescription(),
+		CreatedAt:   app.CreatedAt,
+		UpdatedAt:   app.UpdatedAt,
+		DeletedAt:   app.DeletedAt,
+
+		EnableDraftSyncHook:   app.Configuration.EnableDraftSyncHook,
+		EnableIssuingSyncHook: app.Configuration.EnableIssuingSyncHook,
+	}
+}
+
+func MapEventAppToAPI(event app.EventApp) (api.App, error) {
+	switch event.GetType() {
+	case app.AppTypeStripe:
+		target := appstripe.App{}
+		if err := target.FromEventAppData(event); err != nil {
+			return api.App{}, err
+		}
+
+		app := api.App{}
+		if err := app.FromStripeApp(mapStripeAppToAPI(target.Meta)); err != nil {
+			return api.App{}, err
+		}
+
+		return app, nil
+	case app.AppTypeSandbox:
+		target := appsandbox.Meta{}
+		if err := target.FromEventAppData(event); err != nil {
+			return api.App{}, err
+		}
+
+		app := api.App{}
+		if err := app.FromSandboxApp(mapSandboxAppToAPI(target)); err != nil {
+			return api.App{}, err
+		}
+
+		return app, nil
+	case app.AppTypeCustomInvoicing:
+		target := appcustominvoicing.App{}
+		if err := target.FromEventAppData(event); err != nil {
+			return api.App{}, err
+		}
+
+		app := api.App{}
+		if err := app.FromCustomInvoicingApp(mapCustomInvoicingAppToAPI(target.Meta)); err != nil {
+			return api.App{}, err
+		}
+
+		return app, nil
+	default:
+		return api.App{}, fmt.Errorf("unsupported app type: %s", event.GetType())
+	}
+}
+
+// fromAPIAppStripeCustomerData maps an API stripe customer data to an app stripe customer data
+func fromAPIAppStripeCustomerData(apiStripeCustomerData api.StripeCustomerAppData) appstripe.CustomerData {
+	return appstripe.CustomerData{
+		StripeCustomerID:             apiStripeCustomerData.StripeCustomerId,
+		StripeDefaultPaymentMethodID: apiStripeCustomerData.StripeDefaultPaymentMethodId,
+	}
+}
+
+// customerAppToAPI converts a CustomerApp to an API CustomerAppData
+func ToAPIStripeCustomerAppData(
+	customerAppData appstripe.CustomerData,
+	stripeApp appstripe.App,
+) api.StripeCustomerAppData {
+	apiStripeCustomerAppData := api.StripeCustomerAppData{
+		Id:                           lo.ToPtr(stripeApp.GetID().ID),
+		Type:                         api.StripeCustomerAppDataTypeStripe,
+		App:                          lo.ToPtr(mapStripeAppToAPI(stripeApp.Meta)),
+		StripeCustomerId:             customerAppData.StripeCustomerID,
+		StripeDefaultPaymentMethodId: customerAppData.StripeDefaultPaymentMethodID,
+	}
+
+	return apiStripeCustomerAppData
+}

app/httpdriver/marketplace.go

@@ -0,0 +1,245 @@
+package httpdriver
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+
+	"github.com/samber/lo"
+
+	"github.com/openmeterio/openmeter/api"
+	"github.com/openmeterio/openmeter/openmeter/app"
+	"github.com/openmeterio/openmeter/pkg/framework/commonhttp"
+	"github.com/openmeterio/openmeter/pkg/framework/transport/httptransport"
+	"github.com/openmeterio/openmeter/pkg/pagination"
+)
+
+// ListMarketplaceListingsHandler is a handler for listing marketplace listings
+type (
+	ListMarketplaceListingsRequest  = app.MarketplaceListInput
+	ListMarketplaceListingsResponse = api.MarketplaceListingPaginatedResponse
+	ListMarketplaceListingsParams   = api.ListMarketplaceListingsParams
+	ListMarketplaceListingsHandler  httptransport.HandlerWithArgs[ListMarketplaceListingsRequest, ListMarketplaceListingsResponse, ListMarketplaceListingsParams]
+)
+
+// ListMarketplaceListings returns a handler for listing marketplace listings
+func (h *handler) ListMarketplaceListings() ListMarketplaceListingsHandler {
+	return httptransport.NewHandlerWithArgs(
+		func(ctx context.Context, r *http.Request, params ListMarketplaceListingsParams) (ListMarketplaceListingsRequest, error) {
+			return ListMarketplaceListingsRequest{
+				Page: pagination.Page{
+					PageSize:   lo.FromPtrOr(params.PageSize, app.DefaultPageSize),
+					PageNumber: lo.FromPtrOr(params.Page, app.DefaultPageNumber),
+				},
+			}, nil
+		},
+		func(ctx context.Context, request ListMarketplaceListingsRequest) (ListMarketplaceListingsResponse, error) {
+			result, err := h.service.ListMarketplaceListings(ctx, request)
+			if err != nil {
+				return ListMarketplaceListingsResponse{}, fmt.Errorf("failed to list marketplace listings: %w", err)
+			}
+
+			return ListMarketplaceListingsResponse{
+				Page:       result.Page.PageNumber,
+				PageSize:   result.Page.PageSize,
+				TotalCount: result.TotalCount,
+				Items: lo.Map(result.Items, func(item app.RegistryItem, _ int) api.MarketplaceListing {
+					return mapMarketplaceListing(item.Listing)
+				}),
+			}, nil
+		},
+		commonhttp.JSONResponseEncoderWithStatus[ListMarketplaceListingsResponse](http.StatusOK),
+		httptransport.AppendOptions(
+			h.options,
+			httptransport.WithOperationName("listMarketplaceListings"),
+		)...,
+	)
+}
+
+// GetMarketplaceListingHandler is a handler to get a marketplace listing
+type (
+	GetMarketplaceListingRequest  = app.MarketplaceGetInput
+	GetMarketplaceListingResponse = api.MarketplaceListing
+	GetMarketplaceListingHandler  httptransport.HandlerWithArgs[GetMarketplaceListingRequest, GetMarketplaceListingResponse, api.AppType]
+)
+
+// GetMarketplaceListing returns a handler for listing marketplace listings
+func (h *handler) GetMarketplaceListing() GetMarketplaceListingHandler {
+	return httptransport.NewHandlerWithArgs(
+		func(ctx context.Context, r *http.Request, appType api.AppType) (GetMarketplaceListingRequest, error) {
+			return GetMarketplaceListingRequest{
+				Type: app.AppType(appType),
+			}, nil
+		},
+		func(ctx context.Context, request GetMarketplaceListingRequest) (GetMarketplaceListingResponse, error) {
+			result, err := h.service.GetMarketplaceListing(ctx, request)
+			if err != nil {
+				return GetMarketplaceListingResponse{}, fmt.Errorf("failed to get marketplace listing: %w", err)
+			}
+
+			return mapMarketplaceListing(result.Listing), nil
+		},
+		commonhttp.JSONResponseEncoderWithStatus[GetMarketplaceListingResponse](http.StatusOK),
+		httptransport.AppendOptions(
+			h.options,
+			httptransport.WithOperationName("getMarketplaceListing"),
+		)...,
+	)
+}
+
+type (
+	MarketplaceAppAPIKeyInstallResponse = api.MarketplaceInstallResponse
+	MarketplaceAppAPIKeyInstallHandler  httptransport.HandlerWithArgs[MarketplaceAppAPIKeyInstallRequest, MarketplaceAppAPIKeyInstallResponse, api.AppType]
+)
+
+type MarketplaceAppAPIKeyInstallRequest struct {
+	app.InstallAppV3Input
+	CreateBillingProfile bool
+}
+
+// MarketplaceAppAPIKeyInstall returns a handler for installing an app type with an API key
+func (h *handler) MarketplaceAppAPIKeyInstall() MarketplaceAppAPIKeyInstallHandler {
+	return httptransport.NewHandlerWithArgs(
+		func(ctx context.Context, r *http.Request, appType api.AppType) (MarketplaceAppAPIKeyInstallRequest, error) {
+			body := api.MarketplaceAppAPIKeyInstallJSONBody{}
+			if err := commonhttp.JSONRequestBodyDecoder(r, &body); err != nil {
+				return MarketplaceAppAPIKeyInstallRequest{}, fmt.Errorf("field to decode marketplace app install request: %w", err)
+			}
+
+			// Resolve namespace
+			namespace, err := h.resolveNamespace(ctx)
+			if err != nil {
+				return MarketplaceAppAPIKeyInstallRequest{}, fmt.Errorf("failed to resolve namespace: %w", err)
+			}
+
+			req := MarketplaceAppAPIKeyInstallRequest{
+				InstallAppV3Input: app.InstallAppV3Input{
+					MarketplaceListingID: app.MarketplaceListingID{Type: app.AppType(appType)},
+					Namespace:            namespace,
+					Name:                 lo.FromPtr(body.Name),
+					APIKey:               lo.ToPtr(body.ApiKey),
+				},
+				CreateBillingProfile: lo.FromPtrOr(body.CreateBillingProfile, true),
+			}
+
+			return req, nil
+		},
+		func(ctx context.Context, request MarketplaceAppAPIKeyInstallRequest) (MarketplaceAppAPIKeyInstallResponse, error) {
+			resp := MarketplaceAppAPIKeyInstallResponse{
+				DefaultForCapabilityTypes: []api.AppCapabilityType{},
+			}
+
+			// Install app
+			installedApp, err := h.service.InstallApp(ctx, request.InstallAppV3Input)
+			if err != nil {
+				return resp, err
+			}
+
+			// Map app to API
+			apiApp, err := MapAppToAPI(installedApp.App)
+			if err != nil {
+				return resp, fmt.Errorf("failed to map app to API: %w", err)
+			}
+
+			resp.App = apiApp
+			resp.DefaultForCapabilityTypes = lo.Map(installedApp.DefaultCapabilies, func(c app.CapabilityType, _ int) api.AppCapabilityType {
+				return api.AppCapabilityType(c)
+			})
+
+			return resp, nil
+		},
+		commonhttp.JSONResponseEncoderWithStatus[MarketplaceAppAPIKeyInstallResponse](http.StatusOK),
+		httptransport.AppendOptions(
+			h.options,
+			httptransport.WithOperationName("marketplaceAppAPIKeyInstall"),
+		)...,
+	)
+}
+
+type (
+	MarketplaceAppInstallResponse = api.MarketplaceInstallResponse
+	MarketplaceAppInstallHandler  httptransport.HandlerWithArgs[MarketplaceAppInstallRequest, MarketplaceAppInstallResponse, api.AppType]
+)
+
+type MarketplaceAppInstallRequest struct {
+	app.InstallAppV3Input
+	CreateBillingProfile bool
+}
+
+// MarketplaceAppInstall returns a handler for installing an app type
+func (h *handler) MarketplaceAppInstall() MarketplaceAppInstallHandler {
+	return httptransport.NewHandlerWithArgs(
+		func(ctx context.Context, r *http.Request, appType api.AppType) (MarketplaceAppInstallRequest, error) {
+			body := api.MarketplaceInstallRequestPayload{}
+			if err := commonhttp.JSONRequestBodyDecoder(r, &body); err != nil {
+				return MarketplaceAppInstallRequest{}, fmt.Errorf("field to decode marketplace app install request: %w", err)
+			}
+
+			// Resolve namespace
+			namespace, err := h.resolveNamespace(ctx)
+			if err != nil {
+				return MarketplaceAppInstallRequest{}, fmt.Errorf("failed to resolve namespace: %w", err)
+			}
+
+			req := MarketplaceAppInstallRequest{
+				InstallAppV3Input: app.InstallAppV3Input{
+					MarketplaceListingID: app.MarketplaceListingID{Type: app.AppType(appType)},
+					Namespace:            namespace,
+					Name:                 lo.FromPtr(body.Name),
+				},
+				CreateBillingProfile: lo.FromPtrOr(body.CreateBillingProfile, true),
+			}
+
+			return req, nil
+		},
+		func(ctx context.Context, request MarketplaceAppInstallRequest) (MarketplaceAppInstallResponse, error) {
+			resp := MarketplaceAppInstallResponse{
+				DefaultForCapabilityTypes: []api.AppCapabilityType{},
+			}
+
+			// Install app
+			installedApp, err := h.service.InstallApp(ctx, request.InstallAppV3Input)
+			if err != nil {
+				return resp, err
+			}
+
+			// Map app to API
+			apiApp, err := MapAppToAPI(installedApp.App)
+			if err != nil {
+				return resp, fmt.Errorf("failed to map app to API: %w", err)
+			}
+
+			resp.App = apiApp
+			resp.DefaultForCapabilityTypes = lo.Map(installedApp.DefaultCapabilies, func(c app.CapabilityType, _ int) api.AppCapabilityType {
+				return api.AppCapabilityType(c)
+			})
+
+			return resp, nil
+		},
+		commonhttp.JSONResponseEncoderWithStatus[MarketplaceAppInstallResponse](http.StatusOK),
+		httptransport.AppendOptions(
+			h.options,
+			httptransport.WithOperationName("marketplaceAppInstall"),
+		)...,
+	)
+}
+
+// Map marketplace listing to API
+func mapMarketplaceListing(listing app.MarketplaceListing) api.MarketplaceListing {
+	return api.MarketplaceListing{
+		Type:        api.AppType(listing.Type),
+		Name:        listing.Name,
+		Description: listing.Description,
+		Capabilities: lo.Map(listing.Capabilities, func(v app.Capability, _ int) api.AppCapability {
+			return api.AppCapability{
+				Type:        api.AppCapabilityType(v.Type),
+				Key:         v.Key,
+				Name:        v.Name,
+				Description: v.Description,
+			}
+		}),
+		InstallMethods: lo.Map(listing.InstallMethods, func(v app.InstallMethod, _ int) api.InstallMethod {
+			return api.InstallMethod(v)
+		}),
+	}
+}

app/input.go

@@ -0,0 +1,91 @@
+package app
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/openmeterio/openmeter/openmeter/customer"
+	"github.com/openmeterio/openmeter/pkg/models"
+	"github.com/openmeterio/openmeter/pkg/pagination"
+)
+
+type ListCustomerInput struct {
+	pagination.Page
+	AppID      *AppID
+	CustomerID customer.CustomerID
+	Type       *AppType
+}
+
+func (a ListCustomerInput) Validate() error {
+	var errs []error
+
+	if err := a.CustomerID.Validate(); err != nil {
+		errs = append(errs, err)
+	}
+
+	if a.AppID != nil {
+		if err := a.AppID.Validate(); err != nil {
+			errs = append(errs, err)
+		}
+	}
+
+	if a.Type != nil {
+		if *a.Type == "" {
+			errs = append(errs, models.NewGenericValidationError(
+				fmt.Errorf("app type cannot be empty"),
+			))
+		}
+	}
+
+	return errors.Join(errs...)
+}
+
+type EnsureCustomerInput struct {
+	AppID      AppID
+	CustomerID customer.CustomerID
+}
+
+func (a EnsureCustomerInput) Validate() error {
+	if err := a.AppID.Validate(); err != nil {
+		return err
+	}
+
+	if err := a.CustomerID.Validate(); err != nil {
+		return err
+	}
+
+	if a.AppID.Namespace != a.CustomerID.Namespace {
+		return fmt.Errorf("app ID namespace %s does not match customer ID namespace %s", a.AppID.Namespace, a.CustomerID.Namespace)
+	}
+
+	return nil
+}
+
+type DeleteCustomerInput struct {
+	AppID      *AppID
+	CustomerID *customer.CustomerID
+}
+
+func (a DeleteCustomerInput) Validate() error {
+	if a.AppID == nil && a.CustomerID == nil {
+		return fmt.Errorf("app ID and customer ID cannot be nil")
+	}
+
+	if a.AppID != nil {
+		if err := a.AppID.Validate(); err != nil {
+			return err
+		}
+	}
+
+	if a.CustomerID != nil {
+		if err := a.CustomerID.Validate(); err != nil {
+			return err
+		}
+	}
+
+	if a.AppID != nil && a.CustomerID != nil && a.AppID.Namespace != a.CustomerID.Namespace {
+		return errors.New("app and customer must be in the same namespace")
+	}
+
+	return nil
+}

app/marketplace.go

@@ -0,0 +1,230 @@
+package app
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"slices"
+
+	"github.com/openmeterio/openmeter/pkg/models"
+	"github.com/openmeterio/openmeter/pkg/pagination"
+)
+
+type InstallMethod string
+
+const (
+	InstallMethodOAuth2        InstallMethod = "with_oauth2"
+	InstallMethodAPIKey        InstallMethod = "with_api_key"
+	InstallMethodNoCredentials InstallMethod = "no_credentials_required"
+)
+
+func (i InstallMethod) Validate() error {
+	if i == "" {
+		return errors.New("install method is required")
+	}
+
+	if !slices.Contains([]InstallMethod{
+		InstallMethodOAuth2,
+		InstallMethodAPIKey,
+		InstallMethodNoCredentials,
+	}, i) {
+		return fmt.Errorf("invalid install method: %s", i)
+	}
+
+	return nil
+}
+
+type MarketplaceListing struct {
+	Type           AppType         `json:"type"`
+	Name           string          `json:"name"`
+	Description    string          `json:"description"`
+	Capabilities   []Capability    `json:"capabilities"`
+	InstallMethods []InstallMethod `json:"installMethods"`
+}
+
+func (p MarketplaceListing) Validate() error {
+	if p.Type == "" {
+		return errors.New("type is required")
+	}
+
+	if p.Name == "" {
+		return errors.New("name is required")
+	}
+
+	if p.Description == "" {
+		return errors.New("description is required")
+	}
+
+	for i, capability := range p.Capabilities {
+		if err := capability.Validate(); err != nil {
+			return fmt.Errorf("error validating capability at position %d: %w", i, err)
+		}
+	}
+
+	for i, installMethod := range p.InstallMethods {
+		if err := installMethod.Validate(); err != nil {
+			return fmt.Errorf("error validating install method at position %d: %w", i, err)
+		}
+	}
+
+	return nil
+}
+
+type Capability struct {
+	Type        CapabilityType `json:"type"`
+	Key         string         `json:"key"`
+	Name        string         `json:"name"`
+	Description string         `json:"description"`
+}
+
+func (c Capability) Validate() error {
+	if c.Key == "" {
+		return errors.New("key is required")
+	}
+
+	if c.Name == "" {
+		return errors.New("name is required")
+	}
+
+	if c.Description == "" {
+		return errors.New("description is required")
+	}
+
+	return nil
+}
+
+type MarketplaceListingID struct {
+	Type AppType
+}
+
+func (i MarketplaceListingID) Validate() error {
+	if i.Type == "" {
+		return errors.New("type is required")
+	}
+
+	return nil
+}
+
+type RegisterMarketplaceListingInput = RegistryItem
+
+type MarketplaceGetInput = MarketplaceListingID
+
+type MarketplaceListInput struct {
+	pagination.Page
+}
+
+func (i MarketplaceListInput) Validate() error {
+	if err := i.Page.Validate(); err != nil {
+		return fmt.Errorf("error validating page: %w", err)
+	}
+
+	return nil
+}
+
+type InstallAppWithAPIKeyInput struct {
+	InstallAppInput
+
+	APIKey string
+}
+
+func (i InstallAppWithAPIKeyInput) Validate() error {
+	if err := i.InstallAppInput.Validate(); err != nil {
+		return fmt.Errorf("error validating install app input: %w", err)
+	}
+
+	if i.APIKey == "" {
+		return errors.New("api key is required")
+	}
+
+	return nil
+}
+
+type InstallAppV3Input struct {
+	MarketplaceListingID
+
+	Namespace                   string
+	Name                        string
+	APIKey                      *string
+	CreateDefaultBillingProfile bool
+
+	CreateDefaultBillingProfileFn func(ctx context.Context, installedApp App) ([]CapabilityType, error)
+}
+
+func (i InstallAppV3Input) Validate() error {
+	var errs []error
+	if err := i.MarketplaceListingID.Validate(); err != nil {
+		errs = append(errs, fmt.Errorf("error validating marketplace listing id: %w", err))
+	}
+
+	if i.Namespace == "" {
+		errs = append(errs, errors.New("namespace is required"))
+	}
+
+	if i.APIKey != nil && *i.APIKey == "" {
+		errs = append(errs, errors.New("api key is required"))
+	}
+
+	return models.NewNillableGenericValidationError(errors.Join(errs...))
+}
+
+type InstallAppV3Output struct {
+	App               App
+	DefaultCapabilies []CapabilityType
+}
+
+type InstallAppInput struct {
+	MarketplaceListingID
+
+	Namespace string
+	Name      string
+}
+
+func (i InstallAppInput) Validate() error {
+	if err := i.MarketplaceListingID.Validate(); err != nil {
+		return models.NewGenericValidationError(
+			fmt.Errorf("error validating marketplace listing id: %w", err),
+		)
+	}
+
+	if i.Namespace == "" {
+		return errors.New("namespace is required")
+	}
+
+	return nil
+}
+
+type GetOauth2InstallURLInput = MarketplaceListingID
+
+type GetOauth2InstallURLOutput struct {
+	URL string
+}
+
+type AuthorizeOauth2InstallInput struct {
+	MarketplaceListingID
+
+	Code string
+	// Success response fields
+	State string
+	// Error response fields
+	Error            string
+	ErrorDescription string
+	ErrorURI         string
+}
+
+func (i AuthorizeOauth2InstallInput) Validate() error {
+	if err := i.MarketplaceListingID.Validate(); err != nil {
+		return models.NewGenericValidationError(
+			fmt.Errorf("error validating marketplace listing id: %w", err),
+		)
+	}
+
+	if i.State == "" {
+		return errors.New("state is required")
+	}
+
+	if i.Error != "" && i.Code != "" {
+		return errors.New("code and error cannot be set at the same time")
+	}
+
+	return nil
+}

app/registry.go

@@ -0,0 +1,78 @@
+package app
+
+import (
+	"context"
+	"errors"
+	"fmt"
+)
+
+type AppFactory interface {
+	NewApp(context.Context, AppBase) (App, error)
+	UninstallApp(ctx context.Context, input UninstallAppInput) error
+}
+
+type AppFactoryInstallWithAPIKey interface {
+	InstallAppWithAPIKey(ctx context.Context, input AppFactoryInstallAppWithAPIKeyInput) (App, error)
+}
+
+type UninstallAppInput = AppID
+
+type AppFactoryInstallAppWithAPIKeyInput struct {
+	Namespace string
+	APIKey    string
+	Name      string
+}
+
+func (i AppFactoryInstallAppWithAPIKeyInput) Validate() error {
+	if i.Namespace == "" {
+		return errors.New("namespace is required")
+	}
+
+	if i.APIKey == "" {
+		return errors.New("api key is required")
+	}
+
+	if i.Name == "" {
+		return errors.New("name is required")
+	}
+
+	return nil
+}
+
+type AppFactoryInstall interface {
+	InstallApp(ctx context.Context, input AppFactoryInstallAppInput) (App, error)
+}
+
+type AppFactoryInstallAppInput struct {
+	Namespace string
+	Name      string
+}
+
+func (i AppFactoryInstallAppInput) Validate() error {
+	if i.Namespace == "" {
+		return errors.New("namespace is required")
+	}
+
+	if i.Name == "" {
+		return errors.New("name is required")
+	}
+
+	return nil
+}
+
+type RegistryItem struct {
+	Listing MarketplaceListing
+	Factory AppFactory
+}
+
+func (r RegistryItem) Validate() error {
+	if err := r.Listing.Validate(); err != nil {
+		return fmt.Errorf("error validating registry item: %w", err)
+	}
+
+	if r.Factory == nil {
+		return errors.New("factory is required")
+	}
+
+	return nil
+}

app/sandbox/app.go

@@ -0,0 +1,255 @@
+package appsandbox
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/samber/lo"
+
+	"github.com/openmeterio/openmeter/openmeter/app"
+	"github.com/openmeterio/openmeter/openmeter/billing"
+	"github.com/openmeterio/openmeter/openmeter/billing/sequence"
+	"github.com/openmeterio/openmeter/openmeter/customer"
+	customerapp "github.com/openmeterio/openmeter/openmeter/customer/app"
+	"github.com/openmeterio/openmeter/pkg/clock"
+	"github.com/openmeterio/openmeter/pkg/models"
+)
+
+const (
+	TargetPaymentStatusMetadataKey = "openmeter.io/sandbox/target-payment-status"
+
+	TargetPaymentStatusPaid           = "paid"
+	TargetPaymentStatusFailed         = "failed"
+	TargetPaymentStatusUncollectible  = "uncollectible"
+	TargetPaymentStatusActionRequired = "action_required"
+)
+
+var (
+	_ customerapp.App                     = (*App)(nil)
+	_ billing.InvoicingApp                = (*App)(nil)
+	_ billing.InvoicingAppPostAdvanceHook = (*App)(nil)
+	_ app.CustomerData                    = (*CustomerData)(nil)
+
+	InvoiceSequenceNumber = sequence.Definition{
+		Prefix:         "OM-SANDBOX",
+		SuffixTemplate: "{{.CustomerPrefix}}-{{.NextSequenceNumber}}",
+		Scope:          "invoices/app/sandbox",
+		CommitMode:     sequence.CommitModeWithCaller,
+	}
+)
+
+type Meta struct {
+	app.AppBase
+}
+
+var _ app.EventAppParser = (*Meta)(nil)
+
+func (m *Meta) FromEventAppData(event app.EventApp) error {
+	m.AppBase = event.AppBase
+
+	return nil
+}
+
+type App struct {
+	Meta
+
+	sequenceService sequence.Service
+}
+
+func (a App) ValidateCustomer(ctx context.Context, customer *customer.Customer, capabilities []app.CapabilityType) error {
+	if err := a.ValidateCapabilities(capabilities...); err != nil {
+		return fmt.Errorf("error validating capabilities: %w", err)
+	}
+
+	return nil
+}
+
+func (a App) GetCustomerData(ctx context.Context, input app.GetAppInstanceCustomerDataInput) (app.CustomerData, error) {
+	return CustomerData{}, nil
+}
+
+func (a App) UpsertCustomerData(ctx context.Context, input app.UpsertAppInstanceCustomerDataInput) error {
+	return nil
+}
+
+func (a App) DeleteCustomerData(ctx context.Context, input app.DeleteAppInstanceCustomerDataInput) error {
+	return nil
+}
+
+func (a App) ValidateStandardInvoice(ctx context.Context, invoice billing.StandardInvoice) error {
+	return nil
+}
+
+func (a App) UpdateAppConfig(ctx context.Context, input app.AppConfigUpdate) error {
+	return nil
+}
+
+func (a App) UpsertStandardInvoice(ctx context.Context, invoice billing.StandardInvoice) (*billing.UpsertStandardInvoiceResult, error) {
+	return billing.NewUpsertStandardInvoiceResult(), nil
+}
+
+func (a App) FinalizeStandardInvoice(ctx context.Context, invoice billing.StandardInvoice) (*billing.FinalizeStandardInvoiceResult, error) {
+	invoiceNumber, err := a.sequenceService.GenerateInvoiceSequenceNumber(
+		ctx,
+		sequence.GenerationInput{
+			Namespace:    invoice.Namespace,
+			CustomerName: invoice.Customer.Name,
+			Currency:     invoice.Currency,
+		},
+		InvoiceSequenceNumber,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to generate invoice sequence number: %w", err)
+	}
+
+	return billing.NewFinalizeStandardInvoiceResult().
+		SetInvoiceNumber(invoiceNumber).
+		SetSentToCustomerAt(clock.Now()), nil
+}
+
+func (a App) DeleteStandardInvoice(ctx context.Context, invoice billing.StandardInvoice) error {
+	return nil
+}
+
+func (a App) PostAdvanceStandardInvoiceHook(ctx context.Context, invoice billing.StandardInvoice) (*billing.PostAdvanceHookResult, error) {
+	if invoice.Status != billing.StandardInvoiceStatusPaymentProcessingPending {
+		return nil, nil
+	}
+
+	targetStatus := TargetPaymentStatusPaid
+
+	// Allow overriding via metadata for testing (unit, customer) purposes
+	override, ok := invoice.Metadata[TargetPaymentStatusMetadataKey]
+	if ok && override != "" {
+		targetStatus = override
+	}
+
+	out := billing.NewPostAdvanceHookResult()
+	// Let's simulate the payment status by invoking the right trigger
+	switch targetStatus {
+	case TargetPaymentStatusFailed:
+		return out.InvokeTrigger(billing.InvoiceTriggerInput{
+			Invoice: invoice.GetInvoiceID(),
+			Trigger: billing.TriggerFailed,
+			ValidationErrors: &billing.InvoiceTriggerValidationInput{
+				Operation: billing.StandardInvoiceOpInitiatePayment,
+				Errors:    []error{ErrSimulatedPaymentFailure},
+			},
+		}), nil
+	case TargetPaymentStatusUncollectible:
+		return out.InvokeTrigger(billing.InvoiceTriggerInput{
+			Invoice: invoice.GetInvoiceID(),
+			Trigger: billing.TriggerPaymentUncollectible,
+		}), nil
+	case TargetPaymentStatusActionRequired:
+		return out.InvokeTrigger(billing.InvoiceTriggerInput{
+			Invoice: invoice.GetInvoiceID(),
+			Trigger: billing.TriggerActionRequired,
+		}), nil
+	case TargetPaymentStatusPaid:
+		fallthrough
+	default:
+		return out.InvokeTrigger(billing.InvoiceTriggerInput{
+			Invoice: invoice.GetInvoiceID(),
+			Trigger: billing.TriggerPaid,
+		}), nil
+	}
+}
+
+func (a App) GetEventAppData() (app.EventAppData, error) {
+	return app.EventAppData{}, nil
+}
+
+type CustomerData struct{}
+
+func (c CustomerData) Validate() error {
+	return nil
+}
+
+type Factory struct {
+	appService      app.Service
+	sequenceService sequence.Service
+}
+
+type Config struct {
+	AppService      app.Service
+	SequenceService sequence.Service
+}
+
+func (c Config) Validate() error {
+	if c.AppService == nil {
+		return fmt.Errorf("app service is required")
+	}
+
+	if c.SequenceService == nil {
+		return fmt.Errorf("sequence service is required")
+	}
+
+	return nil
+}
+
+func NewFactory(config Config) (*Factory, error) {
+	if err := config.Validate(); err != nil {
+		return nil, fmt.Errorf("failed to validate config: %w", err)
+	}
+
+	fact := &Factory{
+		appService:      config.AppService,
+		sequenceService: config.SequenceService,
+	}
+
+	err := config.AppService.RegisterMarketplaceListing(app.RegistryItem{
+		Listing: MarketplaceListing,
+		Factory: fact,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to register marketplace listing: %w", err)
+	}
+
+	return fact, nil
+}
+
+// Factory
+func (a *Factory) NewApp(_ context.Context, appBase app.AppBase) (app.App, error) {
+	return App{
+		Meta: Meta{
+			AppBase: appBase,
+		},
+		sequenceService: a.sequenceService,
+	}, nil
+}
+
+func (a *Factory) InstallApp(ctx context.Context, input app.AppFactoryInstallAppInput) (app.App, error) {
+	if err := input.Validate(); err != nil {
+		return nil, fmt.Errorf("invalid input: %w", err)
+	}
+
+	// Sandbox is a singleton per namespace — only one instance makes sense since all
+	// instances are functionally identical (no credentials, no external state).
+	existing, err := a.appService.ListApps(ctx, app.ListAppInput{
+		Namespace: input.Namespace,
+		Type:      lo.ToPtr(app.AppTypeSandbox),
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to list sandbox apps: %w", err)
+	}
+
+	if existing.TotalCount > 0 {
+		return nil, models.NewGenericConflictError(fmt.Errorf("sandbox app: %s already exists", existing.Items[0].GetName()))
+	}
+
+	appBase, err := a.appService.CreateApp(ctx, app.CreateAppInput{
+		Namespace: input.Namespace,
+		Name:      input.Name,
+		Type:      app.AppTypeSandbox,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to create app: %w", err)
+	}
+
+	return a.NewApp(ctx, appBase.GetAppBase())
+}
+
+func (a *Factory) UninstallApp(ctx context.Context, input app.UninstallAppInput) error {
+	return nil
+}

app/sandbox/config.go

@@ -0,0 +1,7 @@
+package appsandbox
+
+type Configuration struct{}
+
+func (c Configuration) Validate() error {
+	return nil
+}

app/sandbox/errors.go

@@ -0,0 +1,5 @@
+package appsandbox
+
+import "github.com/openmeterio/openmeter/openmeter/billing"
+
+var ErrSimulatedPaymentFailure = billing.NewValidationError("simulated_payment_failure", "simulated payment failure")

app/sandbox/helpers.go

@@ -0,0 +1,70 @@
+package appsandbox
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/samber/lo"
+
+	"github.com/openmeterio/openmeter/openmeter/app"
+	"github.com/openmeterio/openmeter/pkg/models"
+)
+
+type AutoProvisionInput struct {
+	Namespace  string
+	AppService app.Service
+}
+
+func (a AutoProvisionInput) Validate() error {
+	if a.Namespace == "" {
+		return errors.New("namespace is required")
+	}
+
+	if a.AppService == nil {
+		return errors.New("app service is required")
+	}
+
+	return nil
+}
+
+// AutoProvision creates a new default sandbox app if it doesn't exist, otherwise returns the existing one.
+//
+// We install the sandbox app by default in the system, so that the user can start trying out the system
+// right away.
+func AutoProvision(ctx context.Context, input AutoProvisionInput) (app.App, error) {
+	if err := input.Validate(); err != nil {
+		return nil, models.NewGenericValidationError(err)
+	}
+
+	// Get the sandbox app list
+	sandboxAppList, err := input.AppService.ListApps(ctx, app.ListAppInput{
+		Namespace: input.Namespace,
+		Type:      lo.ToPtr(app.AppTypeSandbox),
+	})
+	if err != nil {
+		return nil, fmt.Errorf("cannot list apps: %w", err)
+	}
+
+	// If there is no sandbox app, we need to provision a new one
+	if sandboxAppList.TotalCount == 0 {
+		// Let's provision the new app
+		appBase, err := input.AppService.CreateApp(ctx, app.CreateAppInput{
+			Namespace:   input.Namespace,
+			Name:        "Sandbox",
+			Description: "OpenMeter Sandbox App to be used for testing purposes.",
+			Type:        app.AppTypeSandbox,
+		})
+		if err != nil {
+			return nil, fmt.Errorf("cannot create sandbox app: %w", err)
+		}
+
+		return input.AppService.GetApp(ctx, app.GetAppInput{
+			Namespace: input.Namespace,
+			ID:        appBase.GetID().ID,
+		})
+	}
+
+	// Otherwise, we return the first one
+	return sandboxAppList.Items[0], nil
+}

app/sandbox/marketplace.go

@@ -0,0 +1,42 @@
+package appsandbox
+
+import (
+	"github.com/openmeterio/openmeter/openmeter/app"
+)
+
+var (
+	MarketplaceListing = app.MarketplaceListing{
+		Type:        app.AppTypeSandbox,
+		Name:        "Sandbox",
+		Description: "Sandbox can be used to test OpenMeter without external connections.",
+		Capabilities: []app.Capability{
+			CollectPaymentCapability,
+			CalculateTaxCapability,
+			InvoiceCustomerCapability,
+		},
+		InstallMethods: []app.InstallMethod{
+			app.InstallMethodNoCredentials,
+		},
+	}
+
+	CollectPaymentCapability = app.Capability{
+		Type:        app.CapabilityTypeCollectPayments,
+		Key:         "sandbox_collect_payment",
+		Name:        "Payment",
+		Description: "Process payments",
+	}
+
+	CalculateTaxCapability = app.Capability{
+		Type:        app.CapabilityTypeCalculateTax,
+		Key:         "sandbox_calculate_tax",
+		Name:        "Calculate Tax",
+		Description: "Calculate tax for a payment",
+	}
+
+	InvoiceCustomerCapability = app.Capability{
+		Type:        app.CapabilityTypeInvoiceCustomers,
+		Key:         "sandbox_invoice_customer",
+		Name:        "Invoice Customer",
+		Description: "Invoice a customer",
+	}
+)

app/sandbox/mock.go

@@ -0,0 +1,284 @@
+package appsandbox
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/samber/mo"
+
+	"github.com/openmeterio/openmeter/openmeter/app"
+	"github.com/openmeterio/openmeter/openmeter/billing"
+	"github.com/openmeterio/openmeter/openmeter/customer"
+	customerapp "github.com/openmeterio/openmeter/openmeter/customer/app"
+)
+
+type AppFactory interface {
+	NewApp(ctx context.Context, appBase app.AppBase) (app.App, error)
+}
+
+type InvoiceUpsertCallback func(billing.StandardInvoice) (*billing.UpsertStandardInvoiceResult, error)
+
+type MockApp struct {
+	validateCustomerResponse mo.Option[error]
+	validateCustomerCalled   bool
+
+	validateInvoiceResponse       mo.Option[error]
+	validateInvoiceResponseCalled bool
+
+	upsertInvoiceCallback mo.Option[InvoiceUpsertCallback]
+	upsertInvoiceCalled   bool
+
+	finalizeInvoiceResponse mo.Option[*billing.FinalizeStandardInvoiceResult]
+	finalizeInvoiceCalled   bool
+
+	deleteInvoiceResponse mo.Option[error]
+	deleteInvoiceCalled   bool
+}
+
+func NewMockApp(_ *testing.T) *MockApp {
+	return &MockApp{}
+}
+
+func (m *MockApp) GetCustomerData(ctx context.Context, input app.GetAppInstanceCustomerDataInput) (app.CustomerData, error) {
+	return nil, nil
+}
+
+func (m *MockApp) UpsertCustomerData(ctx context.Context, input app.UpsertAppInstanceCustomerDataInput) error {
+	return nil
+}
+
+func (m *MockApp) DeleteCustomerData(ctx context.Context, input app.DeleteAppInstanceCustomerDataInput) error {
+	return nil
+}
+
+func (m *MockApp) UpdateAppConfig(ctx context.Context, input app.AppConfigUpdate) error {
+	return nil
+}
+
+func (m *MockApp) ValidateCustomer(appID string, customer *customer.Customer, capabilities []app.CapabilityType) error {
+	m.validateCustomerCalled = true
+	return m.validateCustomerResponse.MustGet()
+}
+
+func (m *MockApp) OnValidateCustomer(err error) {
+	m.validateCustomerResponse = mo.Some(err)
+}
+
+// InvoicingApp
+
+func (m *MockApp) ValidateStandardInvoice(appID string, invoice billing.StandardInvoice) error {
+	m.validateInvoiceResponseCalled = true
+	return m.validateInvoiceResponse.MustGet()
+}
+
+func (m *MockApp) OnValidateStandardInvoice(err error) {
+	m.validateInvoiceResponse = mo.Some(err)
+}
+
+func (m *MockApp) UpsertStandardInvoice(ctx context.Context, invoice billing.StandardInvoice) (*billing.UpsertStandardInvoiceResult, error) {
+	m.upsertInvoiceCalled = true
+
+	if m.upsertInvoiceCallback.IsPresent() && m.upsertInvoiceCallback.MustGet() != nil {
+		return m.upsertInvoiceCallback.MustGet()(invoice)
+	}
+
+	return billing.NewUpsertStandardInvoiceResult(), nil
+}
+
+func (m *MockApp) OnUpsertStandardInvoice(cb InvoiceUpsertCallback) {
+	m.upsertInvoiceCallback = mo.Some(cb)
+}
+
+func (m *MockApp) FinalizeStandardInvoice(ctx context.Context, invoice billing.StandardInvoice) (*billing.FinalizeStandardInvoiceResult, error) {
+	m.finalizeInvoiceCalled = true
+	return m.finalizeInvoiceResponse.MustGet(), nil
+}
+
+func (m *MockApp) OnFinalizeStandardInvoice(result *billing.FinalizeStandardInvoiceResult) {
+	m.finalizeInvoiceResponse = mo.Some(result)
+}
+
+func (m *MockApp) DeleteStandardInvoice(ctx context.Context, invoice billing.StandardInvoice) error {
+	m.deleteInvoiceCalled = true
+	return m.deleteInvoiceResponse.MustGet()
+}
+
+func (m *MockApp) OnDeleteStandardInvoice(err error) {
+	m.deleteInvoiceResponse = mo.Some(err)
+}
+
+func (m *MockApp) Reset(t *testing.T) {
+	t.Helper()
+
+	m.AssertExpectations(t)
+
+	m.validateCustomerResponse = mo.None[error]()
+	m.validateCustomerCalled = false
+
+	m.validateInvoiceResponse = mo.None[error]()
+	m.validateInvoiceResponseCalled = false
+
+	m.upsertInvoiceCallback = mo.None[InvoiceUpsertCallback]()
+	m.upsertInvoiceCalled = false
+
+	m.finalizeInvoiceResponse = mo.None[*billing.FinalizeStandardInvoiceResult]()
+	m.finalizeInvoiceCalled = false
+
+	m.deleteInvoiceResponse = mo.None[error]()
+	m.deleteInvoiceCalled = false
+}
+
+func (m *MockApp) AssertExpectations(t *testing.T) {
+	t.Helper()
+
+	if m.validateCustomerResponse.IsPresent() && !m.validateCustomerCalled {
+		t.Errorf("expected ValidateCustomer to be called")
+	}
+
+	if m.validateInvoiceResponse.IsPresent() && !m.validateInvoiceResponseCalled {
+		t.Errorf("expected ValidateInvoice to be called")
+	}
+
+	if m.upsertInvoiceCallback.IsPresent() && !m.upsertInvoiceCalled {
+		t.Errorf("expected UpsertInvoice to be called")
+	}
+
+	if m.finalizeInvoiceResponse.IsPresent() && !m.finalizeInvoiceCalled {
+		t.Errorf("expected FinalizeInvoice to be called")
+	}
+
+	if m.deleteInvoiceResponse.IsPresent() && !m.deleteInvoiceCalled {
+		t.Errorf("expected DeleteInvoice to be called")
+	}
+}
+
+func (m *MockApp) NewApp(_ context.Context, app app.AppBase) (app.App, error) {
+	return &mockAppInstance{
+		AppBase: app,
+		parent:  m,
+	}, nil
+}
+
+type mockAppInstance struct {
+	app.AppBase
+
+	parent *MockApp
+}
+
+var (
+	_ billing.InvoicingApp = (*mockAppInstance)(nil)
+	_ customerapp.App      = (*mockAppInstance)(nil)
+)
+
+func (m *mockAppInstance) GetCustomerData(ctx context.Context, input app.GetAppInstanceCustomerDataInput) (app.CustomerData, error) {
+	return m.parent.GetCustomerData(ctx, input)
+}
+
+func (m *mockAppInstance) UpsertCustomerData(ctx context.Context, input app.UpsertAppInstanceCustomerDataInput) error {
+	return m.parent.UpsertCustomerData(ctx, input)
+}
+
+func (m *mockAppInstance) DeleteCustomerData(ctx context.Context, input app.DeleteAppInstanceCustomerDataInput) error {
+	return m.parent.DeleteCustomerData(ctx, input)
+}
+
+func (m *mockAppInstance) UpdateAppConfig(ctx context.Context, input app.AppConfigUpdate) error {
+	return m.parent.UpdateAppConfig(ctx, input)
+}
+
+func (m *mockAppInstance) ValidateCustomer(ctx context.Context, customer *customer.Customer, capabilities []app.CapabilityType) error {
+	return m.parent.ValidateCustomer(m.GetID().ID, customer, capabilities)
+}
+
+func (m *mockAppInstance) ValidateStandardInvoice(ctx context.Context, invoice billing.StandardInvoice) error {
+	return m.parent.ValidateStandardInvoice(m.GetID().ID, invoice)
+}
+
+func (m *mockAppInstance) UpsertStandardInvoice(ctx context.Context, invoice billing.StandardInvoice) (*billing.UpsertStandardInvoiceResult, error) {
+	return m.parent.UpsertStandardInvoice(ctx, invoice)
+}
+
+func (m *mockAppInstance) FinalizeStandardInvoice(ctx context.Context, invoice billing.StandardInvoice) (*billing.FinalizeStandardInvoiceResult, error) {
+	return m.parent.FinalizeStandardInvoice(ctx, invoice)
+}
+
+func (m *mockAppInstance) DeleteStandardInvoice(ctx context.Context, invoice billing.StandardInvoice) error {
+	return m.parent.DeleteStandardInvoice(ctx, invoice)
+}
+
+func (m *mockAppInstance) GetEventAppData() (app.EventAppData, error) {
+	return app.EventAppData{}, nil
+}
+
+type MockableFactory struct {
+	*Factory
+
+	overrideFactory AppFactory
+}
+
+type mockConfig struct {
+	OverrideType app.AppType
+}
+
+type mockConfigOption func(*mockConfig)
+
+func MockWithAppType(t app.AppType) mockConfigOption {
+	return func(c *mockConfig) {
+		c.OverrideType = t
+	}
+}
+
+func NewMockableFactory(_ *testing.T, config Config, opts ...mockConfigOption) (*MockableFactory, error) {
+	if err := config.Validate(); err != nil {
+		return nil, fmt.Errorf("failed to validate config: %w", err)
+	}
+
+	fact := &MockableFactory{
+		Factory: &Factory{
+			appService:      config.AppService,
+			sequenceService: config.SequenceService,
+		},
+	}
+
+	mockConfig := &mockConfig{}
+	for _, opt := range opts {
+		opt(mockConfig)
+	}
+
+	listing := MarketplaceListing
+
+	if mockConfig.OverrideType != "" {
+		listing.Type = mockConfig.OverrideType
+	}
+
+	err := config.AppService.RegisterMarketplaceListing(app.RegistryItem{
+		Listing: listing,
+		Factory: fact,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to register marketplace listing: %w", err)
+	}
+
+	return fact, nil
+}
+
+func (m *MockableFactory) NewApp(ctx context.Context, appBase app.AppBase) (app.App, error) {
+	if m.overrideFactory != nil {
+		return m.overrideFactory.NewApp(ctx, appBase)
+	}
+
+	return m.Factory.NewApp(ctx, appBase)
+}
+
+func (m *MockableFactory) EnableMock(t *testing.T) *MockApp {
+	mock := NewMockApp(t)
+
+	m.overrideFactory = mock
+
+	return mock
+}
+
+func (m *MockableFactory) DisableMock() {
+	m.overrideFactory = nil
+}

app/service.go

@@ -0,0 +1,34 @@
+package app
+
+import (
+	"context"
+
+	"github.com/openmeterio/openmeter/pkg/pagination"
+)
+
+type Service interface {
+	AppService
+}
+
+type AppService interface {
+	// Marketplace
+	RegisterMarketplaceListing(input RegisterMarketplaceListingInput) error
+	GetMarketplaceListing(ctx context.Context, input MarketplaceGetInput) (RegistryItem, error)
+	ListMarketplaceListings(ctx context.Context, input MarketplaceListInput) (pagination.Result[RegistryItem], error)
+	InstallApp(ctx context.Context, input InstallAppV3Input) (InstallAppV3Output, error)
+	GetMarketplaceListingOauth2InstallURL(ctx context.Context, input GetOauth2InstallURLInput) (GetOauth2InstallURLOutput, error)
+	AuthorizeMarketplaceListingOauth2Install(ctx context.Context, input AuthorizeOauth2InstallInput) error
+
+	// Installed app
+	CreateApp(ctx context.Context, input CreateAppInput) (AppBase, error)
+	GetApp(ctx context.Context, input GetAppInput) (App, error)
+	UpdateAppStatus(ctx context.Context, input UpdateAppStatusInput) error
+	UpdateApp(ctx context.Context, input UpdateAppInput) (App, error)
+	ListApps(ctx context.Context, input ListAppInput) (pagination.Result[App], error)
+	UninstallApp(ctx context.Context, input UninstallAppInput) error
+
+	// Customer data
+	ListCustomerData(ctx context.Context, input ListCustomerInput) (pagination.Result[CustomerApp], error)
+	EnsureCustomer(ctx context.Context, input EnsureCustomerInput) error
+	DeleteCustomer(ctx context.Context, input DeleteCustomerInput) error
+}

app/service/app.go

@@ -0,0 +1,151 @@
+package appservice
+
+import (
+	"context"
+
+	"github.com/openmeterio/openmeter/openmeter/app"
+	"github.com/openmeterio/openmeter/pkg/framework/transaction"
+	"github.com/openmeterio/openmeter/pkg/models"
+	"github.com/openmeterio/openmeter/pkg/pagination"
+)
+
+var _ app.AppService = (*Service)(nil)
+
+func (s *Service) CreateApp(ctx context.Context, input app.CreateAppInput) (app.AppBase, error) {
+	// Validate the input
+	if err := input.Validate(); err != nil {
+		return app.AppBase{}, models.NewGenericValidationError(err)
+	}
+
+	// Create the app
+	appBase, err := s.adapter.CreateApp(ctx, input)
+	if err != nil {
+		return app.AppBase{}, err
+	}
+
+	// Emit the app created event
+	event := app.NewAppCreateEvent(ctx, appBase)
+	if err := s.publisher.Publish(ctx, event); err != nil {
+		return app.AppBase{}, err
+	}
+
+	return appBase, nil
+}
+
+func (s *Service) GetApp(ctx context.Context, input app.GetAppInput) (app.App, error) {
+	if err := input.Validate(); err != nil {
+		return nil, models.NewGenericValidationError(err)
+	}
+
+	return s.adapter.GetApp(ctx, input)
+}
+
+func (s *Service) UpdateApp(ctx context.Context, input app.UpdateAppInput) (app.App, error) {
+	// Validate the input
+	if err := input.Validate(); err != nil {
+		return nil, models.NewGenericValidationError(err)
+	}
+
+	return transaction.Run(ctx, s.adapter, func(ctx context.Context) (app.App, error) {
+		// Update the app
+		updatedApp, err := s.adapter.UpdateApp(ctx, input)
+		if err != nil {
+			return nil, err
+		}
+
+		// Update the app specific entity
+		if input.AppConfigUpdate != nil {
+			err := updatedApp.UpdateAppConfig(ctx, input.AppConfigUpdate)
+			if err != nil {
+				return nil, err
+			}
+
+			updatedApp, err = s.adapter.GetApp(ctx, input.AppID)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		// Emit the app updated event
+		event, err := app.NewAppUpdateEvent(ctx, updatedApp)
+		if err != nil {
+			return nil, err
+		}
+
+		if err := s.publisher.Publish(ctx, event); err != nil {
+			return nil, err
+		}
+
+		return updatedApp, nil
+	})
+}
+
+func (s *Service) ListApps(ctx context.Context, input app.ListAppInput) (pagination.Result[app.App], error) {
+	if err := input.Validate(); err != nil {
+		return pagination.Result[app.App]{}, models.NewGenericValidationError(err)
+	}
+
+	return s.adapter.ListApps(ctx, input)
+}
+
+func (s *Service) UninstallApp(ctx context.Context, input app.UninstallAppInput) error {
+	// Validate the input
+	if err := input.Validate(); err != nil {
+		return models.NewGenericValidationError(err)
+	}
+
+	// Existing app
+	existingApp, err := s.adapter.GetApp(ctx, input)
+	if err != nil {
+		return err
+	}
+
+	// Delete the app
+	appBase, err := s.adapter.UninstallApp(ctx, input)
+	if err != nil {
+		return err
+	}
+
+	// Emit the app deleted event
+	eventAppData, err := existingApp.GetEventAppData()
+	if err != nil {
+		return err
+	}
+
+	event := app.NewAppDeleteEvent(ctx, *appBase, eventAppData)
+	if err := s.publisher.Publish(ctx, event); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *Service) UpdateAppStatus(ctx context.Context, input app.UpdateAppStatusInput) error {
+	// Validate the input
+	if err := input.Validate(); err != nil {
+		return models.NewGenericValidationError(err)
+	}
+
+	// Update the app status
+	if err := s.adapter.UpdateAppStatus(ctx, input); err != nil {
+		return err
+	}
+
+	// Get the app after status update to include in the event
+	updatedApp, err := s.adapter.GetApp(ctx, input.ID)
+	if err != nil {
+		return err
+	}
+
+	// Emit the app updated event
+	event, err := app.NewAppUpdateEvent(ctx, updatedApp)
+	if err != nil {
+		return err
+	}
+
+	if err := s.publisher.Publish(ctx, event); err != nil {
+		return err
+	}
+
+	return nil
+}

app/service/customer.go

@@ -0,0 +1,22 @@
+package appservice
+
+import (
+	"context"
+
+	"github.com/openmeterio/openmeter/openmeter/app"
+	"github.com/openmeterio/openmeter/pkg/pagination"
+)
+
+var _ app.AppService = (*Service)(nil)
+
+func (s *Service) ListCustomerData(ctx context.Context, input app.ListCustomerInput) (pagination.Result[app.CustomerApp], error) {
+	return s.adapter.ListCustomerData(ctx, input)
+}
+
+func (s *Service) EnsureCustomer(ctx context.Context, input app.EnsureCustomerInput) error {
+	return s.adapter.EnsureCustomer(ctx, input)
+}
+
+func (s *Service) DeleteCustomer(ctx context.Context, input app.DeleteCustomerInput) error {
+	return s.adapter.DeleteCustomer(ctx, input)
+}

app/service/marketplace.go

@@ -0,0 +1,105 @@
+package appservice
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/openmeterio/openmeter/openmeter/app"
+	"github.com/openmeterio/openmeter/pkg/framework/transaction"
+	"github.com/openmeterio/openmeter/pkg/models"
+	"github.com/openmeterio/openmeter/pkg/pagination"
+)
+
+var _ app.AppService = (*Service)(nil)
+
+func (s *Service) RegisterMarketplaceListing(input app.RegisterMarketplaceListingInput) error {
+	if err := input.Validate(); err != nil {
+		return models.NewGenericValidationError(err)
+	}
+
+	return s.adapter.RegisterMarketplaceListing(input)
+}
+
+func (s *Service) GetMarketplaceListing(ctx context.Context, input app.MarketplaceGetInput) (app.RegistryItem, error) {
+	if err := input.Validate(); err != nil {
+		return app.RegistryItem{}, models.NewGenericValidationError(err)
+	}
+
+	return s.adapter.GetMarketplaceListing(ctx, input)
+}
+
+func (s *Service) ListMarketplaceListings(ctx context.Context, input app.MarketplaceListInput) (pagination.Result[app.RegistryItem], error) {
+	if err := input.Validate(); err != nil {
+		return pagination.Result[app.RegistryItem]{}, models.NewGenericValidationError(err)
+	}
+
+	return s.adapter.ListMarketplaceListings(ctx, input)
+}
+
+func (s *Service) InstallApp(ctx context.Context, input app.InstallAppV3Input) (app.InstallAppV3Output, error) {
+	if err := input.Validate(); err != nil {
+		return app.InstallAppV3Output{}, models.NewGenericValidationError(err)
+	}
+
+	return transaction.Run(ctx, s.adapter, func(ctx context.Context) (app.InstallAppV3Output, error) {
+		var installedApp app.App
+		var err error
+		if input.APIKey != nil {
+			installedApp, err = s.adapter.InstallMarketplaceListingWithAPIKey(ctx, app.InstallAppWithAPIKeyInput{
+				InstallAppInput: app.InstallAppInput{
+					MarketplaceListingID: app.MarketplaceListingID{
+						Type: input.Type,
+					},
+					Namespace: input.Namespace,
+					Name:      input.Name,
+				},
+				APIKey: *input.APIKey,
+			})
+		} else {
+			installedApp, err = s.adapter.InstallMarketplaceListing(ctx, app.InstallAppInput{
+				MarketplaceListingID: input.MarketplaceListingID,
+				Namespace:            input.Namespace,
+				Name:                 input.Name,
+			})
+		}
+
+		if err != nil {
+			return app.InstallAppV3Output{}, err
+		}
+
+		out := app.InstallAppV3Output{
+			App: installedApp,
+		}
+
+		if input.CreateDefaultBillingProfile {
+			if input.CreateDefaultBillingProfileFn == nil {
+				return app.InstallAppV3Output{}, errors.New("create default billing profile function is required when CreateDefaultBillingProfile is true")
+			}
+			defaultForCapabilityTypes, err := input.CreateDefaultBillingProfileFn(ctx, installedApp)
+			if err != nil {
+				return app.InstallAppV3Output{}, fmt.Errorf("create billing profile: %w", err)
+			}
+
+			out.DefaultCapabilies = defaultForCapabilityTypes
+		}
+
+		return out, nil
+	})
+}
+
+func (s *Service) GetMarketplaceListingOauth2InstallURL(ctx context.Context, input app.GetOauth2InstallURLInput) (app.GetOauth2InstallURLOutput, error) {
+	if err := input.Validate(); err != nil {
+		return app.GetOauth2InstallURLOutput{}, models.NewGenericValidationError(err)
+	}
+
+	return s.adapter.GetMarketplaceListingOauth2InstallURL(ctx, input)
+}
+
+func (s *Service) AuthorizeMarketplaceListingOauth2Install(ctx context.Context, input app.AuthorizeOauth2InstallInput) error {
+	if err := input.Validate(); err != nil {
+		return models.NewGenericValidationError(err)
+	}
+
+	return s.adapter.AuthorizeMarketplaceListingOauth2Install(ctx, input)
+}