Skip to content

Modern Docker Management, Designed for Everyone

23.6 KB
Raw Blame
package gitrepo

import (
	"cmp"
	"context"
	"errors"
	"fmt"
	"strings"

	"github.com/getarcaneapp/arcane/types/v2/base"
	"github.com/getarcaneapp/arcane/types/v2/gitops"
	"github.com/getarcaneapp/arcane/types/v2/user"
	"github.com/samber/mo"
	"go.getarcane.app/builds/pkg/contextsource"
	"go.getarcane.app/kit/normalization"
	"go.getarcane.app/sys/crypto"
	"gorm.io/gorm"

	"github.com/getarcaneapp/arcane/backend/v2/internal/common"
	"github.com/getarcaneapp/arcane/backend/v2/internal/database"
	"github.com/getarcaneapp/arcane/backend/v2/internal/event"
	"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/gitutil"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/timeouts"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/pagination"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/utils"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/validation"
)

type GitRepositoryService struct {
	*git.Client

	db              *database.DB
	eventService    *event.EventService
	settingsService *settings.SettingsService
}

func NewGitRepositoryService(db *database.DB, workDir string, eventService *event.EventService, settingsService *settings.SettingsService) *GitRepositoryService {
	return &GitRepositoryService{
		Client:          git.NewClient(workDir),
		db:              db,
		eventService:    eventService,
		settingsService: settingsService,
	}
}

func (s *GitRepositoryService) GetRepositoriesPaginated(ctx context.Context, params pagination.QueryParams) ([]gitops.GitRepository, pagination.Response, error) {
	var repositories []GitRepository
	q := s.db.WithContext(ctx).Model(&GitRepository{})

	q = pagination.ApplyLikeSearch(q, params.Search, "name LIKE ? OR url LIKE ? OR COALESCE(description, '') LIKE ?")

	q = pagination.ApplyBooleanFilter(q, "enabled", params.Filters["enabled"])
	q = pagination.ApplyFilter(q, "auth_type", params.Filters["authType"])

	out, paginationResp, err := params.PaginateSortAndMapDB[GitRepository, gitops.GitRepository](q, &repositories)
	if err != nil {
		return nil, pagination.Response{}, fmt.Errorf("failed to list git repositories: %w", err)
	}

	return out, paginationResp, nil
}

func (s *GitRepositoryService) GetRepositoryByID(ctx context.Context, id string) (*GitRepository, error) {
	var repository GitRepository
	if err := s.db.WithContext(ctx).Where("id = ?", id).First(&repository).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, common.Classify(common.ErrNotFound, errors.New("repository not found"))
		}
		return nil, fmt.Errorf("failed to get repository: %w", err)
	}
	return &repository, nil
}

func (s *GitRepositoryService) GetRepositoryByName(ctx context.Context, name string) (*GitRepository, error) {
	var repository GitRepository
	if err := s.db.WithContext(ctx).Where("name = ?", name).First(&repository).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, common.Classify(common.ErrNotFound, errors.New("repository not found"))
		}
		return nil, fmt.Errorf("failed to get repository: %w", err)
	}
	return &repository, nil
}

func (s *GitRepositoryService) FindEnabledRepositoryByURL(ctx context.Context, rawURL string) (*GitRepository, error) {
	if s == nil || s.db == nil {
		return nil, nil
	}

	normalizedURL := contextsource.NormalizeGitBuildContextSourceForMatch(rawURL)
	if normalizedURL == "" {
		return nil, nil
	}

	likePrefix := normalizedURL
	if idx := strings.Index(likePrefix, "#"); idx >= 0 {
		likePrefix = likePrefix[:idx]
	}
	likePrefix = strings.TrimSuffix(likePrefix, "/")

	var repositories []GitRepository
	query := s.db.WithContext(ctx).Where("enabled = ?", true)
	if likePrefix != "" {
		query = query.Where("url = ? OR url = ? OR url LIKE ? OR url LIKE ?", rawURL, normalizedURL, likePrefix+"%", likePrefix+"/%")
	}
	if err := query.Find(&repositories).Error; err != nil {
		return nil, fmt.Errorf("failed to list repositories: %w", err)
	}

	for i := range repositories {
		if contextsource.NormalizeGitBuildContextSourceForMatch(repositories[i].URL) == normalizedURL {
			return new(repositories[i]), nil
		}
	}

	return nil, nil
}

