chore: move the go code into a subfolder

apps/api/internal/repository/user/schemauser/aggregate.go

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

apps/api/internal/repository/user/schemauser/email.go

@@ -0,0 +1,175 @@
+package schemauser
+
+import (
+	"context"
+	"time"
+
+	"github.com/zitadel/zitadel/internal/api/http"
+	"github.com/zitadel/zitadel/internal/crypto"
+	"github.com/zitadel/zitadel/internal/domain"
+	"github.com/zitadel/zitadel/internal/eventstore"
+)
+
+const (
+	emailEventPrefix            = eventPrefix + "email."
+	EmailUpdatedType            = emailEventPrefix + "updated"
+	EmailVerifiedType           = emailEventPrefix + "verified"
+	EmailVerificationFailedType = emailEventPrefix + "verification.failed"
+	EmailCodeAddedType          = emailEventPrefix + "code.added"
+	EmailCodeSentType           = emailEventPrefix + "code.sent"
+)
+
+type EmailUpdatedEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+
+	EmailAddress domain.EmailAddress `json:"email,omitempty"`
+}
+
+func (e *EmailUpdatedEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+
+func (e *EmailUpdatedEvent) Payload() interface{} {
+	return e
+}
+
+func (e *EmailUpdatedEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+func NewEmailUpdatedEvent(ctx context.Context, aggregate *eventstore.Aggregate, emailAddress domain.EmailAddress) *EmailUpdatedEvent {
+	return &EmailUpdatedEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			EmailUpdatedType,
+		),
+		EmailAddress: emailAddress,
+	}
+}
+
+type EmailVerifiedEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+
+	IsEmailVerified bool `json:"-"`
+}
+
+func (e *EmailVerifiedEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+
+func (e *EmailVerifiedEvent) Payload() interface{} {
+	return nil
+}
+
+func (e *EmailVerifiedEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+func NewEmailVerifiedEvent(ctx context.Context, aggregate *eventstore.Aggregate) *EmailVerifiedEvent {
+	return &EmailVerifiedEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			EmailVerifiedType,
+		),
+	}
+}
+
+type EmailVerificationFailedEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+}
+
+func (e *EmailVerificationFailedEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+func (e *EmailVerificationFailedEvent) Payload() interface{} {
+	return nil
+}
+
+func (e *EmailVerificationFailedEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+func NewEmailVerificationFailedEvent(ctx context.Context, aggregate *eventstore.Aggregate) *EmailVerificationFailedEvent {
+	return &EmailVerificationFailedEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			EmailVerificationFailedType,
+		),
+	}
+}
+
+type EmailCodeAddedEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+
+	Code              *crypto.CryptoValue `json:"code,omitempty"`
+	Expiry            time.Duration       `json:"expiry,omitempty"`
+	URLTemplate       string              `json:"url_template,omitempty"`
+	CodeReturned      bool                `json:"code_returned,omitempty"`
+	TriggeredAtOrigin string              `json:"triggerOrigin,omitempty"`
+}
+
+func (e *EmailCodeAddedEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+
+func (e *EmailCodeAddedEvent) Payload() interface{} {
+	return e
+}
+
+func (e *EmailCodeAddedEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+func (e *EmailCodeAddedEvent) TriggerOrigin() string {
+	return e.TriggeredAtOrigin
+}
+
+func NewEmailCodeAddedEvent(
+	ctx context.Context,
+	aggregate *eventstore.Aggregate,
+	code *crypto.CryptoValue,
+	expiry time.Duration,
+	urlTemplate string,
+	codeReturned bool,
+) *EmailCodeAddedEvent {
+	return &EmailCodeAddedEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			EmailCodeAddedType,
+		),
+		Code:              code,
+		Expiry:            expiry,
+		URLTemplate:       urlTemplate,
+		CodeReturned:      codeReturned,
+		TriggeredAtOrigin: http.DomainContext(ctx).Origin(),
+	}
+}
+
+type EmailCodeSentEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+}
+
+func (e *EmailCodeSentEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+func (e *EmailCodeSentEvent) Payload() interface{} {
+	return nil
+}
+
+func (e *EmailCodeSentEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+func NewEmailCodeSentEvent(ctx context.Context, aggregate *eventstore.Aggregate) *EmailCodeSentEvent {
+	return &EmailCodeSentEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			EmailCodeSentType,
+		),
+	}
+}

