fix: commandside queries (#1313)

* fix: move user by id to query side * fix: move get passwordless to query side # Conflicts: # internal/user/repository/eventsourcing/eventstore.go * fix: move get passwordless to query side * remove user eventstore * remove unused models * org changes * org changes * fix: move org queries to query side * fix: remove org eventstore * fix: remove org eventstore * fix: remove org eventstore * remove project from es v1 * project cleanup * project cleanup * fix: remove org eventstore * fix: remove iam eventstore Co-authored-by: Livio Amstutz <livio.a@gmail.com>
2025-08-12 15:37:32 +00:00 · 2021-02-22 14:08:47 +01:00
parent 2ba56595b1
commit 428ef4acdb
106 changed files with 2301 additions and 2799 deletions
--- a/internal/auth/repository/eventsourcing/handler/application.go
+++ b/internal/auth/repository/eventsourcing/handler/application.go
@@ -5,13 +5,15 @@ import (

 	"github.com/caos/logging"

+	"github.com/caos/zitadel/internal/errors"
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/models"
 	"github.com/caos/zitadel/internal/eventstore/query"
+	es_sdk "github.com/caos/zitadel/internal/eventstore/sdk"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
-	"github.com/caos/zitadel/internal/project/repository/eventsourcing"
-	proj_event "github.com/caos/zitadel/internal/project/repository/eventsourcing"
+	proj_model "github.com/caos/zitadel/internal/project/model"
 	es_model "github.com/caos/zitadel/internal/project/repository/eventsourcing/model"
+	proj_view "github.com/caos/zitadel/internal/project/repository/view"
 	view_model "github.com/caos/zitadel/internal/project/repository/view/model"
 )

@@ -21,14 +23,12 @@ const (

 type Application struct {
 	handler
-	projectEvents *proj_event.ProjectEventstore
-	subscription  *eventstore.Subscription
+	subscription *eventstore.Subscription
 }

-func newApplication(handler handler, projectEvents *proj_event.ProjectEventstore) *Application {
+func newApplication(handler handler) *Application {
 	h := &Application{
-		handler:       handler,
-		projectEvents: projectEvents,
+		handler: handler,
 	}

 	h.subscribe()
@@ -66,14 +66,14 @@ func (a *Application) EventQuery() (*models.SearchQuery, error) {
 	if err != nil {
 		return nil, err
 	}
-	return eventsourcing.ProjectQuery(sequence.CurrentSequence), nil
+	return proj_view.ProjectQuery(sequence.CurrentSequence), nil
 }

 func (a *Application) Reduce(event *models.Event) (err error) {
 	app := new(view_model.ApplicationView)
 	switch event.Type {
 	case es_model.ApplicationAdded:
-		project, err := a.projectEvents.ProjectByID(context.Background(), event.AggregateID)
+		project, err := a.getProjectByID(context.Background(), event.AggregateID)
 		if err != nil {
 			return err
 		}
@@ -139,3 +139,24 @@ func (a *Application) OnError(event *models.Event, spoolerError error) error {
 func (a *Application) OnSuccess() error {
 	return spooler.HandleSuccess(a.view.UpdateApplicationSpoolerRunTimestamp)
 }
+
+func (a *Application) getProjectByID(ctx context.Context, projID string) (*proj_model.Project, error) {
+	query, err := proj_view.ProjectByIDQuery(projID, 0)
+	if err != nil {
+		return nil, err
+	}
+	esProject := &es_model.Project{
+		ObjectRoot: models.ObjectRoot{
+			AggregateID: projID,
+		},
+	}
+	err = es_sdk.Filter(ctx, a.Eventstore().FilterEvents, esProject.AppendEvents, query)
+	if err != nil && !errors.IsNotFound(err) {
+		return nil, err
+	}
+	if esProject.Sequence == 0 {
+		return nil, errors.ThrowNotFound(nil, "EVENT-DBf32", "Errors.Project.NotFound")
+	}
+
+	return es_model.ProjectToModel(esProject), nil
+}
--- a/internal/auth/repository/eventsourcing/handler/handler.go
+++ b/internal/auth/repository/eventsourcing/handler/handler.go
@@ -3,16 +3,11 @@ package handler
 import (
 	"time"

+	"github.com/caos/zitadel/internal/auth/repository/eventsourcing/view"
 	sd "github.com/caos/zitadel/internal/config/systemdefaults"
+	"github.com/caos/zitadel/internal/config/types"
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/query"
-	iam_events "github.com/caos/zitadel/internal/iam/repository/eventsourcing"
-	org_events "github.com/caos/zitadel/internal/org/repository/eventsourcing"
-	proj_event "github.com/caos/zitadel/internal/project/repository/eventsourcing"
-
-	"github.com/caos/zitadel/internal/auth/repository/eventsourcing/view"
-	"github.com/caos/zitadel/internal/config/types"
-	usr_event "github.com/caos/zitadel/internal/user/repository/eventsourcing"
 )

 type Configs map[string]*Config
@@ -34,42 +29,24 @@ func (h *handler) Eventstore() eventstore.Eventstore {
 	return h.es
 }

-type EventstoreRepos struct {
-	UserEvents    *usr_event.UserEventstore
-	ProjectEvents *proj_event.ProjectEventstore
-	OrgEvents     *org_events.OrgEventstore
-	IamEvents     *iam_events.IAMEventstore
-}
-
-func Register(configs Configs, bulkLimit, errorCount uint64, view *view.View, es eventstore.Eventstore, repos EventstoreRepos, systemDefaults sd.SystemDefaults) []query.Handler {
+func Register(configs Configs, bulkLimit, errorCount uint64, view *view.View, es eventstore.Eventstore, systemDefaults sd.SystemDefaults) []query.Handler {
 	return []query.Handler{
 		newUser(
 			handler{view, bulkLimit, configs.cycleDuration("User"), errorCount, es},
-			repos.OrgEvents,
-			repos.IamEvents,
 			systemDefaults.IamID),
 		newUserSession(
-			handler{view, bulkLimit, configs.cycleDuration("UserSession"), errorCount, es},
-			repos.UserEvents),
+			handler{view, bulkLimit, configs.cycleDuration("UserSession"), errorCount, es}),
 		newUserMembership(
-			handler{view, bulkLimit, configs.cycleDuration("UserMembership"), errorCount, es},
-			repos.OrgEvents,
-			repos.ProjectEvents),
+			handler{view, bulkLimit, configs.cycleDuration("UserMembership"), errorCount, es}),
 		newToken(
-			handler{view, bulkLimit, configs.cycleDuration("Token"), errorCount, es},
-			repos.ProjectEvents),
+			handler{view, bulkLimit, configs.cycleDuration("Token"), errorCount, es}),
 		newKey(
 			handler{view, bulkLimit, configs.cycleDuration("Key"), errorCount, es}),
-		newApplication(handler{view, bulkLimit, configs.cycleDuration("Application"), errorCount, es},
-			repos.ProjectEvents),
+		newApplication(handler{view, bulkLimit, configs.cycleDuration("Application"), errorCount, es}),
 		newOrg(
 			handler{view, bulkLimit, configs.cycleDuration("Org"), errorCount, es}),
 		newUserGrant(
 			handler{view, bulkLimit, configs.cycleDuration("UserGrant"), errorCount, es},
-			repos.ProjectEvents,
-			repos.UserEvents,
-			repos.OrgEvents,
-			repos.IamEvents,
 			systemDefaults.IamID),
 		newAuthNKeys(
 			handler{view, bulkLimit, configs.cycleDuration("MachineKey"), errorCount, es}),
@@ -79,20 +56,15 @@ func Register(configs Configs, bulkLimit, errorCount uint64, view *view.View, es
 			handler{view, bulkLimit, configs.cycleDuration("IDPConfig"), errorCount, es}),
 		newIDPProvider(
 			handler{view, bulkLimit, configs.cycleDuration("IDPProvider"), errorCount, es},
-			systemDefaults,
-			repos.IamEvents,
-			repos.OrgEvents),
+			systemDefaults),
 		newExternalIDP(
 			handler{view, bulkLimit, configs.cycleDuration("ExternalIDP"), errorCount, es},
-			systemDefaults,
-			repos.IamEvents,
-			repos.OrgEvents),
+			systemDefaults),
 		newPasswordComplexityPolicy(
 			handler{view, bulkLimit, configs.cycleDuration("PasswordComplexityPolicy"), errorCount, es}),
 		newOrgIAMPolicy(
 			handler{view, bulkLimit, configs.cycleDuration("OrgIAMPolicy"), errorCount, es}),
-		newProjectRole(handler{view, bulkLimit, configs.cycleDuration("ProjectRole"), errorCount, es},
-			repos.ProjectEvents),
+		newProjectRole(handler{view, bulkLimit, configs.cycleDuration("ProjectRole"), errorCount, es}),
 	}
 }

--- a/internal/auth/repository/eventsourcing/handler/idp_providers.go
+++ b/internal/auth/repository/eventsourcing/handler/idp_providers.go
@@ -2,12 +2,16 @@ package handler

 import (
 	"context"
+	"github.com/caos/zitadel/internal/errors"
+	es_sdk "github.com/caos/zitadel/internal/eventstore/sdk"
+	iam_view "github.com/caos/zitadel/internal/iam/repository/view"
+	org_model "github.com/caos/zitadel/internal/org/model"
+	"github.com/caos/zitadel/internal/org/repository/view"
+	"github.com/caos/zitadel/internal/v2/domain"

 	"github.com/caos/logging"
 	"github.com/caos/zitadel/internal/config/systemdefaults"
 	"github.com/caos/zitadel/internal/eventstore"
-	"github.com/caos/zitadel/internal/iam/repository/eventsourcing"
-	org_es "github.com/caos/zitadel/internal/org/repository/eventsourcing"
 	org_es_model "github.com/caos/zitadel/internal/org/repository/eventsourcing/model"

 	"github.com/caos/zitadel/internal/eventstore/models"
@@ -26,22 +30,16 @@ const (
 type IDPProvider struct {
 	handler
 	systemDefaults systemdefaults.SystemDefaults
-	iamEvents      *eventsourcing.IAMEventstore
-	orgEvents      *org_es.OrgEventstore
 	subscription   *eventstore.Subscription
 }

 func newIDPProvider(
 	h handler,
 	defaults systemdefaults.SystemDefaults,
-	iamEvents *eventsourcing.IAMEventstore,
-	orgEvents *org_es.OrgEventstore,
 ) *IDPProvider {
 	idpProvider := &IDPProvider{
 		handler:        h,
 		systemDefaults: defaults,
-		iamEvents:      iamEvents,
-		orgEvents:      orgEvents,
 	}

 	idpProvider.subscribe()
@@ -121,9 +119,9 @@ func (i *IDPProvider) processIdpProvider(event *models.Event) (err error) {
 		}
 		config := new(iam_model.IDPConfig)
 		if event.AggregateID == i.systemDefaults.IamID {
-			config, err = i.iamEvents.GetIDPConfig(context.Background(), event.AggregateID, esConfig.IDPConfigID)
+			config, err = i.getDefaultIDPConfig(context.TODO(), esConfig.IDPConfigID)
 		} else {
-			config, err = i.orgEvents.GetIDPConfig(context.Background(), event.AggregateID, esConfig.IDPConfigID)
+			config, err = i.getOrgIDPConfig(context.TODO(), event.AggregateID, esConfig.IDPConfigID)
 		}
 		if err != nil {
 			return err
@@ -146,9 +144,9 @@ func (i *IDPProvider) processIdpProvider(event *models.Event) (err error) {
 func (i *IDPProvider) fillData(provider *iam_view_model.IDPProviderView) (err error) {
 	var config *iam_model.IDPConfig
 	if provider.IDPProviderType == int32(iam_model.IDPProviderTypeSystem) {
-		config, err = i.iamEvents.GetIDPConfig(context.Background(), i.systemDefaults.IamID, provider.IDPConfigID)
+		config, err = i.getDefaultIDPConfig(context.Background(), provider.IDPConfigID)
 	} else {
-		config, err = i.orgEvents.GetIDPConfig(context.Background(), provider.AggregateID, provider.IDPConfigID)
+		config, err = i.getOrgIDPConfig(context.Background(), provider.AggregateID, provider.IDPConfigID)
 	}
 	if err != nil {
 		return err
@@ -172,3 +170,64 @@ func (i *IDPProvider) OnError(event *models.Event, err error) error {
 func (i *IDPProvider) OnSuccess() error {
 	return spooler.HandleSuccess(i.view.UpdateIDPProviderSpoolerRunTimestamp)
 }
+
+func (i *IDPProvider) getOrgIDPConfig(ctx context.Context, aggregateID, idpConfigID string) (*iam_model.IDPConfig, error) {
+	existing, err := i.getOrgByID(ctx, aggregateID)
+	if err != nil {
+		return nil, err
+	}
+	if _, i := existing.GetIDP(idpConfigID); i != nil {
+		return i, nil
+	}
+	return nil, errors.ThrowNotFound(nil, "EVENT-2m9fS", "Errors.Org.IdpNotExisting")
+}
+
+func (i *IDPProvider) getOrgByID(ctx context.Context, orgID string) (*org_model.Org, error) {
+	query, err := view.OrgByIDQuery(orgID, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	esOrg := &org_es_model.Org{
+		ObjectRoot: models.ObjectRoot{
+			AggregateID: orgID,
+		},
+	}
+	err = es_sdk.Filter(ctx, i.Eventstore().FilterEvents, esOrg.AppendEvents, query)
+	if err != nil && !errors.IsNotFound(err) {
+		return nil, err
+	}
+	if esOrg.Sequence == 0 {
+		return nil, errors.ThrowNotFound(nil, "EVENT-6m0fS", "Errors.Org.NotFound")
+	}
+
+	return org_es_model.OrgToModel(esOrg), nil
+}
+
+func (u *IDPProvider) getIAMByID(ctx context.Context) (*iam_model.IAM, error) {
+	query, err := iam_view.IAMByIDQuery(domain.IAMID, 0)
+	if err != nil {
+		return nil, err
+	}
+	iam := &model.IAM{
+		ObjectRoot: es_models.ObjectRoot{
+			AggregateID: domain.IAMID,
+		},
+	}
+	err = es_sdk.Filter(ctx, u.Eventstore().FilterEvents, iam.AppendEvents, query)
+	if err != nil && errors.IsNotFound(err) && iam.Sequence == 0 {
+		return nil, err
+	}
+	return model.IAMToModel(iam), nil
+}
+
+func (u *IDPProvider) getDefaultIDPConfig(ctx context.Context, idpConfigID string) (*iam_model.IDPConfig, error) {
+	existing, err := u.getIAMByID(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if _, existingIDP := existing.GetIDP(idpConfigID); existingIDP != nil {
+		return existingIDP, nil
+	}
+	return nil, errors.ThrowNotFound(nil, "EVENT-49O0f", "Errors.IAM.IdpNotExisting")
+}
--- a/internal/auth/repository/eventsourcing/handler/org.go
+++ b/internal/auth/repository/eventsourcing/handler/org.go
@@ -2,12 +2,12 @@ package handler

 import (
 	"github.com/caos/logging"
+	"github.com/caos/zitadel/internal/org/repository/view"

 	"github.com/caos/zitadel/internal/eventstore"
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
 	"github.com/caos/zitadel/internal/eventstore/query"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
-	"github.com/caos/zitadel/internal/org/repository/eventsourcing"
 	"github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
 	org_model "github.com/caos/zitadel/internal/org/repository/view/model"
 )
@@ -61,7 +61,7 @@ func (o *Org) EventQuery() (*es_models.SearchQuery, error) {
 	if err != nil {
 		return nil, err
 	}
-	return eventsourcing.OrgQuery(sequence.CurrentSequence), nil
+	return view.OrgQuery(sequence.CurrentSequence), nil
 }

 func (o *Org) Reduce(event *es_models.Event) (err error) {
--- a/internal/auth/repository/eventsourcing/handler/project_role.go
+++ b/internal/auth/repository/eventsourcing/handler/project_role.go
@@ -7,9 +7,8 @@ import (
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
 	"github.com/caos/zitadel/internal/eventstore/query"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
-	proj_event "github.com/caos/zitadel/internal/project/repository/eventsourcing"
-	proj_events "github.com/caos/zitadel/internal/project/repository/eventsourcing"
 	"github.com/caos/zitadel/internal/project/repository/eventsourcing/model"
+	proj_view "github.com/caos/zitadel/internal/project/repository/view"
 	view_model "github.com/caos/zitadel/internal/project/repository/view/model"
 )

@@ -19,17 +18,14 @@ const (

 type ProjectRole struct {
 	handler
-	projectEvents *proj_event.ProjectEventstore
-	subscription  *eventstore.Subscription
+	subscription *eventstore.Subscription
 }

 func newProjectRole(
 	handler handler,
-	projectEvents *proj_events.ProjectEventstore,
 ) *ProjectRole {
 	h := &ProjectRole{
-		handler:       handler,
-		projectEvents: projectEvents,
+		handler: handler,
 	}

 	h.subscribe()
@@ -67,7 +63,7 @@ func (p *ProjectRole) EventQuery() (*es_models.SearchQuery, error) {
 	if err != nil {
 		return nil, err
 	}
-	return proj_events.ProjectQuery(sequence.CurrentSequence), nil
+	return proj_view.ProjectQuery(sequence.CurrentSequence), nil
 }

 func (p *ProjectRole) Reduce(event *es_models.Event) (err error) {
--- a/internal/auth/repository/eventsourcing/handler/token.go
+++ b/internal/auth/repository/eventsourcing/handler/token.go
@@ -5,15 +5,18 @@ import (
 	"encoding/json"

 	"github.com/caos/logging"
+	"k8s.io/apimachinery/pkg/api/errors"

 	caos_errs "github.com/caos/zitadel/internal/errors"
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/models"
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
 	"github.com/caos/zitadel/internal/eventstore/query"
+	es_sdk "github.com/caos/zitadel/internal/eventstore/sdk"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
-	proj_event "github.com/caos/zitadel/internal/project/repository/eventsourcing"
+	proj_model "github.com/caos/zitadel/internal/project/model"
 	project_es_model "github.com/caos/zitadel/internal/project/repository/eventsourcing/model"
+	proj_view "github.com/caos/zitadel/internal/project/repository/view"
 	user_es_model "github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
 	view_model "github.com/caos/zitadel/internal/user/repository/view/model"
 )
@@ -24,17 +27,14 @@ const (

 type Token struct {
 	handler
-	ProjectEvents *proj_event.ProjectEventstore
-	subscription  *eventstore.Subscription
+	subscription *eventstore.Subscription
 }

 func newToken(
 	handler handler,
-	projectEvents *proj_event.ProjectEventstore,
 ) *Token {
 	h := &Token{
-		handler:       handler,
-		ProjectEvents: projectEvents,
+		handler: handler,
 	}

 	h.subscribe()
@@ -118,7 +118,7 @@ func (t *Token) Reduce(event *models.Event) (err error) {
 		return t.view.DeleteApplicationTokens(event, application.AppID)
 	case project_es_model.ProjectDeactivated,
 		project_es_model.ProjectRemoved:
-		project, err := t.ProjectEvents.ProjectByID(context.Background(), event.AggregateID)
+		project, err := t.getProjectByID(context.Background(), event.AggregateID)
 		if err != nil {
 			return err
 		}
@@ -158,3 +158,24 @@ func applicationFromSession(event *models.Event) (*project_es_model.Application,
 func (t *Token) OnSuccess() error {
 	return spooler.HandleSuccess(t.view.UpdateTokenSpoolerRunTimestamp)
 }
+
+func (t *Token) getProjectByID(ctx context.Context, projID string) (*proj_model.Project, error) {
+	query, err := proj_view.ProjectByIDQuery(projID, 0)
+	if err != nil {
+		return nil, err
+	}
+	esProject := &project_es_model.Project{
+		ObjectRoot: models.ObjectRoot{
+			AggregateID: projID,
+		},
+	}
+	err = es_sdk.Filter(ctx, t.Eventstore().FilterEvents, esProject.AppendEvents, query)
+	if err != nil && !errors.IsNotFound(err) {
+		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
+}
--- a/internal/auth/repository/eventsourcing/handler/user.go
+++ b/internal/auth/repository/eventsourcing/handler/user.go
@@ -2,19 +2,23 @@ package handler

 import (
 	"context"
-
 	"github.com/caos/logging"
+	"github.com/caos/zitadel/internal/errors"
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/models"
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
 	"github.com/caos/zitadel/internal/eventstore/query"
+	es_sdk "github.com/caos/zitadel/internal/eventstore/sdk"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
-	iam_es "github.com/caos/zitadel/internal/iam/repository/eventsourcing"
+	iam_model "github.com/caos/zitadel/internal/iam/model"
+	"github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
+	iam_view "github.com/caos/zitadel/internal/iam/repository/view"
 	org_model "github.com/caos/zitadel/internal/org/model"
-	org_events "github.com/caos/zitadel/internal/org/repository/eventsourcing"
 	org_es_model "github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
+	"github.com/caos/zitadel/internal/org/repository/view"
 	es_model "github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
 	view_model "github.com/caos/zitadel/internal/user/repository/view/model"
+	"github.com/caos/zitadel/internal/v2/domain"
 )

 const (
@@ -23,23 +27,17 @@ const (

 type User struct {
 	handler
-	orgEvents    *org_events.OrgEventstore
-	iamEvents    *iam_es.IAMEventstore
 	iamID        string
 	subscription *eventstore.Subscription
 }

 func newUser(
 	handler handler,
-	orgEvents *org_events.OrgEventstore,
-	iamEvents *iam_es.IAMEventstore,
 	iamID string,
 ) *User {
 	h := &User{
-		handler:   handler,
-		orgEvents: orgEvents,
-		iamEvents: iamEvents,
-		iamID:     iamID,
+		handler: handler,
+		iamID:   iamID,
 	}

 	h.subscribe()
@@ -169,13 +167,13 @@ func (u *User) ProcessUser(event *models.Event) (err error) {
 }

 func (u *User) fillLoginNames(user *view_model.UserView) (err error) {
-	org, err := u.orgEvents.OrgByID(context.Background(), org_model.NewOrg(user.ResourceOwner))
+	org, err := u.getOrgByID(context.Background(), user.ResourceOwner)
 	if err != nil {
 		return err
 	}
 	policy := org.OrgIamPolicy
 	if policy == nil {
-		policy, err = u.iamEvents.GetOrgIAMPolicy(context.Background(), u.iamID)
+		policy, err = u.getDefaultOrgIAMPolicy(context.Background())
 		if err != nil {
 			return err
 		}
@@ -201,13 +199,13 @@ func (u *User) ProcessOrg(event *models.Event) (err error) {
 }

 func (u *User) fillLoginNamesOnOrgUsers(event *models.Event) error {
-	org, err := u.orgEvents.OrgByID(context.Background(), org_model.NewOrg(event.ResourceOwner))
+	org, err := u.getOrgByID(context.Background(), event.ResourceOwner)
 	if err != nil {
 		return err
 	}
 	policy := org.OrgIamPolicy
 	if policy == nil {
-		policy, err = u.iamEvents.GetOrgIAMPolicy(context.Background(), u.iamID)
+		policy, err = u.getDefaultOrgIAMPolicy(context.Background())
 		if err != nil {
 			return err
 		}
@@ -223,13 +221,13 @@ func (u *User) fillLoginNamesOnOrgUsers(event *models.Event) error {
 }

 func (u *User) fillPreferredLoginNamesOnOrgUsers(event *models.Event) error {
-	org, err := u.orgEvents.OrgByID(context.Background(), org_model.NewOrg(event.ResourceOwner))
+	org, err := u.getOrgByID(context.Background(), event.ResourceOwner)
 	if err != nil {
 		return err
 	}
 	policy := org.OrgIamPolicy
 	if policy == nil {
-		policy, err = u.iamEvents.GetOrgIAMPolicy(context.Background(), u.iamID)
+		policy, err = u.getDefaultOrgIAMPolicy(context.Background())
 		if err != nil {
 			return err
 		}
@@ -255,3 +253,53 @@ func (u *User) OnError(event *models.Event, err error) error {
 func (u *User) OnSuccess() error {
 	return spooler.HandleSuccess(u.view.UpdateUserSpoolerRunTimestamp)
 }
+
+func (u *User) getOrgByID(ctx context.Context, orgID string) (*org_model.Org, error) {
+	query, err := view.OrgByIDQuery(orgID, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	esOrg := &org_es_model.Org{
+		ObjectRoot: models.ObjectRoot{
+			AggregateID: orgID,
+		},
+	}
+	err = es_sdk.Filter(ctx, u.Eventstore().FilterEvents, esOrg.AppendEvents, query)
+	if err != nil && !errors.IsNotFound(err) {
+		return nil, err
+	}
+	if esOrg.Sequence == 0 {
+		return nil, errors.ThrowNotFound(nil, "EVENT-3m9vs", "Errors.Org.NotFound")
+	}
+
+	return org_es_model.OrgToModel(esOrg), nil
+}
+
+func (u *User) getIAMByID(ctx context.Context) (*iam_model.IAM, error) {
+	query, err := iam_view.IAMByIDQuery(domain.IAMID, 0)
+	if err != nil {
+		return nil, err
+	}
+	iam := &model.IAM{
+		ObjectRoot: models.ObjectRoot{
+			AggregateID: domain.IAMID,
+		},
+	}
+	err = es_sdk.Filter(ctx, u.Eventstore().FilterEvents, iam.AppendEvents, query)
+	if err != nil && errors.IsNotFound(err) && iam.Sequence == 0 {
+		return nil, err
+	}
+	return model.IAMToModel(iam), nil
+}
+
+func (u *User) getDefaultOrgIAMPolicy(ctx context.Context) (*iam_model.OrgIAMPolicy, error) {
+	existingIAM, err := u.getIAMByID(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if existingIAM.DefaultOrgIAMPolicy == nil {
+		return nil, errors.ThrowNotFound(nil, "EVENT-3m9fs", "Errors.IAM.OrgIAMPolicy.NotExisting")
+	}
+	return existingIAM.DefaultOrgIAMPolicy, nil
+}
--- a/internal/auth/repository/eventsourcing/handler/user_external_idps.go
+++ b/internal/auth/repository/eventsourcing/handler/user_external_idps.go
@@ -2,7 +2,6 @@ package handler

 import (
 	"context"
-
 	"github.com/caos/logging"
 	"github.com/caos/zitadel/internal/config/systemdefaults"
 	caos_errs "github.com/caos/zitadel/internal/errors"
@@ -10,15 +9,18 @@ import (
 	"github.com/caos/zitadel/internal/eventstore/models"
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
 	"github.com/caos/zitadel/internal/eventstore/query"
+	es_sdk "github.com/caos/zitadel/internal/eventstore/sdk"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
 	iam_model "github.com/caos/zitadel/internal/iam/model"
-	"github.com/caos/zitadel/internal/iam/repository/eventsourcing"
 	iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
+	iam_view "github.com/caos/zitadel/internal/iam/repository/view"
 	iam_view_model "github.com/caos/zitadel/internal/iam/repository/view/model"
-	org_es "github.com/caos/zitadel/internal/org/repository/eventsourcing"
+	org_model "github.com/caos/zitadel/internal/org/model"
 	org_es_model "github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
+	"github.com/caos/zitadel/internal/org/repository/view"
 	"github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
 	usr_view_model "github.com/caos/zitadel/internal/user/repository/view/model"
+	"github.com/caos/zitadel/internal/v2/domain"
 )

 const (
@@ -28,22 +30,16 @@ const (
 type ExternalIDP struct {
 	handler
 	systemDefaults systemdefaults.SystemDefaults
-	iamEvents      *eventsourcing.IAMEventstore
-	orgEvents      *org_es.OrgEventstore
 	subscription   *eventstore.Subscription
 }

 func newExternalIDP(
 	handler handler,
 	defaults systemdefaults.SystemDefaults,
-	iamEvents *eventsourcing.IAMEventstore,
-	orgEvents *org_es.OrgEventstore,
 ) *ExternalIDP {
 	h := &ExternalIDP{
 		handler:        handler,
 		systemDefaults: defaults,
-		iamEvents:      iamEvents,
-		orgEvents:      orgEvents,
 	}

 	h.subscribe()
@@ -137,9 +133,9 @@ func (i *ExternalIDP) processIdpConfig(event *models.Event) (err error) {
 			return err
 		}
 		if event.AggregateType == iam_es_model.IAMAggregate {
-			config, err = i.iamEvents.GetIDPConfig(context.Background(), event.AggregateID, configView.IDPConfigID)
+			config, err = i.getDefaultIDPConfig(context.Background(), configView.IDPConfigID)
 		} else {
-			config, err = i.orgEvents.GetIDPConfig(context.Background(), event.AggregateID, configView.IDPConfigID)
+			config, err = i.getOrgIDPConfig(context.Background(), event.AggregateID, configView.IDPConfigID)
 		}
 		if err != nil {
 			return err
@@ -155,9 +151,9 @@ func (i *ExternalIDP) processIdpConfig(event *models.Event) (err error) {
 }

 func (i *ExternalIDP) fillData(externalIDP *usr_view_model.ExternalIDPView) error {
-	config, err := i.orgEvents.GetIDPConfig(context.Background(), externalIDP.ResourceOwner, externalIDP.IDPConfigID)
+	config, err := i.getOrgIDPConfig(context.Background(), externalIDP.ResourceOwner, externalIDP.IDPConfigID)
 	if caos_errs.IsNotFound(err) {
-		config, err = i.iamEvents.GetIDPConfig(context.Background(), i.systemDefaults.IamID, externalIDP.IDPConfigID)
+		config, err = i.getDefaultIDPConfig(context.Background(), externalIDP.IDPConfigID)
 	}
 	if err != nil {
 		return err
@@ -178,3 +174,64 @@ func (i *ExternalIDP) OnError(event *models.Event, err error) error {
 func (i *ExternalIDP) OnSuccess() error {
 	return spooler.HandleSuccess(i.view.UpdateExternalIDPSpoolerRunTimestamp)
 }
+
+func (i *ExternalIDP) getOrgIDPConfig(ctx context.Context, aggregateID, idpConfigID string) (*iam_model.IDPConfig, error) {
+	existing, err := i.getOrgByID(ctx, aggregateID)
+	if err != nil {
+		return nil, err
+	}
+	if _, i := existing.GetIDP(idpConfigID); i != nil {
+		return i, nil
+	}
+	return nil, caos_errs.ThrowNotFound(nil, "EVENT-2m9fS", "Errors.Org.IdpNotExisting")
+}
+
+func (i *ExternalIDP) getOrgByID(ctx context.Context, orgID string) (*org_model.Org, error) {
+	query, err := view.OrgByIDQuery(orgID, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	esOrg := &org_es_model.Org{
+		ObjectRoot: models.ObjectRoot{
+			AggregateID: orgID,
+		},
+	}
+	err = es_sdk.Filter(ctx, i.Eventstore().FilterEvents, esOrg.AppendEvents, query)
+	if err != nil && !caos_errs.IsNotFound(err) {
+		return nil, err
+	}
+	if esOrg.Sequence == 0 {
+		return nil, caos_errs.ThrowNotFound(nil, "EVENT-6m0fS", "Errors.Org.NotFound")
+	}
+
+	return org_es_model.OrgToModel(esOrg), nil
+}
+
+func (u *ExternalIDP) getIAMByID(ctx context.Context) (*iam_model.IAM, error) {
+	query, err := iam_view.IAMByIDQuery(domain.IAMID, 0)
+	if err != nil {
+		return nil, err
+	}
+	iam := &iam_es_model.IAM{
+		ObjectRoot: es_models.ObjectRoot{
+			AggregateID: domain.IAMID,
+		},
+	}
+	err = es_sdk.Filter(ctx, u.Eventstore().FilterEvents, iam.AppendEvents, query)
+	if err != nil && caos_errs.IsNotFound(err) && iam.Sequence == 0 {
+		return nil, err
+	}
+	return iam_es_model.IAMToModel(iam), nil
+}
+
+func (u *ExternalIDP) getDefaultIDPConfig(ctx context.Context, idpConfigID string) (*iam_model.IDPConfig, error) {
+	existing, err := u.getIAMByID(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if _, existingIDP := existing.GetIDP(idpConfigID); existingIDP != nil {
+		return existingIDP, nil
+	}
+	return nil, caos_errs.ThrowNotFound(nil, "EVENT-mmk5d", "Errors.IAM.IdpNotExisting")
+}
--- a/internal/auth/repository/eventsourcing/handler/user_grant.go
+++ b/internal/auth/repository/eventsourcing/handler/user_grant.go
@@ -2,8 +2,16 @@ package handler

 import (
 	"context"
+	iam_model "github.com/caos/zitadel/internal/iam/model"
+	iam_view "github.com/caos/zitadel/internal/iam/repository/view"
 	"strings"

+	es_sdk "github.com/caos/zitadel/internal/eventstore/sdk"
+	org_view "github.com/caos/zitadel/internal/org/repository/view"
+	proj_view "github.com/caos/zitadel/internal/project/repository/view"
+	"github.com/caos/zitadel/internal/user/repository/view"
+	"github.com/caos/zitadel/internal/user/repository/view/model"
+
 	"github.com/caos/logging"

 	"github.com/caos/zitadel/internal/errors"
@@ -13,16 +21,12 @@ import (
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
 	"github.com/caos/zitadel/internal/eventstore/query"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
-	iam_events "github.com/caos/zitadel/internal/iam/repository/eventsourcing"
 	iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
 	org_model "github.com/caos/zitadel/internal/org/model"
-	org_events "github.com/caos/zitadel/internal/org/repository/eventsourcing"
 	org_es_model "github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
 	proj_model "github.com/caos/zitadel/internal/project/model"
-	proj_event "github.com/caos/zitadel/internal/project/repository/eventsourcing"
 	proj_es_model "github.com/caos/zitadel/internal/project/repository/eventsourcing/model"
 	usr_model "github.com/caos/zitadel/internal/user/model"
-	usr_events "github.com/caos/zitadel/internal/user/repository/eventsourcing"
 	usr_es_model "github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
 	grant_es_model "github.com/caos/zitadel/internal/usergrant/repository/eventsourcing/model"
 	view_model "github.com/caos/zitadel/internal/usergrant/repository/view/model"
@@ -35,30 +39,18 @@ const (

 type UserGrant struct {
 	handler
-	projectEvents *proj_event.ProjectEventstore
-	userEvents    *usr_events.UserEventstore
-	orgEvents     *org_events.OrgEventstore
-	iamEvents     *iam_events.IAMEventstore
-	iamID         string
-	iamProjectID  string
-	subscription  *eventstore.Subscription
+	iamID        string
+	iamProjectID string
+	subscription *eventstore.Subscription
 }

 func newUserGrant(
 	handler handler,
-	projectEvents *proj_event.ProjectEventstore,
-	userEvents *usr_events.UserEventstore,
-	orgEvents *org_events.OrgEventstore,
-	iamEvents *iam_events.IAMEventstore,
 	iamID string,
 ) *UserGrant {
 	h := &UserGrant{
-		handler:       handler,
-		projectEvents: projectEvents,
-		userEvents:    userEvents,
-		orgEvents:     orgEvents,
-		iamEvents:     iamEvents,
-		iamID:         iamID,
+		handler: handler,
+		iamID:   iamID,
 	}

 	h.subscribe()
@@ -166,7 +158,7 @@ func (u *UserGrant) processUser(event *models.Event) (err error) {
 		if len(grants) == 0 {
 			return u.view.ProcessedUserGrantSequence(event)
 		}
-		user, err := u.userEvents.UserByID(context.Background(), event.AggregateID)
+		user, err := u.getUserByID(event.AggregateID)
 		if err != nil {
 			return err
 		}
@@ -186,7 +178,7 @@ func (u *UserGrant) processProject(event *models.Event) (err error) {
 		if err != nil {
 			return err
 		}
-		project, err := u.projectEvents.ProjectByID(context.Background(), event.AggregateID)
+		project, err := u.getProjectByID(context.Background(), event.AggregateID)
 		if err != nil {
 			return err
 		}
@@ -348,7 +340,7 @@ func (u *UserGrant) setIamProjectID() error {
 	if u.iamProjectID != "" {
 		return nil
 	}
-	iam, err := u.iamEvents.IAMByID(context.Background(), u.iamID)
+	iam, err := u.getIAMByID(context.Background())
 	if err != nil {
 		return err
 	}
@@ -361,18 +353,18 @@ func (u *UserGrant) setIamProjectID() error {
 }

 func (u *UserGrant) fillData(grant *view_model.UserGrantView, resourceOwner string) (err error) {
-	user, err := u.userEvents.UserByID(context.Background(), grant.UserID)
+	user, err := u.getUserByID(grant.UserID)
 	if err != nil {
 		return err
 	}
 	u.fillUserData(grant, user)
-	project, err := u.projectEvents.ProjectByID(context.Background(), grant.ProjectID)
+	project, err := u.getProjectByID(context.Background(), grant.ProjectID)
 	if err != nil {
 		return err
 	}
 	u.fillProjectData(grant, project)

-	org, err := u.orgEvents.OrgByID(context.TODO(), org_model.NewOrg(resourceOwner))
+	org, err := u.getOrgByID(context.TODO(), resourceOwner)
 	if err != nil {
 		return err
 	}
@@ -380,16 +372,16 @@ func (u *UserGrant) fillData(grant *view_model.UserGrantView, resourceOwner stri
 	return nil
 }

-func (u *UserGrant) fillUserData(grant *view_model.UserGrantView, user *usr_model.User) {
+func (u *UserGrant) fillUserData(grant *view_model.UserGrantView, user *model.UserView) {
 	grant.UserName = user.UserName
-	if user.Human != nil {
+	if user.HumanView != nil {
 		grant.FirstName = user.FirstName
 		grant.LastName = user.LastName
 		grant.DisplayName = user.FirstName + " " + user.LastName
-		grant.Email = user.EmailAddress
+		grant.Email = user.Email
 	}
-	if user.Machine != nil {
-		grant.DisplayName = user.Machine.Name
+	if user.MachineView != nil {
+		grant.DisplayName = user.MachineView.Name
 	}
 }

@@ -416,3 +408,96 @@ func (u *UserGrant) OnError(event *models.Event, err error) error {
 func (u *UserGrant) OnSuccess() error {
 	return spooler.HandleSuccess(u.view.UpdateUserGrantSpoolerRunTimestamp)
 }
+
+func (u *UserGrant) getUserByID(userID string) (*model.UserView, error) {
+	user, usrErr := u.view.UserByID(userID)
+	if usrErr != nil && !caos_errs.IsNotFound(usrErr) {
+		return nil, usrErr
+	}
+	if user == nil {
+		user = &model.UserView{}
+	}
+	events, err := u.getUserEvents(userID, user.Sequence)
+	if err != nil {
+		return user, usrErr
+	}
+	userCopy := *user
+	for _, event := range events {
+		if err := userCopy.AppendEvent(event); err != nil {
+			return user, nil
+		}
+	}
+	if userCopy.State == int32(usr_model.UserStateDeleted) {
+		return nil, caos_errs.ThrowNotFound(nil, "HANDLER-m9dos", "Errors.User.NotFound")
+	}
+	return &userCopy, nil
+}
+
+func (u *UserGrant) getUserEvents(userID string, sequence uint64) ([]*models.Event, error) {
+	query, err := view.UserByIDQuery(userID, sequence)
+	if err != nil {
+		return nil, err
+	}
+
+	return u.es.FilterEvents(context.Background(), query)
+}
+
+func (u *UserGrant) getOrgByID(ctx context.Context, orgID string) (*org_model.Org, error) {
+	query, err := org_view.OrgByIDQuery(orgID, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	esOrg := &org_es_model.Org{
+		ObjectRoot: models.ObjectRoot{
+			AggregateID: orgID,
+		},
+	}
+	err = es_sdk.Filter(ctx, u.Eventstore().FilterEvents, esOrg.AppendEvents, query)
+	if err != nil && !errors.IsNotFound(err) {
+		return nil, err
+	}
+	if esOrg.Sequence == 0 {
+		return nil, errors.ThrowNotFound(nil, "EVENT-3m9vs", "Errors.Org.NotFound")
+	}
+
+	return org_es_model.OrgToModel(esOrg), nil
+}
+
+func (u *UserGrant) getProjectByID(ctx context.Context, projID string) (*proj_model.Project, error) {
+	query, err := proj_view.ProjectByIDQuery(projID, 0)
+	if err != nil {
+		return nil, err
+	}
+	esProject := &proj_es_model.Project{
+		ObjectRoot: models.ObjectRoot{
+			AggregateID: projID,
+		},
+	}
+	err = es_sdk.Filter(ctx, u.Eventstore().FilterEvents, esProject.AppendEvents, query)
+	if err != nil && !errors.IsNotFound(err) {
+		return nil, err
+	}
+	if esProject.Sequence == 0 {
+		return nil, errors.ThrowNotFound(nil, "EVENT-DAfng", "Errors.Project.NotFound")
+	}
+
+	return proj_es_model.ProjectToModel(esProject), nil
+}
+
+func (u *UserGrant) getIAMByID(ctx context.Context) (*iam_model.IAM, error) {
+	query, err := iam_view.IAMByIDQuery(domain.IAMID, 0)
+	if err != nil {
+		return nil, err
+	}
+	iam := &iam_es_model.IAM{
+		ObjectRoot: models.ObjectRoot{
+			AggregateID: domain.IAMID,
+		},
+	}
+	err = es_sdk.Filter(ctx, u.Eventstore().FilterEvents, iam.AppendEvents, query)
+	if err != nil && errors.IsNotFound(err) && iam.Sequence == 0 {
+		return nil, err
+	}
+	return iam_es_model.IAMToModel(iam), nil
+}
--- a/internal/auth/repository/eventsourcing/handler/user_membership.go
+++ b/internal/auth/repository/eventsourcing/handler/user_membership.go
@@ -4,17 +4,21 @@ import (
 	"context"

 	"github.com/caos/logging"
+
+	"github.com/caos/zitadel/internal/errors"
 	"github.com/caos/zitadel/internal/eventstore"
 	"github.com/caos/zitadel/internal/eventstore/models"
 	es_models "github.com/caos/zitadel/internal/eventstore/models"
 	"github.com/caos/zitadel/internal/eventstore/query"
+	es_sdk "github.com/caos/zitadel/internal/eventstore/sdk"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
 	iam_es_model "github.com/caos/zitadel/internal/iam/repository/eventsourcing/model"
 	org_model "github.com/caos/zitadel/internal/org/model"
-	org_event "github.com/caos/zitadel/internal/org/repository/eventsourcing"
 	org_es_model "github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
-	proj_event "github.com/caos/zitadel/internal/project/repository/eventsourcing"
+	org_view "github.com/caos/zitadel/internal/org/repository/view"
+	proj_model "github.com/caos/zitadel/internal/project/model"
 	proj_es_model "github.com/caos/zitadel/internal/project/repository/eventsourcing/model"
+	proj_view "github.com/caos/zitadel/internal/project/repository/view"
 	usr_model "github.com/caos/zitadel/internal/user/model"
 	"github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
 	usr_es_model "github.com/caos/zitadel/internal/user/repository/view/model"
@@ -26,20 +30,14 @@ const (

 type UserMembership struct {
 	handler
-	orgEvents     *org_event.OrgEventstore
-	projectEvents *proj_event.ProjectEventstore
-	subscription  *eventstore.Subscription
+	subscription *eventstore.Subscription
 }

 func newUserMembership(
 	handler handler,
-	orgEvents *org_event.OrgEventstore,
-	projectEvents *proj_event.ProjectEventstore,
 ) *UserMembership {
 	h := &UserMembership{
-		handler:       handler,
-		orgEvents:     orgEvents,
-		projectEvents: projectEvents,
+		handler: handler,
 	}

 	h.subscribe()
@@ -156,7 +154,7 @@ func (m *UserMembership) processOrg(event *models.Event) (err error) {
 }

 func (m *UserMembership) fillOrgName(member *usr_es_model.UserMembershipView) (err error) {
-	org, err := m.orgEvents.OrgByID(context.Background(), org_model.NewOrg(member.ResourceOwner))
+	org, err := m.getOrgByID(context.Background(), member.ResourceOwner)
 	if err != nil {
 		return err
 	}
@@ -168,7 +166,7 @@ func (m *UserMembership) fillOrgName(member *usr_es_model.UserMembershipView) (e
 }

 func (m *UserMembership) updateOrgName(event *models.Event) error {
-	org, err := m.orgEvents.OrgByID(context.Background(), org_model.NewOrg(event.AggregateID))
+	org, err := m.getOrgByID(context.Background(), event.AggregateID)
 	if err != nil {
 		return err
 	}
@@ -231,7 +229,7 @@ func (m *UserMembership) processProject(event *models.Event) (err error) {
 }

 func (m *UserMembership) fillProjectDisplayName(member *usr_es_model.UserMembershipView) (err error) {
-	project, err := m.projectEvents.ProjectByID(context.Background(), member.AggregateID)
+	project, err := m.getProjectByID(context.Background(), member.AggregateID)
 	if err != nil {
 		return err
 	}
@@ -240,7 +238,7 @@ func (m *UserMembership) fillProjectDisplayName(member *usr_es_model.UserMembers
 }

 func (m *UserMembership) updateProjectDisplayName(event *models.Event) error {
-	project, err := m.projectEvents.ProjectByID(context.Background(), event.AggregateID)
+	project, err := m.getProjectByID(context.Background(), event.AggregateID)
 	if err != nil {
 		return err
 	}
@@ -272,3 +270,45 @@ func (m *UserMembership) OnError(event *models.Event, err error) error {
 func (m *UserMembership) OnSuccess() error {
 	return spooler.HandleSuccess(m.view.UpdateUserMembershipSpoolerRunTimestamp)
 }
+
+func (u *UserMembership) getOrgByID(ctx context.Context, orgID string) (*org_model.Org, error) {
+	query, err := org_view.OrgByIDQuery(orgID, 0)
+	if err != nil {
+		return nil, err
+	}
+	esOrg := &org_es_model.Org{
+		ObjectRoot: models.ObjectRoot{
+			AggregateID: orgID,
+		},
+	}
+	err = es_sdk.Filter(ctx, u.Eventstore().FilterEvents, esOrg.AppendEvents, query)
+	if err != nil && !errors.IsNotFound(err) {
+		return nil, err
+	}
+	if esOrg.Sequence == 0 {
+		return nil, errors.ThrowNotFound(nil, "EVENT-3m9vs", "Errors.Org.NotFound")
+	}
+
+	return org_es_model.OrgToModel(esOrg), nil
+}
+
+func (u *UserMembership) getProjectByID(ctx context.Context, projID string) (*proj_model.Project, error) {
+	query, err := proj_view.ProjectByIDQuery(projID, 0)
+	if err != nil {
+		return nil, err
+	}
+	esProject := &proj_es_model.Project{
+		ObjectRoot: models.ObjectRoot{
+			AggregateID: projID,
+		},
+	}
+	err = es_sdk.Filter(ctx, u.Eventstore().FilterEvents, esProject.AppendEvents, query)
+	if err != nil && !errors.IsNotFound(err) {
+		return nil, err
+	}
+	if esProject.Sequence == 0 {
+		return nil, errors.ThrowNotFound(nil, "EVENT-Dbfw2", "Errors.Project.NotFound")
+	}
+
+	return proj_es_model.ProjectToModel(esProject), nil
+}
--- a/internal/auth/repository/eventsourcing/handler/user_session.go
+++ b/internal/auth/repository/eventsourcing/handler/user_session.go
@@ -8,9 +8,8 @@ import (
 	"github.com/caos/zitadel/internal/eventstore/models"
 	"github.com/caos/zitadel/internal/eventstore/query"
 	"github.com/caos/zitadel/internal/eventstore/spooler"
-	"github.com/caos/zitadel/internal/user/repository/eventsourcing"
-	user_events "github.com/caos/zitadel/internal/user/repository/eventsourcing"
 	es_model "github.com/caos/zitadel/internal/user/repository/eventsourcing/model"
+	"github.com/caos/zitadel/internal/user/repository/view"
 	view_model "github.com/caos/zitadel/internal/user/repository/view/model"
 )

@@ -20,17 +19,14 @@ const (

 type UserSession struct {
 	handler
-	userEvents   *user_events.UserEventstore
 	subscription *eventstore.Subscription
 }

 func newUserSession(
 	handler handler,
-	userEvents *user_events.UserEventstore,
 ) *UserSession {
 	h := &UserSession{
-		handler:    handler,
-		userEvents: userEvents,
+		handler: handler,
 	}

 	h.subscribe()
@@ -68,7 +64,7 @@ func (u *UserSession) EventQuery() (*models.SearchQuery, error) {
 	if err != nil {
 		return nil, err
 	}
-	return eventsourcing.UserQuery(sequence.CurrentSequence), nil
+	return view.UserQuery(sequence.CurrentSequence), nil
 }

 func (u *UserSession) Reduce(event *models.Event) (err error) {