feat: Implement cache invalidation endpoint (#33)

Author: zmotso

.github/instructions/go-development.instructions.md

@@ -7,9 +7,6 @@ applyTo: "**/*.go"
 - Follow Go best practices and idioms
 - Use latest Go 1.24 features
 - Split function parameters into separate lines if they exceed 120 characters
-- Use meaningful variable and function names
-- Keep functions concise and focused
-- Properly handle errors with appropriate context
 - Add comments for complex logic, but prefer self-documenting code
 
 ## Error Handling

.github/prompts/implement-feature.prompt.md

@@ -23,6 +23,7 @@ I'll help you implement a new feature in the GitFusion service, following best p
    - Identify files that need to be created or modified
    - Update OpenAPI `internal/api/oapi.yaml` if API changes are needed and run `make generate` to regenerate code for API stubs and models
    - Plan tests to verify the implementation
+   - At the end of the implementation, run `make lint` to ensure code quality and adherence to project standards and fix any issues reported by the linter
 
 4. **Testing Approach**
    - Unit tests for core functionality

internal/api/cache_handler.go

@@ -0,0 +1,58 @@
+package api
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/KubeRocketCI/gitfusion/internal/cache"
+)
+
+// CacheHandler handles cache management requests.
+type CacheHandler struct {
+	cacheManager *cache.Manager
+}
+
+// NewCacheHandler creates a new CacheHandler.
+func NewCacheHandler(cacheManager *cache.Manager) *CacheHandler {
+	return &CacheHandler{
+		cacheManager: cacheManager,
+	}
+}
+
+// InvalidateCache implements api.StrictServerInterface.
+func (c *CacheHandler) InvalidateCache(
+	ctx context.Context,
+	request InvalidateCacheRequestObject,
+) (InvalidateCacheResponseObject, error) {
+	endpoint := string(request.Params.Endpoint)
+
+	if err := c.cacheManager.InvalidateCache(endpoint); err != nil {
+		return c.errResponse(err), nil
+	}
+
+	return InvalidateCache200JSONResponse{
+		Message:  fmt.Sprintf("Cache for endpoint '%s' has been successfully invalidated", endpoint),
+		Endpoint: endpoint,
+	}, nil
+}
+
+// errResponse handles error responses for cache operations.
+func (c *CacheHandler) errResponse(err error) InvalidateCacheResponseObject {
+	if err == nil {
+		return InvalidateCache200JSONResponse{}
+	}
+
+	// Check if it's an unsupported endpoint error (validation error)
+	if err.Error() == "unsupported endpoint" {
+		return InvalidateCache400JSONResponse{
+			Code:    "invalid_endpoint",
+			Message: err.Error(),
+		}
+	}
+
+	// Default to 500 internal server error
+	return InvalidateCache500JSONResponse{
+		Code:    "internal_error",
+		Message: err.Error(),
+	}
+}

internal/api/oapi.yaml

@@ -139,6 +139,40 @@ paths:
               schema:
                 $ref: '#/components/schemas/Error'
 
+  /api/v1/cache/invalidate:
+    delete:
+      summary: Invalidate cache for a specific endpoint
+      operationId: invalidateCache
+      tags:
+        - Cache
+      parameters:
+        - name: endpoint
+          in: query
+          required: true
+          description: The endpoint name to invalidate cache for (repositories, organizations, branches)
+          schema:
+            type: string
+            enum: [repositories, organizations, branches]
+      responses:
+        '200':
+          description: Cache invalidated successfully
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/CacheInvalidationResponse'
+        '400':
+          description: Bad request due to invalid parameters.
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+        '500':
+          description: Internal server error.
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+
 components:
   parameters:
     repoNameQueryParam:
@@ -300,3 +334,15 @@ components:
             $ref: '#/components/schemas/Branch'
       required:
         - data