const (
	defaultCommitAuthorName  = "Arcane"
	defaultCommitAuthorEmail = "arcane@localhost"
)

func (s *GitRepositoryService) CreateRepository(ctx context.Context, req gitops.CreateRepositoryRequest, actor user.Actor) (*GitRepository, error) {
	if err := normalization.Normalize(&req); err != nil {
		return nil, err
	}
	repository := GitRepository{
		Name:                   req.Name,
		URL:                    req.URL,
		AuthType:               req.AuthType,
		Username:               req.Username,
		SSHHostKeyVerification: req.SSHHostKeyVerification,
		CommitAuthorName:       req.CommitAuthorName,
		CommitAuthorEmail:      req.CommitAuthorEmail,
		Description:            req.Description,
		Enabled:                true,
	}

	// Default to accept_new if not specified
	repository.SSHHostKeyVerification = cmp.Or(repository.SSHHostKeyVerification, "accept_new")

	if req.Enabled != nil {
		repository.Enabled = *req.Enabled
	}

	// Encrypt sensitive fields
	if req.Token != "" {
		encrypted, err := crypto.Encrypt(req.Token)
		if err != nil {
			return nil, fmt.Errorf("failed to encrypt token: %w", err)
		}
		repository.Token = encrypted
	}

	if req.SSHKey != "" {
		encrypted, err := crypto.Encrypt(req.SSHKey)
		if err != nil {
			return nil, fmt.Errorf("failed to encrypt SSH key: %w", err)
		}
		repository.SSHKey = encrypted
	}

	if req.SigningKey != "" {
		signingKey, passphrase, err := encryptSigningKeyInternal(req.SigningKey, req.SigningKeyPassphrase)
		if err != nil {
			return nil, err
		}
		repository.SigningKey = signingKey
		repository.SigningKeyPassphrase = passphrase
	}

	if err := s.db.WithContext(ctx).Create(&repository).Error; err != nil {
		return nil, fmt.Errorf("failed to create repository: %w", err)
	}

	// Log event
	_, _ = s.eventService.CreateEvent(ctx, event.CreateEventRequest{
		Type:         event.EventTypeGitRepositoryCreate,
		Severity:     event.EventSeveritySuccess,
		Title:        "Git repository created",
		Description:  fmt.Sprintf("Created git repository '%s' (%s)", repository.Name, repository.URL),
		ResourceType: new("git_repository"),
		ResourceID:   new(repository.ID),
		ResourceName: new(repository.Name),
		UserID:       new(actor.ID),
		Username:     new(actor.Username),
	})

	return &repository, nil
}

