Avoid pruning unused dependencies for buf dep update

private/buf/bufworkspace/malformed_dep.go

@@ -38,11 +38,12 @@ const (
 type MalformedDepType int
 
 // MalformedDep is a dep that was malformed in some way in the buf.yaml.
+// It provides the module ref information and the malformed dep type.
 type MalformedDep interface {
- // ModuleFullName returns the full name of the malformed dep.
+ // ModuleRef is the module ref information of the malformed dep.
  //
  // Always present.
- ModuleFullName() bufmodule.ModuleFullName
+ ModuleRef() bufmodule.ModuleRef
  // Type is why this dep was malformed.
  //
  // Always present.
@@ -105,7 +106,7 @@ func MalformedDepsForWorkspace(workspace Workspace) ([]MalformedDep, error) {
  malformedDeps = append(
  malformedDeps,
  newMalformedDep(
- configuredDepModuleRef.ModuleFullName(),
+ configuredDepModuleRef,
  MalformedDepTypeUnused,
  ),
  )
@@ -114,8 +115,8 @@ func MalformedDepsForWorkspace(workspace Workspace) ([]MalformedDep, error) {
  sort.Slice(
  malformedDeps,
  func(i int, j int) bool {
- return malformedDeps[i].ModuleFullName().String() <
- malformedDeps[j].ModuleFullName().String()
+ return malformedDeps[i].ModuleRef().ModuleFullName().String() <
+ malformedDeps[j].ModuleRef().ModuleFullName().String()
  },
  )
  return malformedDeps, nil
@@ -124,19 +125,22 @@ func MalformedDepsForWorkspace(workspace Workspace) ([]MalformedDep, error) {
 // *** PRIVATE ***
 
 type malformedDep struct {
- moduleFullName bufmodule.ModuleFullName
+ moduleRef  bufmodule.ModuleRef
  malformedDepType MalformedDepType
 }
 
-func newMalformedDep(moduleFullName bufmodule.ModuleFullName, malformedDepType MalformedDepType) *malformedDep {
+func newMalformedDep(
+ moduleRef bufmodule.ModuleRef,
+ malformedDepType MalformedDepType,
+) *malformedDep {
  return &malformedDep{
- moduleFullName: moduleFullName,
+ moduleRef:  moduleRef,
  malformedDepType: malformedDepType,
  }
 }
 
-func (m *malformedDep) ModuleFullName() bufmodule.ModuleFullName {
- return m.moduleFullName
+func (m *malformedDep) ModuleRef() bufmodule.ModuleRef {
+ return m.moduleRef
 }
 
 func (m *malformedDep) Type() MalformedDepType {

private/buf/bufworkspace/workspace_test.go

@@ -221,9 +221,9 @@ func TestUnusedDep(t *testing.T) {
  malformedDeps, err := MalformedDepsForWorkspace(workspace)
  require.NoError(t, err)
  require.Equal(t, 2, len(malformedDeps))
- require.Equal(t, "buf.testing/acme/date", malformedDeps[0].ModuleFullName().String())
+ require.Equal(t, "buf.testing/acme/date", malformedDeps[0].ModuleRef().ModuleFullName().String())
  require.Equal(t, MalformedDepTypeUnused, malformedDeps[0].Type())
- require.Equal(t, "buf.testing/acme/extension", malformedDeps[1].ModuleFullName().String())
+ require.Equal(t, "buf.testing/acme/extension", malformedDeps[1].ModuleRef().ModuleFullName().String())
  require.Equal(t, MalformedDepTypeUnused, malformedDeps[1].Type())
 }
 

private/buf/cmd/buf/command/dep/depprune/depprune.go

@@ -75,5 +75,14 @@ func run(
  if err != nil {
  return err
  }
- return internal.Prune(ctx, container.Logger(), controller, configuredDepModuleKeys, workspaceDepManager, dirPath)
+ return internal.Prune(
+ ctx,
+ container.Logger(),
+ controller,
+ container,
+ configuredDepModuleKeys,
+ workspaceDepManager,
+ dirPath,
+ false, // keepUnused
+ )
 }

private/buf/cmd/buf/command/dep/depupdate/depupdate.go

@@ -149,5 +149,14 @@ func run(
  // Note that the check to make sure configuredDepModuleKeys is a superset of the remote deps should be a no-op
  // in this case, they should be equivalent based on the updates we just did, but we do the check
  // anyways to triple verify.
- return internal.Prune(ctx, logger, controller, configuredDepModuleKeys, workspaceDepManager, dirPath)
+ return internal.Prune(
+ ctx,
+ logger,
+ controller,
+ container,
+ configuredDepModuleKeys,
+ workspaceDepManager,
+ dirPath,
+ true, // keepUnused
+ )
 }

private/buf/cmd/buf/command/dep/internal/internal.go

@@ -53,11 +53,12 @@ func ModuleKeysAndTransitiveDepModuleKeysForModuleRefs(
 
 // Prune prunes the buf.lock.
 //
-// Used by both mod prune and mod update.
+// Used by both dep/mod prune and dep/mod update.
 func Prune(
  ctx context.Context,
  logger *zap.Logger,
  controller bufctl.Controller,
+ container appext.Container,
  // Contains all the Modules and their transitive dependencies based on the buf.yaml.
  //
  // All dependencies must be within this group from RemoteDepsForModuleSet. If a dependency
@@ -69,6 +70,9 @@ func Prune(
  bufYAMLBasedDepModuleKeys []bufmodule.ModuleKey,
  workspaceDepManager bufworkspace.WorkspaceDepManager,
  dirPath string,
+ // For some use cases, such as dep/mod update, we want to keep unused declared dependencies
+ // in buf.lock (and only prune dependencies that are no longer declared) when set to true.
+ keepUnused bool,
 ) error {
  workspace, err := controller.GetWorkspace(ctx, dirPath, bufctl.WithIgnoreAndDisallowV1BufWorkYAMLs())
  if err != nil {
@@ -88,18 +92,20 @@ func Prune(
  if err != nil {
  return err
  }
+ var unusedModuleRefs []bufmodule.ModuleRef
  for _, malformedDep := range malformedDeps {
  switch t := malformedDep.Type(); t {
  case bufworkspace.MalformedDepTypeUnused:
  logger.Sugar().Warnf(
  `Module %[1]s is declared in your buf.yaml deps but is unused. This command only modifies buf.lock files, not buf.yaml files. Please remove %[1]s from your buf.yaml deps if it is not needed.`,
- malformedDep.ModuleFullName(),
+ malformedDep.ModuleRef().ModuleFullName(),
  )
+ unusedModuleRefs = append(unusedModuleRefs, malformedDep.ModuleRef())
  default:
  return fmt.Errorf("unknown MalformedDepType: %v", t)
  }
  }
- // Sep that actual computed remote dependencies based on imports. These are all
+ // Step that actual computed remote dependencies based on imports. These are all
  // that is needed for buf.lock.
  depModules, err := bufmodule.RemoteDepsForModuleSet(workspace)
  if err != nil {
@@ -114,6 +120,34 @@ func Prune(
  if err != nil {
  return err
  }
+ // If keepUnused is set to true, we add the unused declared dependencies to depModuleKeys.
+ if keepUnused {
+ moduleKeyProvider, err := bufcli.NewModuleKeyProvider(container)
+ if err != nil {
+ return err
+ }
+ unusedModuleKeys, err := moduleKeyProvider.GetModuleKeysForModuleRefs(
+ ctx,
+ unusedModuleRefs,
+ workspaceDepManager.BufLockFileDigestType(),
+ )
+ if err != nil {
+ return err
+ }
+ foundDepModuleKeys := copy(make([]bufmodule.ModuleKey, len(depModuleKeys)), depModuleKeys)
+ depModuleKeys = append(depModuleKeys, unusedModuleKeys...)
+ // Check that `depModuleKeys` and `unusedModuleKeys` do not overlap, since `depModuleKeys`
+ // should be based on used deps.
+ // Return a syserror if an overlap is found.
+ dedupedDepModuleKeys := slicesext.DeduplicateAny(
+ depModuleKeys,
+ func(moduleKey bufmodule.ModuleKey) string { return moduleKey.ModuleFullName().String() },
+ )
+ if len(depModuleKeys) != len(dedupedDepModuleKeys) {
+ return syserror.Newf("unexpected overlap found between depModuleKeys and unsuedModuleKeys: %v, %v", foundDepModuleKeys, unusedModuleKeys)
+ }
+ }
+
  if err := validateModuleKeysContains(bufYAMLBasedDepModuleKeys, depModuleKeys); err != nil {
  return err
  }