apps/api/internal/repository/user/schemauser/eventstore.go

@@ -0,0 +1,23 @@
+package schemauser
+
+import "github.com/zitadel/zitadel/internal/eventstore"
+
+func init() {
+	eventstore.RegisterFilterEventMapper(AggregateType, CreatedType, eventstore.GenericEventMapper[CreatedEvent])
+	eventstore.RegisterFilterEventMapper(AggregateType, UpdatedType, eventstore.GenericEventMapper[UpdatedEvent])
+	eventstore.RegisterFilterEventMapper(AggregateType, DeletedType, eventstore.GenericEventMapper[DeletedEvent])
+	eventstore.RegisterFilterEventMapper(AggregateType, LockedType, eventstore.GenericEventMapper[LockedEvent])
+	eventstore.RegisterFilterEventMapper(AggregateType, UnlockedType, eventstore.GenericEventMapper[UnlockedEvent])
+	eventstore.RegisterFilterEventMapper(AggregateType, ActivatedType, eventstore.GenericEventMapper[ActivatedEvent])
+	eventstore.RegisterFilterEventMapper(AggregateType, DeactivatedType, eventstore.GenericEventMapper[DeactivatedEvent])
+	eventstore.RegisterFilterEventMapper(AggregateType, EmailUpdatedType, eventstore.GenericEventMapper[EmailUpdatedEvent])
+	eventstore.RegisterFilterEventMapper(AggregateType, EmailCodeAddedType, eventstore.GenericEventMapper[EmailCodeAddedEvent])
+	eventstore.RegisterFilterEventMapper(AggregateType, EmailCodeSentType, eventstore.GenericEventMapper[EmailCodeSentEvent])
+	eventstore.RegisterFilterEventMapper(AggregateType, EmailVerifiedType, eventstore.GenericEventMapper[EmailVerifiedEvent])
+	eventstore.RegisterFilterEventMapper(AggregateType, EmailVerificationFailedType, eventstore.GenericEventMapper[EmailVerificationFailedEvent])
+	eventstore.RegisterFilterEventMapper(AggregateType, PhoneUpdatedType, eventstore.GenericEventMapper[PhoneUpdatedEvent])
+	eventstore.RegisterFilterEventMapper(AggregateType, PhoneCodeAddedType, eventstore.GenericEventMapper[PhoneCodeAddedEvent])
+	eventstore.RegisterFilterEventMapper(AggregateType, PhoneCodeSentType, eventstore.GenericEventMapper[PhoneCodeSentEvent])
+	eventstore.RegisterFilterEventMapper(AggregateType, PhoneVerifiedType, eventstore.GenericEventMapper[PhoneVerifiedEvent])
+	eventstore.RegisterFilterEventMapper(AggregateType, PhoneVerificationFailedType, eventstore.GenericEventMapper[PhoneVerificationFailedEvent])
+}

apps/api/internal/repository/user/schemauser/phone.go

