Change CheckSyncedGitCommits to IsGitCommitSynced

private/buf/bufsync/bufsync.go

@@ -167,14 +167,13 @@ type Handler interface {
 		branch string,
 	) (git.Hash, error)
 
-	// CheckSyncedGitCommits is invoked when syncing branches to know which commits hashes from a set
-	// are already synced inthe BSR. It expects to receive the commit hashes that are synced already. If
-	// an error is returned, sync will abort.
-	CheckSyncedGitCommits(
+	// IsGitCommitSynced is invoked when syncing branches to know if a Git commit is already synced.
+	// If an error is returned, sync will abort.
+	IsGitCommitSynced(
 		ctx context.Context,
 		module bufmoduleref.ModuleIdentity,
-		commitHashes map[string]struct{},
-	) (map[string]struct{}, error)
+		hash git.Hash,
+	) (bool, error)
 
 	// GetModuleReleaseBranch is invoked before syncing, to gather release branch names for all the
 	// modules that are about to be synced. If the BSR module does not exist, the implementation should

private/buf/bufsync/bufsync_test.go

@@ -221,18 +221,13 @@ func (c *mockSyncHandler) SyncModuleCommit(
 	return err
 }
 
-func (c *mockSyncHandler) CheckSyncedGitCommits(
+func (c *mockSyncHandler) IsGitCommitSynced(
 	ctx context.Context,
 	module bufmoduleref.ModuleIdentity,
-	commitHashes map[string]struct{},
-) (map[string]struct{}, error) {
-	syncedHashes := make(map[string]struct{})
-	for hash := range commitHashes {
-		if _, isSynced := c.syncedCommitsSHAs[hash]; isSynced {
-			syncedHashes[hash] = struct{}{}
-		}
-	}
-	return syncedHashes, nil
+	hash git.Hash,
+) (bool, error) {
+	_, isSynced := c.syncedCommitsSHAs[hash.Hex()]
+	return isSynced, nil
 }
 
 var _ bufsync.Handler = (*mockSyncHandler)(nil)

private/buf/bufsync/syncer.go

@@ -425,7 +425,7 @@ func (s *syncer) branchSyncableCommits(
 		commitHash := commit.Hash().Hex()
 		logger := logger.With(zap.String("commit", commitHash))
 		// check if this commit is already synced
-		isSynced, err := s.isGitCommitSynced(ctx, moduleIdentity, commitHash)
+		isSynced, err := s.isGitCommitSynced(ctx, moduleIdentity, commit.Hash())
 		if err != nil {
 			return fmt.Errorf(
 				"checking if module %s already synced git commit %s: %w",
@@ -516,26 +516,25 @@ func (s *syncer) branchSyncableCommits(
 }
 
 // isGitCommitSynced checks if a commit hash is already synced to a BSR module.
-func (s *syncer) isGitCommitSynced(ctx context.Context, moduleIdentity bufmoduleref.ModuleIdentity, commitHash string) (bool, error) {
+func (s *syncer) isGitCommitSynced(ctx context.Context, moduleIdentity bufmoduleref.ModuleIdentity, commitHash git.Hash) (bool, error) {
 	modIdentity := moduleIdentity.IdentityString()
 	// check local cache first
 	if syncedModuleCommits, ok := s.modulesIdentitiesToCommitsSyncedCache[modIdentity]; ok {
-		if _, commitSynced := syncedModuleCommits[commitHash]; commitSynced {
+		if _, commitSynced := syncedModuleCommits[commitHash.Hex()]; commitSynced {
 			return true, nil
 		}
 	}
 	// not in the cache, request BSR check
-	syncedModuleCommits, err := s.handler.CheckSyncedGitCommits(ctx, moduleIdentity, map[string]struct{}{commitHash: {}})
+	commitSynced, err := s.handler.IsGitCommitSynced(ctx, moduleIdentity, commitHash)
 	if err != nil {
 		return false, err
 	}
-	_, commitSynced := syncedModuleCommits[commitHash]
 	if commitSynced {
 		// populate local cache
 		if s.modulesIdentitiesToCommitsSyncedCache[modIdentity] == nil {
 			s.modulesIdentitiesToCommitsSyncedCache[modIdentity] = make(map[string]struct{})
 		}
-		s.modulesIdentitiesToCommitsSyncedCache[modIdentity][commitHash] = struct{}{}
+		s.modulesIdentitiesToCommitsSyncedCache[modIdentity][commitHash.Hex()] = struct{}{}
 	}
 	return commitSynced, nil
 }

private/buf/cmd/buf/command/alpha/repo/reposync/sync_handler.go

@@ -31,7 +31,6 @@ import (
 	"github.com/bufbuild/buf/private/pkg/connectclient"
 	"github.com/bufbuild/buf/private/pkg/git"
 	"github.com/bufbuild/buf/private/pkg/storage"
-	"github.com/bufbuild/buf/private/pkg/stringutil"
 	"go.uber.org/zap"
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
@@ -88,30 +87,22 @@ func (h *syncHandler) ResolveSyncPoint(ctx context.Context, module bufmoduleref.
 	return hash, nil
 }
 
-func (h *syncHandler) CheckSyncedGitCommits(ctx context.Context, module bufmoduleref.ModuleIdentity, commitHashes map[string]struct{}) (map[string]struct{}, error) {
+func (h *syncHandler) IsGitCommitSynced(ctx context.Context, module bufmoduleref.ModuleIdentity, hash git.Hash) (bool, error) {
 	service := connectclient.Make(h.clientConfig, module.Remote(), registryv1alpha1connect.NewLabelServiceClient)
 	res, err := service.GetLabelsInNamespace(ctx, connect.NewRequest(&registryv1alpha1.GetLabelsInNamespaceRequest{
 		RepositoryOwner: module.Owner(),
 		RepositoryName:  module.Repository(),
 		LabelNamespace:  registryv1alpha1.LabelNamespace_LABEL_NAMESPACE_GIT_COMMIT,
-		LabelNames:      stringutil.MapToSlice(commitHashes),
+		LabelNames:      []string{hash.Hex()},
 	}))
 	if err != nil {
 		if connect.CodeOf(err) == connect.CodeNotFound {
 			// Repo is not created
-			return nil, nil
-		}
-		return nil, fmt.Errorf("get labels in namespace: %w", err)
-	}
-	syncedHashes := make(map[string]struct{})
-	for _, label := range res.Msg.Labels {
-		syncedHash := label.LabelName.Name
-		if _, expected := commitHashes[syncedHash]; !expected {
-			return nil, fmt.Errorf("received unexpected synced hash %q, expected %v", syncedHash, commitHashes)
+			return false, nil
 		}
-		syncedHashes[syncedHash] = struct{}{}
+		return false, fmt.Errorf("get labels in namespace: %w", err)
 	}
-	return syncedHashes, nil
+	return len(res.Msg.Labels) == 1, nil
 }
 
 func (h *syncHandler) GetModuleReleaseBranch(ctx context.Context, module bufmoduleref.ModuleIdentity) (string, error) {