feat: add support for multiple github connectors (#616)

* chore(release): v0.1.0-alpha.71 [skip ci]

* chore(release): update version.txt to v0.1.0-alpha.71

* feat: improvise github connector flow ux

* fix: add missing translation keys to locales

* feat: enable support for github connector settings

* feat: add support for creating multiple github connectors

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

Author: raghavyuva

api/internal/features/github-connector/controller/delete_connector.go

@@ -0,0 +1,66 @@
+package controller
+
+import (
+	"net/http"
+
+	"github.com/go-fuego/fuego"
+	"github.com/raghavyuva/nixopus-api/internal/features/github-connector/types"
+	"github.com/raghavyuva/nixopus-api/internal/features/logger"
+	"github.com/raghavyuva/nixopus-api/internal/utils"
+
+	shared_types "github.com/raghavyuva/nixopus-api/internal/types"
+)
+
+func (c *GithubConnectorController) DeleteGithubConnector(f fuego.ContextWithBody[types.DeleteGithubConnectorRequest]) (*shared_types.Response, error) {
+	deleteRequest, err := f.Body()
+
+	if err != nil {
+		return nil, fuego.HTTPError{
+			Err:    err,
+			Status: http.StatusBadRequest,
+		}
+	}
+
+	w, r := f.Response(), f.Request()
+
+	if !c.parseAndValidate(w, r, &deleteRequest) {
+		// parseAndValidate already sent the error response, so return nil to prevent duplicate response
+		return nil, nil
+	}
+
+	user := utils.GetUser(w, r)
+
+	if user == nil {
+		return nil, fuego.HTTPError{
+			Err:    nil,
+			Status: http.StatusUnauthorized,
+		}
+	}
+
+	err = c.service.DeleteConnector(deleteRequest.ID, user.ID.String())
+	if err != nil {
+		c.logger.Log(logger.Error, err.Error(), "")
+		if err == types.ErrConnectorDoesNotExist {
+			return nil, fuego.HTTPError{
+				Err:    err,
+				Status: http.StatusNotFound,
+			}
+		}
+		if err == types.ErrPermissionDenied {
+			return nil, fuego.HTTPError{
+				Err:    err,
+				Status: http.StatusForbidden,
+			}
+		}
+		return nil, fuego.HTTPError{
+			Err:    err,
+			Status: http.StatusInternalServerError,
+		}
+	}
+
+	return &shared_types.Response{
+		Status:  "success",
+		Message: "Github Connector deleted successfully",
+	}, nil
+}
+

api/internal/features/github-connector/controller/get_github_repositories.go

@@ -25,6 +25,7 @@ func (c *GithubConnectorController) GetGithubRepositories(f fuego.ContextNoBody)
 	q := r.URL.Query()
 	page := 1
 	pageSize := 10
+	connectorID := q.Get("connector_id")
 
 	if v := q.Get("page"); v != "" {
 		if p, err := strconv.Atoi(v); err == nil && p > 0 {
@@ -37,7 +38,7 @@ func (c *GithubConnectorController) GetGithubRepositories(f fuego.ContextNoBody)
 		}
 	}
 
-	repositories, totalCount, err := c.service.GetGithubRepositoriesPaginated(user.ID.String(), page, pageSize)
+	repositories, totalCount, err := c.service.GetGithubRepositoriesPaginated(user.ID.String(), page, pageSize, connectorID)
 	if err != nil {
 		c.logger.Log(logger.Error, err.Error(), "")
 		return nil, fuego.HTTPError{

api/internal/features/github-connector/controller/update_connector.go

@@ -41,7 +41,7 @@ func (c *GithubConnectorController) UpdateGithubConnectorRequest(f fuego.Context
 		}
 	}
 
-	err = c.service.UpdateGithubConnectorRequest(UpdateConnectorRequest.InstallationID, user.ID.String())
+	err = c.service.UpdateGithubConnectorRequest(UpdateConnectorRequest.InstallationID, user.ID.String(), UpdateConnectorRequest.ConnectorID)
 	if err != nil {
 		c.logger.Log(logger.Error, err.Error(), "")
 		return nil, fuego.HTTPError{

api/internal/features/github-connector/service/delete_connector.go

@@ -0,0 +1,49 @@
+package service
+
+import (
+	"github.com/raghavyuva/nixopus-api/internal/features/github-connector/types"
+	"github.com/raghavyuva/nixopus-api/internal/features/logger"
+)
+
+// DeleteConnector deletes a GitHub connector for the given user.
+//
+// This method performs a soft delete on the connector by setting its DeletedAt field.
+// It verifies that the connector belongs to the user before deletion.
+//
+// Parameters:
+//
+//	ConnectorID - the unique identifier of the connector to delete.
+//	UserID - the unique identifier of the user who owns the connector.
+//
+// Returns:
+//
+//	error - an error if the connector cannot be deleted or does not exist.
+func (c *GithubConnectorService) DeleteConnector(ConnectorID string, UserID string) error {
+	// Verify connector exists and belongs to user
+	connector, err := c.storage.GetConnector(ConnectorID)
+	if err != nil {
+		c.logger.Log(logger.Error, err.Error(), "")
+		return types.ErrConnectorDoesNotExist
+	}
+
+	if connector.UserID.String() != UserID {
+		c.logger.Log(logger.Error, "User does not own this connector", "")
+		return types.ErrPermissionDenied
+	}
+
+	// Check if connector is already deleted
+	if connector.DeletedAt != nil {
+		c.logger.Log(logger.Error, "Connector already deleted", "")
+		return types.ErrConnectorDoesNotExist
+	}
+
+	// Perform soft delete
+	err = c.storage.DeleteConnector(ConnectorID, UserID)
+	if err != nil {
+		c.logger.Log(logger.Error, err.Error(), "")
+		return err
+	}
+
+	return nil
+}
+

api/internal/features/github-connector/service/get_github_repositories.go

@@ -11,7 +11,8 @@ import (
 )
 
 // GetGithubRepositoriesPaginated fetches repositories for the user's GitHub installation with pagination.
-func (c *GithubConnectorService) GetGithubRepositoriesPaginated(userID string, page int, pageSize int) ([]shared_types.GithubRepository, int, error) {
+// If connectorID is provided, it uses that specific connector. Otherwise, it finds a connector with a valid installation_id.
+func (c *GithubConnectorService) GetGithubRepositoriesPaginated(userID string, page int, pageSize int, connectorID string) ([]shared_types.GithubRepository, int, error) {
 	connectors, err := c.storage.GetAllConnectors(userID)
 	if err != nil {
 		c.logger.Log(logger.Error, err.Error(), "")
@@ -23,8 +24,43 @@ func (c *GithubConnectorService) GetGithubRepositoriesPaginated(userID string, p
 		return []shared_types.GithubRepository{}, 0, nil
 	}
 
-	installation_id := connectors[0].InstallationID
-	jwt := GenerateJwt(&connectors[0])
+	var connectorToUse *shared_types.GithubConnector
+
+	// If connectorID is provided, find that specific connector
+	if connectorID != "" {
+		for i := range connectors {
+			if connectors[i].ID.String() == connectorID {
+				connectorToUse = &connectors[i]
+				break
+			}
+		}
+		if connectorToUse == nil {
+			c.logger.Log(logger.Error, fmt.Sprintf("Connector with id %s not found for user", connectorID), userID)
+			return nil, 0, fmt.Errorf("connector not found")
+		}
+	} else {
+		// Find connector with valid installation_id (not empty)
+		for i := range connectors {
+			if connectors[i].InstallationID != "" && connectors[i].InstallationID != " " {
+				connectorToUse = &connectors[i]
+				break
+			}
+		}
+		// If no connector with installation_id found, return error
+		if connectorToUse == nil {
+			c.logger.Log(logger.Error, "No connector with valid installation_id found for user", userID)
+			return nil, 0, fmt.Errorf("no connector with valid installation found")
+		}
+	}
+
+	// Validate installation_id is not empty
+	if connectorToUse.InstallationID == "" || connectorToUse.InstallationID == " " {
+		c.logger.Log(logger.Error, fmt.Sprintf("Connector %s has empty installation_id", connectorToUse.ID.String()), userID)
+		return nil, 0, fmt.Errorf("connector has no installation_id")
+	}
+
+	installation_id := connectorToUse.InstallationID
+	jwt := GenerateJwt(connectorToUse)
 
 	accessToken, err := c.getInstallationToken(jwt, installation_id)
 	if err != nil {

api/internal/features/github-connector/service/update_connector.go

@@ -1,29 +1,68 @@
 package service
 
-import "fmt"
+import (
+	"fmt"
+	"strings"
+
+	"github.com/google/uuid"
+	shared_types "github.com/raghavyuva/nixopus-api/internal/types"
+)
 
 // UpdateGithubConnectorRequest updates the GitHub connector request for the given user ID.
 //
-// The method first retrieves all GitHub connectors associated with the user ID.
-// If no connectors are found, the method simply returns.
-//
-// Otherwise, the method takes the ID of the first connector and updates the
-// associated GitHub app ID with the provided InstallationID.
+// If ConnectorID is provided, it updates that specific connector.
+// Otherwise, it finds the connector without an installation_id and updates that one.
+// If no connector without installation_id is found, it updates the first connector (backward compatibility).
 //
 // If any errors occur during the update process, the method returns the error.
-func (c *GithubConnectorService) UpdateGithubConnectorRequest(InstallationID string, UserID string) error {
-	connector, err := c.storage.GetAllConnectors(UserID)
+func (c *GithubConnectorService) UpdateGithubConnectorRequest(InstallationID string, UserID string, ConnectorID string) error {
+	connectors, err := c.storage.GetAllConnectors(UserID)
 	if err != nil {
 		fmt.Println(err)
 		return err
 	}
 
-	if len(connector) == 0 {
+	if len(connectors) == 0 {
 		fmt.Println("no connector found")
 		return nil
 	}
 
-	err = c.storage.UpdateConnector(connector[0].ID.String(), InstallationID)
+	var connectorToUpdate *shared_types.GithubConnector
+
+	// If ConnectorID is provided, find and update that specific connector
+	if ConnectorID != "" {
+		// Validate UUID format
+		if _, err := uuid.Parse(ConnectorID); err != nil {
+			return fmt.Errorf("invalid connector_id format: %v", err)
+		}
+
+		// Find the connector with matching ID
+		for i := range connectors {
+			if connectors[i].ID.String() == ConnectorID {
+				connectorToUpdate = &connectors[i]
+				break
+			}
+		}
+
+		if connectorToUpdate == nil {
+			return fmt.Errorf("connector with id %s not found", ConnectorID)
+		}
+	} else {
+		// Find connector without installation_id (newly created connector)
+		for i := range connectors {
+			if connectors[i].InstallationID == "" || strings.TrimSpace(connectors[i].InstallationID) == "" {
+				connectorToUpdate = &connectors[i]
+				break
+			}
+		}
+
+		// If no connector without installation_id found, use first connector 
+		if connectorToUpdate == nil {
+			connectorToUpdate = &connectors[0]
+		}
+	}
+
+	err = c.storage.UpdateConnector(connectorToUpdate.ID.String(), InstallationID)
 	if err != nil {
 		return err
 	}

api/internal/features/github-connector/storage/init.go

@@ -14,6 +14,7 @@ type GithubConnectorStorage struct {
 type GithubConnectorRepository interface {
 	CreateConnector(connector *shared_types.GithubConnector) error
 	UpdateConnector(ConnectorID, InstallationID string) error
+	DeleteConnector(ConnectorID string, UserID string) error
 	GetConnector(ConnectorID string) (*shared_types.GithubConnector, error)
 	GetAllConnectors(UserID string) ([]shared_types.GithubConnector, error)
 	GetConnectorByAppID(AppID string) (*shared_types.GithubConnector, error)
@@ -92,7 +93,7 @@ func (s *GithubConnectorStorage) UpdateConnector(ConnectorID, InstallationID str
 //	error - an error if the connector cannot be retrieved or does not exist.
 func (s *GithubConnectorStorage) GetConnector(ConnectorID string) (*shared_types.GithubConnector, error) {
 	var connector shared_types.GithubConnector
-	err := s.DB.NewSelect().Model(&connector).Where("id = ?", ConnectorID).Scan(s.Ctx)
+	err := s.DB.NewSelect().Model(&connector).Where("id = ? AND deleted_at IS NULL", ConnectorID).Scan(s.Ctx)
 	return &connector, err
 }
 
@@ -112,10 +113,48 @@ func (s *GithubConnectorStorage) GetConnector(ConnectorID string) (*shared_types
 //	error - an error if the connectors cannot be retrieved or do not exist.
 func (s *GithubConnectorStorage) GetAllConnectors(UserID string) ([]shared_types.GithubConnector, error) {
 	var connectors []shared_types.GithubConnector
-	err := s.DB.NewSelect().Model(&connectors).Where("user_id = ?", UserID).Scan(s.Ctx)
+	err := s.DB.NewSelect().Model(&connectors).Where("user_id = ? AND deleted_at IS NULL", UserID).Scan(s.Ctx)
 	return connectors, err
 }
 
+// DeleteConnector performs a soft delete on a GitHub connector.
+//
+// The method sets the DeletedAt field to the current time, effectively
+// marking the connector as deleted without removing it from the database.
+// It also verifies that the connector belongs to the provided UserID.
+//
+// Parameters:
+//
+//	ConnectorID - the unique identifier of the connector to delete.
+//	UserID - the unique identifier of the user who owns the connector.
+//
+// Returns:
+//
+//	error - an error if the connector cannot be deleted or does not exist.
+func (s *GithubConnectorStorage) DeleteConnector(ConnectorID string, UserID string) error {
+	tx, err := s.DB.BeginTx(s.Ctx, nil)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
+
+	var connector shared_types.GithubConnector
+	_, err = tx.NewUpdate().Model(&connector).
+		Set("deleted_at = NOW()").
+		Set("updated_at = NOW()").
+		Where("id = ? AND user_id = ? AND deleted_at IS NULL", ConnectorID, UserID).
+		Exec(s.Ctx)
+	if err != nil {
+		return err
+	}
+
+	if err := tx.Commit(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
 // GetConnectorByAppID retrieves a GitHub connector by its GitHub app ID.
 //
 // The method queries the storage to find a GitHub connector associated with

api/internal/features/github-connector/types/delete.go

@@ -0,0 +1,6 @@
+package types
+
+type DeleteGithubConnectorRequest struct {
+	ID string `json:"id" validate:"required"`
+}
+

api/internal/features/github-connector/types/init.go

@@ -13,6 +13,7 @@ type CreateGithubConnectorRequest struct {
 
 type UpdateGithubConnectorRequest struct {
 	InstallationID string `json:"installation_id"`
+	ConnectorID    string `json:"connector_id,omitempty"` // Optional: if provided, update this specific connector
 }
 
 var (
@@ -22,6 +23,7 @@ var (
 	ErrMissingClientSecret   = errors.New("client_secret is required")
 	ErrMissingWebhookSecret  = errors.New("webhook_secret is required")
 	ErrMissingInstallationID = errors.New("installation_id is required")
+	ErrMissingID             = errors.New("id is required")
 	ErrInvalidRequestType    = errors.New("invalid request type")
 	ErrConnectorDoesNotExist = errors.New("connector does not exist")
 	ErrNoConnectors          = errors.New("no connectors found")

api/internal/features/github-connector/validation/validator.go

@@ -29,6 +29,7 @@ func NewValidator(storage GithubConnectorRepository) *Validator {
 // The supported request types are:
 // - types.CreateGithubConnectorRequest
 // - types.UpdateGithubConnectorRequest
+// - types.DeleteGithubConnectorRequest
 //
 // If the request object is not of one of the above types, it returns
 // types.ErrInvalidRequestType.
@@ -38,6 +39,8 @@ func (v *Validator) ValidateRequest(req any) error {
 		return v.validateCreateGithubConnectorRequest(*r)
 	case *types.UpdateGithubConnectorRequest:
 		return v.validateUpdateGithubConnectorRequest(*r)
+	case *types.DeleteGithubConnectorRequest:
+		return v.validateDeleteGithubConnectorRequest(*r)
 	default:
 		return types.ErrInvalidRequestType
 	}
@@ -81,3 +84,11 @@ func (v *Validator) validateUpdateGithubConnectorRequest(req types.UpdateGithubC
 
 	return nil
 }
+
+func (v *Validator) validateDeleteGithubConnectorRequest(req types.DeleteGithubConnectorRequest) error {
+	if req.ID == "" {
+		return types.ErrMissingID
+	}
+
+	return nil
+}