feat: authenticator events for user v3 API

internal/repository/user/authenticator/aggregate.go

@@ -0,0 +1,27 @@
+package authenticator
+
+import (
+	"github.com/zitadel/zitadel/internal/eventstore"
+)
+
+const (
+	AggregateType    = "authenticator"
+	AggregateVersion = "v1"
+
+	eventPrefix = "authenticator."
+)
+
+type Aggregate struct {
+	eventstore.Aggregate
+}
+
+func NewAggregate(id, resourceOwner string) *Aggregate {
+	return &Aggregate{
+		Aggregate: eventstore.Aggregate{
+			Type:          AggregateType,
+			Version:       AggregateVersion,
+			ID:            id,
+			ResourceOwner: resourceOwner,
+		},
+	}
+}

internal/repository/user/authenticator/eventstore.go

@@ -0,0 +1,10 @@
+package authenticator
+
+import "github.com/zitadel/zitadel/internal/eventstore"
+
+func init() {
+	eventstore.RegisterFilterEventMapper(AggregateType, UsernameCreatedType, eventstore.GenericEventMapper[UsernameCreatedEvent])
+	eventstore.RegisterFilterEventMapper(AggregateType, UsernameDeletedType, eventstore.GenericEventMapper[UsernameDeletedEvent])
+	eventstore.RegisterFilterEventMapper(AggregateType, PasswordCreatedType, eventstore.GenericEventMapper[PasswordCreatedEvent])
+	eventstore.RegisterFilterEventMapper(AggregateType, PasswordDeletedType, eventstore.GenericEventMapper[PasswordDeletedEvent])
+}

internal/repository/user/authenticator/jwt.go

@@ -0,0 +1,86 @@
+package authenticator
+
+import (
+	"context"
+	"time"
+
+	"github.com/zitadel/zitadel/internal/api/http"
+	"github.com/zitadel/zitadel/internal/eventstore"
+)
+
+const (
+	jwtPrefix      = eventPrefix + "jwt."
+	JWTCreatedType = jwtPrefix + "created"
+	JWTDeletedType = jwtPrefix + "deleted"
+)
+
+type JWTCreatedEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+
+	UserID string `json:"userID"`
+
+	ExpirationDate time.Time `json:"expirationDate,omitempty"`
+	PublicKey      []byte    `json:"publicKey,omitempty"`
+	TriggerOrigin  string    `json:"triggerOrigin,omitempty"`
+}
+
+func (e *JWTCreatedEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+
+func (e *JWTCreatedEvent) Payload() interface{} {
+	return e
+}
+
+func (e *JWTCreatedEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+func NewJWTCreatedEvent(
+	ctx context.Context,
+	aggregate *eventstore.Aggregate,
+	userID string,
+	expirationDate time.Time,
+	publicKey []byte,
+) *JWTCreatedEvent {
+	return &JWTCreatedEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			JWTCreatedType,
+		),
+		UserID:         userID,
+		ExpirationDate: expirationDate,
+		PublicKey:      publicKey,
+		TriggerOrigin:  http.DomainContext(ctx).Origin(),
+	}
+}
+
+type JWTDeletedEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+}
+
+func (e *JWTDeletedEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+
+func (e *JWTDeletedEvent) Payload() interface{} {
+	return e
+}
+
+func (e *JWTDeletedEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+func NewJWTDeletedEvent(
+	ctx context.Context,
+	aggregate *eventstore.Aggregate,
+) *JWTDeletedEvent {
+	return &JWTDeletedEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			JWTDeletedType,
+		),
+	}
+}

internal/repository/user/authenticator/password.go

@@ -0,0 +1,84 @@
+package authenticator
+
+import (
+	"context"
+
+	"github.com/zitadel/zitadel/internal/api/http"
+	"github.com/zitadel/zitadel/internal/eventstore"
+)
+
+const (
+	passwordPrefix      = eventPrefix + "password."
+	PasswordCreatedType = passwordPrefix + "created"
+	PasswordDeletedType = passwordPrefix + "deleted"
+)
+
+type PasswordCreatedEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+
+	UserID         string `json:"userID"`
+	EncodedHash    string `json:"encodedHash,omitempty"`
+	ChangeRequired bool   `json:"changeRequired,omitempty"`
+	TriggerOrigin  string `json:"triggerOrigin,omitempty"`
+}
+
+func (e *PasswordCreatedEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+
+func (e *PasswordCreatedEvent) Payload() interface{} {
+	return e
+}
+
+func (e *PasswordCreatedEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+func NewPasswordCreatedEvent(
+	ctx context.Context,
+	aggregate *eventstore.Aggregate,
+	userID string,
+	encodeHash string,
+	changeRequired bool,
+) *PasswordCreatedEvent {
+	return &PasswordCreatedEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			PasswordCreatedType,
+		),
+		UserID:         userID,
+		EncodedHash:    encodeHash,
+		ChangeRequired: changeRequired,
+		TriggerOrigin:  http.DomainContext(ctx).Origin(),
+	}
+}
+
+type PasswordDeletedEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+}
+
+func (e *PasswordDeletedEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+
+func (e *PasswordDeletedEvent) Payload() interface{} {
+	return e
+}
+
+func (e *PasswordDeletedEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+func NewPasswordDeletedEvent(
+	ctx context.Context,
+	aggregate *eventstore.Aggregate,
+) *PasswordDeletedEvent {
+	return &PasswordDeletedEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			PasswordDeletedType,
+		),
+	}
+}

