remove improved_performance from feature API

remove `eventstore.Searcher` interface

remove code which uses the `eventstore.Searcher` interface

remove implementation of `eventstore.Searcher` interface

cleanup code to use functions which were suffixed with `*Old`

internal/command/org_domain.go

@@ -7,14 +7,11 @@ import (
 
 	"github.com/zitadel/logging"
 
-	"github.com/zitadel/zitadel/internal/api/authz"
 	http_utils "github.com/zitadel/zitadel/internal/api/http"
 	"github.com/zitadel/zitadel/internal/command/preparation"
 	"github.com/zitadel/zitadel/internal/crypto"
 	"github.com/zitadel/zitadel/internal/domain"
 	"github.com/zitadel/zitadel/internal/eventstore"
-	"github.com/zitadel/zitadel/internal/feature"
-	"github.com/zitadel/zitadel/internal/query/projection"
 	"github.com/zitadel/zitadel/internal/repository/org"
 	"github.com/zitadel/zitadel/internal/telemetry/tracing"
 	"github.com/zitadel/zitadel/internal/zerrors"
@@ -353,38 +350,6 @@ func (c *Commands) changeDefaultDomain(ctx context.Context, orgID, newName strin
 	return nil, nil
 }
 
-func (c *Commands) removeCustomDomains(ctx context.Context, orgID string) ([]eventstore.Command, error) {
-	orgDomains := NewOrgDomainsWriteModel(orgID)
-	err := c.eventstore.FilterToQueryReducer(ctx, orgDomains)
-	if err != nil {
-		return nil, err
-	}
-	hasDefault := false
-	defaultDomain, _ := domain.NewIAMDomainName(orgDomains.OrgName, http_utils.DomainContext(ctx).RequestedDomain())
-	isPrimary := defaultDomain == orgDomains.PrimaryDomain
-	orgAgg := OrgAggregateFromWriteModel(&orgDomains.WriteModel)
-	events := make([]eventstore.Command, 0, len(orgDomains.Domains))
-	for _, orgDomain := range orgDomains.Domains {
-		if orgDomain.State == domain.OrgDomainStateActive {
-			if orgDomain.Domain == defaultDomain {
-				hasDefault = true
-				continue
-			}
-			events = append(events, org.NewDomainRemovedEvent(ctx, orgAgg, orgDomain.Domain, orgDomain.Verified))
-		}
-	}
-	if !hasDefault {
-		return append([]eventstore.Command{
-			org.NewDomainAddedEvent(ctx, orgAgg, defaultDomain),
-			org.NewDomainPrimarySetEvent(ctx, orgAgg, defaultDomain),
-		}, events...), nil
-	}
-	if !isPrimary {
-		return append([]eventstore.Command{org.NewDomainPrimarySetEvent(ctx, orgAgg, defaultDomain)}, events...), nil
-	}
-	return events, nil
-}
-
 func (c *Commands) getOrgDomainWriteModel(ctx context.Context, orgID, domain string) (_ *OrgDomainWriteModel, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
@@ -404,45 +369,6 @@ type OrgDomainVerified struct {
 }
 
 func (c *Commands) searchOrgDomainVerifiedByDomain(ctx context.Context, domain string) (_ *OrgDomainVerified, err error) {
-	if !authz.GetFeatures(ctx).ShouldUseImprovedPerformance(feature.ImprovedPerformanceTypeOrgDomainVerified) {
-		return c.searchOrgDomainVerifiedByDomainOld(ctx, domain)
-	}
-
-	ctx, span := tracing.NewSpan(ctx)
-	defer func() { span.EndWithError(err) }()
-
-	condition := map[eventstore.FieldType]any{
-		eventstore.FieldTypeAggregateType:  org.AggregateType,
-		eventstore.FieldTypeObjectType:     org.OrgDomainSearchType,
-		eventstore.FieldTypeObjectID:       domain,
-		eventstore.FieldTypeObjectRevision: org.OrgDomainObjectRevision,
-		eventstore.FieldTypeFieldName:      org.OrgDomainVerifiedSearchField,
-	}
-
-	results, err := c.eventstore.Search(ctx, condition)
-	if err != nil {
-		return nil, err
-	}
-	if len(results) == 0 {
-		_ = projection.OrgDomainVerifiedFields.Trigger(ctx)
-		results, err = c.eventstore.Search(ctx, condition)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	orgDomain := new(OrgDomainVerified)
-	for _, result := range results {
-		orgDomain.OrgID = result.Aggregate.ID
-		if err = result.Value.Unmarshal(&orgDomain.Verified); err != nil {
-			return nil, err
-		}
-	}
-
-	return orgDomain, nil
-}
-
-func (c *Commands) searchOrgDomainVerifiedByDomainOld(ctx context.Context, domain string) (_ *OrgDomainVerified, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 

internal/command/project.go

@@ -7,13 +7,10 @@ import (
 
 	"github.com/zitadel/logging"
 
-	"github.com/zitadel/zitadel/internal/api/authz"
 	"github.com/zitadel/zitadel/internal/command/preparation"
 	"github.com/zitadel/zitadel/internal/domain"
 	"github.com/zitadel/zitadel/internal/eventstore"
 	"github.com/zitadel/zitadel/internal/eventstore/v1/models"
-	"github.com/zitadel/zitadel/internal/feature"
-	"github.com/zitadel/zitadel/internal/query/projection"
 	"github.com/zitadel/zitadel/internal/repository/project"
 	"github.com/zitadel/zitadel/internal/telemetry/tracing"
 	"github.com/zitadel/zitadel/internal/zerrors"
@@ -138,53 +135,18 @@ func projectWriteModel(ctx context.Context, filter preparation.FilterToQueryRedu
 	return project, nil
 }
 
-func (c *Commands) projectAggregateByID(ctx context.Context, projectID, resourceOwner string) (*eventstore.Aggregate, domain.ProjectState, error) {
-	result, err := c.projectState(ctx, projectID, resourceOwner)
-	if err != nil {
-		return nil, domain.ProjectStateUnspecified, zerrors.ThrowNotFound(err, "COMMA-NDQoF", "Errors.Project.NotFound")
-	}
-	if len(result) == 0 {
-		_ = projection.ProjectGrantFields.Trigger(ctx)
-		result, err = c.projectState(ctx, projectID, resourceOwner)
-		if err != nil || len(result) == 0 {
-			return nil, domain.ProjectStateUnspecified, zerrors.ThrowNotFound(err, "COMMA-U1nza", "Errors.Project.NotFound")
-		}
-	}
-
-	var state domain.ProjectState
-	err = result[0].Value.Unmarshal(&state)
-	if err != nil {
-		return nil, state, zerrors.ThrowNotFound(err, "COMMA-o4n6F", "Errors.Project.NotFound")
-	}
-	return &result[0].Aggregate, state, nil
-}
-
-func (c *Commands) projectState(ctx context.Context, projectID, resourceOwner string) ([]*eventstore.SearchResult, error) {
-	return c.eventstore.Search(
-		ctx,
-		map[eventstore.FieldType]any{
-			eventstore.FieldTypeObjectType:     project.ProjectSearchType,
-			eventstore.FieldTypeObjectID:       projectID,
-			eventstore.FieldTypeObjectRevision: project.ProjectObjectRevision,
-			eventstore.FieldTypeFieldName:      project.ProjectStateSearchField,
-			eventstore.FieldTypeResourceOwner:  resourceOwner,
-		},
-	)
-}
-
 func (c *Commands) checkProjectExists(ctx context.Context, projectID, resourceOwner string) (_ string, err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()
 
-	if !authz.GetFeatures(ctx).ShouldUseImprovedPerformance(feature.ImprovedPerformanceTypeProject) {
-		return c.checkProjectExistsOld(ctx, projectID, resourceOwner)
+	projectWriteModel, err := c.getProjectWriteModelByID(ctx, projectID, resourceOwner)
+	if err != nil {
+		return "", err
 	}
-
-	agg, state, err := c.projectAggregateByID(ctx, projectID, resourceOwner)
-	if err != nil || !state.Valid() {
-		return "", zerrors.ThrowPreconditionFailed(err, "COMMA-VCnwD", "Errors.Project.NotFound")
+	if !isProjectStateExists(projectWriteModel.State) {
+		return "", zerrors.ThrowPreconditionFailed(nil, "COMMAND-EbFMN", "Errors.Project.NotFound")
 	}
-	return agg.ResourceOwner, nil
+	return projectWriteModel.ResourceOwner, nil
 }
 
 type ChangeProject struct {
@@ -246,35 +208,31 @@ func (c *Commands) DeactivateProject(ctx context.Context, projectID string, reso
 		return nil, zerrors.ThrowInvalidArgument(nil, "COMMAND-88iF0", "Errors.Project.ProjectIDMissing")
 	}
 
-	if !authz.GetFeatures(ctx).ShouldUseImprovedPerformance(feature.ImprovedPerformanceTypeProject) {
-		return c.deactivateProjectOld(ctx, projectID, resourceOwner)
-	}
-
-	projectAgg, state, err := c.projectAggregateByID(ctx, projectID, resourceOwner)
+	existingProject, err := c.getProjectWriteModelByID(ctx, projectID, resourceOwner)
 	if err != nil {
 		return nil, err
 	}
-
-	if !isProjectStateExists(state) {
+	if !isProjectStateExists(existingProject.State) {
 		return nil, zerrors.ThrowNotFound(nil, "COMMAND-112M9", "Errors.Project.NotFound")
 	}
-	if state != domain.ProjectStateActive {
+	if existingProject.State != domain.ProjectStateActive {
 		return nil, zerrors.ThrowPreconditionFailed(nil, "COMMAND-mki55", "Errors.Project.NotActive")
 	}
-	if err := c.checkPermissionUpdateProject(ctx, projectAgg.ResourceOwner, projectAgg.ID); err != nil {
+	if err := c.checkPermissionUpdateProject(ctx, existingProject.ResourceOwner, existingProject.AggregateID); err != nil {
 		return nil, err
 	}
 
+	//nolint: contextcheck
+	projectAgg := ProjectAggregateFromWriteModel(&existingProject.WriteModel)
 	pushedEvents, err := c.eventstore.Push(ctx, project.NewProjectDeactivatedEvent(ctx, projectAgg))
 	if err != nil {
 		return nil, err
 	}
-
-	return &domain.ObjectDetails{
-		ResourceOwner: pushedEvents[0].Aggregate().ResourceOwner,
-		Sequence:      pushedEvents[0].Sequence(),
-		EventDate:     pushedEvents[0].CreatedAt(),
-	}, nil
+	err = AppendAndReduce(existingProject, pushedEvents...)
+	if err != nil {
+		return nil, err
+	}
+	return writeModelToObjectDetails(&existingProject.WriteModel), nil
 }
 
 func (c *Commands) ReactivateProject(ctx context.Context, projectID string, resourceOwner string) (*domain.ObjectDetails, error) {
@@ -282,35 +240,31 @@ func (c *Commands) ReactivateProject(ctx context.Context, projectID string, reso
 		return nil, zerrors.ThrowInvalidArgument(nil, "COMMAND-3ihsF", "Errors.Project.ProjectIDMissing")
 	}
 
-	if !authz.GetFeatures(ctx).ShouldUseImprovedPerformance(feature.ImprovedPerformanceTypeProject) {
-		return c.reactivateProjectOld(ctx, projectID, resourceOwner)
-	}
-
-	projectAgg, state, err := c.projectAggregateByID(ctx, projectID, resourceOwner)
+	existingProject, err := c.getProjectWriteModelByID(ctx, projectID, resourceOwner)
 	if err != nil {
 		return nil, err
 	}
-
-	if !isProjectStateExists(state) {
+	if !isProjectStateExists(existingProject.State) {
 		return nil, zerrors.ThrowNotFound(nil, "COMMAND-3M9sd", "Errors.Project.NotFound")
 	}
-	if state != domain.ProjectStateInactive {
+	if existingProject.State != domain.ProjectStateInactive {
 		return nil, zerrors.ThrowPreconditionFailed(nil, "COMMAND-5M9bs", "Errors.Project.NotInactive")
 	}
-	if err := c.checkPermissionUpdateProject(ctx, projectAgg.ResourceOwner, projectAgg.ID); err != nil {
+	if err := c.checkPermissionUpdateProject(ctx, existingProject.ResourceOwner, existingProject.AggregateID); err != nil {
 		return nil, err
 	}
 
+	//nolint: contextcheck
+	projectAgg := ProjectAggregateFromWriteModel(&existingProject.WriteModel)
 	pushedEvents, err := c.eventstore.Push(ctx, project.NewProjectReactivatedEvent(ctx, projectAgg))
 	if err != nil {
 		return nil, err
 	}
-
-	return &domain.ObjectDetails{
-		ResourceOwner: pushedEvents[0].Aggregate().ResourceOwner,
-		Sequence:      pushedEvents[0].Sequence(),
-		EventDate:     pushedEvents[0].CreatedAt(),
-	}, nil
+	err = AppendAndReduce(existingProject, pushedEvents...)
+	if err != nil {
+		return nil, err
+	}
+	return writeModelToObjectDetails(&existingProject.WriteModel), nil
 }
 
 // Deprecated: use commands.DeleteProject

internal/command/project_grant.go

@@ -6,12 +6,9 @@ import (
 
 	"github.com/zitadel/logging"
 
-	"github.com/zitadel/zitadel/internal/api/authz"
 	"github.com/zitadel/zitadel/internal/domain"
 	"github.com/zitadel/zitadel/internal/eventstore"
 	es_models "github.com/zitadel/zitadel/internal/eventstore/v1/models"
-	"github.com/zitadel/zitadel/internal/feature"
-	"github.com/zitadel/zitadel/internal/repository/org"
 	"github.com/zitadel/zitadel/internal/repository/project"
 	"github.com/zitadel/zitadel/internal/telemetry/tracing"
 	"github.com/zitadel/zitadel/internal/zerrors"
@@ -379,94 +376,19 @@ func (c *Commands) projectGrantWriteModelByID(ctx context.Context, grantID, gran
 }
 
 func (c *Commands) checkProjectGrantPreCondition(ctx context.Context, projectID, grantedOrgID, resourceOwner string, roles []string) (string, error) {
-	if !authz.GetFeatures(ctx).ShouldUseImprovedPerformance(feature.ImprovedPerformanceTypeProjectGrant) {
-		return c.checkProjectGrantPreConditionOld(ctx, projectID, grantedOrgID, resourceOwner, roles)
-	}
-	projectResourceOwner, existingRoleKeys, err := c.searchProjectGrantState(ctx, projectID, grantedOrgID, resourceOwner)
+	preConditions := NewProjectGrantPreConditionReadModel(projectID, grantedOrgID, resourceOwner)
+	err := c.eventstore.FilterToQueryReducer(ctx, preConditions)
 	if err != nil {
 		return "", err
 	}
-
-	if domain.HasInvalidRoles(existingRoleKeys, roles) {
+	if !preConditions.ProjectExists {
+		return "", zerrors.ThrowPreconditionFailed(err, "COMMAND-m9gsd", "Errors.Project.NotFound")
+	}
+	if !preConditions.GrantedOrgExists {
+		return "", zerrors.ThrowPreconditionFailed(err, "COMMAND-3m9gg", "Errors.Org.NotFound")
+	}
+	if domain.HasInvalidRoles(preConditions.ExistingRoleKeys, roles) {
 		return "", zerrors.ThrowPreconditionFailed(err, "COMMAND-6m9gd", "Errors.Project.Role.NotFound")
 	}
-	return projectResourceOwner, nil
-}
-
-func (c *Commands) searchProjectGrantState(ctx context.Context, projectID, grantedOrgID, resourceOwner string) (_ string, existingRoleKeys []string, err error) {
-	projectStateQuery := map[eventstore.FieldType]any{
-		eventstore.FieldTypeAggregateType: project.AggregateType,
-		eventstore.FieldTypeAggregateID:   projectID,
-		eventstore.FieldTypeFieldName:     project.ProjectStateSearchField,
-		eventstore.FieldTypeObjectType:    project.ProjectSearchType,
-	}
-	grantedOrgQuery := map[eventstore.FieldType]any{
-		eventstore.FieldTypeAggregateType: org.AggregateType,
-		eventstore.FieldTypeAggregateID:   grantedOrgID,
-		eventstore.FieldTypeFieldName:     org.OrgStateSearchField,
-		eventstore.FieldTypeObjectType:    org.OrgSearchType,
-	}
-	roleQuery := map[eventstore.FieldType]any{
-		eventstore.FieldTypeAggregateType: project.AggregateType,
-		eventstore.FieldTypeAggregateID:   projectID,
-		eventstore.FieldTypeFieldName:     project.ProjectRoleKeySearchField,
-		eventstore.FieldTypeObjectType:    project.ProjectRoleSearchType,
-	}
-
-	// as resourceowner is not always provided, it has to be separately
-	if resourceOwner != "" {
-		projectStateQuery[eventstore.FieldTypeResourceOwner] = resourceOwner
-		roleQuery[eventstore.FieldTypeResourceOwner] = resourceOwner
-	}
-
-	results, err := c.eventstore.Search(
-		ctx,
-		projectStateQuery,
-		grantedOrgQuery,
-		roleQuery,
-	)
-	if err != nil {
-		return "", nil, err
-	}
-
-	var (
-		existsProject                bool
-		existingProjectResourceOwner string
-		existsGrantedOrg             bool
-	)
-
-	for _, result := range results {
-		switch result.Object.Type {
-		case project.ProjectRoleSearchType:
-			var role string
-			err := result.Value.Unmarshal(&role)
-			if err != nil {
-				return "", nil, err
-			}
-			existingRoleKeys = append(existingRoleKeys, role)
-		case org.OrgSearchType:
-			var state domain.OrgState
-			err := result.Value.Unmarshal(&state)
-			if err != nil {
-				return "", nil, err
-			}
-			existsGrantedOrg = state.Valid() && state != domain.OrgStateRemoved
-		case project.ProjectSearchType:
-			var state domain.ProjectState
-			err := result.Value.Unmarshal(&state)
-			if err != nil {
-				return "", nil, err
-			}
-			existsProject = state.Valid() && state != domain.ProjectStateRemoved
-			existingProjectResourceOwner = result.Aggregate.ResourceOwner
-		}
-	}
-
-	if !existsProject {
-		return "", nil, zerrors.ThrowPreconditionFailed(err, "COMMAND-m9gsd", "Errors.Project.NotFound")
-	}
-	if !existsGrantedOrg {
-		return "", nil, zerrors.ThrowPreconditionFailed(err, "COMMAND-3m9gg", "Errors.Org.NotFound")
-	}
-	return existingProjectResourceOwner, existingRoleKeys, nil
+	return preConditions.ProjectResourceOwner, nil
 }

internal/command/project_old.go

@@ -1,98 +0,0 @@
-package command
-
-import (
-	"context"
-
-	"github.com/zitadel/zitadel/internal/domain"
-	"github.com/zitadel/zitadel/internal/repository/project"
-	"github.com/zitadel/zitadel/internal/telemetry/tracing"
-	"github.com/zitadel/zitadel/internal/zerrors"
-)
-
-func (c *Commands) checkProjectExistsOld(ctx context.Context, projectID, resourceOwner string) (_ string, err error) {
-	ctx, span := tracing.NewSpan(ctx)
-	defer func() { span.EndWithError(err) }()
-
-	projectWriteModel, err := c.getProjectWriteModelByID(ctx, projectID, resourceOwner)
-	if err != nil {
-		return "", err
-	}
-	if !isProjectStateExists(projectWriteModel.State) {
-		return "", zerrors.ThrowPreconditionFailed(nil, "COMMAND-EbFMN", "Errors.Project.NotFound")
-	}
-	return projectWriteModel.ResourceOwner, nil
-}
-
-func (c *Commands) deactivateProjectOld(ctx context.Context, projectID string, resourceOwner string) (*domain.ObjectDetails, error) {
-	existingProject, err := c.getProjectWriteModelByID(ctx, projectID, resourceOwner)
-	if err != nil {
-		return nil, err
-	}
-	if !isProjectStateExists(existingProject.State) {
-		return nil, zerrors.ThrowNotFound(nil, "COMMAND-112M9", "Errors.Project.NotFound")
-	}
-	if existingProject.State != domain.ProjectStateActive {
-		return nil, zerrors.ThrowPreconditionFailed(nil, "COMMAND-mki55", "Errors.Project.NotActive")
-	}
-	if err := c.checkPermissionUpdateProject(ctx, existingProject.ResourceOwner, existingProject.AggregateID); err != nil {
-		return nil, err
-	}
-
-	//nolint: contextcheck
-	projectAgg := ProjectAggregateFromWriteModel(&existingProject.WriteModel)
-	pushedEvents, err := c.eventstore.Push(ctx, project.NewProjectDeactivatedEvent(ctx, projectAgg))
-	if err != nil {
-		return nil, err
-	}
-	err = AppendAndReduce(existingProject, pushedEvents...)
-	if err != nil {
-		return nil, err
-	}
-	return writeModelToObjectDetails(&existingProject.WriteModel), nil
-}
-
-func (c *Commands) reactivateProjectOld(ctx context.Context, projectID string, resourceOwner string) (*domain.ObjectDetails, error) {
-	existingProject, err := c.getProjectWriteModelByID(ctx, projectID, resourceOwner)
-	if err != nil {
-		return nil, err
-	}
-	if !isProjectStateExists(existingProject.State) {
-		return nil, zerrors.ThrowNotFound(nil, "COMMAND-3M9sd", "Errors.Project.NotFound")
-	}
-	if existingProject.State != domain.ProjectStateInactive {
-		return nil, zerrors.ThrowPreconditionFailed(nil, "COMMAND-5M9bs", "Errors.Project.NotInactive")
-	}
-	if err := c.checkPermissionUpdateProject(ctx, existingProject.ResourceOwner, existingProject.AggregateID); err != nil {
-		return nil, err
-	}
-
-	//nolint: contextcheck
-	projectAgg := ProjectAggregateFromWriteModel(&existingProject.WriteModel)
-	pushedEvents, err := c.eventstore.Push(ctx, project.NewProjectReactivatedEvent(ctx, projectAgg))
-	if err != nil {
-		return nil, err
-	}
-	err = AppendAndReduce(existingProject, pushedEvents...)
-	if err != nil {
-		return nil, err
-	}
-	return writeModelToObjectDetails(&existingProject.WriteModel), nil
-}
-
-func (c *Commands) checkProjectGrantPreConditionOld(ctx context.Context, projectID, grantedOrgID, resourceOwner string, roles []string) (string, error) {
-	preConditions := NewProjectGrantPreConditionReadModel(projectID, grantedOrgID, resourceOwner)
-	err := c.eventstore.FilterToQueryReducer(ctx, preConditions)
-	if err != nil {
-		return "", err
-	}
-	if !preConditions.ProjectExists {
-		return "", zerrors.ThrowPreconditionFailed(err, "COMMAND-m9gsd", "Errors.Project.NotFound")
-	}
-	if !preConditions.GrantedOrgExists {
-		return "", zerrors.ThrowPreconditionFailed(err, "COMMAND-3m9gg", "Errors.Org.NotFound")
-	}
-	if domain.HasInvalidRoles(preConditions.ExistingRoleKeys, roles) {
-		return "", zerrors.ThrowPreconditionFailed(err, "COMMAND-6m9gd", "Errors.Project.Role.NotFound")
-	}
-	return preConditions.ProjectResourceOwner, nil
-}

internal/command/user_grant.go

@@ -4,12 +4,8 @@ import (
 	"context"
 	"reflect"
 
-	"github.com/zitadel/zitadel/internal/api/authz"
 	"github.com/zitadel/zitadel/internal/domain"
 	"github.com/zitadel/zitadel/internal/eventstore"
-	"github.com/zitadel/zitadel/internal/feature"
-	"github.com/zitadel/zitadel/internal/repository/org"
-	"github.com/zitadel/zitadel/internal/repository/project"
 	"github.com/zitadel/zitadel/internal/repository/usergrant"
 	"github.com/zitadel/zitadel/internal/telemetry/tracing"
 	"github.com/zitadel/zitadel/internal/zerrors"
@@ -292,140 +288,6 @@ func (c *Commands) userGrantWriteModelByID(ctx context.Context, userGrantID, res
 }
 
 func (c *Commands) checkUserGrantPreCondition(ctx context.Context, usergrant *domain.UserGrant, resourceOwner string) (err error) {
-	if !authz.GetFeatures(ctx).ShouldUseImprovedPerformance(feature.ImprovedPerformanceTypeUserGrant) {
-		return c.checkUserGrantPreConditionOld(ctx, usergrant, resourceOwner)
-	}
-
-	ctx, span := tracing.NewSpan(ctx)
-	defer func() { span.EndWithError(err) }()
-
-	if err := c.checkUserExists(ctx, usergrant.UserID, ""); err != nil {
-		return err
-	}
-	existingRoleKeys, err := c.searchUserGrantPreConditionState(ctx, usergrant, resourceOwner)
-	if err != nil {
-		return err
-	}
-	if usergrant.HasInvalidRoles(existingRoleKeys) {
-		return zerrors.ThrowPreconditionFailed(err, "COMMAND-mm9F4", "Errors.Project.Role.NotFound")
-	}
-	return nil
-}
-
-// this code needs to be rewritten anyways as soon as we improved the fields handling
-//
-//nolint:gocognit
-func (c *Commands) searchUserGrantPreConditionState(ctx context.Context, userGrant *domain.UserGrant, resourceOwner string) (existingRoleKeys []string, err error) {
-	criteria := []map[eventstore.FieldType]any{
-		// project state query
-		{
-			eventstore.FieldTypeAggregateType: project.AggregateType,
-			eventstore.FieldTypeAggregateID:   userGrant.ProjectID,
-			eventstore.FieldTypeFieldName:     project.ProjectStateSearchField,
-			eventstore.FieldTypeObjectType:    project.ProjectSearchType,
-		},
-		// granted org query
-		{
-			eventstore.FieldTypeAggregateType: org.AggregateType,
-			eventstore.FieldTypeAggregateID:   resourceOwner,
-			eventstore.FieldTypeFieldName:     org.OrgStateSearchField,
-			eventstore.FieldTypeObjectType:    org.OrgSearchType,
-		},
-	}
-	if userGrant.ProjectGrantID != "" {
-		criteria = append(criteria, map[eventstore.FieldType]any{
-			eventstore.FieldTypeAggregateType: project.AggregateType,
-			eventstore.FieldTypeAggregateID:   userGrant.ProjectID,
-			eventstore.FieldTypeObjectType:    project.ProjectGrantSearchType,
-			eventstore.FieldTypeObjectID:      userGrant.ProjectGrantID,
-		})
-	} else {
-		criteria = append(criteria, map[eventstore.FieldType]any{
-			eventstore.FieldTypeAggregateType: project.AggregateType,
-			eventstore.FieldTypeAggregateID:   userGrant.ProjectID,
-			eventstore.FieldTypeObjectType:    project.ProjectRoleSearchType,
-			eventstore.FieldTypeFieldName:     project.ProjectRoleKeySearchField,
-		})
-	}
-	results, err := c.eventstore.Search(ctx, criteria...)
-	if err != nil {
-		return nil, err
-	}
-
-	var (
-		existsProject    bool
-		existsGrantedOrg bool
-		existsGrant      bool
-	)
-
-	for _, result := range results {
-		switch result.Object.Type {
-		case project.ProjectRoleSearchType:
-			var role string
-			err := result.Value.Unmarshal(&role)
-			if err != nil {
-				return nil, err
-			}
-			existingRoleKeys = append(existingRoleKeys, role)
-		case org.OrgSearchType:
-			var state domain.OrgState
-			err := result.Value.Unmarshal(&state)
-			if err != nil {
-				return nil, err
-			}
-			existsGrantedOrg = state.Valid() && state != domain.OrgStateRemoved
-		case project.ProjectSearchType:
-			var state domain.ProjectState
-			err := result.Value.Unmarshal(&state)
-			if err != nil {
-				return nil, err
-			}
-			existsProject = state.Valid() && state != domain.ProjectStateRemoved
-		case project.ProjectGrantSearchType:
-			switch result.FieldName {
-			case project.ProjectGrantGrantedOrgIDSearchField:
-				var orgID string
-				err := result.Value.Unmarshal(&orgID)
-				if err != nil || orgID != resourceOwner {
-					return nil, zerrors.ThrowPreconditionFailed(err, "COMMAND-3m9gg", "Errors.Org.NotFound")
-				}
-			case project.ProjectGrantStateSearchField:
-				var state domain.ProjectGrantState
-				err := result.Value.Unmarshal(&state)
-				if err != nil {
-					return nil, err
-				}
-				existsGrant = state.Valid() && state != domain.ProjectGrantStateRemoved
-			case project.ProjectGrantRoleKeySearchField:
-				var role string
-				err := result.Value.Unmarshal(&role)
-				if err != nil {
-					return nil, err
-				}
-				existingRoleKeys = append(existingRoleKeys, role)
-			case project.ProjectGrantGrantIDSearchField:
-				var grantID string
-				err := result.Value.Unmarshal(&grantID)
-				if err != nil || grantID != userGrant.ProjectGrantID {
-					return nil, zerrors.ThrowPreconditionFailed(err, "COMMAND-huvKF", "Errors.Project.Grant.NotFound")
-				}
-			}
-		}
-	}
-
-	if !existsProject {
-		return nil, zerrors.ThrowPreconditionFailed(err, "COMMAND-m9gsd", "Errors.Project.NotFound")
-	}
-	if !existsGrantedOrg {
-		return nil, zerrors.ThrowPreconditionFailed(err, "COMMAND-3m9gg", "Errors.Org.NotFound")
-	}
-	if userGrant.ProjectGrantID != "" && !existsGrant {
-		return nil, zerrors.ThrowPreconditionFailed(err, "COMMAND-huvKF", "Errors.Project.Grant.NotFound")
-	}
-	return existingRoleKeys, nil
-}
-
-func (c *Commands) checkUserGrantPreConditionOld(ctx context.Context, usergrant *domain.UserGrant, resourceOwner string) (err error) {
 	ctx, span := tracing.NewSpan(ctx)
 	defer func() { span.EndWithError(err) }()