feat: automatic migrate the buf configs to v2

changelog.md

@@ -24,6 +24,7 @@
 - [#4289](https://github.com/ignite/cli/pull/4289), [#4423](https://github.com/ignite/cli/pull/4423), [#4432](https://github.com/ignite/cli/pull/4432) Cosmos SDK v0.52 support
 - [#4477](https://github.com/ignite/cli/pull/4477) IBC v10 support
 - [#4166](https://github.com/ignite/cli/issues/4166) Migrate buf config files to v2
+- [#4494](https://github.com/ignite/cli/pull/4494) Automatic migrate the buf configs to v2
 
 ### Changes
 

ignite/cmd/chain.go

@@ -14,6 +14,7 @@
 	"github.com/ignite/cli/v29/ignite/pkg/cliui"
 	"github.com/ignite/cli/v29/ignite/pkg/cliui/colors"
 	"github.com/ignite/cli/v29/ignite/pkg/cliui/icons"
+	"github.com/ignite/cli/v29/ignite/pkg/cosmosbuf"
 	"github.com/ignite/cli/v29/ignite/pkg/cosmosgen"
 	"github.com/ignite/cli/v29/ignite/pkg/errors"
 	"github.com/ignite/cli/v29/ignite/pkg/goanalysis"
@@ -28,13 +29,17 @@
 	msgMigrationPrefix       = "Your blockchain config version is v%d and the latest is v%d."
 	msgMigrationPrompt       = "Would you like to upgrade your config file to v%d"
 	msgMigrationBuf          = "Now ignite supports the `buf.build` (https://buf.build) registry to manage the protobuf dependencies. The embed protoc binary was deprecated and, your blockchain is still using it. Would you like to upgrade and add the `buf.build` config files to `proto/` folder"
+	msgMigrationBufV2        = "Now ignite supports the new `buf.build` (https://buf.build) v2 configuration. Would you like to upgrade your buf files to v2 using the `buf config migrate` command"
 	msgMigrationBufProtoDir  = "Ignite proto directory path from the chain config doesn't match the proto directory path from the chain `buf.work.yaml`. Do you want to add the proto path `%[1]v` to the directories list from the buf work file"
 	msgMigrationBufProtoDirs = "Chain `buf.work.yaml` file contains directories that don't exist anymore (%[1]v). Do you want to delete them"
 	msgMigrationAddTools     = "Some required imports are missing in %s file: %s. Would you like to add them"
 	msgMigrationRemoveTools  = "File %s contains deprecated imports: %s. Would you like to remove them"
 )
 
-var ErrProtocUnsupported = errors.New("code generation using protoc is only supported by Ignite CLI v0.26.1 or older")
+var (
+	ErrProtocUnsupported           = errors.New("code generation using protoc is only supported by Ignite CLI v0.26.1 or older")
+	ErrBufConfigVersionUnsupported = errors.New("buf config version must be v2")
+)
 
 // NewChain returns a command that groups sub commands related to compiling, serving
 // blockchains and so on.
@@ -192,11 +197,29 @@
 
 func bufMigrationPreRunHandler(cmd *cobra.Command, session *cliui.Session, appPath, protoDir string) error {
 	// check if the buf files exist.
-	hasFiles, err := chain.CheckBufFiles(appPath, protoDir)
+	hasFiles, needMigration, err := chain.CheckBufFiles(appPath, protoDir)
 	if err != nil {
 		return err
 	}
 
+	if needMigration {
+		if !getYes(cmd) {
+			if err := session.AskConfirm(msgMigrationBufV2); err != nil {
+				return ErrBufConfigVersionUnsupported
+			}
+		}
+
+		cacheStorage, err := newCache(cmd)
+		b, err := cosmosbuf.New(cacheStorage, appPath)
+		if err != nil {
+			return err
+		}
+
+		if err := b.Migrate(cmd.Context(), protoDir); err != nil {
+			return err
+		}
+	}
+
 	if !hasFiles {
 		if !getYes(cmd) {
 			if err := session.AskConfirm(msgMigrationBuf); err != nil {

ignite/pkg/cosmosbuf/buf.go

@@ -26,14 +26,18 @@ const (
 	flagOutput                = "output"
 	flagErrorFormat           = "error-format"
 	flagLogFormat             = "log-format"
+	flagWorkspace             = "workspace"
+	flagBufGenYaml            = "buf-gen-yaml"
 	flagIncludeImports        = "include-imports"
 	flagIncludeWellKnownTypes = "include-wkt"
 	flagPath                  = "path"
 	fmtJSON                   = "json"
+	bufGenPrefix              = "buf.gen."
 
 	// CMDGenerate generate command.
 	CMDGenerate Command = "generate"
 	CMDExport   Command = "export"
+	CMDConfig   Command = "config"
 	CMDDep      Command = "dep"
 
 	specCacheNamespace = "generate.buf"
@@ -43,6 +47,7 @@ var (
 	commands = map[Command]struct{}{
 		CMDGenerate: {},
 		CMDExport:   {},
+		CMDConfig:   {},
 		CMDDep:      {},
 	}
 
@@ -152,7 +157,7 @@ func (c Command) String() string {
 // Update updates module dependencies.
 // By default updates all dependencies unless one or more dependencies are specified.
 func (b Buf) Update(ctx context.Context, modDir string) error {
-	files, err := xos.FindFilesExtension(modDir, xos.ProtoFile)
+	files, err := xos.FindFiles(modDir, xos.WithExtension(xos.ProtoFile))
 	if err != nil {
 		return err
 	}
@@ -167,9 +172,35 @@ func (b Buf) Update(ctx context.Context, modDir string) error {
 	return b.runCommand(ctx, cmd...)
 }
 
+// Migrate runs the buf Migrate command for the files in the app directory.
+func (b Buf) Migrate(ctx context.Context, protoDir string) error {
+	yamlFiles, err := xos.FindFiles(protoDir, xos.WithExtension(xos.YAMLFile), xos.WithPrefix(bufGenPrefix))
+	if err != nil {
+		return err
+	}
+	ymlfiles, err := xos.FindFiles(protoDir, xos.WithExtension(xos.YMLFile), xos.WithPrefix(bufGenPrefix))
+	if err != nil {
+		return err
+	}
+	yamlFiles = append(yamlFiles, ymlfiles...)
+
+	flags := map[string]string{
+		flagWorkspace: ".",
+	}
+	if len(yamlFiles) > 0 {
+		flags[flagBufGenYaml] = strings.Join(yamlFiles, ",")
+	}
+
+	cmd, err := b.command(CMDConfig, flags, "migrate")
+	if err != nil {
+		return err
+	}
+	return b.runCommand(ctx, cmd...)
+}
+
 // Export runs the buf Export command for the files in the proto directory.
 func (b Buf) Export(ctx context.Context, protoDir, output string) error {
-	files, err := xos.FindFilesExtension(protoDir, xos.ProtoFile)
+	files, err := xos.FindFiles(protoDir, xos.WithExtension(xos.ProtoFile))
 	if err != nil {
 		return err
 	}
@@ -202,7 +233,7 @@ func (b Buf) Generate(
 	}
 
 	// find all proto files into the path.
-	foundFiles, err := xos.FindFilesExtension(protoPath, xos.ProtoFile)
+	foundFiles, err := xos.FindFiles(protoPath, xos.WithExtension(xos.ProtoFile))
 	if err != nil || len(foundFiles) == 0 {
 		return err
 	}

ignite/pkg/cosmosgen/generate_go.go

@@ -20,10 +20,6 @@ func (g *generator) protoPath() string {
 }
 
 func (g *generator) generateGoGo(ctx context.Context) error {
-	return g.generate(ctx, g.gogoTemplate(), g.goModPath)
-}
-
-func (g *generator) generate(ctx context.Context, template, fromPath string, excluded ...string) error {
 	// create a temporary dir to locate generated code under which later only some of them will be moved to the
 	// app's source code. this also prevents having leftover files in the app's source code or its parent dir - when
 	// command executed directly there - in case of an interrupt.
@@ -38,14 +34,14 @@ func (g *generator) generate(ctx context.Context, template, fromPath string, exc
 		ctx,
 		g.protoPath(),
 		tmp,
-		template,
-		cosmosbuf.ExcludeFiles(excluded...),
+		g.gogoTemplate(),
+		cosmosbuf.ExcludeFiles("*/module.proto"),
 	); err != nil {
 		return err
 	}
 
 	// move generated code for the app under the relative locations in its source code.
-	path := filepath.Join(tmp, fromPath)
+	path := filepath.Join(tmp, g.goModPath)
 	if _, err := os.Stat(path); err == nil {
 		err = copy.Copy(path, g.appPath)
 		if err != nil {

ignite/pkg/cosmosgen/generate_openapi.go

@@ -94,7 +94,7 @@ func (g *generator) generateOpenAPISpec(ctx context.Context) error {
 			return errors.Wrapf(err, "failed to generate openapi spec %s, probally you need to exclude some proto files", protoPath)
 		}
 
-		specs, err := xos.FindFilesExtension(dir, xos.JSONFile)
+		specs, err := xos.FindFiles(dir, xos.WithExtension(xos.JSONFile))
 		if err != nil {
 			return err
 		}

ignite/pkg/xos/files.go

@@ -4,39 +4,64 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 )
 
 const (
 	JSONFile  = "json"
 	ProtoFile = "proto"
+	YAMLFile  = "yaml"
+	YMLFile   = "yml"
 )
 
-func FindFiles(directory string) ([]string, error) {
+type findFileOptions struct {
+	extension string
+	prefix    string
+}
+
+type FindFileOptions func(o *findFileOptions)
+
+func WithExtension(extension string) FindFileOptions {
+	return func(o *findFileOptions) {
+		o.extension = extension
+	}
+}
+
+func WithPrefix(prefix string) FindFileOptions {
+	return func(o *findFileOptions) {
+		o.prefix = prefix
+	}
+}
+
+// FindFiles searches for files in the specified directory based on the given options.
+// It supports filtering files by extension and prefix. Returns a list of matching files or an error.
+func FindFiles(directory string, options ...FindFileOptions) ([]string, error) {
+	opts := findFileOptions{}
+	for _, apply := range options {
+		apply(&opts)
+	}
+
 	files := make([]string, 0)
 	return files, filepath.Walk(directory, func(path string, info os.FileInfo, err error) error {
 		if err != nil {
 			return err
 		}
 
-		if !info.IsDir() {
-			files = append(files, path)
+		// Filter by file extension if provided
+		if opts.extension != "" && filepath.Ext(path) != fmt.Sprintf(".%s", opts.extension) {
+			return nil // Skip files that don't match the extension
 		}
-		return nil
-	})
-}
 
-func FindFilesExtension(directory, extension string) ([]string, error) {
-	files := make([]string, 0)
-	return files, filepath.Walk(directory, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			return err
+		// Filter by file prefix if provided
+		if opts.prefix != "" && !strings.HasPrefix(filepath.Base(path), opts.prefix) {
+			return nil // Skip files that don't match the prefix
 		}
 
+		// Add file to the result list if it is not a directory
 		if !info.IsDir() {
-			if filepath.Ext(path) == fmt.Sprintf(".%s", extension) {
-				files = append(files, path)
-			}
+			files = append(files, path)
 		}
+
 		return nil
 	})
 }

ignite/pkg/xos/files_test.go

@@ -16,44 +16,92 @@ func TestFindFiles(t *testing.T) {
 		name      string
 		files     []string
 		extension string
+		prefix    string
 		want      []string
 		err       error
 	}{
 		{
-			name:      "test 3 json files",
+			name:  "test zero files",
+			files: []string{},
+			want:  []string{},
+			err:   nil,
+		},
+		{
+			name:  "test one file",
+			files: []string{"file.json"},
+			want:  []string{"file.json"},
+			err:   nil,
+		},
+		{
+			name:  "test 3 files",
+			files: []string{"file1.json", "file2.txt", "file3.json"},
+			want:  []string{"file1.json", "file2.txt", "file3.json"},
+			err:   nil,
+		},
+		{
+			name:   "test file prefix",
+			files:  []string{"file.prefix.test.json"},
+			prefix: "file.prefix",
+			want:   []string{"file.prefix.test.json"},
+			err:    nil,
+		},
+		{
+			name:   "test bigger file prefix",
+			files:  []string{"file.prefix.test.json"},
+			prefix: "file.prefix.test",
+			want:   []string{"file.prefix.test.json"},
+			err:    nil,
+		},
+		{
+			name:   "test 3 files prefix",
+			files:  []string{"test.file1.json", "test.file2.txt", "test.file3.json"},
+			prefix: "test.file",
+			want:   []string{"test.file1.json", "test.file2.txt", "test.file3.json"},
+			err:    nil,
+		},
+		{
+			name:      "test 3 extension json files",
 			files:     []string{"file1.json", "file2.txt", "file3.json", "file4.json"},
 			extension: "json",
 			want:      []string{"file1.json", "file3.json", "file4.json"},
 			err:       nil,
 		},
 		{
-			name:      "test 3 json files with subfolder",
+			name:      "test 3 extension json files with subfolder",
 			files:     []string{"testdata/file1.json", "file2.txt", "foo/file3.json", "file4.json"},
 			extension: "json",
 			want:      []string{"testdata/file1.json", "foo/file3.json", "file4.json"},
 			err:       nil,
 		},
 		{
-			name:      "test 1 txt files",
+			name:      "test 1 extension txt files",
 			files:     []string{"file1.json", "file2.txt", "file3.json", "file4.json"},
 			extension: "txt",
 			want:      []string{"file2.txt"},
 			err:       nil,
 		},
 		{
-			name:      "test 1 json files",
+			name:      "test 1 extension json files",
 			files:     []string{"file1.json"},
 			extension: "json",
 			want:      []string{"file1.json"},
 			err:       nil,
 		},
 		{
-			name:      "test no files",
+			name:      "test invalid files extension",
 			files:     []string{"file1.json", "file2.json", "file3.json", "file4.json"},
 			extension: "txt",
 			want:      []string{},
 			err:       nil,
 		},
+		{
+			name:      "test file prefix and extension",
+			files:     []string{"test.file1.json", "test.file2.txt", "test.file3.json"},
+			prefix:    "test.file",
+			extension: "json",
+			want:      []string{"test.file1.json", "test.file3.json"},
+			err:       nil,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -72,7 +120,15 @@ func TestFindFiles(t *testing.T) {
 				require.NoError(t, file.Close())
 			}
 
-			gotFiles, err := xos.FindFilesExtension(tempDir, tt.extension)
+			opts := make([]xos.FindFileOptions, 0)
+			if tt.prefix != "" {
+				opts = append(opts, xos.WithPrefix(tt.prefix))
+			}
+			if tt.extension != "" {
+				opts = append(opts, xos.WithExtension(tt.extension))
+			}
+
+			gotFiles, err := xos.FindFiles(tempDir, opts...)
 			if tt.err != nil {
 				require.Error(t, err)
 				require.ErrorIs(t, err, tt.err)