feat: [CDE-669]: Integrating gitspaces and infra providers with delete spaces functionality. (#3558)

* Addressing review comments.
* Rebasing
* Removing reliance on space paths for gitspace service.
* feat: [CDE-669]: Integrating gitspaces and infra providers with soft delete spaces functionality.

app/api/controller/gitspace/action.go

@@ -51,7 +51,7 @@ func (c *Controller) Action(
 		return nil, fmt.Errorf("failed to authorize: %w", err)
 	}
 
-	gitspaceConfig, err := c.gitspaceSvc.FindWithLatestInstance(ctx, space.Path, in.Identifier)
+	gitspaceConfig, err := c.gitspaceSvc.FindWithLatestInstance(ctx, space.ID, space.Path, in.Identifier)
 	if err != nil {
 		return nil, fmt.Errorf("failed to find gitspace config: %w", err)
 	}

app/api/controller/gitspace/delete.go

@@ -21,8 +21,6 @@ import (
 	apiauth "github.com/harness/gitness/app/api/auth"
 	"github.com/harness/gitness/app/auth"
 	"github.com/harness/gitness/types/enum"
-
-	"github.com/rs/zerolog/log"
 )
 
 func (c *Controller) Delete(
@@ -36,34 +34,5 @@ func (c *Controller) Delete(
 		return fmt.Errorf("failed to authorize: %w", err)
 	}
 
-	gitspaceConfig, err := c.gitspaceSvc.FindWithLatestInstance(ctx, spaceRef, identifier)
+	return c.gitspaceSvc.DeleteGitspaceByIdentifier(ctx, spaceRef, identifier)
-	if err != nil {
-		log.Err(err).Msgf("Failed to find latest gitspace config : %s", identifier)
-		return err
-	}
-	instance := gitspaceConfig.GitspaceInstance
-	if instance == nil || instance.State == enum.GitspaceInstanceStateUninitialized {
-		gitspaceConfig.IsMarkedForDeletion = true
-		gitspaceConfig.IsDeleted = true
-		if err = c.gitspaceSvc.UpdateConfig(ctx, gitspaceConfig); err != nil {
-			return fmt.Errorf("failed to mark gitspace config as deleted: %w", err)
-		}
-
-		return nil
-	}
-
-	// mark can_delete for gitconfig as true so that if delete operation fails, cron job can clean up resources.
-	gitspaceConfig.IsMarkedForDeletion = true
-	if err = c.gitspaceSvc.UpdateConfig(ctx, gitspaceConfig); err != nil {
-		return fmt.Errorf("failed to mark gitspace config is_marked_for_deletion column: %w", err)
-	}
-
-	ctxWithoutCancel := context.WithoutCancel(ctx)
-	go func() {
-		err2 := c.gitspaceSvc.RemoveGitspace(ctxWithoutCancel, *gitspaceConfig, true)
-		if err2 != nil {
-			log.Debug().Err(err2).Msgf("unable to Delete gitspace: " + identifier)
-		}
-	}()
-	return nil
 }

app/api/controller/gitspace/find.go

@@ -35,7 +35,7 @@ func (c *Controller) Find(
 		return nil, fmt.Errorf("failed to authorize: %w", err)
 	}
 
-	res, err := c.gitspaceSvc.FindWithLatestInstance(ctx, spaceRef, identifier)
+	res, err := c.gitspaceSvc.FindWithLatestInstanceWithSpacePath(ctx, spaceRef, identifier)
 	if err != nil {
 		return nil, fmt.Errorf("failed to find gitspace: %w", err)
 	}

app/api/controller/gitspace/list_all.go

@@ -30,11 +30,11 @@ import (
 func (c *Controller) ListAllGitspaces( // nolint:gocognit
 	ctx context.Context,
 	session *auth.Session,
-	filter *types.GitspaceFilter,
+	filter types.GitspaceFilter,
 ) ([]*types.GitspaceConfig, error) {
 	var result []*types.GitspaceConfig
 	err := c.tx.WithTx(ctx, func(ctx context.Context) (err error) {
-		allGitspaceConfigs, _, _, err := c.gitspaceSvc.ListGitspacesWithInstance(ctx, *filter)
+		allGitspaceConfigs, _, _, err := c.gitspaceSvc.ListGitspacesWithInstance(ctx, filter, false)
 		if err != nil {
 			return fmt.Errorf("failed to list gitspace configs: %w", err)
 		}

app/api/controller/gitspace/logs_stream.go

@@ -37,7 +37,7 @@ func (c *Controller) LogsStream(
 		return nil, nil, fmt.Errorf("failed to authorize: %w", err)
 	}
 
-	gitspaceConfig, err := c.gitspaceSvc.FindWithLatestInstance(ctx, spaceRef, identifier)
+	gitspaceConfig, err := c.gitspaceSvc.FindWithLatestInstanceWithSpacePath(ctx, spaceRef, identifier)
 	if err != nil {
 		return nil, nil, fmt.Errorf("failed to find gitspace config: %w", err)
 	}

app/api/controller/gitspace/update.go

@@ -52,7 +52,7 @@ func (c *Controller) Update(
 		return fmt.Errorf("failed to authorize: %w", err)
 	}
 
-	gitspaceConfig, err := c.gitspaceSvc.FindWithLatestInstance(ctx, spaceRef, identifier)
+	gitspaceConfig, err := c.gitspaceSvc.FindWithLatestInstanceWithSpacePath(ctx, spaceRef, identifier)
 	if err != nil {
 		return fmt.Errorf("failed to find gitspace config: %w", err)
 	}

app/api/controller/infraprovider/delete_config.go

@@ -37,5 +37,5 @@ func (c *Controller) DeleteConfig(
 	if err != nil {
 		return fmt.Errorf("failed to authorize: %w", err)
 	}
-	return c.infraproviderSvc.DeleteConfig(ctx, space, identifier)
+	return c.infraproviderSvc.DeleteConfig(ctx, space, identifier, true)
 }

app/api/controller/infraprovider/list.go

@@ -37,5 +37,8 @@ func (c *Controller) List(
 	if err != nil {
 		return nil, fmt.Errorf("failed to authorize: %w", err)
 	}
-	return c.infraproviderSvc.List(ctx, space)
+	filter := types.InfraProviderConfigFilter{
+		SpaceIDs: []int64{space.ID},
+	}
+	return c.infraproviderSvc.List(ctx, &filter)
 }

app/api/controller/space/controller.go

@@ -30,6 +30,7 @@ import (
 	"github.com/harness/gitness/app/services/exporter"
 	"github.com/harness/gitness/app/services/gitspace"
 	"github.com/harness/gitness/app/services/importer"
+	"github.com/harness/gitness/app/services/infraprovider"
 	"github.com/harness/gitness/app/services/instrument"
 	"github.com/harness/gitness/app/services/label"
 	"github.com/harness/gitness/app/services/publicaccess"
@@ -103,6 +104,7 @@ type Controller struct {
 	rulesSvc            *rules.Service
 	usageMetricStore    store.UsageMetricStore
 	repoIdentifierCheck check.RepoIdentifier
+	infraProviderSvc    *infraprovider.Service
 }
 
 func NewController(config *types.Config, tx dbtx.Transactor, urlProvider url.Provider,
@@ -117,6 +119,7 @@ func NewController(config *types.Config, tx dbtx.Transactor, urlProvider url.Pro
 	gitspaceSvc *gitspace.Service, labelSvc *label.Service,
 	instrumentation instrument.Service, executionStore store.ExecutionStore,
 	rulesSvc *rules.Service, usageMetricStore store.UsageMetricStore, repoIdentifierCheck check.RepoIdentifier,
+	infraProviderSvc *infraprovider.Service,
 ) *Controller {
 	return &Controller{
 		nestedSpacesEnabled: config.NestedSpacesEnabled,
@@ -149,6 +152,7 @@ func NewController(config *types.Config, tx dbtx.Transactor, urlProvider url.Pro
 		rulesSvc:            rulesSvc,
 		usageMetricStore:    usageMetricStore,
 		repoIdentifierCheck: repoIdentifierCheck,
+		infraProviderSvc:    infraProviderSvc,
 	}
 }
 

app/api/controller/space/list_gitspaces.go

@@ -22,6 +22,8 @@ import (
 	"github.com/harness/gitness/app/auth"
 	"github.com/harness/gitness/types"
 	"github.com/harness/gitness/types/enum"
+
+	"github.com/gotidy/ptr"
 )
 
 func (c *Controller) ListGitspaces(
@@ -42,10 +44,8 @@ func (c *Controller) ListGitspaces(
 
 	filter.UserIdentifier = session.Principal.UID
 	filter.SpaceIDs = []int64{space.ID}
-	deleted := false
+	filter.Deleted = ptr.Bool(false)
-	markedForDeletion := false
+	filter.MarkedForDeletion = ptr.Bool(false)
-	filter.Deleted = &deleted
-	filter.MarkedForDeletion = &markedForDeletion
 
-	return c.gitspaceSvc.ListGitspacesWithInstance(ctx, filter)
+	return c.gitspaceSvc.ListGitspacesWithInstance(ctx, filter, true)
 }

app/api/controller/space/soft_delete.go

@@ -97,8 +97,25 @@ func (c *Controller) softDeleteInnerInTx(
 		return nil, fmt.Errorf("failed to list space %d sub spaces recursively: %w", space.ID, err)
 	}
 
+	allSpaces := []*types.Space{space}
+	allSpaces = append(allSpaces, subSpaces...)
+
 	now := time.Now().UnixMilli()
 
+	if c.gitspaceSvc != nil {
+		err = c.gitspaceSvc.DeleteAllForSpaces(ctx, allSpaces)
+		if err != nil {
+			return nil, fmt.Errorf("failed to soft delete gitspaces of space %d: %w", space.ID, err)
+		}
+	}
+
+	if c.infraProviderSvc != nil {
+		err = c.infraProviderSvc.DeleteAllForSpaces(ctx, allSpaces)
+		if err != nil {
+			return nil, fmt.Errorf("failed to soft delete infra providers of space %d: %w", space.ID, err)
+		}
+	}
+
 	for _, space := range subSpaces {
 		_, err := c.spaceStore.FindForUpdate(ctx, space.ID)
 		if err != nil {
@@ -110,9 +127,11 @@ func (c *Controller) softDeleteInnerInTx(
 		}
 	}
 
-	err = c.softDeleteRepositoriesNoAuth(ctx, session, space.ID, now)
+	if c.repoStore != nil && c.repoCtrl != nil {
-	if err != nil {
+		err = c.softDeleteRepositoriesNoAuth(ctx, session, space.ID, now)
-		return nil, fmt.Errorf("failed to soft delete repositories of space %d: %w", space.ID, err)
+		if err != nil {
+			return nil, fmt.Errorf("failed to soft delete repositories of space %d: %w", space.ID, err)
+		}
 	}
 
 	if err = c.spaceStore.SoftDelete(ctx, space, now); err != nil {

app/api/controller/space/wire.go

@@ -21,6 +21,7 @@ import (
 	"github.com/harness/gitness/app/services/exporter"
 	"github.com/harness/gitness/app/services/gitspace"
 	"github.com/harness/gitness/app/services/importer"
+	infraprovider2 "github.com/harness/gitness/app/services/infraprovider"
 	"github.com/harness/gitness/app/services/instrument"
 	"github.com/harness/gitness/app/services/label"
 	"github.com/harness/gitness/app/services/publicaccess"
@@ -55,6 +56,7 @@ func ProvideController(config *types.Config, tx dbtx.Transactor, urlProvider url
 	auditService audit.Service, gitspaceService *gitspace.Service,
 	labelSvc *label.Service, instrumentation instrument.Service, executionStore store.ExecutionStore,
 	rulesSvc *rules.Service, usageMetricStore store.UsageMetricStore, repoIdentifierCheck check.RepoIdentifier,
+	infraProviderSvc *infraprovider2.Service,
 ) *Controller {
 	return NewController(config, tx, urlProvider,
 		sseStreamer, identifierCheck, authorizer,
@@ -67,5 +69,6 @@ func ProvideController(config *types.Config, tx dbtx.Transactor, urlProvider url
 		auditService, gitspaceService,
 		labelSvc, instrumentation, executionStore,
 		rulesSvc, usageMetricStore, repoIdentifierCheck,
+		infraProviderSvc,
 	)
 }

app/api/handler/gitspace/list_all_gitspaces.go

@@ -30,7 +30,7 @@ func HandleListAllGitspaces(gitspaceCtrl *gitspace.Controller) http.HandlerFunc
 		session, _ := request.AuthSessionFrom(ctx)
 		deleted := false
 		markedForDeletion := false
-		filter := &types.GitspaceFilter{
+		filter := types.GitspaceFilter{
 			GitspaceInstanceFilter: types.GitspaceInstanceFilter{UserIdentifier: session.Principal.UID},
 			Deleted:                &deleted,
 			MarkedForDeletion:      &markedForDeletion,

app/events/gitspace/events.go

@@ -45,11 +45,11 @@ func (r *Reporter) EmitGitspaceEvent(ctx context.Context, event events.EventType
 	}
 	eventID, err := events.ReporterSendEvent(r.innerReporter, ctx, event, payload)
 	if err != nil {
-		log.Ctx(ctx).Err(err).Msgf("failed to send %v event", event)
+		log.Ctx(ctx).Err(err).Msgf("failed to send %s event", event)
 		return
 	}
 
-	log.Ctx(ctx).Debug().Msgf("reported %v event with id '%s'", event, eventID)
+	log.Ctx(ctx).Debug().Msgf("reported %s event with id '%s'", event, eventID)
 }
 
 func (r *Reader) RegisterGitspaceEvent(

app/events/gitspacedelete/category.go

@@ -0,0 +1,20 @@
+// Copyright 2023 Harness, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package events
+
+const (
+	// category defines the event category used for this package.
+	category = "gitspace_delete"
+)

app/events/gitspacedelete/events.go

@@ -0,0 +1,65 @@
+// Copyright 2023 Harness, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package events
+
+import (
+	"context"
+
+	"github.com/harness/gitness/events"
+
+	"github.com/rs/zerolog/log"
+)
+
+const (
+	GitspaceDeleteEvent events.EventType = "gitspace_delete_event"
+)
+
+type (
+	GitspaceDeleteEventPayload struct {
+		GitspaceConfigIdentifier string `json:"gitspace_config_identifier"`
+		SpaceID                  int64  `json:"space_id"`
+	}
+)
+
+func (r *Reporter) EmitGitspaceDeleteEvent(
+	ctx context.Context,
+	event events.EventType,
+	payload *GitspaceDeleteEventPayload,
+) {
+	if payload == nil {
+		return
+	}
+
+	if event != GitspaceDeleteEvent {
+		log.Ctx(ctx).Error().Msgf("event type should be %s, got %s, aborting emission, payload: %+v",
+			GitspaceDeleteEvent, event, payload)
+		return
+	}
+
+	eventID, err := events.ReporterSendEvent(r.innerReporter, ctx, event, payload)
+	if err != nil {
+		log.Ctx(ctx).Err(err).Msgf("failed to send %s event", event)
+		return
+	}
+
+	log.Ctx(ctx).Debug().Msgf("reported %s event with id '%s'", event, eventID)
+}
+
+func (r *Reader) RegisterGitspaceDeleteEvent(
+	fn events.HandlerFunc[*GitspaceDeleteEventPayload],
+	opts ...events.HandlerOption,
+) error {
+	return events.ReaderRegisterEvent(r.innerReader, GitspaceDeleteEvent, fn, opts...)
+}

app/events/gitspacedelete/reader.go

@@ -0,0 +1,38 @@
+// Copyright 2023 Harness, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package events
+
+import (
+	"github.com/harness/gitness/events"
+)
+
+func NewReaderFactory(eventsSystem *events.System) (*events.ReaderFactory[*Reader], error) {
+	readerFactoryFunc := func(innerReader *events.GenericReader) (*Reader, error) {
+		return &Reader{
+			innerReader: innerReader,
+		}, nil
+	}
+
+	return events.NewReaderFactory(eventsSystem, category, readerFactoryFunc)
+}
+
+// Reader is the event reader for this package.
+type Reader struct {
+	innerReader *events.GenericReader
+}
+
+func (r *Reader) Configure(opts ...events.ReaderOption) {
+	r.innerReader.Configure(opts...)
+}

app/events/gitspacedelete/reporter.go

@@ -0,0 +1,37 @@
+// Copyright 2023 Harness, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package events
+
+import (
+	"errors"
+
+	"github.com/harness/gitness/events"
+)
+
+// Reporter is the event reporter for this package.
+type Reporter struct {
+	innerReporter *events.GenericReporter
+}
+
+func NewReporter(eventsSystem *events.System) (*Reporter, error) {
+	innerReporter, err := events.NewReporter(eventsSystem, category)
+	if err != nil {
+		return nil, errors.New("failed to create new GenericReporter from event system")
+	}
+
+	return &Reporter{
+		innerReporter: innerReporter,
+	}, nil
+}

app/events/gitspacedelete/wire.go

@@ -0,0 +1,35 @@
+// Copyright 2023 Harness, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package events
+
+import (
+	"github.com/harness/gitness/events"
+
+	"github.com/google/wire"
+)
+
+// WireSet provides a wire set for this package.
+var WireSet = wire.NewSet(
+	ProvideReaderFactory,
+	ProvideReporter,
+)
+
+func ProvideReaderFactory(eventsSystem *events.System) (*events.ReaderFactory[*Reader], error) {
+	return NewReaderFactory(eventsSystem)
+}
+
+func ProvideReporter(eventsSystem *events.System) (*Reporter, error) {
+	return NewReporter(eventsSystem)
+}

app/gitspace/infrastructure/find.go

@@ -92,8 +92,8 @@ func (i InfraProvisioner) paramsForProvisioningTypeNew(
 	ctx context.Context,
 	gitspaceConfig types.GitspaceConfig,
 ) ([]types.InfraProviderParameter, map[string]any, error) {
-	infraProvisionedLatest, err := i.infraProvisionedStore.FindLatestByGitspaceInstanceID(
+	infraProvisionedLatest, err := i.infraProvisionedStore.FindLatestByGitspaceInstanceID(ctx,
-		ctx, gitspaceConfig.GitspaceInstance.ID)
+		gitspaceConfig.GitspaceInstance.ID)
 	if err != nil {
 		return nil, nil, fmt.Errorf(
 			"could not find latest infra provisioned entity for instance %d: %w",
@@ -107,7 +107,7 @@ func (i InfraProvisioner) paramsForProvisioningTypeNew(
 		return nil, nil, err
 	}
 	infraProviderConfig, err := i.infraProviderConfigStore.Find(ctx,
-		gitspaceConfig.InfraProviderResource.InfraProviderConfigID)
+		gitspaceConfig.InfraProviderResource.InfraProviderConfigID, true)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -174,7 +174,7 @@ func (i InfraProvisioner) getConfigFromResource(
 	ctx context.Context,
 	infraProviderResource types.InfraProviderResource,
 ) (*types.InfraProviderConfig, error) {
-	config, err := i.infraProviderConfigStore.Find(ctx, infraProviderResource.InfraProviderConfigID)
+	config, err := i.infraProviderConfigStore.Find(ctx, infraProviderResource.InfraProviderConfigID, true)
 	if err != nil {
 		return nil, fmt.Errorf(
 			"unable to get infra provider details for ID %d: %w",
@@ -278,7 +278,7 @@ func (i InfraProvisioner) configMetadata(
 	ctx context.Context,
 	infraProviderResource types.InfraProviderResource,
 ) (map[string]any, error) {
-	infraProviderConfig, err := i.infraProviderConfigStore.Find(ctx, infraProviderResource.InfraProviderConfigID)
+	infraProviderConfig, err := i.infraProviderConfigStore.Find(ctx, infraProviderResource.InfraProviderConfigID, true)
 	if err != nil {
 		return nil, err
 	}

app/services/gitspace/action_delete.go

@@ -19,12 +19,47 @@ import (
 	"fmt"
 	"time"
 
+	events "github.com/harness/gitness/app/events/gitspacedelete"
 	"github.com/harness/gitness/types"
 	"github.com/harness/gitness/types/enum"
 
 	"github.com/rs/zerolog/log"
 )
 
+func (c *Service) DeleteGitspaceByIdentifier(ctx context.Context, spaceRef string, identifier string) error {
+	gitspaceConfig, err := c.FindWithLatestInstanceWithSpacePath(ctx, spaceRef, identifier)
+	if err != nil {
+		log.Err(err).Msgf("Failed to find latest gitspace config : %s", identifier)
+		return err
+	}
+	return c.deleteGitspace(ctx, gitspaceConfig)
+}
+
+func (c *Service) deleteGitspace(ctx context.Context, gitspaceConfig *types.GitspaceConfig) error {
+	if gitspaceConfig.GitspaceInstance == nil ||
+		gitspaceConfig.GitspaceInstance.State == enum.GitspaceInstanceStateUninitialized {
+		gitspaceConfig.IsMarkedForDeletion = true
+		gitspaceConfig.IsDeleted = true
+		if err := c.UpdateConfig(ctx, gitspaceConfig); err != nil {
+			return fmt.Errorf("failed to mark gitspace config as deleted: %w", err)
+		}
+
+		return nil
+	}
+
+	// mark can_delete for gitconfig as true so that if delete operation fails, cron job can clean up resources.
+	gitspaceConfig.IsMarkedForDeletion = true
+	if err := c.UpdateConfig(ctx, gitspaceConfig); err != nil {
+		return fmt.Errorf("failed to mark gitspace config is_marked_for_deletion column: %w", err)
+	}
+
+	c.gitspaceDeleteEventReporter.EmitGitspaceDeleteEvent(ctx, events.GitspaceDeleteEvent,
+		&events.GitspaceDeleteEventPayload{GitspaceConfigIdentifier: gitspaceConfig.Identifier,
+			SpaceID: gitspaceConfig.SpaceID})
+
+	return nil
+}
+
 func (c *Service) RemoveGitspace(ctx context.Context, config types.GitspaceConfig, canDeleteUserData bool) error {
 	if config.GitspaceInstance.State == enum.GitSpaceInstanceStateCleaning &&
 		time.Since(time.UnixMilli(config.GitspaceInstance.Updated)).Milliseconds() <=

app/services/gitspace/actions.go

@@ -170,7 +170,7 @@ func (c *Service) EmitGitspaceConfigEvent(
 	config types.GitspaceConfig,
 	eventType enum.GitspaceEventType,
 ) {
-	c.eventReporter.EmitGitspaceEvent(ctx, events.GitspaceEvent, &events.GitspaceEventPayload{
+	c.gitspaceEventReporter.EmitGitspaceEvent(ctx, events.GitspaceEvent, &events.GitspaceEventPayload{
 		QueryKey:   config.Identifier,
 		EntityID:   config.ID,
 		EntityType: enum.GitspaceEntityTypeGitspaceConfig,

app/services/gitspace/delete_all_for_spaces.go

@@ -0,0 +1,58 @@
+// Copyright 2023 Harness, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package gitspace
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/harness/gitness/types"
+
+	"github.com/gotidy/ptr"
+	"github.com/rs/zerolog/log"
+)
+
+func (c *Service) DeleteAllForSpaces(ctx context.Context, spaces []*types.Space) error {
+	spaceIDs := make([]int64, 0, len(spaces))
+	for _, space := range spaces {
+		spaceIDs = append(spaceIDs, space.ID)
+	}
+
+	log.Debug().Msgf("Deleting all gitspaces for spaces %+v", spaceIDs)
+
+	var gitspaceFilter = types.GitspaceFilter{}
+	gitspaceFilter.SpaceIDs = spaceIDs
+	gitspaceFilter.Deleted = ptr.Bool(false)
+	gitspaceFilter.MarkedForDeletion = ptr.Bool(false)
+
+	gitspaces, _, _, err := c.ListGitspacesWithInstance(ctx, gitspaceFilter, false)
+	if err != nil {
+		return fmt.Errorf("error while listing gitspaces with instance before deleting all for spaces: %w", err)
+	}
+
+	for _, gitspace := range gitspaces {
+		log.Debug().Msgf("Deleting gitspace %s for space %d", gitspace.Identifier, gitspace.SpaceID)
+		err = c.deleteGitspace(ctx, gitspace)
+		if err != nil {
+			return fmt.Errorf("error while deleting gitspace %s while deleting all for spaces: %w",
+				gitspace.Identifier, err)
+		}
+		log.Debug().Msgf("Deleted gitspace %s for space %d", gitspace.Identifier, gitspace.SpaceID)
+	}
+
+	log.Debug().Msgf("Deleted all gitspaces for spaces %+v", spaceIDs)
+
+	return nil
+}

app/services/gitspace/find.go

@@ -24,26 +24,36 @@ import (
 	"github.com/harness/gitness/store/database/dbtx"
 	"github.com/harness/gitness/types"
 	"github.com/harness/gitness/types/enum"
+
+	"github.com/rs/zerolog/log"
 )
 
-func (c *Service) FindWithLatestInstance(
+func (c *Service) FindWithLatestInstanceWithSpacePath(
 	ctx context.Context,
-	spaceRef string,
+	spacePath string,
 	identifier string,
 ) (*types.GitspaceConfig, error) {
-	space, err := c.spaceFinder.FindByRef(ctx, spaceRef)
+	space, err := c.spaceFinder.FindByRef(ctx, spacePath)
 	if err != nil {
 		return nil, fmt.Errorf("failed to find space: %w", err)
 	}
+	return c.FindWithLatestInstance(ctx, space.ID, spacePath, identifier)
+}
 
+func (c *Service) FindWithLatestInstance(
+	ctx context.Context,
+	spaceID int64,
+	spacePath string,
+	identifier string,
+) (*types.GitspaceConfig, error) {
 	var gitspaceConfigResult *types.GitspaceConfig
 	txErr := c.tx.WithTx(ctx, func(ctx context.Context) error {
-		gitspaceConfig, err := c.gitspaceConfigStore.FindByIdentifier(ctx, space.ID, identifier)
+		gitspaceConfig, err := c.gitspaceConfigStore.FindByIdentifier(ctx, spaceID, identifier)
 		if err != nil {
 			return fmt.Errorf("failed to find gitspace config: %w", err)
 		}
 		gitspaceConfigResult = gitspaceConfig
-		if err = c.setInstance(ctx, gitspaceConfigResult, space); err != nil {
+		if err = c.setInstance(ctx, gitspaceConfigResult); err != nil {
 			return err
 		}
 		return nil
@@ -52,19 +62,28 @@ func (c *Service) FindWithLatestInstance(
 		return nil, txErr
 	}
 	gitspaceConfigResult.BranchURL = c.GetBranchURL(ctx, gitspaceConfigResult)
+
+	if spacePath == "" {
+		space, err := c.spaceFinder.FindByID(ctx, spaceID)
+		if err != nil {
+			log.Warn().Err(err).Msgf("failed to find space path for id %d", spaceID)
+		} else {
+			spacePath = space.Path
+		}
+	}
+
+	gitspaceConfigResult.SpacePath = spacePath
 	return gitspaceConfigResult, nil
 }
 
 func (c *Service) setInstance(
 	ctx context.Context,
 	gitspaceConfig *types.GitspaceConfig,
-	space *types.SpaceCore,
 ) error {
 	instance, err := c.gitspaceInstanceStore.FindLatestByGitspaceConfigID(ctx, gitspaceConfig.ID)
 	if err != nil && !errors.Is(err, store.ErrResourceNotFound) {
 		return err
 	}
-	gitspaceConfig.SpacePath = space.Path
 	if instance != nil {
 		gitspaceConfig.GitspaceInstance = instance
 		instance.SpacePath = gitspaceConfig.SpacePath
@@ -95,7 +114,8 @@ func (c *Service) FindWithLatestInstanceByID(
 		if err != nil {
 			return fmt.Errorf("failed to find space: %w", err)
 		}
-		return c.setInstance(ctx, gitspaceConfigResult, space)
+		gitspaceConfigResult.SpacePath = space.Path
+		return c.setInstance(ctx, gitspaceConfigResult)
 	}, dbtx.TxDefaultReadOnly)
 	if txErr != nil {
 		return nil, txErr
@@ -134,21 +154,14 @@ func (c *Service) FindAll(
 func (c *Service) FindInstanceByIdentifier(
 	ctx context.Context,
 	identifier string,
-	spaceRef string,
 ) (*types.GitspaceInstance, error) {
 	var gitspaceInstanceResult *types.GitspaceInstance
 	txErr := c.tx.WithTx(ctx, func(ctx context.Context) error {
-		space, err := c.spaceFinder.FindByRef(ctx, spaceRef)
-		if err != nil {
-			return fmt.Errorf("failed to find space: %w", err)
-		}
 		gitspaceInstance, err := c.gitspaceInstanceStore.FindByIdentifier(ctx, identifier)
 		if err != nil {
 			return fmt.Errorf("failed to find gitspace instance: %w", err)
 		}
 		gitspaceInstanceResult = gitspaceInstance
-		gitspaceInstanceResult.SpacePath = space.Path
-
 		return nil
 	}, dbtx.TxDefaultReadOnly)
 	if txErr != nil {

app/services/gitspace/gitspace.go

@@ -20,6 +20,7 @@ import (
 	"strconv"
 
 	gitspaceevents "github.com/harness/gitness/app/events/gitspace"
+	gitspacedeleteevents "github.com/harness/gitness/app/events/gitspacedelete"
 	"github.com/harness/gitness/app/gitspace/orchestrator"
 	"github.com/harness/gitness/app/gitspace/scm"
 	"github.com/harness/gitness/app/services/infraprovider"
@@ -42,41 +43,47 @@ func NewService(
 	orchestrator orchestrator.Orchestrator,
 	scm *scm.SCM,
 	config *types.Config,
+	gitspaceDeleteEventReporter *gitspacedeleteevents.Reporter,
 ) *Service {
 	return &Service{
-		tx:                    tx,
+		tx:                          tx,
-		gitspaceConfigStore:   gitspaceStore,
+		gitspaceConfigStore:         gitspaceStore,
-		gitspaceInstanceStore: gitspaceInstanceStore,
+		gitspaceInstanceStore:       gitspaceInstanceStore,
-		eventReporter:         eventReporter,
+		gitspaceEventReporter:       eventReporter,
-		gitspaceEventStore:    gitspaceEventStore,
+		gitspaceEventStore:          gitspaceEventStore,
-		spaceFinder:           spaceFinder,
+		spaceFinder:                 spaceFinder,
-		infraProviderSvc:      infraProviderSvc,
+		infraProviderSvc:            infraProviderSvc,
-		orchestrator:          orchestrator,
+		orchestrator:                orchestrator,
-		scm:                   scm,
+		scm:                         scm,
-		config:                config,
+		config:                      config,
+		gitspaceDeleteEventReporter: gitspaceDeleteEventReporter,
 	}
 }
 
 type Service struct {
-	gitspaceConfigStore   store.GitspaceConfigStore
+	gitspaceConfigStore         store.GitspaceConfigStore
-	gitspaceInstanceStore store.GitspaceInstanceStore
+	gitspaceInstanceStore       store.GitspaceInstanceStore
-	eventReporter         *gitspaceevents.Reporter
+	gitspaceEventReporter       *gitspaceevents.Reporter
-	gitspaceEventStore    store.GitspaceEventStore
+	gitspaceDeleteEventReporter *gitspacedeleteevents.Reporter
-	spaceFinder           refcache.SpaceFinder
+	gitspaceEventStore          store.GitspaceEventStore
-	tx                    dbtx.Transactor
+	spaceFinder                 refcache.SpaceFinder
-	infraProviderSvc      *infraprovider.Service
+	tx                          dbtx.Transactor
-	orchestrator          orchestrator.Orchestrator
+	infraProviderSvc            *infraprovider.Service
-	scm                   *scm.SCM
+	orchestrator                orchestrator.Orchestrator
-	config                *types.Config
+	scm                         *scm.SCM
+	config                      *types.Config
 }
 
 func (c *Service) ListGitspacesWithInstance(
 	ctx context.Context,
 	filter types.GitspaceFilter,
+	useTransaction bool,
 ) ([]*types.GitspaceConfig, int64, int64, error) {
 	var gitspaceConfigs []*types.GitspaceConfig
 	var filterCount, allGitspacesCount int64
-	err := c.tx.WithTx(ctx, func(ctx context.Context) (err error) {
+	var err error
+
+	findFunc := func(ctx context.Context) (err error) {
 		gitspaceConfigs, err = c.gitspaceConfigStore.ListWithLatestInstance(ctx, &filter)
 		if err != nil {
 			return fmt.Errorf("failed to list gitspace configs: %w", err)
@@ -101,7 +108,14 @@ func (c *Service) ListGitspacesWithInstance(
 		}
 
 		return nil
-	}, dbtx.TxDefaultReadOnly)
+	}
+
+	if useTransaction {
+		err = c.tx.WithTx(ctx, findFunc, dbtx.TxDefaultReadOnly)
+	} else {
+		err = findFunc(ctx)
+	}
+
 	if err != nil {
 		return nil, 0, 0, err
 	}

app/services/gitspace/wire.go

@@ -16,6 +16,7 @@ package gitspace
 
 import (
 	gitspaceevents "github.com/harness/gitness/app/events/gitspace"
+	gitspacedeleteevents "github.com/harness/gitness/app/events/gitspacedelete"
 	"github.com/harness/gitness/app/gitspace/orchestrator"
 	"github.com/harness/gitness/app/gitspace/scm"
 	"github.com/harness/gitness/app/services/infraprovider"
@@ -42,7 +43,8 @@ func ProvideGitspace(
 	orchestrator orchestrator.Orchestrator,
 	scm *scm.SCM,
 	config *types.Config,
+	gitspaceDeleteEventReporter *gitspacedeleteevents.Reporter,
 ) *Service {
 	return NewService(tx, gitspaceStore, gitspaceInstanceStore, eventReporter,
-		gitspaceEventStore, spaceFinder, infraProviderSvc, orchestrator, scm, config)
+		gitspaceEventStore, spaceFinder, infraProviderSvc, orchestrator, scm, config, gitspaceDeleteEventReporter)
 }

app/services/gitspacedeleteevent/handler.go

@@ -0,0 +1,48 @@
+// Copyright 2023 Harness, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package gitspacedeleteevent
+
+import (
+	"context"
+	"fmt"
+
+	gitspacedeleteevents "github.com/harness/gitness/app/events/gitspacedelete"
+	"github.com/harness/gitness/events"
+
+	"github.com/rs/zerolog/log"
+)
+
+func (s *Service) handleGitspaceDeleteEvent(
+	ctx context.Context,
+	event *events.Event[*gitspacedeleteevents.GitspaceDeleteEventPayload],
+) error {
+	log.Debug().Msgf("handling gitspace delete event with payload: %+v", event.Payload)
+	gitspaceConfigIdentifier := event.Payload.GitspaceConfigIdentifier
+	spaceID := event.Payload.SpaceID
+	gitspaceConfig, err := s.gitspaceSvc.FindWithLatestInstance(ctx, spaceID, "", gitspaceConfigIdentifier)
+	if err != nil {
+		return fmt.Errorf("failed to find gitspace config %s for space %d while handling delete event: %w",
+			gitspaceConfigIdentifier, spaceID, err)
+	}
+
+	err = s.gitspaceSvc.RemoveGitspace(ctx, *gitspaceConfig, true)
+	if err != nil {
+		// NOTE: No need to retry from the event handler. The background job will take care.
+		log.Debug().Err(err).Msgf("unable to delete gitspace: " + gitspaceConfigIdentifier)
+	}
+
+	log.Debug().Msgf("handled gitspace delete event with payload: %+v", event.Payload)
+	return nil
+}

app/services/gitspacedeleteevent/service.go

@@ -0,0 +1,89 @@
+// Copyright 2023 Harness, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package gitspacedeleteevent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	gitspacedeleteevents "github.com/harness/gitness/app/events/gitspacedelete"
+	"github.com/harness/gitness/app/services/gitspace"
+	"github.com/harness/gitness/events"
+	"github.com/harness/gitness/stream"
+)
+
+const groupGitspaceDeleteEvents = "gitness:gitspace_delete"
+
+type Config struct {
+	EventReaderName string
+	Concurrency     int
+	MaxRetries      int
+	TimeoutInMins   int
+}
+
+func (c *Config) Sanitize() error {
+	if c.EventReaderName == "" {
+		return errors.New("config.EventReaderName is required")
+	}
+	if c.Concurrency < 1 {
+		return errors.New("config.Concurrency has to be a positive number")
+	}
+	if c.MaxRetries < 0 {
+		return errors.New("config.MaxRetries can't be negative")
+	}
+	return nil
+}
+
+type Service struct {
+	config      *Config
+	gitspaceSvc *gitspace.Service
+}
+
+func NewService(
+	ctx context.Context,
+	config *Config,
+	gitspaceDeleteEventReaderFactory *events.ReaderFactory[*gitspacedeleteevents.Reader],
+	gitspaceSvc *gitspace.Service,
+) (*Service, error) {
+	if err := config.Sanitize(); err != nil {
+		return nil, fmt.Errorf("provided gitspace event service config is invalid: %w", err)
+	}
+	service := &Service{
+		config:      config,
+		gitspaceSvc: gitspaceSvc,
+	}
+
+	_, err := gitspaceDeleteEventReaderFactory.Launch(ctx, groupGitspaceDeleteEvents, config.EventReaderName,
+		func(r *gitspacedeleteevents.Reader) error {
+			var idleTimeout = time.Duration(config.TimeoutInMins) * time.Minute
+			r.Configure(
+				stream.WithConcurrency(config.Concurrency),
+				stream.WithHandlerOptions(
+					stream.WithIdleTimeout(idleTimeout),
+					stream.WithMaxRetries(config.MaxRetries),
+				))
+
+			_ = r.RegisterGitspaceDeleteEvent(service.handleGitspaceDeleteEvent)
+
+			return nil
+		})
+	if err != nil {
+		return nil, fmt.Errorf("failed to launch gitspace delete event reader: %w", err)
+	}
+
+	return service, nil
+}

app/services/gitspacedeleteevent/wire.go

@@ -0,0 +1,43 @@
+// Copyright 2023 Harness, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package gitspacedeleteevent
+
+import (
+	"context"
+
+	gitspacedeleteevents "github.com/harness/gitness/app/events/gitspacedelete"
+	"github.com/harness/gitness/app/services/gitspace"
+	"github.com/harness/gitness/events"
+
+	"github.com/google/wire"
+)
+
+// WireSet provides a wire set for this package.
+var WireSet = wire.NewSet(
+	ProvideService,
+)
+
+func ProvideService(ctx context.Context,
+	config *Config,
+	gitspaceDeleteEventReaderFactory *events.ReaderFactory[*gitspacedeleteevents.Reader],
+	gitspaceSvc *gitspace.Service,
+) (*Service, error) {
+	return NewService(
+		ctx,
+		config,
+		gitspaceDeleteEventReaderFactory,
+		gitspaceSvc,
+	)
+}

app/services/gitspaceinfraevent/handler.go

@@ -35,8 +35,7 @@ func (s *Service) handleGitspaceInfraResumeEvent(
 	payload := event.Payload
 	ctxWithTimedOut, cancel := context.WithTimeout(ctx, time.Duration(s.config.TimeoutInMins)*time.Minute)
 	defer cancel()
-	config, fetchErr := s.getConfig(
+	config, fetchErr := s.getConfig(ctxWithTimedOut, payload.Infra.SpaceID, payload.Infra.GitspaceConfigIdentifier)
-		ctxWithTimedOut, payload.Infra.SpacePath, payload.Infra.GitspaceConfigIdentifier)
 	if fetchErr != nil {
 		return fetchErr
 	}
@@ -46,7 +45,6 @@ func (s *Service) handleGitspaceInfraResumeEvent(
 		gitspaceInstance, err := s.gitspaceSvc.FindInstanceByIdentifier(
 			ctxWithTimedOut,
 			payload.Infra.GitspaceInstanceIdentifier,
-			payload.Infra.SpacePath,
 		)
 		if err != nil {
 			return fmt.Errorf("failed to fetch gitspace instance: %w", err)
@@ -127,10 +125,10 @@ func (s *Service) handleGitspaceInfraResumeEvent(
 
 func (s *Service) getConfig(
 	ctx context.Context,
-	spaceRef string,
+	spaceID int64,
 	identifier string,
 ) (*types.GitspaceConfig, error) {
-	config, err := s.gitspaceSvc.FindWithLatestInstance(ctx, spaceRef, identifier)
+	config, err := s.gitspaceSvc.FindWithLatestInstance(ctx, spaceID, "", identifier)
 	if err != nil {
 		return nil, fmt.Errorf(
 			"failed to find gitspace config during infra event handling, identifier %s: %w", identifier, err)

app/services/gitspaceoperationsevent/handler.go

@@ -50,7 +50,6 @@ func (s *Service) handleGitspaceOperationsEvent(
 		gitspaceInstance, err := s.gitspaceSvc.FindInstanceByIdentifier(
 			ctxWithTimedOut,
 			payload.Infra.GitspaceInstanceIdentifier,
-			payload.Infra.SpacePath,
 		)
 		if err != nil {
 			return fmt.Errorf("failed to fetch gitspace instance: %w", err)
@@ -131,7 +130,7 @@ func (s *Service) getConfig(
 	spaceRef string,
 	identifier string,
 ) (*types.GitspaceConfig, error) {
-	config, err := s.gitspaceSvc.FindWithLatestInstance(ctx, spaceRef, identifier)
+	config, err := s.gitspaceSvc.FindWithLatestInstanceWithSpacePath(ctx, spaceRef, identifier)
 	if err != nil {
 		return nil, fmt.Errorf(
 			"failed to find gitspace config during infra event handling, identifier %s: %w", identifier, err)

app/services/infraprovider/create_config.go

@@ -64,8 +64,8 @@ func (c *Service) fetchExistingConfigs(
 	infraProviderConfig *types.InfraProviderConfig,
 ) ([]*types.InfraProviderConfig, error) {
 	existingConfigs, err := c.infraProviderConfigStore.List(ctx, &types.InfraProviderConfigFilter{
-		SpaceID: infraProviderConfig.SpaceID,
+		SpaceIDs: []int64{infraProviderConfig.SpaceID},
-		Type:    infraProviderConfig.Type,
+		Type:     infraProviderConfig.Type,
 	})
 	if err != nil {
 		return nil, fmt.Errorf("failed to find existing infraprovider config for type %s & space %d: %w",

app/services/infraprovider/delete_all_for_spaces.go

@@ -0,0 +1,74 @@
+// Copyright 2023 Harness, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package infraprovider
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/harness/gitness/types"
+
+	"github.com/rs/zerolog/log"
+)
+
+func (c *Service) DeleteAllForSpaces(ctx context.Context, spaces []*types.Space) error {
+	spaceIDsMap := make(map[int64]*types.SpaceCore)
+	spaceIDs := make([]int64, 0, len(spaces))
+	for _, space := range spaces {
+		spaceIDs = append(spaceIDs, space.ID)
+		spaceIDsMap[space.ID] = space.Core()
+	}
+
+	log.Debug().Msgf("Deleting all infra providers for spaces %+v", spaceIDs)
+
+	infraProviderConfigFilter := types.InfraProviderConfigFilter{SpaceIDs: spaceIDs}
+	infraProviderConfigs, err := c.List(ctx, &infraProviderConfigFilter)
+	if err != nil {
+		return fmt.Errorf("error while listing infra provider entities before deleting all for spaces: %w", err)
+	}
+
+	for _, infraProviderConfig := range infraProviderConfigs {
+		for _, infraProviderResource := range infraProviderConfig.Resources {
+			log.Debug().Msgf("Deleting infra resource %s for space %d", infraProviderResource.UID,
+				infraProviderResource.SpaceID)
+
+			err = c.DeleteResource(ctx, infraProviderConfig.SpaceID, infraProviderConfig.Identifier,
+				infraProviderResource.UID, false)
+			if err != nil {
+				return fmt.Errorf("error while deleting infra resource %s while deleting all for spaces: %w",
+					infraProviderResource.UID, err)
+			}
+
+			log.Debug().Msgf("Deleted infra resource %s for space %d", infraProviderResource.UID,
+				infraProviderResource.SpaceID)
+		}
+
+		log.Debug().Msgf("Deleting infra config %s for space %d", infraProviderConfig.Identifier,
+			infraProviderConfig.SpaceID)
+
+		err = c.DeleteConfig(ctx, spaceIDsMap[infraProviderConfig.SpaceID], infraProviderConfig.Identifier, false)
+		if err != nil {
+			return fmt.Errorf("error while deleting infra config %s while deleting all for spaces: %w",
+				infraProviderConfig.Identifier, err)
+		}
+
+		log.Debug().Msgf("Deleted infra config %s for space %d", infraProviderConfig.Identifier,
+			infraProviderConfig.SpaceID)
+	}
+
+	log.Debug().Msgf("Deleted all infra providers for spaces %+v", spaceIDs)
+
+	return nil
+}

app/services/infraprovider/delete_config.go

@@ -23,8 +23,13 @@ import (
 	"github.com/harness/gitness/types"
 )
 
-func (c *Service) DeleteConfig(ctx context.Context, space *types.SpaceCore, identifier string) error {
+func (c *Service) DeleteConfig(
-	err := c.tx.WithTx(ctx, func(ctx context.Context) error {
+	ctx context.Context,
+	space *types.SpaceCore,
+	identifier string,
+	useTransaction bool,
+) error {
+	deleteFunc := func(ctx context.Context) error {
 		infraProviderConfig, err := c.Find(ctx, space, identifier)
 		if err != nil {
 			return fmt.Errorf("could not find infra provider config %s to delete: %w", identifier, err)
@@ -34,9 +39,9 @@ func (c *Service) DeleteConfig(ctx context.Context, space *types.SpaceCore, iden
 				"not allowed until all resources are deleted.", len(infraProviderConfig.Resources))
 		}
 		return c.infraProviderConfigStore.Delete(ctx, infraProviderConfig.ID)
-	})
-	if err != nil {
-		return err
 	}
-	return nil
+	if useTransaction {
+		return c.tx.WithTx(ctx, deleteFunc)
+	}
+	return deleteFunc(ctx)
 }

app/services/infraprovider/delete_resource.go

@@ -27,8 +27,10 @@ func (c *Service) DeleteResource(
 	spaceID int64,
 	infraProviderConfigIdentifier string,
 	identifier string,
+	useTransaction bool,
 ) error {
-	err := c.tx.WithTx(ctx, func(ctx context.Context) error {
+	var err error
+	deleteFunc := func(ctx context.Context) error {
 		infraProviderConfig, err := c.infraProviderConfigStore.FindByIdentifier(ctx, spaceID,
 			infraProviderConfigIdentifier)
 		if err != nil {
@@ -56,7 +58,13 @@ func (c *Service) DeleteResource(
 		}
 
 		return c.infraProviderResourceStore.Delete(ctx, infraProviderResource.ID)
-	})
+	}
+
+	if useTransaction {
+		err = c.tx.WithTx(ctx, deleteFunc)
+	} else {
+		err = deleteFunc(ctx)
+	}
 
 	if err != nil {
 		return fmt.Errorf("failed to complete txn for deleting the infra resource %s: %w", identifier, err)

app/services/infraprovider/list.go

@@ -23,16 +23,18 @@ import (
 
 func (c *Service) List(
 	ctx context.Context,
-	space *types.SpaceCore,
+	filter *types.InfraProviderConfigFilter,
 ) ([]*types.InfraProviderConfig, error) {
-	infraProviderConfigs, err := c.infraProviderConfigStore.List(ctx, &types.InfraProviderConfigFilter{
+	infraProviderConfigs, err := c.infraProviderConfigStore.List(ctx, filter)
-		SpaceID: space.ID,
-	})
 	if err != nil {
 		return nil, fmt.Errorf("failed to list infraprovider configs: %w", err)
 	}
 
 	for _, infraProviderConfig := range infraProviderConfigs {
+		space, err := c.spaceFinder.FindByID(ctx, infraProviderConfig.SpaceID)
+		if err != nil {
+			return nil, fmt.Errorf("failed to list infraprovider configs: %w", err)
+		}
 		err = c.populateDetails(ctx, space.Path, infraProviderConfig)
 		if err != nil {
 			return nil, err

app/services/wire.go

@@ -17,6 +17,7 @@ package services
 import (
 	"github.com/harness/gitness/app/services/cleanup"
 	"github.com/harness/gitness/app/services/gitspace"
+	"github.com/harness/gitness/app/services/gitspacedeleteevent"
 	"github.com/harness/gitness/app/services/gitspaceevent"
 	"github.com/harness/gitness/app/services/gitspaceinfraevent"
 	"github.com/harness/gitness/app/services/gitspaceoperationsevent"
@@ -63,10 +64,12 @@ type GitspaceServices struct {
 	gitspace                   *gitspace.Service
 	gitspaceInfraEventSvc      *gitspaceinfraevent.Service
 	gitspaceOperationsEventSvc *gitspaceoperationsevent.Service
+	gitspaceDeleteEventSvc     *gitspacedeleteevent.Service
 }
 
 func ProvideGitspaceServices(
 	gitspaceEventSvc *gitspaceevent.Service,
+	gitspaceDeleteEventSvc *gitspacedeleteevent.Service,
 	infraProviderSvc *infraprovider.Service,
 	gitspaceSvc *gitspace.Service,
 	gitspaceInfraEventSvc *gitspaceinfraevent.Service,
@@ -78,6 +81,7 @@ func ProvideGitspaceServices(
 		gitspace:                   gitspaceSvc,
 		gitspaceInfraEventSvc:      gitspaceInfraEventSvc,
 		gitspaceOperationsEventSvc: gitspaceOperationsEventSvc,
+		gitspaceDeleteEventSvc:     gitspaceDeleteEventSvc,
 	}
 }
 

app/store/database.go

@@ -767,7 +767,7 @@ type (
 
 	InfraProviderConfigStore interface {
 		// Find returns a infra provider config given a ID from the datastore.
-		Find(ctx context.Context, id int64) (*types.InfraProviderConfig, error)
+		Find(ctx context.Context, id int64, includeDeleted bool) (*types.InfraProviderConfig, error)
 
 		// FindByIdentifier returns a infra provider config with a given UID in a space
 		FindByIdentifier(ctx context.Context, spaceID int64, identifier string) (*types.InfraProviderConfig, error)

app/store/database/infra_provider_config.go

@@ -25,6 +25,7 @@ import (
 	"github.com/harness/gitness/types"
 	"github.com/harness/gitness/types/enum"
 
+	"github.com/Masterminds/squirrel"
 	"github.com/guregu/null"
 	"github.com/jmoiron/sqlx"
 	"github.com/pkg/errors"
@@ -95,12 +96,20 @@ func (i infraProviderConfigStore) Update(ctx context.Context, infraProviderConfi
 	return nil
 }
 
-func (i infraProviderConfigStore) Find(ctx context.Context, id int64) (*types.InfraProviderConfig, error) {
+func (i infraProviderConfigStore) Find(
+	ctx context.Context,
+	id int64,
+	includeDeleted bool,
+) (*types.InfraProviderConfig, error) {
 	stmt := database.Builder.
 		Select(infraProviderConfigSelectColumns).
 		From(infraProviderConfigTable).
-		Where("ipconf_is_deleted = false").
 		Where(infraProviderConfigIDColumn+" = ?", id) //nolint:goconst
+
+	if !includeDeleted {
+		stmt = stmt.Where("ipconf_is_deleted = false")
+	}
+
 	sql, args, err := stmt.ToSql()
 	if err != nil {
 		return nil, errors.Wrap(err, "Failed to convert squirrel builder to sql")
@@ -122,8 +131,8 @@ func (i infraProviderConfigStore) List(
 		From(infraProviderConfigTable).
 		Where("ipconf_is_deleted = false")
 
-	if filter != nil && filter.SpaceID > 0 {
+	if filter != nil && len(filter.SpaceIDs) > 0 {
-		stmt = stmt.Where("ipconf_space_id = ?", filter.SpaceID)
+		stmt = stmt.Where(squirrel.Eq{"ipconf_space_id": filter.SpaceIDs})
 	}
 
 	if filter != nil && filter.Type != "" {

cli/operations/server/config.go

@@ -27,6 +27,7 @@ import (
 	"github.com/harness/gitness/app/gitspace/orchestrator/ide"
 	"github.com/harness/gitness/app/services/cleanup"
 	"github.com/harness/gitness/app/services/codeowners"
+	"github.com/harness/gitness/app/services/gitspacedeleteevent"
 	"github.com/harness/gitness/app/services/gitspaceevent"
 	"github.com/harness/gitness/app/services/keywordsearch"
 	"github.com/harness/gitness/app/services/notification"
@@ -480,3 +481,13 @@ func ProvideGitspaceEventConfig(config *types.Config) *gitspaceevent.Config {
 		TimeoutInMins:   config.Gitspace.Events.TimeoutInMins,
 	}
 }
+
+// ProvideGitspaceDeleteEventConfig loads the gitspace delete event service config from the main config.
+func ProvideGitspaceDeleteEventConfig(config *types.Config) *gitspacedeleteevent.Config {
+	return &gitspacedeleteevent.Config{
+		EventReaderName: config.InstanceID,
+		Concurrency:     config.Gitspace.Events.Concurrency,
+		MaxRetries:      config.Gitspace.Events.MaxRetries,
+		TimeoutInMins:   config.Gitspace.Events.TimeoutInMins,
+	}
+}

cmd/gitness/wire.go

@@ -55,6 +55,7 @@ import (
 	connectorservice "github.com/harness/gitness/app/connector"
 	gitevents "github.com/harness/gitness/app/events/git"
 	gitspaceevents "github.com/harness/gitness/app/events/gitspace"
+	gitspacedeleteevents "github.com/harness/gitness/app/events/gitspacedelete"
 	gitspaceinfraevents "github.com/harness/gitness/app/events/gitspaceinfra"
 	gitspaceoperationsevents "github.com/harness/gitness/app/events/gitspaceoperations"
 	pipelineevents "github.com/harness/gitness/app/events/pipeline"
@@ -85,6 +86,7 @@ import (
 	"github.com/harness/gitness/app/services/codecomments"
 	"github.com/harness/gitness/app/services/codeowners"
 	"github.com/harness/gitness/app/services/exporter"
+	gitspacedeleteeventservice "github.com/harness/gitness/app/services/gitspacedeleteevent"
 	"github.com/harness/gitness/app/services/gitspaceevent"
 	"github.com/harness/gitness/app/services/gitspaceservice"
 	"github.com/harness/gitness/app/services/importer"
@@ -266,6 +268,7 @@ func initSystem(ctx context.Context, config *types.Config) (*cliserver.System, e
 		cliserver.ProvideIDEVSCodeWebConfig,
 		cliserver.ProvideDockerConfig,
 		cliserver.ProvideGitspaceEventConfig,
+		cliserver.ProvideGitspaceDeleteEventConfig,
 		logutil.WireSet,
 		cliserver.ProvideGitspaceOrchestratorConfig,
 		ide.WireSet,
@@ -283,6 +286,8 @@ func initSystem(ctx context.Context, config *types.Config) (*cliserver.System, e
 		usage.WireSet,
 		registryevents.WireSet,
 		registrywebhooks.WireSet,
+		gitspacedeleteevents.WireSet,
+		gitspacedeleteeventservice.WireSet,
 	)
 	return &cliserver.System{}, nil
 }

cmd/gitness/wire_gen.go

@@ -42,12 +42,13 @@ import (
 	"github.com/harness/gitness/app/auth/authz"
 	"github.com/harness/gitness/app/bootstrap"
 	"github.com/harness/gitness/app/connector"
-	events8 "github.com/harness/gitness/app/events/git"
+	events9 "github.com/harness/gitness/app/events/git"
 	events3 "github.com/harness/gitness/app/events/gitspace"
+	events6 "github.com/harness/gitness/app/events/gitspacedelete"
 	events4 "github.com/harness/gitness/app/events/gitspaceinfra"
 	events5 "github.com/harness/gitness/app/events/gitspaceoperations"
-	events6 "github.com/harness/gitness/app/events/pipeline"
+	events7 "github.com/harness/gitness/app/events/pipeline"
-	events7 "github.com/harness/gitness/app/events/pullreq"
+	events8 "github.com/harness/gitness/app/events/pullreq"
 	events2 "github.com/harness/gitness/app/events/repo"
 	"github.com/harness/gitness/app/gitspace/infrastructure"
 	"github.com/harness/gitness/app/gitspace/logutil"
@@ -75,6 +76,7 @@ import (
 	"github.com/harness/gitness/app/services/codeowners"
 	"github.com/harness/gitness/app/services/exporter"
 	"github.com/harness/gitness/app/services/gitspace"
+	"github.com/harness/gitness/app/services/gitspacedeleteevent"
 	"github.com/harness/gitness/app/services/gitspaceevent"
 	"github.com/harness/gitness/app/services/gitspaceinfraevent"
 	"github.com/harness/gitness/app/services/gitspaceoperationsevent"
@@ -123,7 +125,7 @@ import (
 	"github.com/harness/gitness/pubsub"
 	api2 "github.com/harness/gitness/registry/app/api"
 	"github.com/harness/gitness/registry/app/api/router"
-	events9 "github.com/harness/gitness/registry/app/events"
+	events10 "github.com/harness/gitness/registry/app/events"
 	"github.com/harness/gitness/registry/app/pkg"
 	"github.com/harness/gitness/registry/app/pkg/docker"
 	"github.com/harness/gitness/registry/app/pkg/filemanager"
@@ -351,14 +353,18 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro
 	passwordResolver := secret.ProvidePasswordResolver()
 	resolverFactory := secret.ProvideResolverFactory(passwordResolver)
 	orchestratorOrchestrator := orchestrator.ProvideOrchestrator(scmSCM, platformConnector, infraProvisioner, containerFactory, eventsReporter, orchestratorConfig, ideFactory, resolverFactory, gitspaceInstanceStore)
-	gitspaceService := gitspace.ProvideGitspace(transactor, gitspaceConfigStore, gitspaceInstanceStore, eventsReporter, gitspaceEventStore, spaceFinder, infraproviderService, orchestratorOrchestrator, scmSCM, config)
-	usageMetricStore := database.ProvideUsageMetricStore(db)
-	spaceController := space.ProvideController(config, transactor, provider, streamer, spaceIdentifier, authorizer, spacePathStore, pipelineStore, secretStore, connectorStore, templateStore, spaceStore, repoStore, principalStore, repoController, membershipStore, listService, spaceFinder, repository, exporterRepository, resourceLimiter, publicaccessService, auditService, gitspaceService, labelService, instrumentService, executionStore, rulesService, usageMetricStore, repoIdentifier)
 	reporter4, err := events6.ProvideReporter(eventsSystem)
 	if err != nil {
 		return nil, err
 	}
-	pipelineController := pipeline.ProvideController(triggerStore, authorizer, pipelineStore, reporter4, repoFinder)
+	gitspaceService := gitspace.ProvideGitspace(transactor, gitspaceConfigStore, gitspaceInstanceStore, eventsReporter, gitspaceEventStore, spaceFinder, infraproviderService, orchestratorOrchestrator, scmSCM, config, reporter4)
+	usageMetricStore := database.ProvideUsageMetricStore(db)
+	spaceController := space.ProvideController(config, transactor, provider, streamer, spaceIdentifier, authorizer, spacePathStore, pipelineStore, secretStore, connectorStore, templateStore, spaceStore, repoStore, principalStore, repoController, membershipStore, listService, spaceFinder, repository, exporterRepository, resourceLimiter, publicaccessService, auditService, gitspaceService, labelService, instrumentService, executionStore, rulesService, usageMetricStore, repoIdentifier, infraproviderService)
+	reporter5, err := events7.ProvideReporter(eventsSystem)
+	if err != nil {
+		return nil, err
+	}
+	pipelineController := pipeline.ProvideController(triggerStore, authorizer, pipelineStore, reporter5, repoFinder)
 	secretController := secret2.ProvideController(encrypter, secretStore, authorizer, spaceFinder)
 	triggerController := trigger.ProvideController(authorizer, triggerStore, pipelineStore, repoFinder)
 	scmService := connector.ProvideSCMConnectorHandler(secretStore)
@@ -372,25 +378,25 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro
 	pullReqReviewerStore := database.ProvidePullReqReviewerStore(db, principalInfoCache)
 	userGroupReviewersStore := database.ProvideUserGroupReviewerStore(db, principalInfoCache, userGroupStore)
 	pullReqFileViewStore := database.ProvidePullReqFileViewStore(db)
-	reporter5, err := events7.ProvideReporter(eventsSystem)
+	reporter6, err := events8.ProvideReporter(eventsSystem)
 	if err != nil {
 		return nil, err
 	}
 	migrator := codecomments.ProvideMigrator(gitInterface)
-	readerFactory, err := events8.ProvideReaderFactory(eventsSystem)
+	readerFactory, err := events9.ProvideReaderFactory(eventsSystem)
 	if err != nil {
 		return nil, err
 	}
-	eventsReaderFactory, err := events7.ProvideReaderFactory(eventsSystem)
+	eventsReaderFactory, err := events8.ProvideReaderFactory(eventsSystem)
 	if err != nil {
 		return nil, err
 	}
-	pullreqService, err := pullreq.ProvideService(ctx, config, readerFactory, eventsReaderFactory, reporter5, gitInterface, repoFinder, repoStore, pullReqStore, pullReqActivityStore, principalInfoCache, codeCommentView, migrator, pullReqFileViewStore, pubSub, provider, streamer)
+	pullreqService, err := pullreq.ProvideService(ctx, config, readerFactory, eventsReaderFactory, reporter6, gitInterface, repoFinder, repoStore, pullReqStore, pullReqActivityStore, principalInfoCache, codeCommentView, migrator, pullReqFileViewStore, pubSub, provider, streamer)
 	if err != nil {
 		return nil, err
 	}
 	pullReq := migrate.ProvidePullReqImporter(provider, gitInterface, principalStore, spaceStore, repoStore, pullReqStore, pullReqActivityStore, labelStore, labelValueStore, pullReqLabelAssignmentStore, repoFinder, transactor, mutexManager)
-	pullreqController := pullreq2.ProvideController(transactor, provider, authorizer, auditService, pullReqStore, pullReqActivityStore, codeCommentView, pullReqReviewStore, pullReqReviewerStore, repoStore, principalStore, userGroupStore, userGroupReviewersStore, principalInfoCache, pullReqFileViewStore, membershipStore, checkStore, gitInterface, repoFinder, reporter5, migrator, pullreqService, listService, protectionManager, streamer, codeownersService, lockerLocker, pullReq, labelService, instrumentService, searchService)
+	pullreqController := pullreq2.ProvideController(transactor, provider, authorizer, auditService, pullReqStore, pullReqActivityStore, codeCommentView, pullReqReviewStore, pullReqReviewerStore, repoStore, principalStore, userGroupStore, userGroupReviewersStore, principalInfoCache, pullReqFileViewStore, membershipStore, checkStore, gitInterface, repoFinder, reporter6, migrator, pullreqService, listService, protectionManager, streamer, codeownersService, lockerLocker, pullReq, labelService, instrumentService, searchService)
 	webhookConfig := server.ProvideWebhookConfig(config)
 	webhookStore := database.ProvideWebhookStore(db)
 	webhookExecutionStore := database.ProvideWebhookExecutionStore(db)
@@ -402,7 +408,7 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro
 	}
 	preprocessor := webhook2.ProvidePreprocessor()
 	webhookController := webhook2.ProvideController(authorizer, spaceFinder, repoFinder, webhookService, encrypter, preprocessor)
-	reporter6, err := events8.ProvideReporter(eventsSystem)
+	reporter7, err := events9.ProvideReporter(eventsSystem)
 	if err != nil {
 		return nil, err
 	}
@@ -419,7 +425,7 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro
 		return nil, err
 	}
 	lfsObjectStore := database.ProvideLFSObjectStore(db)
-	githookController := githook.ProvideController(authorizer, principalStore, repoStore, repoFinder, reporter6, reporter, gitInterface, pullReqStore, provider, protectionManager, clientFactory, resourceLimiter, settingsService, preReceiveExtender, updateExtender, postReceiveExtender, streamer, lfsObjectStore)
+	githookController := githook.ProvideController(authorizer, principalStore, repoStore, repoFinder, reporter7, reporter, gitInterface, pullReqStore, provider, protectionManager, clientFactory, resourceLimiter, settingsService, preReceiveExtender, updateExtender, postReceiveExtender, streamer, lfsObjectStore)
 	serviceaccountController := serviceaccount.NewController(principalUID, authorizer, principalStore, spaceStore, repoStore, tokenStore)
 	principalController := principal.ProvideController(principalStore, authorizer)
 	usergroupController := usergroup2.ProvideController(userGroupStore, spaceStore, authorizer, searchService)
@@ -464,11 +470,11 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro
 	layerRepository := database2.ProvideLayerDao(db, mediaTypesRepository)
 	eventReporter := docker.ProvideReporter()
 	ociImageIndexMappingRepository := database2.ProvideOCIImageIndexMappingDao(db)
-	reporter7, err := events9.ProvideArtifactReporter(eventsSystem)
+	reporter8, err := events10.ProvideArtifactReporter(eventsSystem)
 	if err != nil {
 		return nil, err
 	}
-	manifestService := docker.ManifestServiceProvider(registryRepository, manifestRepository, blobRepository, mediaTypesRepository, manifestReferenceRepository, tagRepository, imageRepository, artifactRepository, layerRepository, gcService, transactor, eventReporter, spaceFinder, ociImageIndexMappingRepository, reporter7, provider)
+	manifestService := docker.ManifestServiceProvider(registryRepository, manifestRepository, blobRepository, mediaTypesRepository, manifestReferenceRepository, tagRepository, imageRepository, artifactRepository, layerRepository, gcService, transactor, eventReporter, spaceFinder, ociImageIndexMappingRepository, reporter8, provider)
 	registryBlobRepository := database2.ProvideRegistryBlobDao(db)
 	bandwidthStatRepository := database2.ProvideBandwidthStatDao(db)
 	downloadStatRepository := database2.ProvideDownloadStatDao(db)
@@ -488,7 +494,7 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro
 	cleanupPolicyRepository := database2.ProvideCleanupPolicyDao(db, transactor)
 	webhooksRepository := database2.ProvideWebhookDao(db)
 	webhooksExecutionRepository := database2.ProvideWebhookExecutionDao(db)
-	readerFactory2, err := events9.ProvideReaderFactory(eventsSystem)
+	readerFactory2, err := events10.ProvideReaderFactory(eventsSystem)
 	if err != nil {
 		return nil, err
 	}
@@ -520,7 +526,7 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro
 	serverServer := server2.ProvideServer(config, routerRouter)
 	publickeyService := publickey.ProvidePublicKey(publicKeyStore, principalInfoCache)
 	sshServer := ssh.ProvideServer(config, publickeyService, repoController, lfsController)
-	executionManager := manager.ProvideExecutionManager(config, executionStore, pipelineStore, provider, streamer, fileService, converterService, logStore, logStream, checkStore, repoStore, schedulerScheduler, secretStore, stageStore, stepStore, principalStore, publicaccessService, reporter4)
+	executionManager := manager.ProvideExecutionManager(config, executionStore, pipelineStore, provider, streamer, fileService, converterService, logStore, logStream, checkStore, repoStore, schedulerScheduler, secretStore, stageStore, stepStore, principalStore, publicaccessService, reporter5)
 	client := manager.ProvideExecutionClient(executionManager, provider, config)
 	resolverManager := resolver.ProvideResolver(config, pluginStore, templateStore, executionStore, repoStore)
 	runtimeRunner, err := runner.ProvideExecutionRunner(config, client, resolverManager)
@@ -575,23 +581,32 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro
 	if err != nil {
 		return nil, err
 	}
-	readerFactory5, err := events4.ProvideReaderFactory(eventsSystem)
+	gitspacedeleteeventConfig := server.ProvideGitspaceDeleteEventConfig(config)
+	readerFactory5, err := events6.ProvideReaderFactory(eventsSystem)
 	if err != nil {
 		return nil, err
 	}
-	gitspaceinfraeventService, err := gitspaceinfraevent.ProvideService(ctx, gitspaceeventConfig, readerFactory5, orchestratorOrchestrator, gitspaceService, eventsReporter)
+	gitspacedeleteeventService, err := gitspacedeleteevent.ProvideService(ctx, gitspacedeleteeventConfig, readerFactory5, gitspaceService)
 	if err != nil {
 		return nil, err
 	}
-	readerFactory6, err := events5.ProvideReaderFactory(eventsSystem)
+	readerFactory6, err := events4.ProvideReaderFactory(eventsSystem)
 	if err != nil {
 		return nil, err
 	}
-	gitspaceoperationseventService, err := gitspaceoperationsevent.ProvideService(ctx, gitspaceeventConfig, readerFactory6, orchestratorOrchestrator, gitspaceService, eventsReporter)
+	gitspaceinfraeventService, err := gitspaceinfraevent.ProvideService(ctx, gitspaceeventConfig, readerFactory6, orchestratorOrchestrator, gitspaceService, eventsReporter)
 	if err != nil {
 		return nil, err
 	}
-	gitspaceServices := services.ProvideGitspaceServices(gitspaceeventService, infraproviderService, gitspaceService, gitspaceinfraeventService, gitspaceoperationseventService)
+	readerFactory7, err := events5.ProvideReaderFactory(eventsSystem)
+	if err != nil {
+		return nil, err
+	}
+	gitspaceoperationseventService, err := gitspaceoperationsevent.ProvideService(ctx, gitspaceeventConfig, readerFactory7, orchestratorOrchestrator, gitspaceService, eventsReporter)
+	if err != nil {
+		return nil, err
+	}
+	gitspaceServices := services.ProvideGitspaceServices(gitspaceeventService, gitspacedeleteeventService, infraproviderService, gitspaceService, gitspaceinfraeventService, gitspaceoperationseventService)
 	consumer, err := instrument.ProvideGitConsumer(ctx, config, readerFactory, repoStore, principalInfoCache, instrumentService)
 	if err != nil {
 		return nil, err

types/infra_provider.go

@@ -162,6 +162,6 @@ type InfraProviderTemplate struct {
 }
 
 type InfraProviderConfigFilter struct {
-	SpaceID int64
+	SpaceIDs []int64
-	Type    enum.InfraProviderType
+	Type     enum.InfraProviderType
 }