@@ -0,0 +1,180 @@
+package schemauser
+
+import (
+	"context"
+	"time"
+
+	"github.com/zitadel/zitadel/internal/api/http"
+	"github.com/zitadel/zitadel/internal/crypto"
+	"github.com/zitadel/zitadel/internal/domain"
+	"github.com/zitadel/zitadel/internal/eventstore"
+	"github.com/zitadel/zitadel/internal/notification/senders"
+)
+
+const (
+	phoneEventPrefix            = eventPrefix + "phone."
+	PhoneUpdatedType            = phoneEventPrefix + "updated"
+	PhoneVerifiedType           = phoneEventPrefix + "verified"
+	PhoneVerificationFailedType = phoneEventPrefix + "verification.failed"
+	PhoneCodeAddedType          = phoneEventPrefix + "code.added"
+	PhoneCodeSentType           = phoneEventPrefix + "code.sent"
+)
+
+type PhoneUpdatedEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+
+	PhoneNumber domain.PhoneNumber `json:"phone,omitempty"`
+}
+
+func (e *PhoneUpdatedEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+
+func (e *PhoneUpdatedEvent) Payload() interface{} {
+	return e
+}
+
+func (e *PhoneUpdatedEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+func NewPhoneUpdatedEvent(ctx context.Context, aggregate *eventstore.Aggregate, phone domain.PhoneNumber) *PhoneUpdatedEvent {
+	return &PhoneUpdatedEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			PhoneUpdatedType,
+		),
+		PhoneNumber: phone,
+	}
+}
+
+type PhoneVerifiedEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+
+	IsPhoneVerified bool `json:"-"`
+}
+
+func (e *PhoneVerifiedEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+func (e *PhoneVerifiedEvent) Payload() interface{} {
+	return nil
+}
+
+func (e *PhoneVerifiedEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+func NewPhoneVerifiedEvent(ctx context.Context, aggregate *eventstore.Aggregate) *PhoneVerifiedEvent {
+	return &PhoneVerifiedEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			PhoneVerifiedType,
+		),
+	}
+}
+
+type PhoneVerificationFailedEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+}
+
+func (e *PhoneVerificationFailedEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+
+func (e *PhoneVerificationFailedEvent) Payload() interface{} {
+	return nil
+}
+
+func (e *PhoneVerificationFailedEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+func NewPhoneVerificationFailedEvent(ctx context.Context, aggregate *eventstore.Aggregate) *PhoneVerificationFailedEvent {
+	return &PhoneVerificationFailedEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			PhoneVerificationFailedType,
+		),
+	}
+}
+
+type PhoneCodeAddedEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+
+	Code              *crypto.CryptoValue `json:"code,omitempty"`
+	Expiry            time.Duration       `json:"expiry,omitempty"`
+	CodeReturned      bool                `json:"code_returned,omitempty"`
+	GeneratorID       string              `json:"generatorId,omitempty"`
+	TriggeredAtOrigin string              `json:"triggerOrigin,omitempty"`
+}
+
+func (e *PhoneCodeAddedEvent) Payload() interface{} {
+	return e
+}
+
+func (e *PhoneCodeAddedEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+func (e *PhoneCodeAddedEvent) TriggerOrigin() string {
+	return e.TriggeredAtOrigin
+}
+
+func (e *PhoneCodeAddedEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+
+func NewPhoneCodeAddedEvent(
+	ctx context.Context,
+	aggregate *eventstore.Aggregate,
+	code *crypto.CryptoValue,
+	expiry time.Duration,
+	codeReturned bool,
+	generatorID string,
+) *PhoneCodeAddedEvent {
+	return &PhoneCodeAddedEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			PhoneCodeAddedType,
+		),
+		Code:              code,
+		Expiry:            expiry,
+		CodeReturned:      codeReturned,
+		GeneratorID:       generatorID,
+		TriggeredAtOrigin: http.DomainContext(ctx).Origin(),
+	}
+}
+
+type PhoneCodeSentEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+
+	GeneratorInfo *senders.CodeGeneratorInfo `json:"generatorInfo,omitempty"`
+}
+
+func (e *PhoneCodeSentEvent) Payload() interface{} {
+	return e
+}
+
+func (e *PhoneCodeSentEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+func (e *PhoneCodeSentEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+
+func NewPhoneCodeSentEvent(ctx context.Context, aggregate *eventstore.Aggregate, generatorInfo *senders.CodeGeneratorInfo) *PhoneCodeSentEvent {
+	return &PhoneCodeSentEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			PhoneCodeSentType,
+		),
+		GeneratorInfo: generatorInfo,
+	}
+}

apps/api/internal/repository/user/schemauser/user.go