func (s *GitRepositoryService) UpdateRepository(ctx context.Context, id string, req gitops.UpdateRepositoryRequest, actor user.Actor) (*GitRepository, error) {
	if err := normalization.Normalize(&req); err != nil {
		return nil, err
	}
	repository, err := s.GetRepositoryByID(ctx, id)
	if err != nil {
		return nil, err
	}

	if validateCredentialTargetChangeErr := validation.ValidateCredentialTargetChange(
		"repository URL",
		repository.URL,
		req.URL,
		nil,
		map[string]bool{
			"sshKey": repository.SSHKey != "",
			"token":  repository.Token != "",
		},
		map[string]bool{
			"sshKey": req.SSHKey != nil,
			"token":  req.Token != nil,
		},
	); validateCredentialTargetChangeErr != nil {
		return nil, validateCredentialTargetChangeErr
	}

	updates := make(map[string]any)

	if req.Name != nil {
		updates["name"] = *req.Name
	}
	if req.URL != nil {
		updates["url"] = *req.URL
	}
	if req.AuthType != nil {
		updates["auth_type"] = *req.AuthType
	}
	if req.Username != nil {
		updates["username"] = *req.Username
	}
	if req.Description != nil {
		updates["description"] = *req.Description
	}
	if req.Enabled != nil {
		updates["enabled"] = *req.Enabled
	}
	if req.SSHHostKeyVerification != nil {
		updates["ssh_host_key_verification"] = *req.SSHHostKeyVerification
	}
	if req.CommitAuthorName != nil {
		updates["commit_author_name"] = *req.CommitAuthorName
	}
	if req.CommitAuthorEmail != nil {
		updates["commit_author_email"] = *req.CommitAuthorEmail
	}

	if req.Token != nil {
		if *req.Token == "" {
			updates["token"] = ""
		} else {
			encrypted, encryptErr := crypto.Encrypt(*req.Token)
			if encryptErr != nil {
				return nil, fmt.Errorf("failed to encrypt token: %w", encryptErr)
			}
			updates["token"] = encrypted
		}
	}

	if req.SSHKey != nil {
		if *req.SSHKey == "" {
			updates["ssh_key"] = ""
		} else {
			encrypted, encryptSSHKeyErr := crypto.Encrypt(*req.SSHKey)
			if encryptSSHKeyErr != nil {
				return nil, fmt.Errorf("failed to encrypt SSH key: %w", encryptSSHKeyErr)
			}
			updates["ssh_key"] = encrypted
		}
	}

	if applySigningKeyUpdateErr := applySigningKeyUpdateInternal(repository, req, updates); applySigningKeyUpdateErr != nil {
		return nil, applySigningKeyUpdateErr
	}

	if len(updates) > 0 {
		if updateRepositoryErr := s.db.WithContext(ctx).Model(repository).Updates(updates).Error; updateRepositoryErr != nil {
			return nil, fmt.Errorf("failed to update repository: %w", updateRepositoryErr)
		}

		// Log event
		_, _ = s.eventService.CreateEvent(ctx, event.CreateEventRequest{
			Type:         event.EventTypeGitRepositoryUpdate,
			Severity:     event.EventSeveritySuccess,
			Title:        "Git repository updated",
			Description:  fmt.Sprintf("Updated git repository '%s'", repository.Name),
			ResourceType: new("git_repository"),
			ResourceID:   new(repository.ID),
			ResourceName: new(repository.Name),
			UserID:       new(actor.ID),
			Username:     new(actor.Username),
		})
	}

	return s.GetRepositoryByID(ctx, id)
}

func (s *GitRepositoryService) DeleteRepository(ctx context.Context, id string, actor user.Actor) error {
	// Check if repository is used by any syncs
	var count int64
	if err := s.db.WithContext(ctx).Table("gitops_syncs").Where("repository_id = ?", id).Count(&count).Error; err != nil {
		return fmt.Errorf("failed to check repository usage: %w", err)
	}

	if count > 0 {
		return common.Classify(common.ErrConflict, fmt.Errorf("repository is used by %d sync configuration(s)", count))
	}

	// Get repository info before deleting
	repository, err := s.GetRepositoryByID(ctx, id)
	if err != nil {
		return err
	}

	if deleteRepositoryErr := s.db.WithContext(ctx).Where("id = ?", id).Delete(&GitRepository{}).Error; deleteRepositoryErr != nil {
		return fmt.Errorf("failed to delete repository: %w", deleteRepositoryErr)
	}

	// Log event
	_, _ = s.eventService.CreateEvent(ctx, event.CreateEventRequest{
		Type:         event.EventTypeGitRepositoryDelete,
		Severity:     event.EventSeverityInfo,
		Title:        "Git repository deleted",
		Description:  fmt.Sprintf("Deleted git repository '%s'", repository.Name),
		ResourceType: new("git_repository"),
		ResourceID:   new(repository.ID),
		ResourceName: new(repository.Name),
		UserID:       new(actor.ID),
		Username:     new(actor.Username),
	})

	return nil
}