internal/repository/user/authenticator/pat.go

@@ -0,0 +1,86 @@
+package authenticator
+
+import (
+	"context"
+	"time"
+
+	"github.com/zitadel/zitadel/internal/api/http"
+	"github.com/zitadel/zitadel/internal/eventstore"
+)
+
+const (
+	patPrefix      = eventPrefix + "pat."
+	PATCreatedType = patPrefix + "created"
+	PATDeletedType = patPrefix + "deleted"
+)
+
+type PATCreatedEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+
+	UserID string `json:"userID"`
+
+	ExpirationDate time.Time `json:"expirationDate,omitempty"`
+	Scopes         []string  `json:"scopes"`
+	TriggerOrigin  string    `json:"triggerOrigin,omitempty"`
+}
+
+func (e *PATCreatedEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+
+func (e *PATCreatedEvent) Payload() interface{} {
+	return e
+}
+
+func (e *PATCreatedEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+func NewPATCreatedEvent(
+	ctx context.Context,
+	aggregate *eventstore.Aggregate,
+	userID string,
+	expirationDate time.Time,
+	scopes []string,
+) *PATCreatedEvent {
+	return &PATCreatedEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			PATCreatedType,
+		),
+		UserID:         userID,
+		ExpirationDate: expirationDate,
+		Scopes:         scopes,
+		TriggerOrigin:  http.DomainContext(ctx).Origin(),
+	}
+}
+
+type PATDeletedEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+}
+
+func (e *PATDeletedEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+
+func (e *PATDeletedEvent) Payload() interface{} {
+	return e
+}
+
+func (e *PATDeletedEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+func NewPATDeletedEvent(
+	ctx context.Context,
+	aggregate *eventstore.Aggregate,
+) *PATDeletedEvent {
+	return &PATDeletedEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			PATDeletedType,
+		),
+	}
+}

internal/repository/user/authenticator/username.go

@@ -0,0 +1,117 @@
+package authenticator
+
+import (
+	"context"
+
+	"github.com/zitadel/zitadel/internal/eventstore"
+)
+
+const (
+	usernamePrefix      = eventPrefix + "username."
+	UsernameCreatedType = usernamePrefix + "created"
+	UsernameDeletedType = usernamePrefix + "deleted"
+
+	uniqueUsernameType = "username"
+)
+
+func NewAddUsernameUniqueConstraint(resourceOwner string, isOrgSpecific bool, username string) *eventstore.UniqueConstraint {
+	if isOrgSpecific {
+		return eventstore.NewAddEventUniqueConstraint(
+			uniqueUsernameType,
+			resourceOwner+":"+username,
+			"TODO")
+	}
+
+	return eventstore.NewAddEventUniqueConstraint(
+		uniqueUsernameType,
+		username,
+		"TODO")
+}
+
+func NewRemoveUsernameUniqueConstraint(resourceOwner string, isOrgSpecific bool, username string) *eventstore.UniqueConstraint {
+	if isOrgSpecific {
+		return eventstore.NewRemoveUniqueConstraint(
+			uniqueUsernameType,
+			resourceOwner+":"+username,
+		)
+	}
+
+	return eventstore.NewRemoveUniqueConstraint(
+		uniqueUsernameType,
+		username,
+	)
+}
+
+type UsernameCreatedEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+
+	UserID        string `json:"userID"`
+	IsOrgSpecific bool   `json:"isOrgSpecific"`
+	Username      string `json:"username"`
+}
+
+func (e *UsernameCreatedEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+
+func (e *UsernameCreatedEvent) Payload() interface{} {
+	return e
+}
+
+func (e *UsernameCreatedEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return []*eventstore.UniqueConstraint{NewAddUsernameUniqueConstraint(e.Agg.ResourceOwner, e.IsOrgSpecific, e.Username)}
+}
+
+func NewUsernameCreatedEvent(
+	ctx context.Context,
+	aggregate *eventstore.Aggregate,
+	userID string,
+	isOrgSpecific bool,
+	username string,
+) *UsernameCreatedEvent {
+	return &UsernameCreatedEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			UsernameCreatedType,
+		),
+	}
+}
+
+type UsernameDeletedEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+
+	isOrgSpecific bool
+	username      string
+}
+
+func (e *UsernameDeletedEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+
+func (e *UsernameDeletedEvent) Payload() interface{} {
+	return e
+}
+
+func (e *UsernameDeletedEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return []*eventstore.UniqueConstraint{
+		NewRemoveUsernameUniqueConstraint(e.Agg.ResourceOwner, e.isOrgSpecific, e.username),
+	}
+}
+
+func NewUsernameDeletedEvent(
+	ctx context.Context,
+	aggregate *eventstore.Aggregate,
+	isOrgSpecific bool,
+	username string,
+) *UsernameDeletedEvent {
+	return &UsernameDeletedEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			UsernameDeletedType,
+		),
+		isOrgSpecific: isOrgSpecific,
+		username:      username,
+	}
+}