@@ -0,0 +1,260 @@
+package schemauser
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/zitadel/zitadel/internal/eventstore"
+)
+
+const (
+	eventPrefix     = "schemauser."
+	CreatedType     = eventPrefix + "created"
+	UpdatedType     = eventPrefix + "updated"
+	DeletedType     = eventPrefix + "deleted"
+	LockedType      = eventPrefix + "locked"
+	UnlockedType    = eventPrefix + "unlocked"
+	DeactivatedType = eventPrefix + "deactivated"
+	ActivatedType   = eventPrefix + "activated"
+)
+
+type CreatedEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+	ID                    string          `json:"id"`
+	SchemaID              string          `json:"schemaID"`
+	SchemaRevision        uint64          `json:"schemaRevision"`
+	Data                  json.RawMessage `json:"user,omitempty"`
+}
+
+func (e *CreatedEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+
+func (e *CreatedEvent) Payload() interface{} {
+	return e
+}
+
+func (e *CreatedEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+func NewCreatedEvent(
+	ctx context.Context,
+	aggregate *eventstore.Aggregate,
+
+	schemaID string,
+	schemaRevision uint64,
+	data json.RawMessage,
+) *CreatedEvent {
+	return &CreatedEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			CreatedType,
+		),
+		SchemaID:       schemaID,
+		SchemaRevision: schemaRevision,
+		Data:           data,
+	}
+}
+
+type UpdatedEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+
+	SchemaID       *string         `json:"schemaID,omitempty"`
+	SchemaRevision *uint64         `json:"schemaRevision,omitempty"`
+	Data           json.RawMessage `json:"schema,omitempty"`
+}
+
+func (e *UpdatedEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+
+func (e *UpdatedEvent) Payload() interface{} {
+	return e
+}
+
+func (e *UpdatedEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+func NewUpdatedEvent(
+	ctx context.Context,
+	aggregate *eventstore.Aggregate,
+	changes []Changes,
+) *UpdatedEvent {
+	updatedEvent := &UpdatedEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			UpdatedType,
+		),
+	}
+	for _, change := range changes {
+		change(updatedEvent)
+	}
+	return updatedEvent
+}
+
+type Changes func(event *UpdatedEvent)
+
+func ChangeSchemaID(schemaID string) func(event *UpdatedEvent) {
+	return func(e *UpdatedEvent) {
+		e.SchemaID = &schemaID
+	}
+}
+func ChangeSchemaRevision(schemaRevision uint64) func(event *UpdatedEvent) {
+	return func(e *UpdatedEvent) {
+		e.SchemaRevision = &schemaRevision
+	}
+}
+
+func ChangeData(data json.RawMessage) func(event *UpdatedEvent) {
+	return func(e *UpdatedEvent) {
+		e.Data = data
+	}
+}
+
+type DeletedEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+}
+
+func (e *DeletedEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+
+func (e *DeletedEvent) Payload() interface{} {
+	return e
+}
+
+func (e *DeletedEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+func NewDeletedEvent(
+	ctx context.Context,
+	aggregate *eventstore.Aggregate,
+) *DeletedEvent {
+	return &DeletedEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			DeletedType,
+		),
+	}
+}
+
+type LockedEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+}
+
+func (e *LockedEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+
+func (e *LockedEvent) Payload() interface{} {
+	return e
+}
+
+func (e *LockedEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+func NewLockedEvent(
+	ctx context.Context,
+	aggregate *eventstore.Aggregate,
+) *LockedEvent {
+	return &LockedEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			LockedType,
+		),
+	}
+}
+
+type UnlockedEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+}
+
+func (e *UnlockedEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+
+func (e *UnlockedEvent) Payload() interface{} {
+	return e
+}
+
+func (e *UnlockedEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+func NewUnlockedEvent(
+	ctx context.Context,
+	aggregate *eventstore.Aggregate,
+) *UnlockedEvent {
+	return &UnlockedEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			UnlockedType,
+		),
+	}
+}
+
+type DeactivatedEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+}
+
+func (e *DeactivatedEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+
+func (e *DeactivatedEvent) Payload() interface{} {
+	return e
+}
+
+func (e *DeactivatedEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+func NewDeactivatedEvent(
+	ctx context.Context,
+	aggregate *eventstore.Aggregate,
+) *DeactivatedEvent {
+	return &DeactivatedEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			DeactivatedType,
+		),
+	}
+}
+
+type ActivatedEvent struct {
+	*eventstore.BaseEvent `json:"-"`
+}
+
+func (e *ActivatedEvent) SetBaseEvent(event *eventstore.BaseEvent) {
+	e.BaseEvent = event
+}
+
+func (e *ActivatedEvent) Payload() interface{} {
+	return e
+}
+
+func (e *ActivatedEvent) UniqueConstraints() []*eventstore.UniqueConstraint {
+	return nil
+}
+
+func NewActivatedEvent(
+	ctx context.Context,
+	aggregate *eventstore.Aggregate,
+) *ActivatedEvent {
+	return &ActivatedEvent{
+		BaseEvent: eventstore.NewBaseEventForPush(
+			ctx,
+			aggregate,
+			ActivatedType,
+		),
+	}
+}