func (s *GitRepositoryService) TestConnection(ctx context.Context, id, branch string, actor user.Actor) error {
	localSettings := s.settingsService.GetSettingsConfig()
	ctx, cancel := context.WithTimeout(ctx, timeouts.GetDuration(localSettings.GitOperationTimeout.AsInt(), timeouts.DefaultGitOperation))
	defer cancel()

	repository, err := s.GetRepositoryByID(ctx, id)
	if err != nil {
		return err
	}

	authConfig, err := s.GetAuthConfig(ctx, repository)
	if err != nil {
		return err
	}

	err = s.Client.TestConnection(ctx, repository.URL, branch, authConfig)
	if err != nil {
		// Log error event
		_, _ = s.eventService.CreateEvent(ctx, event.CreateEventRequest{
			Type:         event.EventTypeGitRepositoryError,
			Severity:     event.EventSeverityError,
			Title:        "Git repository connection test failed",
			Description:  fmt.Sprintf("Failed to connect to repository '%s': %s", repository.Name, err.Error()),
			ResourceType: new("git_repository"),
			ResourceID:   new(repository.ID),
			ResourceName: new(repository.Name),
			UserID:       new(actor.ID),
			Username:     new(actor.Username),
		})
		return err
	}

	// Log success event
	_, _ = s.eventService.CreateEvent(ctx, event.CreateEventRequest{
		Type:         event.EventTypeGitRepositoryTest,
		Severity:     event.EventSeveritySuccess,
		Title:        "Git repository connection successful",
		Description:  fmt.Sprintf("Successfully connected to repository '%s'", repository.Name),
		ResourceType: new("git_repository"),
		ResourceID:   new(repository.ID),
		ResourceName: new(repository.Name),
		UserID:       new(actor.ID),
		Username:     new(actor.Username),
	})

	return nil
}

func (s *GitRepositoryService) GetAuthConfig(ctx context.Context, repository *GitRepository) (git.AuthConfig, error) {
	authConfig := git.AuthConfig{
		AuthType:               repository.AuthType,
		Username:               repository.Username,
		SSHHostKeyVerification: repository.SSHHostKeyVerification,
	}

	if repository.Token != "" {
		token, err := crypto.Decrypt(repository.Token)
		if err != nil {
			return authConfig, fmt.Errorf("failed to decrypt token: %w", err)
		}
		authConfig.Token = token
	}

	if repository.SSHKey != "" {
		sshKey, err := crypto.Decrypt(repository.SSHKey)
		if err != nil {
			return authConfig, fmt.Errorf("failed to decrypt SSH key: %w", err)
		}
		authConfig.SSHKey = sshKey
	}

	return authConfig, nil
}

// GetCommitIdentity returns the author for commits Arcane pushes to the
// repository, with the signing key unlocked when one is stored.
func (s *GitRepositoryService) GetCommitIdentity(ctx context.Context, repository *GitRepository) (git.CommitIdentity, error) {
	identity := git.CommitIdentity{Name: repository.CommitAuthorName, Email: repository.CommitAuthorEmail}
	identity.Name = cmp.Or(identity.Name, defaultCommitAuthorName)
	identity.Email = cmp.Or(identity.Email, defaultCommitAuthorEmail)
	if repository.SigningKey == "" {
		return identity, nil
	}
	armored, err := crypto.Decrypt(repository.SigningKey)
	if err != nil {
		return identity, fmt.Errorf("failed to decrypt signing key: %w", err)
	}
	passphrase := ""
	if repository.SigningKeyPassphrase != "" {
		if passphrase, err = crypto.Decrypt(repository.SigningKeyPassphrase); err != nil {
			return identity, fmt.Errorf("failed to decrypt signing key passphrase: %w", err)
		}
	}
	identity.SignKey, err = git.ParseSigningKey(armored, passphrase)
	return identity, err
}

