TheArchive/zitadel
1
0
Fork 0
mirror of https://github.com/zitadel/zitadel.git synced 2025-08-12 01:37:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat(eventstore): increase parallel write capabilities (#5940)

Browse Source 
This implementation increases parallel write capabilities of the eventstore.
Please have a look at the technical advisories: [05](https://zitadel.com/docs/support/advisory/a10005) and  [06](https://zitadel.com/docs/support/advisory/a10006).
The implementation of eventstore.push is rewritten and stored events are migrated to a new table `eventstore.events2`.
If you are using cockroach: make sure that the database user of ZITADEL has `VIEWACTIVITY` grant. This is used to query events.
This commit is contained in:
Silvan
2023-10-19 12:19:10 +02:00
committed by GitHub
parent 259faba3f0
commit b5564572bc
791 changed files with 30326 additions and 43202 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
internal/auth/repository/eventsourcing/eventstore/auth_request.go
View File

@@ -16,7 +16,6 @@ import (
"github.com/zitadel/zitadel/internal/domain"
"github.com/zitadel/zitadel/internal/errors"
"github.com/zitadel/zitadel/internal/eventstore"
v1 "github.com/zitadel/zitadel/internal/eventstore/v1"
es_models "github.com/zitadel/zitadel/internal/eventstore/v1/models"
"github.com/zitadel/zitadel/internal/id"
"github.com/zitadel/zitadel/internal/query"
@@ -24,7 +23,6 @@ import (
"github.com/zitadel/zitadel/internal/telemetry/tracing"
user_model "github.com/zitadel/zitadel/internal/user/model"
user_view_model "github.com/zitadel/zitadel/internal/user/repository/view/model"
"github.com/zitadel/zitadel/internal/view/repository"
)
const unknownUserID = "UNKNOWN"
@@ -34,7 +32,6 @@ type AuthRequestRepo struct {
Query *query.Queries
AuthRequests cache.AuthRequestCache
View *view.View
Eventstore v1.Eventstore
UserCodeAlg crypto.EncryptionAlgorithm
LabelPolicyProvider labelPolicyProvider
@@ -69,7 +66,7 @@ type privacyPolicyProvider interface {
type userSessionViewProvider interface {
UserSessionByIDs(string, string, string) (*user_view_model.UserSessionView, error)
UserSessionsByAgentID(string, string) ([]*user_view_model.UserSessionView, error)
GetLatestUserSessionSequence(ctx context.Context, instanceID string) (*repository.CurrentSequence, error)
GetLatestUserSessionSequence(ctx context.Context, instanceID string) (*query.CurrentState, error)
}
type userViewProvider interface {
@@ -93,7 +90,7 @@ type idpUserLinksProvider interface {
}
type userEventProvider interface {
UserEventsByID(ctx context.Context, id string, sequence uint64, eventTypes []es_models.EventType) ([]*es_models.Event, error)
UserEventsByID(ctx context.Context, id string, sequence uint64, eventTypes []eventstore.EventType) ([]eventstore.Event, error)
}
type userCommandProvider interface {
@@ -1436,25 +1433,25 @@ func userSessionsByUserAgentID(ctx context.Context, provider userSessionViewProv
}
var (
userSessionEventTypes = []es_models.EventType{
es_models.EventType(user_repo.UserV1PasswordCheckSucceededType),
es_models.EventType(user_repo.UserV1PasswordCheckFailedType),
es_models.EventType(user_repo.UserV1MFAOTPCheckSucceededType),
es_models.EventType(user_repo.UserV1MFAOTPCheckFailedType),
es_models.EventType(user_repo.UserV1SignedOutType),
es_models.EventType(user_repo.UserLockedType),
es_models.EventType(user_repo.UserDeactivatedType),
es_models.EventType(user_repo.HumanPasswordCheckSucceededType),
es_models.EventType(user_repo.HumanPasswordCheckFailedType),
es_models.EventType(user_repo.UserIDPLoginCheckSucceededType),
es_models.EventType(user_repo.HumanMFAOTPCheckSucceededType),
es_models.EventType(user_repo.HumanMFAOTPCheckFailedType),
es_models.EventType(user_repo.HumanSignedOutType),
es_models.EventType(user_repo.HumanPasswordlessTokenCheckSucceededType),
es_models.EventType(user_repo.HumanPasswordlessTokenCheckFailedType),
es_models.EventType(user_repo.HumanU2FTokenCheckSucceededType),
es_models.EventType(user_repo.HumanU2FTokenCheckFailedType),
es_models.EventType(user_repo.UserRemovedType),
userSessionEventTypes = []eventstore.EventType{
user_repo.UserV1PasswordCheckSucceededType,
user_repo.UserV1PasswordCheckFailedType,
user_repo.UserV1MFAOTPCheckSucceededType,
user_repo.UserV1MFAOTPCheckFailedType,
user_repo.UserV1SignedOutType,
user_repo.UserLockedType,
user_repo.UserDeactivatedType,
user_repo.HumanPasswordCheckSucceededType,
user_repo.HumanPasswordCheckFailedType,
user_repo.UserIDPLoginCheckSucceededType,
user_repo.HumanMFAOTPCheckSucceededType,
user_repo.HumanMFAOTPCheckFailedType,
user_repo.HumanSignedOutType,
user_repo.HumanPasswordlessTokenCheckSucceededType,
user_repo.HumanPasswordlessTokenCheckFailedType,
user_repo.HumanU2FTokenCheckSucceededType,
user_repo.HumanU2FTokenCheckFailedType,
user_repo.UserRemovedType,
}
)
@@ -1471,7 +1468,7 @@ func userSessionByIDs(ctx context.Context, provider userSessionViewProvider, eve
Errorf("could not get current sequence for userSessionByIDs")
session = &user_view_model.UserSessionView{UserAgentID: agentID, UserID: user.ID}
if sequence != nil {
session.Sequence = sequence.CurrentSequence
session.Sequence = sequence.Sequence
}
}
events, err := eventProvider.UserEventsByID(ctx, user.ID, session.Sequence, append(session.EventTypes(), userSessionEventTypes...))
@@ -1481,7 +1478,7 @@ func userSessionByIDs(ctx context.Context, provider userSessionViewProvider, eve
}
sessionCopy := *session
for _, event := range events {
switch eventstore.EventType(event.Type) {
switch event.Type() {
case user_repo.UserV1PasswordCheckSucceededType,
user_repo.UserV1PasswordCheckFailedType,
user_repo.UserV1MFAOTPCheckSucceededType,

52
internal/auth/repository/eventsourcing/eventstore/auth_request_test.go
View File

@@ -15,13 +15,13 @@ import (
"github.com/zitadel/zitadel/internal/crypto"
"github.com/zitadel/zitadel/internal/domain"
"github.com/zitadel/zitadel/internal/errors"
"github.com/zitadel/zitadel/internal/eventstore"
es_models "github.com/zitadel/zitadel/internal/eventstore/v1/models"
"github.com/zitadel/zitadel/internal/query"
user_repo "github.com/zitadel/zitadel/internal/repository/user"
user_model "github.com/zitadel/zitadel/internal/user/model"
user_es_model "github.com/zitadel/zitadel/internal/user/repository/eventsourcing/model"
user_view_model "github.com/zitadel/zitadel/internal/user/repository/view/model"
"github.com/zitadel/zitadel/internal/view/repository"
)
var (
@@ -38,8 +38,8 @@ func (m *mockViewNoUserSession) UserSessionsByAgentID(string, string) ([]*user_v
return nil, nil
}
func (m *mockViewNoUserSession) GetLatestUserSessionSequence(ctx context.Context, instanceID string) (*repository.CurrentSequence, error) {
return &repository.CurrentSequence{}, nil
func (m *mockViewNoUserSession) GetLatestUserSessionSequence(ctx context.Context, instanceID string) (*query.CurrentState, error) {
return &query.CurrentState{State: query.State{Sequence: 0}}, nil
}
type mockViewErrUserSession struct{}
@@ -52,8 +52,8 @@ func (m *mockViewErrUserSession) UserSessionsByAgentID(string, string) ([]*user_
return nil, errors.ThrowInternal(nil, "id", "internal error")
}
func (m *mockViewErrUserSession) GetLatestUserSessionSequence(ctx context.Context, instanceID string) (*repository.CurrentSequence, error) {
return &repository.CurrentSequence{}, nil
func (m *mockViewErrUserSession) GetLatestUserSessionSequence(ctx context.Context, instanceID string) (*query.CurrentState, error) {
return &query.CurrentState{State: query.State{Sequence: 0}}, nil
}
type mockViewUserSession struct {
@@ -95,8 +95,8 @@ func (m *mockViewUserSession) UserSessionsByAgentID(string, string) ([]*user_vie
return sessions, nil
}
func (m *mockViewUserSession) GetLatestUserSessionSequence(ctx context.Context, instanceID string) (*repository.CurrentSequence, error) {
return &repository.CurrentSequence{}, nil
func (m *mockViewUserSession) GetLatestUserSessionSequence(ctx context.Context, instanceID string) (*query.CurrentState, error) {
return &query.CurrentState{State: query.State{Sequence: 0}}, nil
}
type mockViewNoUser struct{}
@@ -106,15 +106,18 @@ func (m *mockViewNoUser) UserByID(string, string) (*user_view_model.UserView, er
}
type mockEventUser struct {
Event *es_models.Event
Event eventstore.Event
}
func (m *mockEventUser) UserEventsByID(ctx context.Context, id string, sequence uint64, types []es_models.EventType) ([]*es_models.Event, error) {
events := make([]*es_models.Event, 0)
func (m *mockEventUser) UserEventsByID(ctx context.Context, id string, sequence uint64, types []eventstore.EventType) ([]eventstore.Event, error) {
if m.Event != nil {
events = append(events, m.Event)
return []eventstore.Event{m.Event}, nil
}
return events, nil
return nil, nil
}
func (m *mockEventUser) GetLatestUserSessionSequence(ctx context.Context, instanceID string) (*query.CurrentState, error) {
return &query.CurrentState{State: query.State{Sequence: 0}}, nil
}
func (m *mockEventUser) BulkAddExternalIDPs(ctx context.Context, userID string, externalIDPs []*user_model.ExternalIDP) error {
@@ -123,7 +126,7 @@ func (m *mockEventUser) BulkAddExternalIDPs(ctx context.Context, userID string,
type mockEventErrUser struct{}
func (m *mockEventErrUser) UserEventsByID(ctx context.Context, id string, sequence uint64, types []es_models.EventType) ([]*es_models.Event, error) {
func (m *mockEventErrUser) UserEventsByID(ctx context.Context, id string, sequence uint64, types []eventstore.EventType) ([]eventstore.Event, error) {
return nil, errors.ThrowInternal(nil, "id", "internal error")
}
@@ -672,7 +675,7 @@ func TestAuthRequestRepo_nextSteps(t *testing.T) {
userEventProvider: &mockEventUser{
&es_models.Event{
AggregateType: user_repo.AggregateType,
Type: es_models.EventType(user_repo.UserDeactivatedType),
Typ: user_repo.UserDeactivatedType,
},
},
orgViewProvider: &mockViewOrg{State: domain.OrgStateActive},
@@ -694,7 +697,7 @@ func TestAuthRequestRepo_nextSteps(t *testing.T) {
userEventProvider: &mockEventUser{
&es_models.Event{
AggregateType: user_repo.AggregateType,
Type: es_models.EventType(user_repo.UserLockedType),
Typ: user_repo.UserLockedType,
},
},
orgViewProvider: &mockViewOrg{State: domain.OrgStateActive},
@@ -2099,7 +2102,7 @@ func Test_userSessionByIDs(t *testing.T) {
eventProvider: &mockEventUser{
&es_models.Event{
AggregateType: user_repo.AggregateType,
Type: es_models.EventType(user_repo.UserV1MFAOTPCheckSucceededType),
Typ: user_repo.UserV1MFAOTPCheckSucceededType,
CreationDate: testNow,
},
},
@@ -2122,7 +2125,7 @@ func Test_userSessionByIDs(t *testing.T) {
eventProvider: &mockEventUser{
&es_models.Event{
AggregateType: user_repo.AggregateType,
Type: es_models.EventType(user_repo.UserV1MFAOTPCheckSucceededType),
Typ: user_repo.UserV1MFAOTPCheckSucceededType,
CreationDate: testNow,
Data: func() []byte {
data, _ := json.Marshal(&user_es_model.AuthRequest{UserAgentID: "otherID"})
@@ -2149,7 +2152,7 @@ func Test_userSessionByIDs(t *testing.T) {
eventProvider: &mockEventUser{
&es_models.Event{
AggregateType: user_repo.AggregateType,
Type: es_models.EventType(user_repo.UserV1MFAOTPCheckSucceededType),
Typ: user_repo.UserV1MFAOTPCheckSucceededType,
CreationDate: testNow,
Data: func() []byte {
data, _ := json.Marshal(&user_es_model.AuthRequest{UserAgentID: "agentID"})
@@ -2176,7 +2179,7 @@ func Test_userSessionByIDs(t *testing.T) {
eventProvider: &mockEventUser{
&es_models.Event{
AggregateType: user_repo.AggregateType,
Type: es_models.EventType(user_repo.UserRemovedType),
Typ: user_repo.UserRemovedType,
},
},
},
@@ -2243,14 +2246,7 @@ func Test_userByID(t *testing.T) {
viewProvider: &mockViewUser{
PasswordChangeRequired: true,
},
eventProvider: &mockEventUser{
&es_models.Event{
AggregateType: user_repo.AggregateType,
Type: es_models.EventType(user_repo.UserV1PasswordChangedType),
CreationDate: testNow,
Data: nil,
},
},
eventProvider: &mockEventErrUser{},
},
&user_model.UserView{
State: user_model.UserStateActive,
@@ -2272,7 +2268,7 @@ func Test_userByID(t *testing.T) {
eventProvider: &mockEventUser{
&es_models.Event{
AggregateType: user_repo.AggregateType,
Type: es_models.EventType(user_repo.UserV1PasswordChangedType),
Typ: user_repo.UserV1PasswordChangedType,
CreationDate: testNow,
Data: func() []byte {
data, _ := json.Marshal(user_es_model.Password{ChangeRequired: false, Secret: &crypto.CryptoValue{}})

4
internal/auth/repository/eventsourcing/eventstore/org.go
View File

@@ -7,7 +7,7 @@ import (
auth_view "github.com/zitadel/zitadel/internal/auth/repository/eventsourcing/view"
"github.com/zitadel/zitadel/internal/config/systemdefaults"
"github.com/zitadel/zitadel/internal/domain"
eventstore "github.com/zitadel/zitadel/internal/eventstore/v1"
"github.com/zitadel/zitadel/internal/eventstore"
iam_model "github.com/zitadel/zitadel/internal/iam/model"
iam_view_model "github.com/zitadel/zitadel/internal/iam/repository/view/model"
"github.com/zitadel/zitadel/internal/query"
@@ -16,7 +16,7 @@ import (
type OrgRepository struct {
SearchLimit uint64
Eventstore eventstore.Eventstore
Eventstore *eventstore.Eventstore
View *auth_view.View
SystemDefaults systemdefaults.SystemDefaults
Query *query.Queries

19
internal/auth/repository/eventsourcing/eventstore/refresh_token.go
View File

@@ -11,8 +11,7 @@ import (
"github.com/zitadel/zitadel/internal/crypto"
"github.com/zitadel/zitadel/internal/domain"
"github.com/zitadel/zitadel/internal/errors"
v1 "github.com/zitadel/zitadel/internal/eventstore/v1"
"github.com/zitadel/zitadel/internal/eventstore/v1/models"
"github.com/zitadel/zitadel/internal/eventstore"
"github.com/zitadel/zitadel/internal/telemetry/tracing"
usr_model "github.com/zitadel/zitadel/internal/user/model"
usr_view "github.com/zitadel/zitadel/internal/user/repository/view"
@@ -20,7 +19,7 @@ import (
)
type RefreshTokenRepo struct {
Eventstore v1.Eventstore
Eventstore *eventstore.Eventstore
View *view.View
SearchLimit uint64
KeyAlgorithm crypto.EncryptionAlgorithm
@@ -48,7 +47,7 @@ func (r *RefreshTokenRepo) RefreshTokenByID(ctx context.Context, tokenID, userID
return nil, viewErr
}
if errors.IsNotFound(viewErr) {
sequence, err := r.View.GetLatestRefreshTokenSequence(ctx, instanceID)
sequence, err := r.View.GetLatestRefreshTokenSequence(ctx)
logging.WithFields("instanceID", instanceID, "userID", userID, "tokenID", tokenID).
OnError(err).
Errorf("could not get current sequence for RefreshTokenByID")
@@ -58,7 +57,7 @@ func (r *RefreshTokenRepo) RefreshTokenByID(ctx context.Context, tokenID, userID
tokenView.UserID = userID
tokenView.InstanceID = instanceID
if sequence != nil {
tokenView.Sequence = sequence.CurrentSequence
tokenView.Sequence = sequence.Sequence
}
}
@@ -89,7 +88,7 @@ func (r *RefreshTokenRepo) SearchMyRefreshTokens(ctx context.Context, userID str
if err != nil {
return nil, err
}
sequence, err := r.View.GetLatestRefreshTokenSequence(ctx, authz.GetInstance(ctx).InstanceID())
sequence, err := r.View.GetLatestRefreshTokenSequence(ctx)
logging.Log("EVENT-GBdn4").OnError(err).WithField("traceID", tracing.TraceIDFromCtx(ctx)).Warn("could not read latest refresh token sequence")
request.Queries = append(request.Queries, &usr_model.RefreshTokenSearchQuery{Key: usr_model.RefreshTokenSearchKeyUserID, Method: domain.SearchMethodEquals, Value: userID})
tokens, count, err := r.View.SearchRefreshTokens(request)
@@ -100,16 +99,16 @@ func (r *RefreshTokenRepo) SearchMyRefreshTokens(ctx context.Context, userID str
Offset: request.Offset,
Limit: request.Limit,
TotalResult: count,
Sequence: sequence.CurrentSequence,
Timestamp: sequence.LastSuccessfulSpoolerRun,
Sequence: sequence.Sequence,
Timestamp: sequence.LastRun,
Result: model.RefreshTokenViewsToModel(tokens),
}, nil
}
func (r *RefreshTokenRepo) getUserEvents(ctx context.Context, userID, instanceID string, sequence uint64, eventTypes []models.EventType) ([]*models.Event, error) {
func (r *RefreshTokenRepo) getUserEvents(ctx context.Context, userID, instanceID string, sequence uint64, eventTypes []eventstore.EventType) ([]eventstore.Event, error) {
query, err := usr_view.UserByIDQuery(userID, instanceID, sequence, eventTypes)
if err != nil {
return nil, err
}
return r.Eventstore.FilterEvents(ctx, query)
return r.Eventstore.Filter(ctx, query)
}

22
internal/auth/repository/eventsourcing/eventstore/token.go
View File

@@ -9,8 +9,7 @@ import (
"github.com/zitadel/zitadel/internal/api/authz"
"github.com/zitadel/zitadel/internal/auth/repository/eventsourcing/view"
"github.com/zitadel/zitadel/internal/errors"
v1 "github.com/zitadel/zitadel/internal/eventstore/v1"
"github.com/zitadel/zitadel/internal/eventstore/v1/models"
"github.com/zitadel/zitadel/internal/eventstore"
"github.com/zitadel/zitadel/internal/telemetry/tracing"
usr_model "github.com/zitadel/zitadel/internal/user/model"
usr_view "github.com/zitadel/zitadel/internal/user/repository/view"
@@ -18,21 +17,10 @@ import (
)
type TokenRepo struct {
Eventstore v1.Eventstore
Eventstore *eventstore.Eventstore
View *view.View
}
func (repo *TokenRepo) IsTokenValid(ctx context.Context, userID, tokenID string) (bool, error) {
token, err := repo.TokenByIDs(ctx, userID, tokenID)
if err == nil {
return token.Expiration.After(time.Now().UTC()), nil
}
if errors.IsNotFound(err) {
return false, nil
}
return false, err
}
func (repo *TokenRepo) TokenByIDs(ctx context.Context, userID, tokenID string) (*usr_model.TokenView, error) {
instanceID := authz.GetInstance(ctx).InstanceID()
@@ -51,7 +39,7 @@ func (repo *TokenRepo) TokenByIDs(ctx context.Context, userID, tokenID string) (
token.UserID = userID
token.InstanceID = instanceID
if sequence != nil {
token.Sequence = sequence.CurrentSequence
token.Sequence = sequence.Sequence
}
}
@@ -77,10 +65,10 @@ func (repo *TokenRepo) TokenByIDs(ctx context.Context, userID, tokenID string) (
return model.TokenViewToModel(token), nil
}
func (r *TokenRepo) getUserEvents(ctx context.Context, userID, instanceID string, sequence uint64, eventTypes []models.EventType) ([]*models.Event, error) {
func (r *TokenRepo) getUserEvents(ctx context.Context, userID, instanceID string, sequence uint64, eventTypes []eventstore.EventType) ([]eventstore.Event, error) {
query, err := usr_view.UserByIDQuery(userID, instanceID, sequence, eventTypes)
if err != nil {
return nil, err
}
return r.Eventstore.FilterEvents(ctx, query)
return r.Eventstore.Filter(ctx, query)
}

11
internal/auth/repository/eventsourcing/eventstore/user.go
View File

@@ -7,15 +7,14 @@ import (
"github.com/zitadel/zitadel/internal/auth/repository/eventsourcing/view"
"github.com/zitadel/zitadel/internal/config/systemdefaults"
"github.com/zitadel/zitadel/internal/domain"
v1 "github.com/zitadel/zitadel/internal/eventstore/v1"
"github.com/zitadel/zitadel/internal/eventstore/v1/models"
"github.com/zitadel/zitadel/internal/eventstore"
"github.com/zitadel/zitadel/internal/query"
usr_view "github.com/zitadel/zitadel/internal/user/repository/view"
)
type UserRepo struct {
SearchLimit uint64
Eventstore v1.Eventstore
Eventstore *eventstore.Eventstore
View *view.View
Query *query.Queries
SystemDefaults systemdefaults.SystemDefaults
@@ -39,14 +38,14 @@ func (repo *UserRepo) UserSessionUserIDsByAgentID(ctx context.Context, agentID s
return userIDs, nil
}
func (repo *UserRepo) UserEventsByID(ctx context.Context, id string, sequence uint64, eventTypes []models.EventType) ([]*models.Event, error) {
func (repo *UserRepo) UserEventsByID(ctx context.Context, id string, sequence uint64, eventTypes []eventstore.EventType) ([]eventstore.Event, error) {
return repo.getUserEvents(ctx, id, sequence, eventTypes)
}
func (r *UserRepo) getUserEvents(ctx context.Context, userID string, sequence uint64, eventTypes []models.EventType) ([]*models.Event, error) {
func (r *UserRepo) getUserEvents(ctx context.Context, userID string, sequence uint64, eventTypes []eventstore.EventType) ([]eventstore.Event, error) {
query, err := usr_view.UserByIDQuery(userID, authz.GetInstance(ctx).InstanceID(), sequence, eventTypes)
if err != nil {
return nil, err
}
return r.Eventstore.FilterEvents(ctx, query)
return r.Eventstore.Filter(ctx, query)
}

114
internal/auth/repository/eventsourcing/handler/handler.go
View File

@@ -4,84 +4,68 @@ import (
"context"
"time"
"github.com/zitadel/zitadel/internal/api/authz"
"github.com/zitadel/zitadel/internal/auth/repository/eventsourcing/view"
v1 "github.com/zitadel/zitadel/internal/eventstore/v1"
"github.com/zitadel/zitadel/internal/eventstore/v1/models"
"github.com/zitadel/zitadel/internal/eventstore/v1/query"
"github.com/zitadel/zitadel/internal/database"
"github.com/zitadel/zitadel/internal/eventstore"
handler2 "github.com/zitadel/zitadel/internal/eventstore/handler/v2"
query2 "github.com/zitadel/zitadel/internal/query"
"github.com/zitadel/zitadel/internal/view/repository"
)
type Configs map[string]*Config
type Config struct {
Client *database.DB
Eventstore *eventstore.Eventstore
BulkLimit uint64
FailureCountUntilSkip uint64
HandleActiveInstances time.Duration
TransactionDuration time.Duration
Handlers map[string]*ConfigOverwrites
}
type ConfigOverwrites struct {
MinimumCycleDuration time.Duration
}
type handler struct {
view *view.View
bulkLimit uint64
cycleDuration time.Duration
errorCountUntilSkip uint64
func Register(ctx context.Context, configs Config, view *view.View, queries *query2.Queries) {
newUser(ctx,
configs.overwrite("User"),
view,
queries,
).Start(ctx)
es v1.Eventstore
newUserSession(ctx,
configs.overwrite("UserSession"),
view,
queries,
).Start(ctx)
newToken(ctx,
configs.overwrite("Token"),
view,
).Start(ctx)
newRefreshToken(ctx,
configs.overwrite("RefreshToken"),
view,
).Start(ctx)
}
func (h *handler) Eventstore() v1.Eventstore {
return h.es
}
func Register(ctx context.Context, configs Configs, bulkLimit, errorCount uint64, view *view.View, es v1.Eventstore, queries *query2.Queries) []query.Handler {
return []query.Handler{
newUser(ctx,
handler{view, bulkLimit, configs.cycleDuration("User"), errorCount, es}, queries),
newUserSession(ctx,
handler{view, bulkLimit, configs.cycleDuration("UserSession"), errorCount, es}, queries),
newToken(ctx,
handler{view, bulkLimit, configs.cycleDuration("Token"), errorCount, es}),
newRefreshToken(ctx, handler{view, bulkLimit, configs.cycleDuration("RefreshToken"), errorCount, es}),
func (config Config) overwrite(viewModel string) handler2.Config {
c := handler2.Config{
Client: config.Client,
Eventstore: config.Eventstore,
BulkLimit: uint16(config.BulkLimit),
RequeueEvery: 3 * time.Minute,
HandleActiveInstances: config.HandleActiveInstances,
MaxFailureCount: uint8(config.FailureCountUntilSkip),
TransactionDuration: config.TransactionDuration,
}
}
func (configs Configs) cycleDuration(viewModel string) time.Duration {
c, ok := configs[viewModel]
overwrite, ok := config.Handlers[viewModel]
if !ok {
return 3 * time.Minute
return c
}
return c.MinimumCycleDuration
}
func (h *handler) MinimumCycleDuration() time.Duration {
return h.cycleDuration
}
func (h *handler) LockDuration() time.Duration {
return h.cycleDuration / 3
}
func (h *handler) QueryLimit() uint64 {
return h.bulkLimit
}
func withInstanceID(ctx context.Context, instanceID string) context.Context {
return authz.WithInstanceID(ctx, instanceID)
}
func newSearchQuery(sequences []*repository.CurrentSequence, aggregateTypes []models.AggregateType, instanceIDs []string) *models.SearchQuery {
searchQuery := models.NewSearchQuery()
for _, instanceID := range instanceIDs {
var seq uint64
for _, sequence := range sequences {
if sequence.InstanceID == instanceID {
seq = sequence.CurrentSequence
break
}
}
searchQuery.AddQuery().
AggregateTypeFilter(aggregateTypes...).
LatestSequenceFilter(seq).
InstanceIDFilter(instanceID)
if overwrite.MinimumCycleDuration > 0 {
c.RequeueEvery = overwrite.MinimumCycleDuration
}
return searchQuery
return c
}

211
internal/auth/repository/eventsourcing/handler/refresh_token.go
View File

@@ -2,19 +2,15 @@ package handler
import (
"context"
"encoding/json"
"github.com/zitadel/logging"
auth_view "github.com/zitadel/zitadel/internal/auth/repository/eventsourcing/view"
caos_errs "github.com/zitadel/zitadel/internal/errors"
"github.com/zitadel/zitadel/internal/eventstore"
v1 "github.com/zitadel/zitadel/internal/eventstore/v1"
es_models "github.com/zitadel/zitadel/internal/eventstore/v1/models"
"github.com/zitadel/zitadel/internal/eventstore/v1/query"
"github.com/zitadel/zitadel/internal/eventstore/v1/spooler"
"github.com/zitadel/zitadel/internal/eventstore/handler/v2"
"github.com/zitadel/zitadel/internal/repository/instance"
"github.com/zitadel/zitadel/internal/repository/org"
"github.com/zitadel/zitadel/internal/repository/project"
"github.com/zitadel/zitadel/internal/repository/user"
view_model "github.com/zitadel/zitadel/internal/user/repository/view/model"
)
@@ -23,110 +19,129 @@ const (
refreshTokenTable = "auth.refresh_tokens"
)
var _ handler.Projection = (*RefreshToken)(nil)
type RefreshToken struct {
handler
subscription *v1.Subscription
view *auth_view.View
}
func newRefreshToken(
ctx context.Context,
handler handler,
) *RefreshToken {
h := &RefreshToken{
handler: handler,
}
h.subscribe(ctx)
return h
config handler.Config,
view *auth_view.View,
) *handler.Handler {
return handler.NewHandler(
ctx,
&config,
&RefreshToken{
view: view,
},
)
}
func (t *RefreshToken) subscribe(ctx context.Context) {
t.subscription = t.es.Subscribe(t.AggregateTypes()...)
go func() {
for event := range t.subscription.Events {
query.ReduceEvent(ctx, t, event)
}
}()
}
func (t *RefreshToken) ViewModel() string {
// Name implements [handler.Projection]
func (*RefreshToken) Name() string {
return refreshTokenTable
}
func (t *RefreshToken) Subscription() *v1.Subscription {
return t.subscription
}
func (t *RefreshToken) AggregateTypes() []es_models.AggregateType {
return []es_models.AggregateType{user.AggregateType, project.AggregateType, instance.AggregateType}
}
func (t *RefreshToken) CurrentSequence(ctx context.Context, instanceID string) (uint64, error) {
sequence, err := t.view.GetLatestRefreshTokenSequence(ctx, instanceID)
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (t *RefreshToken) EventQuery(ctx context.Context, instanceIDs []string) (*es_models.SearchQuery, error) {
sequences, err := t.view.GetLatestRefreshTokenSequences(ctx, instanceIDs)
if err != nil {
return nil, err
}
return newSearchQuery(sequences, t.AggregateTypes(), instanceIDs), nil
}
func (t *RefreshToken) Reduce(event *es_models.Event) (err error) {
switch eventstore.EventType(event.Type) {
case user.HumanRefreshTokenAddedType:
token := new(view_model.RefreshTokenView)
err := token.AppendEvent(event)
if err != nil {
return err
}
return t.view.PutRefreshToken(token, event)
case user.HumanRefreshTokenRenewedType:
e := new(user.HumanRefreshTokenRenewedEvent)
if err := json.Unmarshal(event.Data, e); err != nil {
logging.WithError(err).Error("could not unmarshal event data")
return caos_errs.ThrowInternal(nil, "MODEL-BHn75", "could not unmarshal data")
}
token, err := t.view.RefreshTokenByID(e.TokenID, event.InstanceID)
if err != nil {
return err
}
err = token.AppendEvent(event)
if err != nil {
return err
}
return t.view.PutRefreshToken(token, event)
case user.HumanRefreshTokenRemovedType:
e := new(user.HumanRefreshTokenRemovedEvent)
if err := json.Unmarshal(event.Data, e); err != nil {
logging.WithError(err).Error("could not unmarshal event data")
return caos_errs.ThrowInternal(nil, "MODEL-Bz653", "could not unmarshal data")
}
return t.view.DeleteRefreshToken(e.TokenID, event.InstanceID, event)
case user.UserLockedType,
user.UserDeactivatedType,
user.UserRemovedType:
return t.view.DeleteUserRefreshTokens(event.AggregateID, event.InstanceID, event)
case instance.InstanceRemovedEventType:
return t.view.DeleteInstanceRefreshTokens(event)
case org.OrgRemovedEventType:
return t.view.DeleteOrgRefreshTokens(event)
default:
return t.view.ProcessedRefreshTokenSequence(event)
// Reducers implements [handler.Projection]
func (t *RefreshToken) Reducers() []handler.AggregateReducer {
return []handler.AggregateReducer{
{
Aggregate: user.AggregateType,
EventReducers: []handler.EventReducer{
{
Event: user.HumanRefreshTokenAddedType,
Reduce: t.Reduce,
},
{
Event: user.HumanRefreshTokenRenewedType,
Reduce: t.Reduce,
},
{
Event: user.HumanRefreshTokenRemovedType,
Reduce: t.Reduce,
},
{
Event: user.UserLockedType,
Reduce: t.Reduce,
},
{
Event: user.UserDeactivatedType,
Reduce: t.Reduce,
},
{
Event: user.UserRemovedType,
Reduce: t.Reduce,
},
},
},
{
Aggregate: instance.AggregateType,
EventReducers: []handler.EventReducer{
{
Event: instance.InstanceRemovedEventType,
Reduce: t.Reduce,
},
},
},
{
Aggregate: org.AggregateType,
EventReducers: []handler.EventReducer{
{
Event: org.OrgRemovedEventType,
Reduce: t.Reduce,
},
},
},
}
}
func (t *RefreshToken) OnError(event *es_models.Event, err error) error {
logging.WithFields("id", event.AggregateID).WithError(err).Warn("something went wrong in token handler")
return spooler.HandleError(event, err, t.view.GetLatestRefreshTokenFailedEvent, t.view.ProcessedRefreshTokenFailedEvent, t.view.ProcessedRefreshTokenSequence, t.errorCountUntilSkip)
}
func (t *RefreshToken) Reduce(event eventstore.Event) (_ *handler.Statement, err error) {
return handler.NewStatement(event, func(ex handler.Executer, projectionName string) error {
switch event.Type() {
case user.HumanRefreshTokenAddedType:
token := new(view_model.RefreshTokenView)
err := token.AppendEvent(event)
if err != nil {
return err
}
func (t *RefreshToken) OnSuccess(instanceIDs []string) error {
return spooler.HandleSuccess(t.view.UpdateRefreshTokenSpoolerRunTimestamp, instanceIDs)
return t.view.PutRefreshToken(token)
case user.HumanRefreshTokenRenewedType:
e := new(user.HumanRefreshTokenRenewedEvent)
if err := event.Unmarshal(e); err != nil {
logging.WithError(err).Error("could not unmarshal event data")
return caos_errs.ThrowInternal(nil, "MODEL-BHn75", "could not unmarshal data")
}
token, err := t.view.RefreshTokenByID(e.TokenID, event.Aggregate().InstanceID)
if err != nil {
return err
}
err = token.AppendEvent(event)
if err != nil {
return err
}
return t.view.PutRefreshToken(token)
case user.HumanRefreshTokenRemovedType:
e := new(user.HumanRefreshTokenRemovedEvent)
if err := event.Unmarshal(e); err != nil {
logging.WithError(err).Error("could not unmarshal event data")
return caos_errs.ThrowInternal(nil, "MODEL-Bz653", "could not unmarshal data")
}
return t.view.DeleteRefreshToken(e.TokenID, event.Aggregate().InstanceID)
case user.UserLockedType,
user.UserDeactivatedType,
user.UserRemovedType:
return t.view.DeleteUserRefreshTokens(event.Aggregate().ID, event.Aggregate().InstanceID)
case instance.InstanceRemovedEventType:
return t.view.DeleteInstanceRefreshTokens(event.Aggregate().InstanceID)
case org.OrgRemovedEventType:
return t.view.DeleteOrgRefreshTokens(event)
default:
return nil
}
}), nil
}

360
internal/auth/repository/eventsourcing/handler/token.go
View File

@@ -2,17 +2,14 @@ package handler
import (
"context"
"encoding/json"
"github.com/zitadel/logging"
auth_view "github.com/zitadel/zitadel/internal/auth/repository/eventsourcing/view"
caos_errs "github.com/zitadel/zitadel/internal/errors"
"github.com/zitadel/zitadel/internal/eventstore"
v1 "github.com/zitadel/zitadel/internal/eventstore/v1"
"github.com/zitadel/zitadel/internal/eventstore/handler/v2"
es_models "github.com/zitadel/zitadel/internal/eventstore/v1/models"
"github.com/zitadel/zitadel/internal/eventstore/v1/query"
es_sdk "github.com/zitadel/zitadel/internal/eventstore/v1/sdk"
"github.com/zitadel/zitadel/internal/eventstore/v1/spooler"
proj_model "github.com/zitadel/zitadel/internal/project/model"
project_es_model "github.com/zitadel/zitadel/internal/project/repository/eventsourcing/model"
proj_view "github.com/zitadel/zitadel/internal/project/repository/view"
@@ -20,7 +17,6 @@ import (
"github.com/zitadel/zitadel/internal/repository/org"
"github.com/zitadel/zitadel/internal/repository/project"
"github.com/zitadel/zitadel/internal/repository/user"
user_repo "github.com/zitadel/zitadel/internal/repository/user"
view_model "github.com/zitadel/zitadel/internal/user/repository/view/model"
)
@@ -28,189 +24,258 @@ const (
tokenTable = "auth.tokens"
)
var _ handler.Projection = (*Token)(nil)
type Token struct {
handler
subscription *v1.Subscription
view *auth_view.View
es handler.EventStore
}
func newToken(
ctx context.Context,
handler handler,
) *Token {
h := &Token{
handler: handler,
}
h.subscribe(ctx)
return h
config handler.Config,
view *auth_view.View,
) *handler.Handler {
return handler.NewHandler(
ctx,
&config,
&Token{
view: view,
es: config.Eventstore,
},
)
}
func (t *Token) subscribe(ctx context.Context) {
t.subscription = t.es.Subscribe(t.AggregateTypes()...)
go func() {
for event := range t.subscription.Events {
query.ReduceEvent(ctx, t, event)
}
}()
}
func (t *Token) ViewModel() string {
// Name implements [handler.Projection]
func (*Token) Name() string {
return tokenTable
}
func (t *Token) Subscription() *v1.Subscription {
return t.subscription
}
func (_ *Token) AggregateTypes() []es_models.AggregateType {
return []es_models.AggregateType{user.AggregateType, project.AggregateType, instance.AggregateType}
}
func (t *Token) CurrentSequence(ctx context.Context, instanceID string) (uint64, error) {
sequence, err := t.view.GetLatestTokenSequence(ctx, instanceID)
if err != nil {
return 0, err
// Reducers implements [handler.Projection]
func (t *Token) Reducers() []handler.AggregateReducer {
return []handler.AggregateReducer{
{
Aggregate: user.AggregateType,
EventReducers: []handler.EventReducer{
{
Event: user.PersonalAccessTokenAddedType,
Reduce: t.Reduce,
},
{
Event: user.UserTokenAddedType,
Reduce: t.Reduce,
},
{
Event: user.UserV1ProfileChangedType,
Reduce: t.Reduce,
},
{
Event: user.HumanProfileChangedType,
Reduce: t.Reduce,
},
{
Event: user.UserV1SignedOutType,
Reduce: t.Reduce,
},
{
Event: user.HumanSignedOutType,
Reduce: t.Reduce,
},
{
Event: user.UserLockedType,
Reduce: t.Reduce,
},
{
Event: user.UserDeactivatedType,
Reduce: t.Reduce,
},
{
Event: user.UserRemovedType,
Reduce: t.Reduce,
},
{
Event: user.UserTokenRemovedType,
Reduce: t.Reduce,
},
{
Event: user.PersonalAccessTokenRemovedType,
Reduce: t.Reduce,
},
{
Event: user.HumanRefreshTokenRemovedType,
Reduce: t.Reduce,
},
},
},
{
Aggregate: project.AggregateType,
EventReducers: []handler.EventReducer{
{
Event: project.ApplicationDeactivatedType,
Reduce: t.Reduce,
},
{
Event: project.ApplicationRemovedType,
Reduce: t.Reduce,
},
{
Event: project.ProjectDeactivatedType,
Reduce: t.Reduce,
},
{
Event: project.ProjectRemovedType,
Reduce: t.Reduce,
},
},
},
{
Aggregate: org.AggregateType,
EventReducers: []handler.EventReducer{
{
Event: org.OrgRemovedEventType,
Reduce: t.Reduce,
},
},
},
{
Aggregate: instance.AggregateType,
EventReducers: []handler.EventReducer{
{
Event: instance.InstanceRemovedEventType,
Reduce: t.Reduce,
},
},
},
}
return sequence.CurrentSequence, nil
}
func (t *Token) EventQuery(ctx context.Context, instanceIDs []string) (*es_models.SearchQuery, error) {
sequences, err := t.view.GetLatestTokenSequences(ctx, instanceIDs)
if err != nil {
return nil, err
}
return newSearchQuery(sequences, t.AggregateTypes(), instanceIDs), nil
}
func (t *Token) Reduce(event *es_models.Event) (err error) {
switch eventstore.EventType(event.Type) {
case user.UserTokenAddedType,
user_repo.PersonalAccessTokenAddedType:
token := new(view_model.TokenView)
err := token.AppendEvent(event)
if err != nil {
return err
}
return t.view.PutToken(token, event)
case user.UserV1ProfileChangedType,
user.HumanProfileChangedType:
user := new(view_model.UserView)
err := user.AppendEvent(event)
if err != nil {
return err
}
tokens, err := t.view.TokensByUserID(event.AggregateID, event.InstanceID)
if err != nil {
return err
}
for _, token := range tokens {
token.PreferredLanguage = user.PreferredLanguage
}
return t.view.PutTokens(tokens, event)
case user.UserV1SignedOutType,
user.HumanSignedOutType:
id, err := agentIDFromSession(event)
if err != nil {
return err
}
return t.view.DeleteSessionTokens(id, event.AggregateID, event.InstanceID, event)
case user.UserLockedType,
user.UserDeactivatedType,
user.UserRemovedType:
return t.view.DeleteUserTokens(event.AggregateID, event.InstanceID, event)
case user_repo.UserTokenRemovedType,
user_repo.PersonalAccessTokenRemovedType:
id, err := tokenIDFromRemovedEvent(event)
if err != nil {
return err
}
return t.view.DeleteToken(id, event.InstanceID, event)
case user_repo.HumanRefreshTokenRemovedType:
id, err := refreshTokenIDFromRemovedEvent(event)
if err != nil {
return err
}
return t.view.DeleteTokensFromRefreshToken(id, event.InstanceID, event)
case project.ApplicationDeactivatedType,
project.ApplicationRemovedType:
application, err := applicationFromSession(event)
if err != nil {
return err
}
return t.view.DeleteApplicationTokens(event, application.AppID)
case project.ProjectDeactivatedType,
project.ProjectRemovedType:
project, err := t.getProjectByID(context.Background(), event.AggregateID, event.InstanceID)
if err != nil {
return err
}
clientIDs := make([]string, 0, len(project.Applications))
for _, app := range project.Applications {
if app.OIDCConfig != nil {
clientIDs = append(clientIDs, app.OIDCConfig.ClientID)
func (t *Token) Reduce(event eventstore.Event) (_ *handler.Statement, err error) { //nolint:gocognit
return handler.NewStatement(event, func(ex handler.Executer, projectionName string) error {
switch event.Type() {
case user.UserTokenAddedType,
user.PersonalAccessTokenAddedType:
token := new(view_model.TokenView)
err := token.AppendEvent(event)
if err != nil {
return err
}
return t.view.PutToken(token)
case user.UserV1ProfileChangedType,
user.HumanProfileChangedType:
user := new(view_model.UserView)
err := user.AppendEvent(event)
if err != nil {
return err
}
tokens, err := t.view.TokensByUserID(event.Aggregate().ID, event.Aggregate().InstanceID)
if err != nil {
return err
}
for _, token := range tokens {
token.PreferredLanguage = user.PreferredLanguage
}
return t.view.PutTokens(tokens)
case user.UserV1SignedOutType,
user.HumanSignedOutType:
id, err := agentIDFromSession(event)
if err != nil {
return err
}
return t.view.DeleteSessionTokens(id, event)
case user.UserLockedType,
user.UserDeactivatedType,
user.UserRemovedType:
return t.view.DeleteUserTokens(event)
case user.UserTokenRemovedType,
user.PersonalAccessTokenRemovedType:
id, err := tokenIDFromRemovedEvent(event)
if err != nil {
return err
}
return t.view.DeleteToken(id, event.Aggregate().InstanceID)
case user.HumanRefreshTokenRemovedType:
id, err := refreshTokenIDFromRemovedEvent(event)
if err != nil {
return err
}
return t.view.DeleteTokensFromRefreshToken(id, event.Aggregate().InstanceID)
case project.ApplicationDeactivatedType,
project.ApplicationRemovedType:
application, err := applicationFromSession(event)
if err != nil {
return err
}
return t.view.DeleteApplicationTokens(event, application.AppID)
case project.ProjectDeactivatedType,
project.ProjectRemovedType:
project, err := t.getProjectByID(context.Background(), event.Aggregate().ID, event.Aggregate().InstanceID)
if err != nil {
return err
}
applicationIDs := make([]string, 0, len(project.Applications))
for _, app := range project.Applications {
if app.OIDCConfig != nil {
applicationIDs = append(applicationIDs, app.OIDCConfig.ClientID)
}
}
return t.view.DeleteApplicationTokens(event, applicationIDs...)
case instance.InstanceRemovedEventType:
return t.view.DeleteInstanceTokens(event)
case org.OrgRemovedEventType:
// deletes all tokens including PATs, which is expected for now
// if there is an undo of the org deletion in the future,
// we will need to have a look on how to handle the deleted PATs
return t.view.DeleteOrgTokens(event)
default:
return nil
}
return t.view.DeleteApplicationTokens(event, clientIDs...)
case instance.InstanceRemovedEventType:
return t.view.DeleteInstanceTokens(event)
case org.OrgRemovedEventType:
// deletes all tokens including PATs, which is expected for now
// if there is an undo of the org deletion in the future,
// we will need to have a look on how to handle the deleted PATs
return t.view.DeleteOrgTokens(event)
default:
return t.view.ProcessedTokenSequence(event)
}
}), nil
}
func (t *Token) OnError(event *es_models.Event, err error) error {
logging.WithFields("id", event.AggregateID).WithError(err).Warn("something went wrong in token handler")
return spooler.HandleError(event, err, t.view.GetLatestTokenFailedEvent, t.view.ProcessedTokenFailedEvent, t.view.ProcessedTokenSequence, t.errorCountUntilSkip)
}
func agentIDFromSession(event *es_models.Event) (string, error) {
func agentIDFromSession(event eventstore.Event) (string, error) {
session := make(map[string]interface{})
if err := json.Unmarshal(event.Data, &session); err != nil {
if err := event.Unmarshal(&session); err != nil {
logging.WithError(err).Error("could not unmarshal event data")
return "", caos_errs.ThrowInternal(nil, "MODEL-sd325", "could not unmarshal data")
}
return session["userAgentID"].(string), nil
}
func applicationFromSession(event *es_models.Event) (*project_es_model.Application, error) {
func applicationFromSession(event eventstore.Event) (*project_es_model.Application, error) {
application := new(project_es_model.Application)
if err := json.Unmarshal(event.Data, &application); err != nil {
if err := event.Unmarshal(application); err != nil {
logging.WithError(err).Error("could not unmarshal event data")
return nil, caos_errs.ThrowInternal(nil, "MODEL-Hrw1q", "could not unmarshal data")
}
return application, nil
}
func tokenIDFromRemovedEvent(event *es_models.Event) (string, error) {
func tokenIDFromRemovedEvent(event eventstore.Event) (string, error) {
removed := make(map[string]interface{})
if err := json.Unmarshal(event.Data, &removed); err != nil {
if err := event.Unmarshal(&removed); err != nil {
logging.WithError(err).Error("could not unmarshal event data")
return "", caos_errs.ThrowInternal(nil, "MODEL-Sff32", "could not unmarshal data")
}
return removed["tokenId"].(string), nil
}
func refreshTokenIDFromRemovedEvent(event *es_models.Event) (string, error) {
func refreshTokenIDFromRemovedEvent(event eventstore.Event) (string, error) {
removed := make(map[string]interface{})
if err := json.Unmarshal(event.Data, &removed); err != nil {
if err := event.Unmarshal(&removed); err != nil {
logging.WithError(err).Error("could not unmarshal event data")
return "", caos_errs.ThrowInternal(nil, "MODEL-Dfb3w", "could not unmarshal data")
}
return removed["tokenId"].(string), nil
}
func (t *Token) OnSuccess(instanceIDs []string) error {
return spooler.HandleSuccess(t.view.UpdateTokenSpoolerRunTimestamp, instanceIDs)
}
func (t *Token) getProjectByID(ctx context.Context, projID, instanceID string) (*proj_model.Project, error) {
projectQuery, err := proj_view.ProjectByIDQuery(projID, instanceID, 0)
query, err := proj_view.ProjectByIDQuery(projID, instanceID, 0)
if err != nil {
return nil, err
}
@@ -219,13 +284,16 @@ func (t *Token) getProjectByID(ctx context.Context, projID, instanceID string) (
AggregateID: projID,
},
}
err = es_sdk.Filter(ctx, t.Eventstore().FilterEvents, esProject.AppendEvents, projectQuery)
if err != nil && !caos_errs.IsNotFound(err) {
events, err := t.es.Filter(ctx, query)
if err != nil {
return nil, err
}
if err = esProject.AppendEvents(events...); err != nil {
return nil, err
}
if esProject.Sequence == 0 {
return nil, caos_errs.ThrowNotFound(nil, "EVENT-Dsdw2", "Errors.Project.NotFound")
}
return project_es_model.ProjectToModel(esProject), nil
}

646
internal/auth/repository/eventsourcing/handler/user.go
View File

@@ -3,18 +3,15 @@ package handler
import (
"context"
"github.com/zitadel/logging"
"github.com/zitadel/zitadel/internal/api/authz"
auth_view "github.com/zitadel/zitadel/internal/auth/repository/eventsourcing/view"
"github.com/zitadel/zitadel/internal/errors"
"github.com/zitadel/zitadel/internal/eventstore"
v1 "github.com/zitadel/zitadel/internal/eventstore/v1"
"github.com/zitadel/zitadel/internal/eventstore/handler/v2"
es_models "github.com/zitadel/zitadel/internal/eventstore/v1/models"
"github.com/zitadel/zitadel/internal/eventstore/v1/query"
es_sdk "github.com/zitadel/zitadel/internal/eventstore/v1/sdk"
"github.com/zitadel/zitadel/internal/eventstore/v1/spooler"
org_model "github.com/zitadel/zitadel/internal/org/model"
org_es_model "github.com/zitadel/zitadel/internal/org/repository/eventsourcing/model"
"github.com/zitadel/zitadel/internal/org/repository/view"
org_view "github.com/zitadel/zitadel/internal/org/repository/view"
query2 "github.com/zitadel/zitadel/internal/query"
"github.com/zitadel/zitadel/internal/repository/instance"
"github.com/zitadel/zitadel/internal/repository/org"
@@ -28,202 +25,405 @@ const (
)
type User struct {
handler
subscription *v1.Subscription
queries *query2.Queries
view *auth_view.View
queries *query2.Queries
es handler.EventStore
}
var _ handler.Projection = (*User)(nil)
func newUser(
ctx context.Context,
handler handler,
config handler.Config,
view *auth_view.View,
queries *query2.Queries,
) *User {
h := &User{
handler: handler,
queries: queries,
}
h.subscribe(ctx)
return h
) *handler.Handler {
return handler.NewHandler(
ctx,
&config,
&User{
view: view,
queries: queries,
es: config.Eventstore,
},
)
}
func (u *User) subscribe(ctx context.Context) {
u.subscription = u.es.Subscribe(u.AggregateTypes()...)
go func() {
for event := range u.subscription.Events {
query.ReduceEvent(ctx, u, event)
}
}()
}
func (u *User) ViewModel() string {
func (*User) Name() string {
return userTable
}
func (u *User) Subscription() *v1.Subscription {
return u.subscription
}
func (_ *User) AggregateTypes() []es_models.AggregateType {
return []es_models.AggregateType{user_repo.AggregateType, org.AggregateType, instance.AggregateType}
}
func (u *User) CurrentSequence(ctx context.Context, instanceID string) (uint64, error) {
sequence, err := u.view.GetLatestUserSequence(ctx, instanceID)
if err != nil {
return 0, err
}
return sequence.CurrentSequence, nil
}
func (u *User) EventQuery(ctx context.Context, instanceIDs []string) (*es_models.SearchQuery, error) {
sequences, err := u.view.GetLatestUserSequences(ctx, instanceIDs)
if err != nil {
return nil, err
}
return newSearchQuery(sequences, u.AggregateTypes(), instanceIDs), nil
}
func (u *User) Reduce(event *es_models.Event) (err error) {
switch event.AggregateType {
case user_repo.AggregateType:
return u.ProcessUser(event)
case org.AggregateType:
return u.ProcessOrg(event)
case instance.AggregateType:
return u.ProcessInstance(event)
default:
return nil
func (u *User) Reducers() []handler.AggregateReducer {
return []handler.AggregateReducer{
{
Aggregate: user_repo.AggregateType,
EventReducers: []handler.EventReducer{
{
Event: user_repo.HumanOTPSMSAddedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanOTPSMSRemovedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanOTPEmailAddedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanOTPEmailRemovedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.MachineAddedEventType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanAddedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.UserV1AddedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.UserV1RegisteredType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanRegisteredType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.UserV1ProfileChangedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.UserV1EmailChangedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.UserV1EmailVerifiedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.UserV1PhoneChangedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.UserV1PhoneVerifiedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.UserV1PhoneRemovedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.UserV1AddressChangedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.UserDeactivatedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.UserReactivatedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.UserLockedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.UserUnlockedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.UserV1MFAOTPAddedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.UserV1MFAOTPVerifiedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.UserV1MFAOTPRemovedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.UserV1MFAInitSkippedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.UserV1PasswordChangedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanProfileChangedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanEmailChangedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanEmailVerifiedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanAvatarAddedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanAvatarRemovedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanPhoneChangedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanPhoneVerifiedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanPhoneRemovedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanAddressChangedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanMFAOTPAddedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanMFAOTPVerifiedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanMFAOTPRemovedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanU2FTokenAddedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanU2FTokenVerifiedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanU2FTokenRemovedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanPasswordlessTokenAddedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanPasswordlessTokenVerifiedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanPasswordlessTokenRemovedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanMFAInitSkippedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.MachineChangedEventType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanPasswordChangedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanInitialCodeAddedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.UserV1InitialCodeAddedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.UserV1InitializedCheckSucceededType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanInitializedCheckSucceededType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanPasswordlessInitCodeAddedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.HumanPasswordlessInitCodeRequestedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.UserDomainClaimedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.UserUserNameChangedType,
Reduce: u.ProcessUser,
},
{
Event: user_repo.UserRemovedType,
Reduce: u.ProcessUser,
},
},
},
{
Aggregate: org.AggregateType,
EventReducers: []handler.EventReducer{
{
Event: org.OrgDomainVerifiedEventType,
Reduce: u.ProcessOrg,
},
{
Event: org.OrgDomainRemovedEventType,
Reduce: u.ProcessOrg,
},
{
Event: org.DomainPolicyAddedEventType,
Reduce: u.ProcessOrg,
},
{
Event: org.DomainPolicyChangedEventType,
Reduce: u.ProcessOrg,
},
{
Event: org.DomainPolicyRemovedEventType,
Reduce: u.ProcessOrg,
},
{
Event: org.OrgDomainPrimarySetEventType,
Reduce: u.ProcessOrg,
},
{
Event: org.OrgRemovedEventType,
Reduce: u.ProcessOrg,
},
},
},
{
Aggregate: instance.AggregateType,
EventReducers: []handler.EventReducer{
{
Event: instance.InstanceRemovedEventType,
Reduce: u.ProcessInstance,
},
},
},
}
}
func (u *User) ProcessUser(event *es_models.Event) (err error) {
user := new(view_model.UserView)
switch eventstore.EventType(event.Type) {
case user_repo.UserV1AddedType,
user_repo.MachineAddedEventType,
user_repo.HumanAddedType,
user_repo.UserV1RegisteredType,
user_repo.HumanRegisteredType:
err = user.AppendEvent(event)
if err != nil {
return err
}
err = u.fillLoginNames(user)
case user_repo.UserV1ProfileChangedType,
user_repo.UserV1EmailChangedType,
user_repo.UserV1EmailVerifiedType,
user_repo.UserV1PhoneChangedType,
user_repo.UserV1PhoneVerifiedType,
user_repo.UserV1PhoneRemovedType,
user_repo.UserV1AddressChangedType,
user_repo.UserDeactivatedType,
user_repo.UserReactivatedType,
user_repo.UserLockedType,
user_repo.UserUnlockedType,
user_repo.UserV1MFAOTPAddedType,
user_repo.UserV1MFAOTPVerifiedType,
user_repo.UserV1MFAOTPRemovedType,
user_repo.UserV1MFAInitSkippedType,
user_repo.UserV1PasswordChangedType,
user_repo.HumanProfileChangedType,
user_repo.HumanEmailChangedType,
user_repo.HumanEmailVerifiedType,
user_repo.HumanAvatarAddedType,
user_repo.HumanAvatarRemovedType,
user_repo.HumanPhoneChangedType,
user_repo.HumanPhoneVerifiedType,
user_repo.HumanPhoneRemovedType,
user_repo.HumanAddressChangedType,
user_repo.HumanMFAOTPAddedType,
user_repo.HumanMFAOTPVerifiedType,
user_repo.HumanMFAOTPRemovedType,
user_repo.HumanOTPSMSAddedType,
user_repo.HumanOTPSMSRemovedType,
user_repo.HumanOTPEmailAddedType,
user_repo.HumanOTPEmailRemovedType,
user_repo.HumanU2FTokenAddedType,
user_repo.HumanU2FTokenVerifiedType,
user_repo.HumanU2FTokenRemovedType,
user_repo.HumanPasswordlessTokenAddedType,
user_repo.HumanPasswordlessTokenVerifiedType,
user_repo.HumanPasswordlessTokenRemovedType,
user_repo.HumanMFAInitSkippedType,
user_repo.MachineChangedEventType,
user_repo.HumanPasswordChangedType,
user_repo.HumanInitialCodeAddedType,
user_repo.UserV1InitialCodeAddedType,
user_repo.UserV1InitializedCheckSucceededType,
user_repo.HumanInitializedCheckSucceededType,
user_repo.HumanPasswordlessInitCodeAddedType,
user_repo.HumanPasswordlessInitCodeRequestedType:
user, err = u.view.UserByID(event.AggregateID, event.InstanceID)
if err != nil {
if !errors.IsNotFound(err) {
return err
}
logging.WithFields(
"instance", event.InstanceID,
"userID", event.AggregateID,
"eventType", event.Type,
).Info("user not found in view")
query, err := usr_view.UserByIDQuery(event.AggregateID, event.InstanceID, 0, user.EventTypes())
//nolint:gocognit
func (u *User) ProcessUser(event eventstore.Event) (_ *handler.Statement, err error) {
return handler.NewStatement(event, func(ex handler.Executer, projectionName string) error {
user := new(view_model.UserView)
switch event.Type() {
case user_repo.UserV1AddedType,
user_repo.MachineAddedEventType,
user_repo.HumanAddedType,
user_repo.UserV1RegisteredType,
user_repo.HumanRegisteredType:
err = user.AppendEvent(event)
if err != nil {
return err
}
events, err := u.es.FilterEvents(context.Background(), query)
err = u.fillLoginNames(user)
case user_repo.UserV1ProfileChangedType,
user_repo.UserV1EmailChangedType,
user_repo.UserV1EmailVerifiedType,
user_repo.UserV1PhoneChangedType,
user_repo.UserV1PhoneVerifiedType,
user_repo.UserV1PhoneRemovedType,
user_repo.UserV1AddressChangedType,
user_repo.UserDeactivatedType,
user_repo.UserReactivatedType,
user_repo.UserLockedType,
user_repo.UserUnlockedType,
user_repo.UserV1MFAOTPAddedType,
user_repo.UserV1MFAOTPVerifiedType,
user_repo.UserV1MFAOTPRemovedType,
user_repo.UserV1MFAInitSkippedType,
user_repo.UserV1PasswordChangedType,
user_repo.HumanProfileChangedType,
user_repo.HumanEmailChangedType,
user_repo.HumanEmailVerifiedType,
user_repo.HumanAvatarAddedType,
user_repo.HumanAvatarRemovedType,
user_repo.HumanPhoneChangedType,
user_repo.HumanPhoneVerifiedType,
user_repo.HumanPhoneRemovedType,
user_repo.HumanAddressChangedType,
user_repo.HumanMFAOTPAddedType,
user_repo.HumanMFAOTPVerifiedType,
user_repo.HumanMFAOTPRemovedType,
user_repo.HumanOTPSMSAddedType,
user_repo.HumanOTPSMSRemovedType,
user_repo.HumanOTPEmailAddedType,
user_repo.HumanOTPEmailRemovedType,
user_repo.HumanU2FTokenAddedType,
user_repo.HumanU2FTokenVerifiedType,
user_repo.HumanU2FTokenRemovedType,
user_repo.HumanPasswordlessTokenAddedType,
user_repo.HumanPasswordlessTokenVerifiedType,
user_repo.HumanPasswordlessTokenRemovedType,
user_repo.HumanMFAInitSkippedType,
user_repo.MachineChangedEventType,
user_repo.HumanPasswordChangedType,
user_repo.HumanInitialCodeAddedType,
user_repo.UserV1InitialCodeAddedType,
user_repo.UserV1InitializedCheckSucceededType,
user_repo.HumanInitializedCheckSucceededType,
user_repo.HumanPasswordlessInitCodeAddedType,
user_repo.HumanPasswordlessInitCodeRequestedType:
user, err = u.view.UserByID(event.Aggregate().ID, event.Aggregate().InstanceID)
if err != nil {
return err
}
user = &view_model.UserView{}
for _, e := range events {
if err = user.AppendEvent(e); err != nil {
if !errors.IsNotFound(err) {
return err
}
user, err = u.userFromEventstore(event.Aggregate(), user.EventTypes())
if err != nil {
return err
}
}
}
err = user.AppendEvent(event)
case user_repo.UserDomainClaimedType,
user_repo.UserUserNameChangedType:
user, err = u.view.UserByID(event.AggregateID, event.InstanceID)
if err != nil {
if !errors.IsNotFound(err) {
return err
}
logging.WithFields(
"instance", event.InstanceID,
"userID", event.AggregateID,
"eventType", event.Type,
).Info("user not found in view")
query, err := usr_view.UserByIDQuery(event.AggregateID, event.InstanceID, 0, user.EventTypes())
err = user.AppendEvent(event)
case user_repo.UserDomainClaimedType,
user_repo.UserUserNameChangedType:
user, err = u.view.UserByID(event.Aggregate().ID, event.Aggregate().InstanceID)
if err != nil {
return err
}
events, err := u.es.FilterEvents(context.Background(), query)
if err != nil {
return err
}
user = &view_model.UserView{}
for _, e := range events {
if err = user.AppendEvent(e); err != nil {
if !errors.IsNotFound(err) {
return err
}
user, err = u.userFromEventstore(event.Aggregate(), user.EventTypes())
if err != nil {
return err
}
}
err = user.AppendEvent(event)
if err != nil {
return err
}
err = u.fillLoginNames(user)
case user_repo.UserRemovedType:
return u.view.DeleteUser(event.Aggregate().ID, event.Aggregate().InstanceID, event)
default:
return nil
}
err = user.AppendEvent(event)
if err != nil {
return err
}
err = u.fillLoginNames(user)
case user_repo.UserRemovedType:
return u.view.DeleteUser(event.AggregateID, event.InstanceID, event)
default:
return u.view.ProcessedUserSequence(event)
}
if err != nil {
return err
}
return u.view.PutUser(user, event)
return u.view.PutUser(user, event)
}), nil
}
func (u *User) fillLoginNames(user *view_model.UserView) (err error) {
@@ -236,38 +436,44 @@ func (u *User) fillLoginNames(user *view_model.UserView) (err error) {
return nil
}
func (u *User) ProcessOrg(event *es_models.Event) (err error) {
switch eventstore.EventType(event.Type) {
case org.OrgDomainVerifiedEventType,
org.OrgDomainRemovedEventType,
org.DomainPolicyAddedEventType,
org.DomainPolicyChangedEventType,
org.DomainPolicyRemovedEventType:
return u.fillLoginNamesOnOrgUsers(event)
case org.OrgDomainPrimarySetEventType:
return u.fillPreferredLoginNamesOnOrgUsers(event)
case org.OrgRemovedEventType:
return u.view.UpdateOrgOwnerRemovedUsers(event)
default:
return u.view.ProcessedUserSequence(event)
}
func (u *User) ProcessOrg(event eventstore.Event) (_ *handler.Statement, err error) {
return handler.NewStatement(event, func(ex handler.Executer, projectionName string) error {
switch event.Type() {
case org.OrgDomainVerifiedEventType,
org.OrgDomainRemovedEventType,
org.DomainPolicyAddedEventType,
org.DomainPolicyChangedEventType,
org.DomainPolicyRemovedEventType:
return u.fillLoginNamesOnOrgUsers(event)
case org.OrgDomainPrimarySetEventType:
return u.fillPreferredLoginNamesOnOrgUsers(event)
case org.OrgRemovedEventType:
return u.view.UpdateOrgOwnerRemovedUsers(event)
default:
return nil
}
}), nil
}
func (u *User) ProcessInstance(event *es_models.Event) (err error) {
switch eventstore.EventType(event.Type) {
func (u *User) ProcessInstance(event eventstore.Event) (_ *handler.Statement, err error) {
switch event.Type() {
case instance.InstanceRemovedEventType:
return u.view.DeleteInstanceUsers(event)
return handler.NewStatement(event,
func(ex handler.Executer, projectionName string) error {
return u.view.DeleteInstanceUsers(event)
},
), nil
default:
return u.view.ProcessedUserSequence(event)
return handler.NewNoOpStatement(event), nil
}
}
func (u *User) fillLoginNamesOnOrgUsers(event *es_models.Event) error {
userLoginMustBeDomain, _, domains, err := u.loginNameInformation(context.Background(), event.ResourceOwner, event.InstanceID)
func (u *User) fillLoginNamesOnOrgUsers(event eventstore.Event) error {
userLoginMustBeDomain, _, domains, err := u.loginNameInformation(context.Background(), event.Aggregate().ResourceOwner, event.Aggregate().InstanceID)
if err != nil {
return err
}
users, err := u.view.UsersByOrgID(event.AggregateID, event.InstanceID)
users, err := u.view.UsersByOrgID(event.Aggregate().ID, event.Aggregate().InstanceID)
if err != nil {
return err
}
@@ -277,15 +483,15 @@ func (u *User) fillLoginNamesOnOrgUsers(event *es_models.Event) error {
return u.view.PutUsers(users, event)
}
func (u *User) fillPreferredLoginNamesOnOrgUsers(event *es_models.Event) error {
userLoginMustBeDomain, primaryDomain, _, err := u.loginNameInformation(context.Background(), event.ResourceOwner, event.InstanceID)
func (u *User) fillPreferredLoginNamesOnOrgUsers(event eventstore.Event) error {
userLoginMustBeDomain, primaryDomain, _, err := u.loginNameInformation(context.Background(), event.Aggregate().ResourceOwner, event.Aggregate().InstanceID)
if err != nil {
return err
}
if !userLoginMustBeDomain {
return nil
}
users, err := u.view.UsersByOrgID(event.AggregateID, event.InstanceID)
users, err := u.view.UsersByOrgID(event.Aggregate().ID, event.Aggregate().InstanceID)
if err != nil {
return err
}
@@ -295,17 +501,8 @@ func (u *User) fillPreferredLoginNamesOnOrgUsers(event *es_models.Event) error {
return u.view.PutUsers(users, event)
}
func (u *User) OnError(event *es_models.Event, err error) error {
logging.WithFields("id", event.AggregateID).WithError(err).Warn("something went wrong in user handler")
return spooler.HandleError(event, err, u.view.GetLatestUserFailedEvent, u.view.ProcessedUserFailedEvent, u.view.ProcessedUserSequence, u.errorCountUntilSkip)
}
func (u *User) OnSuccess(instanceIDs []string) error {
return spooler.HandleSuccess(u.view.UpdateUserSpoolerRunTimestamp, instanceIDs)
}
func (u *User) getOrgByID(ctx context.Context, orgID, instanceID string) (*org_model.Org, error) {
orgQuery, err := view.OrgByIDQuery(orgID, instanceID, 0)
query, err := org_view.OrgByIDQuery(orgID, instanceID, 0)
if err != nil {
return nil, err
}
@@ -315,8 +512,11 @@ func (u *User) getOrgByID(ctx context.Context, orgID, instanceID string) (*org_m
AggregateID: orgID,
},
}
err = es_sdk.Filter(ctx, u.Eventstore().FilterEvents, esOrg.AppendEvents, orgQuery)
if err != nil && !errors.IsNotFound(err) {
events, err := u.es.Filter(ctx, query)
if err != nil {
return nil, err
}
if err = esOrg.AppendEvents(events...); err != nil {
return nil, err
}
if esOrg.Sequence == 0 {
@@ -334,9 +534,27 @@ func (u *User) loginNameInformation(ctx context.Context, orgID string, instanceI
if org.DomainPolicy != nil {
return org.DomainPolicy.UserLoginMustBeDomain, org.GetPrimaryDomain().Domain, org.Domains, nil
}
policy, err := u.queries.DefaultDomainPolicy(withInstanceID(ctx, org.InstanceID))
policy, err := u.queries.DefaultDomainPolicy(authz.WithInstanceID(ctx, org.InstanceID))
if err != nil {
return false, "", nil, err
}
return policy.UserLoginMustBeDomain, org.GetPrimaryDomain().Domain, org.Domains, nil
}
func (u *User) userFromEventstore(agg *eventstore.Aggregate, eventTypes []eventstore.EventType) (*view_model.UserView, error) {
query, err := usr_view.UserByIDQuery(agg.ID, agg.InstanceID, 0, eventTypes)
if err != nil {
return nil, err
}
events, err := u.es.Filter(context.Background(), query)
if err != nil {
return nil, err
}
user := &view_model.UserView{}
for _, e := range events {
if err = user.AppendEvent(e); err != nil {
return nil, err
}
}
return user, nil
}

427
internal/auth/repository/eventsourcing/handler/user_session.go
View File

@@ -3,19 +3,16 @@ package handler
import (
"context"
"github.com/zitadel/logging"
"github.com/zitadel/zitadel/internal/api/authz"
auth_view "github.com/zitadel/zitadel/internal/auth/repository/eventsourcing/view"
"github.com/zitadel/zitadel/internal/domain"
"github.com/zitadel/zitadel/internal/errors"
"github.com/zitadel/zitadel/internal/eventstore"
v1 "github.com/zitadel/zitadel/internal/eventstore/v1"
"github.com/zitadel/zitadel/internal/eventstore/handler/v2"
"github.com/zitadel/zitadel/internal/eventstore/v1/models"
"github.com/zitadel/zitadel/internal/eventstore/v1/query"
es_sdk "github.com/zitadel/zitadel/internal/eventstore/v1/sdk"
"github.com/zitadel/zitadel/internal/eventstore/v1/spooler"
org_model "github.com/zitadel/zitadel/internal/org/model"
org_es_model "github.com/zitadel/zitadel/internal/org/repository/eventsourcing/model"
"github.com/zitadel/zitadel/internal/org/repository/view"
org_view "github.com/zitadel/zitadel/internal/org/repository/view"
query2 "github.com/zitadel/zitadel/internal/query"
"github.com/zitadel/zitadel/internal/repository/instance"
"github.com/zitadel/zitadel/internal/repository/org"
@@ -28,158 +25,299 @@ const (
)
type UserSession struct {
handler
subscription *v1.Subscription
queries *query2.Queries
queries *query2.Queries
view *auth_view.View
es handler.EventStore
}
func newUserSession(ctx context.Context, handler handler, queries *query2.Queries) *UserSession {
h := &UserSession{
handler: handler,
queries: queries,
}
var _ handler.Projection = (*UserSession)(nil)
h.subscribe(ctx)
return h
func newUserSession(
ctx context.Context,
config handler.Config,
view *auth_view.View,
queries *query2.Queries,
) *handler.Handler {
return handler.NewHandler(
ctx,
&config,
&UserSession{
queries: queries,
view: view,
es: config.Eventstore,
},
)
}
func (u *UserSession) subscribe(ctx context.Context) {
u.subscription = u.es.Subscribe(u.AggregateTypes()...)
go func() {
for event := range u.subscription.Events {
query.ReduceEvent(ctx, u, event)
}
}()
}
func (u *UserSession) ViewModel() string {
// Name implements [handler.Projection]
func (*UserSession) Name() string {
return userSessionTable
}
func (u *UserSession) Subscription() *v1.Subscription {
return u.subscription
}
func (_ *UserSession) AggregateTypes() []models.AggregateType {
return []models.AggregateType{user.AggregateType, org.AggregateType, instance.AggregateType}
}
func (u *UserSession) CurrentSequence(ctx context.Context, instanceID string) (uint64, error) {
sequence, err := u.view.GetLatestUserSessionSequence(ctx, instanceID)
if err != nil {
return 0, err
// Reducers implements [handler.Projection]
func (s *UserSession) Reducers() []handler.AggregateReducer {
return []handler.AggregateReducer{
{
Aggregate: user.AggregateType,
EventReducers: []handler.EventReducer{
{
Event: user.UserV1PasswordCheckSucceededType,
Reduce: s.Reduce,
},
{
Event: user.UserV1PasswordCheckFailedType,
Reduce: s.Reduce,
},
{
Event: user.UserV1MFAOTPCheckSucceededType,
Reduce: s.Reduce,
},
{
Event: user.UserV1MFAOTPCheckFailedType,
Reduce: s.Reduce,
},
{
Event: user.UserV1SignedOutType,
Reduce: s.Reduce,
},
{
Event: user.HumanPasswordCheckSucceededType,
Reduce: s.Reduce,
},
{
Event: user.HumanPasswordCheckFailedType,
Reduce: s.Reduce,
},
{
Event: user.UserIDPLoginCheckSucceededType,
Reduce: s.Reduce,
},
{
Event: user.HumanMFAOTPCheckSucceededType,
Reduce: s.Reduce,
},
{
Event: user.HumanMFAOTPCheckFailedType,
Reduce: s.Reduce,
},
{
Event: user.HumanU2FTokenCheckSucceededType,
Reduce: s.Reduce,
},
{
Event: user.HumanU2FTokenCheckFailedType,
Reduce: s.Reduce,
},
{
Event: user.HumanPasswordlessTokenCheckSucceededType,
Reduce: s.Reduce,
},
{
Event: user.HumanPasswordlessTokenCheckFailedType,
Reduce: s.Reduce,
},
{
Event: user.HumanSignedOutType,
Reduce: s.Reduce,
},
{
Event: user.UserV1PasswordChangedType,
Reduce: s.Reduce,
},
{
Event: user.UserV1MFAOTPRemovedType,
Reduce: s.Reduce,
},
{
Event: user.UserV1ProfileChangedType,
Reduce: s.Reduce,
},
{
Event: user.UserLockedType,
Reduce: s.Reduce,
},
{
Event: user.UserDeactivatedType,
Reduce: s.Reduce,
},
{
Event: user.HumanPasswordChangedType,
Reduce: s.Reduce,
},
{
Event: user.HumanMFAOTPRemovedType,
Reduce: s.Reduce,
},
{
Event: user.HumanProfileChangedType,
Reduce: s.Reduce,
},
{
Event: user.HumanAvatarAddedType,
Reduce: s.Reduce,
},
{
Event: user.HumanAvatarRemovedType,
Reduce: s.Reduce,
},
{
Event: user.UserDomainClaimedType,
Reduce: s.Reduce,
},
{
Event: user.UserUserNameChangedType,
Reduce: s.Reduce,
},
{
Event: user.UserIDPLinkRemovedType,
Reduce: s.Reduce,
},
{
Event: user.UserIDPLinkCascadeRemovedType,
Reduce: s.Reduce,
},
{
Event: user.HumanPasswordlessTokenRemovedType,
Reduce: s.Reduce,
},
{
Event: user.HumanU2FTokenRemovedType,
Reduce: s.Reduce,
},
{
Event: user.UserRemovedType,
Reduce: s.Reduce,
},
},
},
{
Aggregate: org.AggregateType,
EventReducers: []handler.EventReducer{
{
Event: org.OrgDomainPrimarySetEventType,
Reduce: s.Reduce,
},
{
Event: org.OrgRemovedEventType,
Reduce: s.Reduce,
},
},
},
{
Aggregate: instance.AggregateType,
EventReducers: []handler.EventReducer{
{
Event: instance.InstanceRemovedEventType,
Reduce: s.Reduce,
},
},
},
}
return sequence.CurrentSequence, nil
}
func (u *UserSession) EventQuery(ctx context.Context, instanceIDs []string) (*models.SearchQuery, error) {
sequences, err := u.view.GetLatestUserSessionSequences(ctx, instanceIDs)
if err != nil {
return nil, err
}
return newSearchQuery(sequences, u.AggregateTypes(), instanceIDs), nil
func (u *UserSession) Reduce(event eventstore.Event) (_ *handler.Statement, err error) {
return handler.NewStatement(event, func(ex handler.Executer, projectionName string) error {
var session *view_model.UserSessionView
switch event.Type() {
case user.UserV1PasswordCheckSucceededType,
user.UserV1PasswordCheckFailedType,
user.UserV1MFAOTPCheckSucceededType,
user.UserV1MFAOTPCheckFailedType,
user.UserV1SignedOutType,
user.HumanPasswordCheckSucceededType,
user.HumanPasswordCheckFailedType,
user.UserIDPLoginCheckSucceededType,
user.HumanMFAOTPCheckSucceededType,
user.HumanMFAOTPCheckFailedType,
user.HumanU2FTokenCheckSucceededType,
user.HumanU2FTokenCheckFailedType,
user.HumanPasswordlessTokenCheckSucceededType,
user.HumanPasswordlessTokenCheckFailedType,
user.HumanSignedOutType:
eventData, err := view_model.UserSessionFromEvent(event)
if err != nil {
return err
}
session, err = u.view.UserSessionByIDs(eventData.UserAgentID, event.Aggregate().ID, event.Aggregate().InstanceID)
if err != nil {
if !errors.IsNotFound(err) {
return err
}
session = &view_model.UserSessionView{
CreationDate: event.CreatedAt(),
ResourceOwner: event.Aggregate().ResourceOwner,
UserAgentID: eventData.UserAgentID,
UserID: event.Aggregate().ID,
State: int32(domain.UserSessionStateActive),
InstanceID: event.Aggregate().InstanceID,
}
}
return u.updateSession(session, event)
case user.UserV1PasswordChangedType,
user.UserV1MFAOTPRemovedType,
user.UserV1ProfileChangedType,
user.UserLockedType,
user.UserDeactivatedType,
user.HumanPasswordChangedType,
user.HumanMFAOTPRemovedType,
user.HumanProfileChangedType,
user.HumanAvatarAddedType,
user.HumanAvatarRemovedType,
user.UserDomainClaimedType,
user.UserUserNameChangedType,
user.UserIDPLinkRemovedType,
user.UserIDPLinkCascadeRemovedType,
user.HumanPasswordlessTokenRemovedType,
user.HumanU2FTokenRemovedType:
sessions, err := u.view.UserSessionsByUserID(event.Aggregate().ID, event.Aggregate().InstanceID)
if err != nil || len(sessions) == 0 {
return err
}
if err = u.appendEventOnSessions(sessions, event); err != nil {
return err
}
if err = u.view.PutUserSessions(sessions); err != nil {
return err
}
return nil
case org.OrgDomainPrimarySetEventType:
return u.fillLoginNamesOnOrgUsers(event)
case user.UserRemovedType:
return u.view.DeleteUserSessions(event.Aggregate().ID, event.Aggregate().InstanceID)
case instance.InstanceRemovedEventType:
return u.view.DeleteInstanceUserSessions(event.Aggregate().InstanceID)
case org.OrgRemovedEventType:
return u.view.DeleteOrgUserSessions(event)
default:
return nil
}
}), nil
}
func (u *UserSession) Reduce(event *models.Event) (err error) {
var session *view_model.UserSessionView
switch eventstore.EventType(event.Type) {
case user.UserV1PasswordCheckSucceededType,
user.UserV1PasswordCheckFailedType,
user.UserV1MFAOTPCheckSucceededType,
user.UserV1MFAOTPCheckFailedType,
user.UserV1SignedOutType,
user.HumanPasswordCheckSucceededType,
user.HumanPasswordCheckFailedType,
user.UserIDPLoginCheckSucceededType,
user.HumanMFAOTPCheckSucceededType,
user.HumanMFAOTPCheckFailedType,
user.HumanU2FTokenCheckSucceededType,
user.HumanU2FTokenCheckFailedType,
user.HumanPasswordlessTokenCheckSucceededType,
user.HumanPasswordlessTokenCheckFailedType,
user.HumanSignedOutType:
eventData, err := view_model.UserSessionFromEvent(event)
if err != nil {
func (u *UserSession) appendEventOnSessions(sessions []*view_model.UserSessionView, event eventstore.Event) error {
for _, session := range sessions {
if err := session.AppendEvent(event); err != nil {
return err
}
session, err = u.view.UserSessionByIDs(eventData.UserAgentID, event.AggregateID, event.InstanceID)
if err != nil {
if !errors.IsNotFound(err) {
return err
}
session = &view_model.UserSessionView{
CreationDate: event.CreationDate,
ResourceOwner: event.ResourceOwner,
UserAgentID: eventData.UserAgentID,
UserID: event.AggregateID,
State: int32(domain.UserSessionStateActive),
InstanceID: event.InstanceID,
}
}
return u.updateSession(session, event)
case user.UserV1PasswordChangedType,
user.UserV1MFAOTPRemovedType,
user.UserV1ProfileChangedType,
user.UserLockedType,
user.UserDeactivatedType,
user.HumanPasswordChangedType,
user.HumanMFAOTPRemovedType,
user.HumanProfileChangedType,
user.HumanAvatarAddedType,
user.HumanAvatarRemovedType,
user.UserDomainClaimedType,
user.UserUserNameChangedType,
user.UserIDPLinkRemovedType,
user.UserIDPLinkCascadeRemovedType,
user.HumanPasswordlessTokenRemovedType,
user.HumanU2FTokenRemovedType:
sessions, err := u.view.UserSessionsByUserID(event.AggregateID, event.InstanceID)
if err != nil {
if err := u.fillUserInfo(session); err != nil {
return err
}
if len(sessions) == 0 {
return u.view.ProcessedUserSessionSequence(event)
}
for _, session := range sessions {
if err := session.AppendEvent(event); err != nil {
return err
}
if err := u.fillUserInfo(session); err != nil {
return err
}
}
return u.view.PutUserSessions(sessions, event)
case org.OrgDomainPrimarySetEventType:
return u.fillLoginNamesOnOrgUsers(event)
case user.UserRemovedType:
return u.view.DeleteUserSessions(event.AggregateID, event.InstanceID, event)
case instance.InstanceRemovedEventType:
return u.view.DeleteInstanceUserSessions(event)
case org.OrgRemovedEventType:
return u.view.DeleteOrgUserSessions(event)
default:
return u.view.ProcessedUserSessionSequence(event)
}
return nil
}
func (u *UserSession) OnError(event *models.Event, err error) error {
logging.WithFields("id", event.AggregateID).WithError(err).Warn("something went wrong in user session handler")
return spooler.HandleError(event, err, u.view.GetLatestUserSessionFailedEvent, u.view.ProcessedUserSessionFailedEvent, u.view.ProcessedUserSessionSequence, u.errorCountUntilSkip)
}
func (u *UserSession) OnSuccess(instanceIDs []string) error {
return spooler.HandleSuccess(u.view.UpdateUserSessionSpoolerRunTimestamp, instanceIDs)
}
func (u *UserSession) updateSession(session *view_model.UserSessionView, event *models.Event) error {
func (u *UserSession) updateSession(session *view_model.UserSessionView, event eventstore.Event) error {
if err := session.AppendEvent(event); err != nil {
return err
}
if err := u.fillUserInfo(session); err != nil {
return err
}
return u.view.PutUserSession(session, event)
if err := u.view.PutUserSession(session); err != nil {
return err
}
return nil
}
func (u *UserSession) fillUserInfo(session *view_model.UserSessionView) error {
@@ -194,15 +332,15 @@ func (u *UserSession) fillUserInfo(session *view_model.UserSessionView) error {
return nil
}
func (u *UserSession) fillLoginNamesOnOrgUsers(event *models.Event) error {
sessions, err := u.view.UserSessionsByOrgID(event.ResourceOwner, event.InstanceID)
func (u *UserSession) fillLoginNamesOnOrgUsers(event eventstore.Event) error {
sessions, err := u.view.UserSessionsByOrgID(event.Aggregate().ResourceOwner, event.Aggregate().InstanceID)
if err != nil {
return err
}
if len(sessions) == 0 {
return u.view.ProcessedUserSessionSequence(event)
return nil
}
userLoginMustBeDomain, primaryDomain, err := u.loginNameInformation(context.Background(), event.ResourceOwner, event.InstanceID)
userLoginMustBeDomain, primaryDomain, err := u.loginNameInformation(context.Background(), event.Aggregate().ResourceOwner, event.Aggregate().InstanceID)
if err != nil {
return err
}
@@ -212,7 +350,7 @@ func (u *UserSession) fillLoginNamesOnOrgUsers(event *models.Event) error {
for _, session := range sessions {
session.LoginName = session.UserName + "@" + primaryDomain
}
return u.view.PutUserSessions(sessions, event)
return u.view.PutUserSessions(sessions)
}
func (u *UserSession) loginNameInformation(ctx context.Context, orgID string, instanceID string) (userLoginMustBeDomain bool, primaryDomain string, err error) {
@@ -223,7 +361,7 @@ func (u *UserSession) loginNameInformation(ctx context.Context, orgID string, in
if org.DomainPolicy != nil {
return org.DomainPolicy.UserLoginMustBeDomain, org.GetPrimaryDomain().Domain, nil
}
policy, err := u.queries.DefaultDomainPolicy(withInstanceID(ctx, org.InstanceID))
policy, err := u.queries.DefaultDomainPolicy(authz.WithInstanceID(ctx, org.InstanceID))
if err != nil {
return false, "", err
}
@@ -231,7 +369,7 @@ func (u *UserSession) loginNameInformation(ctx context.Context, orgID string, in
}
func (u *UserSession) getOrgByID(ctx context.Context, orgID, instanceID string) (*org_model.Org, error) {
orgQuery, err := view.OrgByIDQuery(orgID, instanceID, 0)
query, err := org_view.OrgByIDQuery(orgID, instanceID, 0)
if err != nil {
return nil, err
}
@@ -241,13 +379,16 @@ func (u *UserSession) getOrgByID(ctx context.Context, orgID, instanceID string)
AggregateID: orgID,
},
}
err = es_sdk.Filter(ctx, u.Eventstore().FilterEvents, esOrg.AppendEvents, orgQuery)
if err != nil && !errors.IsNotFound(err) {
events, err := u.es.Filter(ctx, query)
if err != nil {
return nil, err
}
if err = esOrg.AppendEvents(events...); err != nil {
return nil, err
}
if esOrg.Sequence == 0 {
return nil, errors.ThrowNotFound(nil, "EVENT-3m9vs", "Errors.Org.NotFound")
}
return org_es_model.OrgToModel(esOrg), nil
}

33
internal/auth/repository/eventsourcing/repository.go
View File

@@ -5,7 +5,7 @@ import (
"github.com/zitadel/zitadel/feature"
"github.com/zitadel/zitadel/internal/auth/repository/eventsourcing/eventstore"
"github.com/zitadel/zitadel/internal/auth/repository/eventsourcing/spooler"
auth_handler "github.com/zitadel/zitadel/internal/auth/repository/eventsourcing/handler"
auth_view "github.com/zitadel/zitadel/internal/auth/repository/eventsourcing/view"
"github.com/zitadel/zitadel/internal/auth_request/repository/cache"
"github.com/zitadel/zitadel/internal/command"
@@ -13,20 +13,16 @@ import (
"github.com/zitadel/zitadel/internal/crypto"
"github.com/zitadel/zitadel/internal/database"
eventstore2 "github.com/zitadel/zitadel/internal/eventstore"
v1 "github.com/zitadel/zitadel/internal/eventstore/v1"
es_spol "github.com/zitadel/zitadel/internal/eventstore/v1/spooler"
"github.com/zitadel/zitadel/internal/id"
"github.com/zitadel/zitadel/internal/query"
)
type Config struct {
SearchLimit uint64
Spooler spooler.SpoolerConfig
Spooler auth_handler.Config
}
type EsRepository struct {
spooler *es_spol.Spooler
Eventstore v1.Eventstore
eventstore.UserRepo
eventstore.AuthRequestRepo
eventstore.TokenRepo
@@ -35,25 +31,19 @@ type EsRepository struct {
eventstore.OrgRepository
}
func Start(ctx context.Context, conf Config, systemDefaults sd.SystemDefaults, command *command.Commands, queries *query.Queries, dbClient *database.DB, esV2 *eventstore2.Eventstore, oidcEncryption crypto.EncryptionAlgorithm, userEncryption crypto.EncryptionAlgorithm, allowOrderByCreationDate bool) (*EsRepository, error) {
es, err := v1.Start(dbClient, allowOrderByCreationDate)
func Start(ctx context.Context, conf Config, systemDefaults sd.SystemDefaults, command *command.Commands, queries *query.Queries, dbClient *database.DB, esV2 *eventstore2.Eventstore, oidcEncryption crypto.EncryptionAlgorithm, userEncryption crypto.EncryptionAlgorithm) (*EsRepository, error) {
view, err := auth_view.StartView(dbClient, oidcEncryption, queries, esV2)
if err != nil {
return nil, err
}
idGenerator := id.SonyFlakeGenerator()
view, err := auth_view.StartView(dbClient, oidcEncryption, queries, idGenerator, es)
if err != nil {
return nil, err
}
auth_handler.Register(ctx, conf.Spooler, view, queries)
authReq := cache.Start(dbClient)
spool := spooler.StartSpooler(ctx, conf.Spooler, es, esV2, view, dbClient, queries)
userRepo := eventstore.UserRepo{
SearchLimit: conf.SearchLimit,
Eventstore: es,
Eventstore: esV2,
View: view,
Query: queries,
SystemDefaults: systemDefaults,
@@ -64,8 +54,6 @@ func Start(ctx context.Context, conf Config, systemDefaults sd.SystemDefaults, c
view,
}
return &EsRepository{
spool,
es,
userRepo,
eventstore.AuthRequestRepo{
PrivacyPolicyProvider: queries,
@@ -75,7 +63,6 @@ func Start(ctx context.Context, conf Config, systemDefaults sd.SystemDefaults, c
OrgViewProvider: queries,
AuthRequests: authReq,
View: view,
Eventstore: es,
UserCodeAlg: userEncryption,
UserSessionViewProvider: view,
UserViewProvider: view,
@@ -90,15 +77,15 @@ func Start(ctx context.Context, conf Config, systemDefaults sd.SystemDefaults, c
ApplicationProvider: queries,
CustomTextProvider: queries,
FeatureCheck: feature.NewCheck(esV2),
IdGenerator: idGenerator,
IdGenerator: id.SonyFlakeGenerator(),
},
eventstore.TokenRepo{
View: view,
Eventstore: es,
Eventstore: esV2,
},
eventstore.RefreshTokenRepo{
View: view,
Eventstore: es,
Eventstore: esV2,
SearchLimit: conf.SearchLimit,
KeyAlgorithm: oidcEncryption,
},
@@ -109,7 +96,7 @@ func Start(ctx context.Context, conf Config, systemDefaults sd.SystemDefaults, c
SearchLimit: conf.SearchLimit,
View: view,
SystemDefaults: systemDefaults,
Eventstore: es,
Eventstore: esV2,
Query: queries,
},
}, nil

24
internal/auth/repository/eventsourcing/spooler/lock.go
View File

@@ -1,24 +0,0 @@
package spooler
import (
"database/sql"
"time"
es_locker "github.com/zitadel/zitadel/internal/eventstore/v1/locker"
)
const (
lockTable = "auth.locks"
)
type locker struct {
dbClient *sql.DB
}
func NewLocker(client *sql.DB) *locker {
return &locker{dbClient: client}
}
func (l *locker) Renew(lockerID, viewModel, instanceID string, waitTime time.Duration) error {
return es_locker.Renew(l.dbClient, lockTable, lockerID, viewModel, instanceID, waitTime)
}

35
internal/auth/repository/eventsourcing/spooler/spooler.go
View File

@@ -1,35 +0,0 @@
package spooler
import (
"context"
"github.com/zitadel/zitadel/internal/auth/repository/eventsourcing/handler"
"github.com/zitadel/zitadel/internal/auth/repository/eventsourcing/view"
"github.com/zitadel/zitadel/internal/database"
"github.com/zitadel/zitadel/internal/eventstore"
v1 "github.com/zitadel/zitadel/internal/eventstore/v1"
"github.com/zitadel/zitadel/internal/eventstore/v1/spooler"
"github.com/zitadel/zitadel/internal/query"
)
type SpoolerConfig struct {
BulkLimit uint64
FailureCountUntilSkip uint64
ConcurrentWorkers int
ConcurrentInstances int
Handlers handler.Configs
}
func StartSpooler(ctx context.Context, c SpoolerConfig, es v1.Eventstore, esV2 *eventstore.Eventstore, view *view.View, client *database.DB, queries *query.Queries) *spooler.Spooler {
spoolerConfig := spooler.Config{
Eventstore: es,
EventstoreV2: esV2,
Locker: &locker{dbClient: client.DB},
ConcurrentWorkers: c.ConcurrentWorkers,
ConcurrentInstances: c.ConcurrentInstances,
ViewHandlers: handler.Register(ctx, c.Handlers, c.BulkLimit, c.FailureCountUntilSkip, view, es, queries),
}
spool := spoolerConfig.New()
spool.Start()
return spool
}

17
internal/auth/repository/eventsourcing/view/error_event.go
View File

@@ -1,17 +0,0 @@
package view
import (
"github.com/zitadel/zitadel/internal/view/repository"
)
const (
errTable = "auth.failed_events"
)
func (v *View) saveFailedEvent(failedEvent *repository.FailedEvent) error {
return repository.SaveFailedEvent(v.Db, errTable, failedEvent)
}
func (v *View) latestFailedEvent(viewName, instanceID string, sequence uint64) (*repository.FailedEvent, error) {
return repository.LatestFailedEvent(v.Db, errTable, viewName, instanceID, sequence)
}

81
internal/auth/repository/eventsourcing/view/refresh_token.go
View File

@@ -3,12 +3,14 @@ package view
import (
"context"
"github.com/zitadel/zitadel/internal/api/authz"
"github.com/zitadel/zitadel/internal/errors"
"github.com/zitadel/zitadel/internal/eventstore"
"github.com/zitadel/zitadel/internal/eventstore/v1/models"
"github.com/zitadel/zitadel/internal/query"
user_model "github.com/zitadel/zitadel/internal/user/model"
usr_view "github.com/zitadel/zitadel/internal/user/repository/view"
"github.com/zitadel/zitadel/internal/user/repository/view/model"
"github.com/zitadel/zitadel/internal/view/repository"
)
const (
@@ -27,36 +29,28 @@ func (v *View) SearchRefreshTokens(request *user_model.RefreshTokenSearchRequest
return usr_view.SearchRefreshTokens(v.Db, refreshTokenTable, request)
}
func (v *View) PutRefreshToken(token *model.RefreshTokenView, event *models.Event) error {
err := usr_view.PutRefreshToken(v.Db, refreshTokenTable, token)
if err != nil {
return err
}
return v.ProcessedRefreshTokenSequence(event)
func (v *View) PutRefreshToken(token *model.RefreshTokenView) error {
return usr_view.PutRefreshToken(v.Db, refreshTokenTable, token)
}
func (v *View) PutRefreshTokens(token []*model.RefreshTokenView, event *models.Event) error {
err := usr_view.PutRefreshTokens(v.Db, refreshTokenTable, token...)
if err != nil {
return err
}
return v.ProcessedRefreshTokenSequence(event)
func (v *View) PutRefreshTokens(token []*model.RefreshTokenView) error {
return usr_view.PutRefreshTokens(v.Db, refreshTokenTable, token...)
}
func (v *View) DeleteRefreshToken(tokenID, instanceID string, event *models.Event) error {
func (v *View) DeleteRefreshToken(tokenID, instanceID string) error {
err := usr_view.DeleteRefreshToken(v.Db, refreshTokenTable, tokenID, instanceID)
if err != nil && !errors.IsNotFound(err) {
return err
}
return v.ProcessedRefreshTokenSequence(event)
return nil
}
func (v *View) DeleteUserRefreshTokens(userID, instanceID string, event *models.Event) error {
func (v *View) DeleteUserRefreshTokens(userID, instanceID string) error {
err := usr_view.DeleteUserRefreshTokens(v.Db, refreshTokenTable, userID, instanceID)
if err != nil && !errors.IsNotFound(err) {
return err
}
return v.ProcessedRefreshTokenSequence(event)
return nil
}
func (v *View) DeleteApplicationRefreshTokens(event *models.Event, ids ...string) error {
@@ -64,45 +58,40 @@ func (v *View) DeleteApplicationRefreshTokens(event *models.Event, ids ...string
if err != nil && !errors.IsNotFound(err) {
return err
}
return v.ProcessedRefreshTokenSequence(event)
return nil
}
func (v *View) DeleteInstanceRefreshTokens(event *models.Event) error {
err := usr_view.DeleteInstanceRefreshTokens(v.Db, refreshTokenTable, event.InstanceID)
func (v *View) DeleteInstanceRefreshTokens(instanceID string) error {
err := usr_view.DeleteInstanceRefreshTokens(v.Db, refreshTokenTable, instanceID)
if err != nil && !errors.IsNotFound(err) {
return err
}
return v.ProcessedRefreshTokenSequence(event)
return nil
}
func (v *View) DeleteOrgRefreshTokens(event *models.Event) error {
err := usr_view.DeleteOrgRefreshTokens(v.Db, refreshTokenTable, event.InstanceID, event.ResourceOwner)
func (v *View) DeleteOrgRefreshTokens(event eventstore.Event) error {
err := usr_view.DeleteOrgRefreshTokens(v.Db, refreshTokenTable, event.Aggregate().InstanceID, event.Aggregate().ResourceOwner)
if err != nil && !errors.IsNotFound(err) {
return err
}
return v.ProcessedRefreshTokenSequence(event)
return nil
}
func (v *View) GetLatestRefreshTokenSequence(ctx context.Context, instanceID string) (*repository.CurrentSequence, error) {
return v.latestSequence(ctx, refreshTokenTable, instanceID)
}
func (v *View) GetLatestRefreshTokenSequences(ctx context.Context, instanceIDs []string) ([]*repository.CurrentSequence, error) {
return v.latestSequences(ctx, refreshTokenTable, instanceIDs)
}
func (v *View) ProcessedRefreshTokenSequence(event *models.Event) error {
return v.saveCurrentSequence(refreshTokenTable, event)
}
func (v *View) UpdateRefreshTokenSpoolerRunTimestamp(instanceIDs []string) error {
return v.updateSpoolerRunSequence(refreshTokenTable, instanceIDs)
}
func (v *View) GetLatestRefreshTokenFailedEvent(sequence uint64, instanceID string) (*repository.FailedEvent, error) {
return v.latestFailedEvent(refreshTokenTable, instanceID, sequence)
}
func (v *View) ProcessedRefreshTokenFailedEvent(failedEvent *repository.FailedEvent) error {
return v.saveFailedEvent(failedEvent)
func (v *View) GetLatestRefreshTokenSequence(ctx context.Context) (_ *query.CurrentState, err error) {
q := &query.CurrentStateSearchQueries{
Queries: make([]query.SearchQuery, 2),
}
q.Queries[0], err = query.NewCurrentStatesInstanceIDSearchQuery(authz.GetInstance(ctx).InstanceID())
if err != nil {
return nil, err
}
q.Queries[1], err = query.NewCurrentStatesProjectionSearchQuery(refreshTokenTable)
if err != nil {
return nil, err
}
states, err := v.query.SearchCurrentStates(ctx, q)
if err != nil || states.SearchResponse.Count == 0 {
return nil, err
}
return states.CurrentStates[0], nil
}

39
internal/auth/repository/eventsourcing/view/sequence.go
View File

@@ -1,39 +0,0 @@
package view
import (
"context"
"time"
"github.com/zitadel/zitadel/internal/eventstore/v1/models"
"github.com/zitadel/zitadel/internal/view/repository"
)
const (
sequencesTable = "auth.current_sequences"
)
func (v *View) saveCurrentSequence(viewName string, event *models.Event) error {
return repository.SaveCurrentSequence(v.Db, sequencesTable, viewName, event.InstanceID, event.Sequence, event.CreationDate)
}
func (v *View) latestSequence(ctx context.Context, viewName, instanceID string) (*repository.CurrentSequence, error) {
return repository.LatestSequence(v.Db, v.TimeTravel(ctx, sequencesTable), viewName, instanceID)
}
func (v *View) latestSequences(ctx context.Context, viewName string, instanceIDs []string) ([]*repository.CurrentSequence, error) {
return repository.LatestSequences(v.Db, v.TimeTravel(ctx, sequencesTable), viewName, instanceIDs)
}
func (v *View) updateSpoolerRunSequence(viewName string, instanceIDs []string) error {
currentSequences, err := repository.LatestSequences(v.Db, sequencesTable, viewName, instanceIDs)
if err != nil {
return err
}
for _, currentSequence := range currentSequences {
if currentSequence.ViewName == "" {
currentSequence.ViewName = viewName
}
currentSequence.LastSuccessfulSpoolerRun = time.Now()
}
return repository.UpdateCurrentSequences(v.Db, sequencesTable, currentSequences)
}

97
internal/auth/repository/eventsourcing/view/token.go
View File

@@ -4,10 +4,10 @@ import (
"context"
"github.com/zitadel/zitadel/internal/errors"
"github.com/zitadel/zitadel/internal/eventstore/v1/models"
"github.com/zitadel/zitadel/internal/eventstore"
"github.com/zitadel/zitadel/internal/query"
usr_view "github.com/zitadel/zitadel/internal/user/repository/view"
"github.com/zitadel/zitadel/internal/user/repository/view/model"
"github.com/zitadel/zitadel/internal/view/repository"
)
const (
@@ -22,98 +22,85 @@ func (v *View) TokensByUserID(userID, instanceID string) ([]*model.TokenView, er
return usr_view.TokensByUserID(v.Db, tokenTable, userID, instanceID)
}
func (v *View) PutToken(token *model.TokenView, event *models.Event) error {
err := usr_view.PutToken(v.Db, tokenTable, token)
if err != nil {
return err
}
return v.ProcessedTokenSequence(event)
func (v *View) PutToken(token *model.TokenView) error {
return usr_view.PutToken(v.Db, tokenTable, token)
}
func (v *View) PutTokens(token []*model.TokenView, event *models.Event) error {
err := usr_view.PutTokens(v.Db, tokenTable, token...)
if err != nil {
return err
}
return v.ProcessedTokenSequence(event)
func (v *View) PutTokens(token []*model.TokenView) error {
return usr_view.PutTokens(v.Db, tokenTable, token...)
}
func (v *View) DeleteToken(tokenID, instanceID string, event *models.Event) error {
func (v *View) DeleteToken(tokenID, instanceID string) error {
err := usr_view.DeleteToken(v.Db, tokenTable, tokenID, instanceID)
if err != nil && !errors.IsNotFound(err) {
return err
}
return v.ProcessedTokenSequence(event)
return nil
}
func (v *View) DeleteSessionTokens(agentID, userID, instanceID string, event *models.Event) error {
err := usr_view.DeleteSessionTokens(v.Db, tokenTable, agentID, userID, instanceID)
func (v *View) DeleteSessionTokens(agentID string, event eventstore.Event) error {
err := usr_view.DeleteSessionTokens(v.Db, tokenTable, agentID, event.Aggregate().ID, event.Aggregate().InstanceID)
if err != nil && !errors.IsNotFound(err) {
return err
}
return v.ProcessedTokenSequence(event)
return nil
}
func (v *View) DeleteUserTokens(userID, instanceID string, event *models.Event) error {
err := usr_view.DeleteUserTokens(v.Db, tokenTable, userID, instanceID)
func (v *View) DeleteUserTokens(event eventstore.Event) error {
err := usr_view.DeleteUserTokens(v.Db, tokenTable, event.Aggregate().ID, event.Aggregate().InstanceID)
if err != nil && !errors.IsNotFound(err) {
return err
}
return v.ProcessedTokenSequence(event)
return nil
}
func (v *View) DeleteApplicationTokens(event *models.Event, ids ...string) error {
err := usr_view.DeleteApplicationTokens(v.Db, tokenTable, event.InstanceID, ids)
func (v *View) DeleteApplicationTokens(event eventstore.Event, ids ...string) error {
err := usr_view.DeleteApplicationTokens(v.Db, tokenTable, event.Aggregate().InstanceID, ids)
if err != nil && !errors.IsNotFound(err) {
return err
}
return v.ProcessedTokenSequence(event)
return nil
}
func (v *View) DeleteTokensFromRefreshToken(refreshTokenID, instanceID string, event *models.Event) error {
func (v *View) DeleteTokensFromRefreshToken(refreshTokenID, instanceID string) error {
err := usr_view.DeleteTokensFromRefreshToken(v.Db, tokenTable, refreshTokenID, instanceID)
if err != nil && !errors.IsNotFound(err) {
return err
}
return v.ProcessedTokenSequence(event)
return nil
}
func (v *View) DeleteInstanceTokens(event *models.Event) error {
err := usr_view.DeleteInstanceTokens(v.Db, tokenTable, event.InstanceID)
func (v *View) DeleteInstanceTokens(event eventstore.Event) error {
err := usr_view.DeleteInstanceTokens(v.Db, tokenTable, event.Aggregate().InstanceID)
if err != nil && !errors.IsNotFound(err) {
return err
}
return v.ProcessedTokenSequence(event)
return nil
}
func (v *View) DeleteOrgTokens(event *models.Event) error {
err := usr_view.DeleteOrgTokens(v.Db, tokenTable, event.InstanceID, event.ResourceOwner)
func (v *View) DeleteOrgTokens(event eventstore.Event) error {
err := usr_view.DeleteOrgTokens(v.Db, tokenTable, event.Aggregate().InstanceID, event.Aggregate().ResourceOwner)
if err != nil && !errors.IsNotFound(err) {
return err
}
return v.ProcessedTokenSequence(event)
return nil
}
func (v *View) GetLatestTokenSequence(ctx context.Context, instanceID string) (*repository.CurrentSequence, error) {
return v.latestSequence(ctx, tokenTable, instanceID)
}
func (v *View) GetLatestTokenSequences(ctx context.Context, instanceIDs []string) ([]*repository.CurrentSequence, error) {
return v.latestSequences(ctx, tokenTable, instanceIDs)
}
func (v *View) ProcessedTokenSequence(event *models.Event) error {
return v.saveCurrentSequence(tokenTable, event)
}
func (v *View) UpdateTokenSpoolerRunTimestamp(instanceIDs []string) error {
return v.updateSpoolerRunSequence(tokenTable, instanceIDs)
}
func (v *View) GetLatestTokenFailedEvent(sequence uint64, instanceID string) (*repository.FailedEvent, error) {
return v.latestFailedEvent(tokenTable, instanceID, sequence)
}
func (v *View) ProcessedTokenFailedEvent(failedEvent *repository.FailedEvent) error {
return v.saveFailedEvent(failedEvent)
func (v *View) GetLatestTokenSequence(ctx context.Context, instanceID string) (_ *query.CurrentState, err error) {
q := &query.CurrentStateSearchQueries{
Queries: make([]query.SearchQuery, 2),
}
q.Queries[0], err = query.NewCurrentStatesInstanceIDSearchQuery(instanceID)
if err != nil {
return nil, err
}
q.Queries[1], err = query.NewCurrentStatesProjectionSearchQuery(tokenTable)
if err != nil {
return nil, err
}
states, err := v.query.SearchCurrentStates(ctx, q)
if err != nil || states.SearchResponse.Count == 0 {
return nil, err
}
return states.CurrentStates[0], nil
}

95
internal/auth/repository/eventsourcing/view/user.go
View File

@@ -4,14 +4,12 @@ import (
"context"
"github.com/zitadel/logging"
"github.com/zitadel/zitadel/internal/errors"
"github.com/zitadel/zitadel/internal/eventstore/v1/models"
"github.com/zitadel/zitadel/internal/eventstore"
"github.com/zitadel/zitadel/internal/query"
usr_model "github.com/zitadel/zitadel/internal/user/model"
"github.com/zitadel/zitadel/internal/user/repository/view"
"github.com/zitadel/zitadel/internal/user/repository/view/model"
"github.com/zitadel/zitadel/internal/view/repository"
)
const (
@@ -104,7 +102,7 @@ func (v *View) userByID(ctx context.Context, instanceID string, queries ...query
Errorf("could not get current sequence for userByID")
user = new(model.UserView)
if sequence != nil {
user.Sequence = sequence.CurrentSequence
user.Sequence = sequence.Sequence
}
}
@@ -112,7 +110,7 @@ func (v *View) userByID(ctx context.Context, instanceID string, queries ...query
if err != nil {
return nil, err
}
events, err := v.es.FilterEvents(ctx, query)
events, err := v.es.Filter(ctx, query)
if err != nil && user.Sequence == 0 {
return nil, err
} else if err != nil {
@@ -138,82 +136,53 @@ func (v *View) UsersByOrgID(orgID, instanceID string) ([]*model.UserView, error)
return view.UsersByOrgID(v.Db, userTable, orgID, instanceID)
}
func (v *View) UserIDsByDomain(domain, instanceID string) ([]string, error) {
return view.UserIDsByDomain(v.Db, userTable, domain, instanceID)
func (v *View) PutUser(user *model.UserView, event eventstore.Event) error {
return view.PutUser(v.Db, userTable, user)
}
func (v *View) SearchUsers(request *usr_model.UserSearchRequest) ([]*model.UserView, uint64, error) {
return view.SearchUsers(v.Db, userTable, request)
func (v *View) PutUsers(users []*model.UserView, event eventstore.Event) error {
return view.PutUsers(v.Db, userTable, users...)
}
func (v *View) GetGlobalUserByLoginName(email, instanceID string) (*model.UserView, error) {
return view.GetGlobalUserByLoginName(v.Db, userTable, email, instanceID)
}
func (v *View) UserMFAs(userID, instanceID string) ([]*usr_model.MultiFactor, error) {
return view.UserMFAs(v.Db, userTable, userID, instanceID)
}
func (v *View) PutUser(user *model.UserView, event *models.Event) error {
err := view.PutUser(v.Db, userTable, user)
if err != nil {
return err
}
return v.ProcessedUserSequence(event)
}
func (v *View) PutUsers(users []*model.UserView, event *models.Event) error {
err := view.PutUsers(v.Db, userTable, users...)
if err != nil {
return err
}
return v.ProcessedUserSequence(event)
}
func (v *View) DeleteUser(userID, instanceID string, event *models.Event) error {
func (v *View) DeleteUser(userID, instanceID string, event eventstore.Event) error {
err := view.DeleteUser(v.Db, userTable, userID, instanceID)
if err != nil && !errors.IsNotFound(err) {
return err
}
return v.ProcessedUserSequence(event)
return nil
}
func (v *View) DeleteInstanceUsers(event *models.Event) error {
err := view.DeleteInstanceUsers(v.Db, userTable, event.InstanceID)
func (v *View) DeleteInstanceUsers(event eventstore.Event) error {
err := view.DeleteInstanceUsers(v.Db, userTable, event.Aggregate().InstanceID)
if err != nil && !errors.IsNotFound(err) {
return err
}
return v.ProcessedUserSequence(event)
return nil
}
func (v *View) UpdateOrgOwnerRemovedUsers(event *models.Event) error {
err := view.UpdateOrgOwnerRemovedUsers(v.Db, userTable, event.InstanceID, event.AggregateID)
func (v *View) UpdateOrgOwnerRemovedUsers(event eventstore.Event) error {
err := view.UpdateOrgOwnerRemovedUsers(v.Db, userTable, event.Aggregate().InstanceID, event.Aggregate().ID)
if err != nil && !errors.IsNotFound(err) {
return err
}
return v.ProcessedUserSequence(event)
return nil
}
func (v *View) GetLatestUserSequence(ctx context.Context, instanceID string) (*repository.CurrentSequence, error) {
return v.latestSequence(ctx, userTable, instanceID)
}
func (v *View) GetLatestUserSequences(ctx context.Context, instanceIDs []string) ([]*repository.CurrentSequence, error) {
return v.latestSequences(ctx, userTable, instanceIDs)
}
func (v *View) ProcessedUserSequence(event *models.Event) error {
return v.saveCurrentSequence(userTable, event)
}
func (v *View) UpdateUserSpoolerRunTimestamp(instanceIDs []string) error {
return v.updateSpoolerRunSequence(userTable, instanceIDs)
}
func (v *View) GetLatestUserFailedEvent(sequence uint64, instanceID string) (*repository.FailedEvent, error) {
return v.latestFailedEvent(userTable, instanceID, sequence)
}
func (v *View) ProcessedUserFailedEvent(failedEvent *repository.FailedEvent) error {
return v.saveFailedEvent(failedEvent)
func (v *View) GetLatestUserSequence(ctx context.Context, instanceID string) (_ *query.CurrentState, err error) {
q := &query.CurrentStateSearchQueries{
Queries: make([]query.SearchQuery, 2),
}
q.Queries[0], err = query.NewCurrentStatesInstanceIDSearchQuery(instanceID)
if err != nil {
return nil, err
}
q.Queries[1], err = query.NewCurrentStatesProjectionSearchQuery(userTable)
if err != nil {
return nil, err
}
states, err := v.query.SearchCurrentStates(ctx, q)
if err != nil || states.SearchResponse.Count == 0 {
return nil, err
}
return states.CurrentStates[0], nil
}

75
internal/auth/repository/eventsourcing/view/user_session.go
View File

@@ -4,10 +4,10 @@ import (
"context"
"github.com/zitadel/zitadel/internal/errors"
"github.com/zitadel/zitadel/internal/eventstore/v1/models"
"github.com/zitadel/zitadel/internal/eventstore"
"github.com/zitadel/zitadel/internal/query"
"github.com/zitadel/zitadel/internal/user/repository/view"
"github.com/zitadel/zitadel/internal/user/repository/view/model"
"github.com/zitadel/zitadel/internal/view/repository"
)
const (
@@ -34,66 +34,53 @@ func (v *View) ActiveUserSessionsCount() (uint64, error) {
return view.ActiveUserSessions(v.Db, userSessionTable)
}
func (v *View) PutUserSession(userSession *model.UserSessionView, event *models.Event) error {
err := view.PutUserSession(v.Db, userSessionTable, userSession)
if err != nil {
return err
}
return v.ProcessedUserSessionSequence(event)
func (v *View) PutUserSession(userSession *model.UserSessionView) error {
return view.PutUserSession(v.Db, userSessionTable, userSession)
}
func (v *View) PutUserSessions(userSession []*model.UserSessionView, event *models.Event) error {
err := view.PutUserSessions(v.Db, userSessionTable, userSession...)
if err != nil {
return err
}
return v.ProcessedUserSessionSequence(event)
func (v *View) PutUserSessions(userSession []*model.UserSessionView) error {
return view.PutUserSessions(v.Db, userSessionTable, userSession...)
}
func (v *View) DeleteUserSessions(userID, instanceID string, event *models.Event) error {
func (v *View) DeleteUserSessions(userID, instanceID string) error {
err := view.DeleteUserSessions(v.Db, userSessionTable, userID, instanceID)
if err != nil && !errors.IsNotFound(err) {
return err
}
return v.ProcessedUserSessionSequence(event)
return nil
}
func (v *View) DeleteInstanceUserSessions(event *models.Event) error {
err := view.DeleteInstanceUserSessions(v.Db, userSessionTable, event.InstanceID)
func (v *View) DeleteInstanceUserSessions(instanceID string) error {
err := view.DeleteInstanceUserSessions(v.Db, userSessionTable, instanceID)
if err != nil && !errors.IsNotFound(err) {
return err
}
return v.ProcessedUserSessionSequence(event)
return nil
}
func (v *View) DeleteOrgUserSessions(event *models.Event) error {
err := view.DeleteOrgUserSessions(v.Db, userSessionTable, event.InstanceID, event.ResourceOwner)
func (v *View) DeleteOrgUserSessions(event eventstore.Event) error {
err := view.DeleteOrgUserSessions(v.Db, userSessionTable, event.Aggregate().InstanceID, event.Aggregate().ResourceOwner)
if err != nil && !errors.IsNotFound(err) {
return err
}
return v.ProcessedUserSessionSequence(event)
return nil
}
func (v *View) GetLatestUserSessionSequence(ctx context.Context, instanceID string) (*repository.CurrentSequence, error) {
return v.latestSequence(ctx, userSessionTable, instanceID)
}
func (v *View) GetLatestUserSessionSequences(ctx context.Context, instanceIDs []string) ([]*repository.CurrentSequence, error) {
return v.latestSequences(ctx, userSessionTable, instanceIDs)
}
func (v *View) ProcessedUserSessionSequence(event *models.Event) error {
return v.saveCurrentSequence(userSessionTable, event)
}
func (v *View) UpdateUserSessionSpoolerRunTimestamp(instanceIDs []string) error {
return v.updateSpoolerRunSequence(userSessionTable, instanceIDs)
}
func (v *View) GetLatestUserSessionFailedEvent(sequence uint64, instanceID string) (*repository.FailedEvent, error) {
return v.latestFailedEvent(userSessionTable, instanceID, sequence)
}
func (v *View) ProcessedUserSessionFailedEvent(failedEvent *repository.FailedEvent) error {
return v.saveFailedEvent(failedEvent)
func (v *View) GetLatestUserSessionSequence(ctx context.Context, instanceID string) (_ *query.CurrentState, err error) {
q := &query.CurrentStateSearchQueries{
Queries: make([]query.SearchQuery, 2),
}
q.Queries[0], err = query.NewCurrentStatesInstanceIDSearchQuery(instanceID)
if err != nil {
return nil, err
}
q.Queries[1], err = query.NewCurrentStatesProjectionSearchQuery(userSessionTable)
if err != nil {
return nil, err
}
states, err := v.query.SearchCurrentStates(ctx, q)
if err != nil || states.SearchResponse.Count == 0 {
return nil, err
}
return states.CurrentStates[0], nil
}

15
internal/auth/repository/eventsourcing/view/view.go
View File

@@ -8,32 +8,29 @@ import (
"github.com/zitadel/zitadel/internal/api/call"
"github.com/zitadel/zitadel/internal/crypto"
"github.com/zitadel/zitadel/internal/database"
eventstore "github.com/zitadel/zitadel/internal/eventstore/v1"
"github.com/zitadel/zitadel/internal/id"
"github.com/zitadel/zitadel/internal/eventstore"
"github.com/zitadel/zitadel/internal/query"
)
type View struct {
Db *gorm.DB
keyAlgorithm crypto.EncryptionAlgorithm
idGenerator id.Generator
query *query.Queries
es eventstore.Eventstore
client *database.DB
keyAlgorithm crypto.EncryptionAlgorithm
query *query.Queries
es *eventstore.Eventstore
}
func StartView(sqlClient *database.DB, keyAlgorithm crypto.EncryptionAlgorithm, queries *query.Queries, idGenerator id.Generator, es eventstore.Eventstore) (*View, error) {
func StartView(sqlClient *database.DB, keyAlgorithm crypto.EncryptionAlgorithm, queries *query.Queries, es *eventstore.Eventstore) (*View, error) {
gorm, err := gorm.Open("postgres", sqlClient.DB)
if err != nil {
return nil, err
}
return &View{
Db: gorm,
client: sqlClient,
keyAlgorithm: keyAlgorithm,
idGenerator: idGenerator,
query: queries,
es: es,
client: sqlClient,
}, nil
}

1
internal/auth/repository/token.go
View File

@@ -7,6 +7,5 @@ import (
)
type TokenRepository interface {
IsTokenValid(ctx context.Context, userID, tokenID string) (bool, error)
TokenByIDs(ctx context.Context, userID, tokenID string) (*usr_model.TokenView, error)
}