+    CacheInvalidationResponse:
+      type: object
+      properties:
+        message:
+          type: string
+          description: A message indicating the result of the cache invalidation
+        endpoint:
+          type: string
+          description: The endpoint for which cache was invalidated
+      required:
+        - message
+        - endpoint

internal/api/server.go

@@ -3,6 +3,7 @@ package api
 import (
 	"context"
 
+	"github.com/KubeRocketCI/gitfusion/internal/cache"
 	"github.com/KubeRocketCI/gitfusion/internal/services/branches"
 	"github.com/KubeRocketCI/gitfusion/internal/services/krci"
 	"github.com/KubeRocketCI/gitfusion/internal/services/organizations"
@@ -22,18 +23,21 @@ type Server struct {
 	repositoryHandler   *RepositoryHandler
 	organizationHandler *OrganizationHandler
 	branchHandler       *BranchHandler
+	cacheHandler        *CacheHandler
 }
 
 // NewServer creates a new Server instance.
 func NewServer(
 	repositoryHandler *RepositoryHandler,
 	organizationHandler *OrganizationHandler,
 	branchHandler *BranchHandler,
+	cacheHandler *CacheHandler,
 ) *Server {
 	return &Server{
 		repositoryHandler:   repositoryHandler,
 		organizationHandler: organizationHandler,
 		branchHandler:       branchHandler,
+		cacheHandler:        cacheHandler,
 	}
 }
 
@@ -69,6 +73,14 @@ func (s *Server) ListBranches(
 	return s.branchHandler.ListBranches(ctx, request)
 }
 
+// InvalidateCache implements StrictServerInterface.
+func (s *Server) InvalidateCache(
+	ctx context.Context,
+	request InvalidateCacheRequestObject,
+) (InvalidateCacheResponseObject, error) {
+	return s.cacheHandler.InvalidateCache(ctx, request)
+}
+
 func BuildHandler(conf Config) (ServerInterface, error) {
 	k8sCl, err := initk8sClient()
 	if err != nil {
@@ -77,27 +89,33 @@ func BuildHandler(conf Config) (ServerInterface, error) {
 
 	gitServerService := krci.NewGitServerService(k8sCl, conf.Namespace)
 
-	repoSvc := repositories.NewRepositoriesService(
-		repositories.NewMultiProviderRepositoryService(),
-		gitServerService,
-	)
-	orgSvc := organizations.NewOrganizationsService(
-		organizations.NewMultiProviderOrganizationsService(
-			gitServerService,
-		),
-		gitServerService,
-	)
-	branchesSvc := branches.NewBranchesService(
-		branches.NewMultiProviderBranchesService(),
-		gitServerService,
+	// Create multi-provider services
+	repoMultiProvider := repositories.NewMultiProviderRepositoryService()
+	orgMultiProvider := organizations.NewMultiProviderOrganizationsService(gitServerService)
+	branchesMultiProvider := branches.NewMultiProviderBranchesService()
+
+	// Create high-level services
+	repoSvc := repositories.NewRepositoriesService(repoMultiProvider, gitServerService)
+	orgSvc := organizations.NewOrganizationsService(orgMultiProvider, gitServerService)
+	branchesSvc := branches.NewBranchesService(branchesMultiProvider, gitServerService)
+
+	// Create cache manager with access to all cache instances
+	cacheManager := cache.NewManager(
+		repoSvc.GetProvider().GetCache(),
+		orgSvc.GetProvider().GetCache(),
+		branchesSvc.GetProvider().GetCache(),
 	)
+
+	// Create handlers
 	branchHandler := NewBranchHandler(branchesSvc)
+	cacheHandler := NewCacheHandler(cacheManager)
 
 	return NewStrictHandlerWithOptions(
 		NewServer(
 			NewRepositoryHandler(repoSvc),
 			NewOrganizationHandler(orgSvc),
 			branchHandler,
+			cacheHandler,
 		),
 		[]StrictMiddlewareFunc{},
 		StrictHTTPServerOptions{},