// encryptSigningKeyInternal validates that armored unlocks with passphrase and
// returns both encrypted for storage.
func encryptSigningKeyInternal(armored, passphrase string) (string, string, error) {
	if _, err := git.ParseSigningKey(armored, passphrase); err != nil {
		return "", "", common.Classify(common.ErrValidation, &base.FieldError{Field: "signingKey", Err: err})
	}
	encryptedKey, err := crypto.Encrypt(armored)
	if err != nil {
		return "", "", fmt.Errorf("failed to encrypt signing key: %w", err)
	}
	encryptedPassphrase := ""
	if passphrase != "" {
		if encryptedPassphrase, err = crypto.Encrypt(passphrase); err != nil {
			return "", "", fmt.Errorf("failed to encrypt signing key passphrase: %w", err)
		}
	}
	return encryptedKey, encryptedPassphrase, nil
}

// applySigningKeyUpdateInternal resolves the signing key and passphrase an
// update leaves in place, re-validating the pair whenever either changes.
func applySigningKeyUpdateInternal(current *GitRepository, req gitops.UpdateRepositoryRequest, updates map[string]any) error {
	if req.SigningKey == nil && req.SigningKeyPassphrase == nil {
		return nil
	}
	if req.SigningKey != nil && *req.SigningKey == "" {
		updates["signing_key"] = ""
		updates["signing_key_passphrase"] = ""
		return nil
	}
	armored := ""
	if req.SigningKey != nil {
		armored = *req.SigningKey
	} else if current.SigningKey != "" {
		decrypted, err := crypto.Decrypt(current.SigningKey)
		if err != nil {
			return fmt.Errorf("failed to decrypt signing key: %w", err)
		}
		armored = decrypted
	}
	if armored == "" {
		return nil
	}
	passphrase := ""
	if req.SigningKeyPassphrase != nil {
		passphrase = *req.SigningKeyPassphrase
	} else if current.SigningKeyPassphrase != "" {
		decrypted, err := crypto.Decrypt(current.SigningKeyPassphrase)
		if err != nil {
			return fmt.Errorf("failed to decrypt signing key passphrase: %w", err)
		}
		passphrase = decrypted
	}
	encryptedKey, encryptedPassphrase, err := encryptSigningKeyInternal(armored, passphrase)
	if err != nil {
		return err
	}
	updates["signing_key"] = encryptedKey
	updates["signing_key_passphrase"] = encryptedPassphrase
	return nil
}

func (s *GitRepositoryService) ListBranches(ctx context.Context, id string) ([]gitops.BranchInfo, error) {
	localSettings := s.settingsService.GetSettingsConfig()
	listCtx, cancel := context.WithTimeout(ctx, timeouts.GetDuration(localSettings.GitOperationTimeout.AsInt(), timeouts.DefaultGitOperation))
	defer cancel()

	repository, err := s.GetRepositoryByID(listCtx, id)
	if err != nil {
		return nil, err
	}

	authConfig, err := s.GetAuthConfig(listCtx, repository)
	if err != nil {
		return nil, err
	}

	branches, err := s.Client.ListBranches(listCtx, repository.URL, authConfig)
	if err != nil {
		return nil, fmt.Errorf("failed to list branches: %w", err)
	}

	var result []gitops.BranchInfo
	for _, branch := range branches {
		result = append(result, gitops.BranchInfo{
			Name:      branch.Name,
			IsDefault: branch.IsDefault,
		})
	}

	return result, nil
}

func (s *GitRepositoryService) BrowseFiles(ctx context.Context, id, branch, path string) (*gitops.BrowseResponse, error) {
	localSettings := s.settingsService.GetSettingsConfig()
	ctx, cancel := context.WithTimeout(ctx, timeouts.GetDuration(localSettings.GitOperationTimeout.AsInt(), timeouts.DefaultGitOperation))
	defer cancel()

	repository, err := s.GetRepositoryByID(ctx, id)
	if err != nil {
		return nil, err
	}

	authConfig, err := s.GetAuthConfig(ctx, repository)
	if err != nil {
		return nil, err
	}

	// Clone the repository
	repoPath, err := s.Clone(ctx, repository.URL, branch, authConfig, 1)
	if err != nil {
		return nil, fmt.Errorf("failed to clone repository: %w", err)
	}
	defer s.Discard(ctx, repoPath)

	// Browse the tree
	files, err := s.BrowseTree(ctx, repoPath, path)
	if err != nil {
		return nil, err
	}

	return &gitops.BrowseResponse{
		Path:  path,
		Files: files,
	}, nil
}

// SyncRepositories syncs repositories from a manager to this agent instance.
// It creates, updates, or deletes repositories to match the provided list.
func (s *GitRepositoryService) SyncRepositories(ctx context.Context, syncItems []gitops.RepositorySync) error {
	if err := normalization.Normalize(&syncItems); err != nil {
		return err
	}
	existingMap, err := s.getExistingRepositoriesMap(ctx)
	if err != nil {
		return err
	}

	syncedIDs := make(map[string]bool)

	// Process each sync item
	for _, item := range syncItems {
		syncedIDs[item.ID] = true

		if processSyncItemErr := s.processSyncItem(ctx, item, existingMap); processSyncItemErr != nil {
			return processSyncItemErr
		}
	}

	// Delete repositories that are not in the sync list
	return s.deleteUnsynced(ctx, existingMap, syncedIDs)
}

func (s *GitRepositoryService) getExistingRepositoriesMap(ctx context.Context) (map[string]*GitRepository, error) {
	var existing []GitRepository
	if err := s.db.WithContext(ctx).Find(&existing).Error; err != nil {
		return nil, fmt.Errorf("failed to get existing repositories: %w", err)
	}

	existingMap := make(map[string]*GitRepository)
	for i := range existing {
		existingMap[existing[i].ID] = &existing[i]
	}
	return existingMap, nil
}

func (s *GitRepositoryService) processSyncItem(ctx context.Context, item gitops.RepositorySync, existingMap map[string]*GitRepository) error {
	existing, exists := existingMap[item.ID]
	if exists {
		return s.updateExistingRepository(ctx, item, existing)
	}
	return s.createNewRepository(ctx, item)
}

func (s *GitRepositoryService) updateExistingRepository(ctx context.Context, item gitops.RepositorySync, existing *GitRepository) error {
	needsUpdate, err := s.checkRepositoryNeedsUpdate(item, existing)
	if err != nil {
		return fmt.Errorf("failed to reconcile repository %s: %w", item.ID, err)
	}

	if needsUpdate {
		// Use Save to trigger GORM callbacks including UpdatedAt
		if syncRepositoryErr := s.db.WithContext(ctx).Save(existing).Error; syncRepositoryErr != nil {
			return fmt.Errorf("failed to update repository %s: %w", item.ID, syncRepositoryErr)
		}
	}

	return nil
}

func (s *GitRepositoryService) checkRepositoryNeedsUpdate(item gitops.RepositorySync, existing *GitRepository) (bool, error) {
	needsUpdate := utils.ApplyChanged(&existing.Name, mo.Some(item.Name))
	needsUpdate = utils.ApplyChanged(&existing.URL, mo.Some(item.URL)) || needsUpdate
	needsUpdate = utils.ApplyChanged(&existing.AuthType, mo.Some(item.AuthType)) || needsUpdate
	needsUpdate = utils.ApplyChanged(&existing.Username, mo.Some(item.Username)) || needsUpdate
	needsUpdate = utils.ApplyChanged(&existing.SSHHostKeyVerification, mo.Some(item.SSHHostKeyVerification)) || needsUpdate
	needsUpdate = utils.ApplyChanged(&existing.CommitAuthorName, mo.Some(item.CommitAuthorName)) || needsUpdate
	needsUpdate = utils.ApplyChanged(&existing.CommitAuthorEmail, mo.Some(item.CommitAuthorEmail)) || needsUpdate
	needsUpdate = utils.ApplyNullable(&existing.Description, mo.PointerToOption(item.Description)) || needsUpdate
	needsUpdate = utils.ApplyChanged(&existing.Enabled, mo.Some(item.Enabled)) || needsUpdate

	signingKey, passphrase := item.SigningKey, item.SigningKeyPassphrase
	if signingKey != "" {
		if _, err := git.ParseSigningKey(signingKey, passphrase); err != nil {
			signingKey, passphrase = "", ""
		}
	}
	for _, credential := range []struct {
		field     *string
		plaintext string
	}{
		{&existing.Token, item.Token},
		{&existing.SSHKey, item.SSHKey},
		{&existing.SigningKey, signingKey},
		{&existing.SigningKeyPassphrase, passphrase},
	} {
		changed, err := utils.ApplyEncrypted(credential.field, credential.plaintext)
		if err != nil {
			return false, err
		}
		needsUpdate = changed || needsUpdate
	}
	return needsUpdate, nil
}

func (s *GitRepositoryService) createNewRepository(ctx context.Context, item gitops.RepositorySync) error {
	var encryptedToken, encryptedSSHKey string
	var err error

	if item.Token != "" {
		encryptedToken, err = crypto.Encrypt(item.Token)
		if err != nil {
			return fmt.Errorf("failed to encrypt token for repository %s: %w", item.ID, err)
		}
	}

	if item.SSHKey != "" {
		encryptedSSHKey, err = crypto.Encrypt(item.SSHKey)
		if err != nil {
			return fmt.Errorf("failed to encrypt SSH key for repository %s: %w", item.ID, err)
		}
	}

	var encryptedSigningKey, encryptedPassphrase string
	if item.SigningKey != "" {
		encryptedSigningKey, encryptedPassphrase, err = encryptSigningKeyInternal(item.SigningKey, item.SigningKeyPassphrase)
		if err != nil {
			return fmt.Errorf("failed to encrypt signing key for repository %s: %w", item.ID, err)
		}
	}

	sshHostKeyVerification := cmp.Or(item.SSHHostKeyVerification, "accept_new")

	repo := GitRepository{
		Name:                   item.Name,
		URL:                    item.URL,
		AuthType:               item.AuthType,
		Username:               item.Username,
		Token:                  encryptedToken,
		SSHKey:                 encryptedSSHKey,
		SSHHostKeyVerification: sshHostKeyVerification,
		CommitAuthorName:       item.CommitAuthorName,
		CommitAuthorEmail:      item.CommitAuthorEmail,
		SigningKey:             encryptedSigningKey,
		SigningKeyPassphrase:   encryptedPassphrase,
		Description:            item.Description,
		Enabled:                item.Enabled,
		ID:                     item.ID,
	}
	if createRepositoryErr := s.db.WithContext(ctx).Create(&repo).Error; createRepositoryErr != nil {
		return fmt.Errorf("failed to create repository %s: %w", item.ID, createRepositoryErr)
	}
	return nil
}

func (s *GitRepositoryService) deleteUnsynced(ctx context.Context, existingMap map[string]*GitRepository, syncedIDs map[string]bool) error {
	var unsyncedIDs []string
	for id := range existingMap {
		if !syncedIDs[id] {
			unsyncedIDs = append(unsyncedIDs, id)
		}
	}
	if len(unsyncedIDs) == 0 {
		return nil
	}
	if err := s.db.WithContext(ctx).Delete(&GitRepository{}, "id IN ?", unsyncedIDs).Error; err != nil {
		return fmt.Errorf("failed to delete repositories %v: %w", unsyncedIDs, err)
	}
	return nil
}