refactor FindPackageRoot and handle error on FindPackageRootFrom calls

teresaromero · teresaromero · commit 4412b0bd218e · 2025-10-09T15:22:16.000+02:00
diff --git a/cmd/benchmark.go b/cmd/benchmark.go
@@ -137,10 +137,7 @@ func pipelineCommandAction(cmd *cobra.Command, args []string) error {
 		return cobraext.FlagParsingError(err, cobraext.BenchNumTopProcsFlagName)
 	}
 
-	packageRootPath, found, err := packages.FindPackageRoot()
-	if !found {
-		return errors.New("package root not found")
-	}
+	packageRootPath, err := packages.FindPackageRoot()
 	if err != nil {
 		return fmt.Errorf("locating package root failed: %w", err)
 	}
@@ -292,12 +289,8 @@ func rallyCommandAction(cmd *cobra.Command, args []string) error {
 	}
 
 	var packageRootPath string
-	var found bool
 	if len(packageName) == 0 {
-		packageRootPath, found, err = packages.FindPackageRoot()
-		if !found {
-			return errors.New("package root not found")
-		}
+		packageRootPath, err = packages.FindPackageRoot()
 		if err != nil {
 			return fmt.Errorf("locating package root failed: %w", err)
 		}
@@ -472,10 +465,7 @@ func streamCommandAction(cmd *cobra.Command, args []string) error {
 		return cobraext.FlagParsingError(err, cobraext.BenchStreamTimestampFieldFlagName)
 	}
 
-	packageRootPath, found, err := packages.FindPackageRoot()
-	if !found {
-		return errors.New("package root not found")
-	}
+	packageRootPath, err := packages.FindPackageRoot()
 	if err != nil {
 		return fmt.Errorf("locating package root failed: %w", err)
 	}
@@ -585,10 +575,7 @@ func systemCommandAction(cmd *cobra.Command, args []string) error {
 		return cobraext.FlagParsingError(err, cobraext.BenchReindexToMetricstoreFlagName)
 	}
 
-	packageRootPath, found, err := packages.FindPackageRoot()
-	if !found {
-		return errors.New("package root not found")
-	}
+	packageRootPath, err := packages.FindPackageRoot()
 	if err != nil {
 		return fmt.Errorf("locating package root failed: %w", err)
 	}
diff --git a/cmd/create_data_stream.go b/cmd/create_data_stream.go
@@ -37,13 +37,13 @@ type newDataStreamAnswers struct {
 func createDataStreamCommandAction(cmd *cobra.Command, args []string) error {
 	cmd.Println("Create a new data stream")
 
-	packageRoot, found, err := packages.FindPackageRoot()
+	packageRoot, err := packages.FindPackageRoot()
 	if err != nil {
+		if errors.Is(err, packages.ErrPackageRootNotFound) {
+			return errors.New("package root not found, you can only create new data stream in the package context")
+		}
 		return fmt.Errorf("locating package root failed: %w", err)
 	}
-	if !found {
-		return errors.New("package root not found, you can only create new data stream in the package context")
-	}
 
 	manifest, err := packages.ReadPackageManifestFromPackageRoot(packageRoot)
 	if err != nil {
diff --git a/cmd/format.go b/cmd/format.go
@@ -5,7 +5,6 @@
 package cmd
 
 import (
-	"errors"
 	"fmt"
 
 	"github.com/spf13/cobra"
@@ -35,13 +34,10 @@ func setupFormatCommand() *cobraext.Command {
 func formatCommandAction(cmd *cobra.Command, args []string) error {
 	cmd.Println("Format the package")
 
-	packageRoot, found, err := packages.FindPackageRoot()
+	packageRoot, err := packages.FindPackageRoot()
 	if err != nil {
 		return fmt.Errorf("locating package root failed: %w", err)
 	}
-	if !found {
-		return errors.New("package root not found")
-	}
 
 	ff, err := cmd.Flags().GetBool(cobraext.FailFastFlagName)
 	if err != nil {
diff --git a/cmd/install.go b/cmd/install.go
@@ -5,7 +5,6 @@
 package cmd
 
 import (
-	"errors"
 	"fmt"
 
 	"github.com/spf13/cobra"
@@ -72,12 +71,8 @@ func installCommandAction(cmd *cobra.Command, _ []string) error {
 	}
 
 	if zipPathFile == "" && packageRootPath == "" {
-		var found bool
 		var err error
-		packageRootPath, found, err = packages.FindPackageRoot()
-		if !found {
-			return errors.New("package root not found")
-		}
+		packageRootPath, err = packages.FindPackageRoot()
 		if err != nil {
 			return fmt.Errorf("locating package root failed: %w", err)
 		}
diff --git a/cmd/lint.go b/cmd/lint.go
@@ -5,7 +5,6 @@
 package cmd
 
 import (
-	"errors"
 	"fmt"
 
 	"github.com/spf13/cobra"
@@ -74,10 +73,7 @@ func lintCommandAction(cmd *cobra.Command, args []string) error {
 }
 
 func validateSourceCommandAction(cmd *cobra.Command, args []string) error {
-	packageRootPath, found, err := packages.FindPackageRoot()
-	if !found {
-		return errors.New("package root not found")
-	}
+	packageRootPath, err := packages.FindPackageRoot()
 	if err != nil {
 		return fmt.Errorf("locating package root failed: %w", err)
 	}
diff --git a/cmd/service.go b/cmd/service.go
@@ -5,7 +5,6 @@
 package cmd
 
 import (
-	"errors"
 	"fmt"
 	"path/filepath"
 
@@ -47,13 +46,10 @@ func setupServiceCommand() *cobraext.Command {
 func upCommandAction(cmd *cobra.Command, args []string) error {
 	cmd.Println("Boot up the service stack")
 
-	packageRoot, found, err := packages.FindPackageRoot()
+	packageRoot, err := packages.FindPackageRoot()
 	if err != nil {
 		return fmt.Errorf("locating package root failed: %w", err)
 	}
-	if !found {
-		return errors.New("package root not found")
-	}
 
 	var dataStreamPath string
 	dataStreamFlag, _ := cmd.Flags().GetString(cobraext.DataStreamFlagName)
diff --git a/cmd/status.go b/cmd/status.go
@@ -163,11 +163,11 @@ func getPackageStatus(packageName string, options registry.SearchOptions) (*stat
 	if packageName != "" {
 		return status.RemotePackage(packageName, options)
 	}
-	packageRootPath, found, err := packages.FindPackageRoot()
-	if !found {
-		return nil, errors.New("no package specified and package root not found")
-	}
+	packageRootPath, err := packages.FindPackageRoot()
 	if err != nil {
+		if errors.Is(err, packages.ErrPackageRootNotFound) {
+			return nil, errors.New("no package specified and package root not found")
+		}
 		return nil, fmt.Errorf("locating package root failed: %w", err)
 	}
 	return status.LocalPackage(packageRootPath, options)
diff --git a/cmd/testrunner.go b/cmd/testrunner.go
@@ -146,10 +146,7 @@ func testRunnerAssetCommandAction(cmd *cobra.Command, args []string) error {
 		return cobraext.FlagParsingError(fmt.Errorf("coverage format not available: %s", testCoverageFormat), cobraext.TestCoverageFormatFlagName)
 	}
 
-	packageRootPath, found, err := packages.FindPackageRoot()
-	if !found {
-		return errors.New("package root not found")
-	}
+	packageRootPath, err := packages.FindPackageRoot()
 	if err != nil {
 		return fmt.Errorf("locating package root failed: %w", err)
 	}
@@ -242,10 +239,7 @@ func testRunnerStaticCommandAction(cmd *cobra.Command, args []string) error {
 		return cobraext.FlagParsingError(fmt.Errorf("coverage format not available: %s", testCoverageFormat), cobraext.TestCoverageFormatFlagName)
 	}
 
-	packageRootPath, found, err := packages.FindPackageRoot()
-	if !found {
-		return errors.New("package root not found")
-	}
+	packageRootPath, err := packages.FindPackageRoot()
 	if err != nil {
 		return fmt.Errorf("locating package root failed: %w", err)
 	}
@@ -349,10 +343,7 @@ func testRunnerPipelineCommandAction(cmd *cobra.Command, args []string) error {
 		return cobraext.FlagParsingError(err, cobraext.DeferCleanupFlagName)
 	}
 
-	packageRootPath, found, err := packages.FindPackageRoot()
-	if !found {
-		return errors.New("package root not found")
-	}
+	packageRootPath, err := packages.FindPackageRoot()
 	if err != nil {
 		return fmt.Errorf("locating package root failed: %w", err)
 	}
@@ -493,10 +484,7 @@ func testRunnerSystemCommandAction(cmd *cobra.Command, args []string) error {
 		return cobraext.FlagParsingError(err, cobraext.VariantFlagName)
 	}
 
-	packageRootPath, found, err := packages.FindPackageRoot()
-	if !found {
-		return errors.New("package root not found")
-	}
+	packageRootPath, err := packages.FindPackageRoot()
 	if err != nil {
 		return fmt.Errorf("locating package root failed: %w", err)
 	}
@@ -664,10 +652,7 @@ func testRunnerPolicyCommandAction(cmd *cobra.Command, args []string) error {
 		return cobraext.FlagParsingError(fmt.Errorf("coverage format not available: %s", testCoverageFormat), cobraext.TestCoverageFormatFlagName)
 	}
 
-	packageRootPath, found, err := packages.FindPackageRoot()
-	if !found {
-		return errors.New("package root not found")
-	}
+	packageRootPath, err := packages.FindPackageRoot()
 	if err != nil {
 		return fmt.Errorf("locating package root failed: %w", err)
 	}
diff --git a/cmd/uninstall.go b/cmd/uninstall.go
@@ -5,7 +5,6 @@
 package cmd
 
 import (
-	"errors"
 	"fmt"
 
 	"github.com/spf13/cobra"
@@ -35,10 +34,7 @@ func setupUninstallCommand() *cobraext.Command {
 }
 
 func uninstallCommandAction(cmd *cobra.Command, args []string) error {
-	packageRootPath, found, err := packages.FindPackageRoot()
-	if !found {
-		return errors.New("package root not found")
-	}
+	packageRootPath, err := packages.FindPackageRoot()
 	if err != nil {
 		return fmt.Errorf("locating package root failed: %w", err)
 	}
diff --git a/internal/fields/validate.go b/internal/fields/validate.go
@@ -257,12 +257,12 @@ func WithOTELValidation(otelValidation bool) ValidatorOption {
 }
 
 type packageRootFinder interface {
-	FindPackageRoot() (string, bool, error)
+	FindPackageRoot() (string, error)
 }
 
 type packageRoot struct{}
 
-func (p packageRoot) FindPackageRoot() (string, bool, error) {
+func (p packageRoot) FindPackageRoot() (string, error) {
 	return packages.FindPackageRoot()
 }
 
@@ -288,13 +288,14 @@ func createValidatorForDirectoryAndPackageRoot(fieldsParentDir string, finder pa
 
 	var fdm *DependencyManager
 	if !v.disabledDependencyManagement {
-		packageRoot, found, err := finder.FindPackageRoot()
+		packageRoot, err := finder.FindPackageRoot()
 		if err != nil {
+			if errors.Is(err, packages.ErrPackageRootNotFound) {
+				return nil, errors.New("package root not found and dependency management is enabled")
+			}
 			return nil, fmt.Errorf("can't find package root: %w", err)
 		}
-		if !found {
-			return nil, errors.New("package root not found and dependency management is enabled")
-		}
+
 		fdm, v.Schema, err = initDependencyManagement(packageRoot, v.specVersion, v.enabledImportAllECSSchema)
 		if err != nil {
 			return nil, fmt.Errorf("failed to initialize dependency management: %w", err)
diff --git a/internal/fields/validate_test.go b/internal/fields/validate_test.go
@@ -28,8 +28,8 @@ type packageRootTestFinder struct {
 	packageRootPath string
 }
 
-func (p packageRootTestFinder) FindPackageRoot() (string, bool, error) {
-	return p.packageRootPath, true, nil
+func (p packageRootTestFinder) FindPackageRoot() (string, error) {
+	return p.packageRootPath, nil
 }
 
 func TestValidate_NoWildcardFields(t *testing.T) {
diff --git a/internal/files/linkedfiles.go b/internal/files/linkedfiles.go
@@ -193,7 +193,10 @@ func newLinkedFile(repoRoot *os.Root, linkFilePath string) (*Link, error) {
 	workDir := filepath.Dir(linkFilePath)
 
 	var linkPackageName string
-	linkPackageRoot, _, _ := packages.FindPackageRootFrom(workDir)
+	linkPackageRoot, err := packages.FindPackageRootFrom(workDir)
+	if err != nil {
+		return nil, fmt.Errorf("could not find package root for link file %s: %w", linkFilePath, err)
+	}
 	if linkPackageRoot != "" {
 		linkPackageName = filepath.Base(linkPackageRoot)
 	} else {
@@ -245,7 +248,10 @@ func newLinkedFile(repoRoot *os.Root, linkFilePath string) (*Link, error) {
 	}
 
 	var includedPackageName string
-	includedPackageRoot, _, _ := packages.FindPackageRootFrom(filepath.Dir(includedFilePath))
+	includedPackageRoot, err := packages.FindPackageRootFrom(filepath.Dir(includedFilePath))
+	if err != nil {
+		return nil, fmt.Errorf("could not find package root for included file %s: %w", includedFilePath, err)
+	}
 	if includedPackageRoot != "" {
 		includedPackageName = filepath.Base(includedPackageRoot)
 	}
@@ -471,7 +477,11 @@ func linkedFilesByPackageFrom(root *os.Root, fromDir string) ([]PackageLinks, er
 	}
 
 	var packageName string
-	if packageRoot, _, _ := packages.FindPackageRootFrom(filepath.Join(root.Name(), fromDir)); packageRoot != "" {
+	packageRoot, err := packages.FindPackageRootFrom(filepath.Join(root.Name(), fromDir))
+	if err != nil {
+		return nil, fmt.Errorf("finding package root failed: %w", err)
+	}
+	if packageRoot != "" {
 		packageName = filepath.Base(packageRoot)
 	}
 	byPackageMap := map[string][]string{}
diff --git a/internal/files/linkedfiles_test.go b/internal/files/linkedfiles_test.go
diff --git a/internal/files/testdata/links/manifest.yml b/internal/files/testdata/links/manifest.yml
diff --git a/internal/packages/packages.go b/internal/packages/packages.go

Original file line number	Diff line number	Diff line change
`@@ -137,10 +137,7 @@ func pipelineCommandAction(cmd *cobra.Command, args []string) error {`
`137`	`137`	`return cobraext.FlagParsingError(err, cobraext.BenchNumTopProcsFlagName)`
`138`	`138`	`}`
`139`	`139`
`140`		`- packageRootPath, found, err := packages.FindPackageRoot()`
`141`		`- if !found {`
`142`		`- return errors.New("package root not found")`
`143`		`- }`
	`140`	`+ packageRootPath, err := packages.FindPackageRoot()`
`144`	`141`	`if err != nil {`
`145`	`142`	`return fmt.Errorf("locating package root failed: %w", err)`
`146`	`143`	`}`
`@@ -292,12 +289,8 @@ func rallyCommandAction(cmd *cobra.Command, args []string) error {`
`292`	`289`	`}`
`293`	`290`
`294`	`291`	`var packageRootPath string`
`295`		`- var found bool`
`296`	`292`	`if len(packageName) == 0 {`
`297`		`- packageRootPath, found, err = packages.FindPackageRoot()`
`298`		`- if !found {`
`299`		`- return errors.New("package root not found")`
`300`		`- }`
	`293`	`+ packageRootPath, err = packages.FindPackageRoot()`
`301`	`294`	`if err != nil {`
`302`	`295`	`return fmt.Errorf("locating package root failed: %w", err)`
`303`	`296`	`}`
`@@ -472,10 +465,7 @@ func streamCommandAction(cmd *cobra.Command, args []string) error {`
`472`	`465`	`return cobraext.FlagParsingError(err, cobraext.BenchStreamTimestampFieldFlagName)`
`473`	`466`	`}`
`474`	`467`
`475`		`- packageRootPath, found, err := packages.FindPackageRoot()`
`476`		`- if !found {`
`477`		`- return errors.New("package root not found")`
`478`		`- }`
	`468`	`+ packageRootPath, err := packages.FindPackageRoot()`
`479`	`469`	`if err != nil {`
`480`	`470`	`return fmt.Errorf("locating package root failed: %w", err)`
`481`	`471`	`}`
`@@ -585,10 +575,7 @@ func systemCommandAction(cmd *cobra.Command, args []string) error {`
`585`	`575`	`return cobraext.FlagParsingError(err, cobraext.BenchReindexToMetricstoreFlagName)`
`586`	`576`	`}`
`587`	`577`
`588`		`- packageRootPath, found, err := packages.FindPackageRoot()`
`589`		`- if !found {`
`590`		`- return errors.New("package root not found")`
`591`		`- }`
	`578`	`+ packageRootPath, err := packages.FindPackageRoot()`
`592`	`579`	`if err != nil {`
`593`	`580`	`return fmt.Errorf("locating package root failed: %w", err)`
`594`	`581`	`}`
Original file line number	Diff line number	Diff line change
`@@ -146,10 +146,7 @@ func testRunnerAssetCommandAction(cmd *cobra.Command, args []string) error {`
`146`	`146`	`return cobraext.FlagParsingError(fmt.Errorf("coverage format not available: %s", testCoverageFormat), cobraext.TestCoverageFormatFlagName)`
`147`	`147`	`}`
`148`	`148`
`149`		`- packageRootPath, found, err := packages.FindPackageRoot()`
`150`		`- if !found {`
`151`		`- return errors.New("package root not found")`
`152`		`- }`
	`149`	`+ packageRootPath, err := packages.FindPackageRoot()`
`153`	`150`	`if err != nil {`
`154`	`151`	`return fmt.Errorf("locating package root failed: %w", err)`
`155`	`152`	`}`
`@@ -242,10 +239,7 @@ func testRunnerStaticCommandAction(cmd *cobra.Command, args []string) error {`
`242`	`239`	`return cobraext.FlagParsingError(fmt.Errorf("coverage format not available: %s", testCoverageFormat), cobraext.TestCoverageFormatFlagName)`
`243`	`240`	`}`
`244`	`241`
`245`		`- packageRootPath, found, err := packages.FindPackageRoot()`
`246`		`- if !found {`
`247`		`- return errors.New("package root not found")`
`248`		`- }`
	`242`	`+ packageRootPath, err := packages.FindPackageRoot()`
`249`	`243`	`if err != nil {`
`250`	`244`	`return fmt.Errorf("locating package root failed: %w", err)`
`251`	`245`	`}`
`@@ -349,10 +343,7 @@ func testRunnerPipelineCommandAction(cmd *cobra.Command, args []string) error {`
`349`	`343`	`return cobraext.FlagParsingError(err, cobraext.DeferCleanupFlagName)`
`350`	`344`	`}`
`351`	`345`
`352`		`- packageRootPath, found, err := packages.FindPackageRoot()`
`353`		`- if !found {`
`354`		`- return errors.New("package root not found")`
`355`		`- }`
	`346`	`+ packageRootPath, err := packages.FindPackageRoot()`
`356`	`347`	`if err != nil {`
`357`	`348`	`return fmt.Errorf("locating package root failed: %w", err)`
`358`	`349`	`}`
`@@ -493,10 +484,7 @@ func testRunnerSystemCommandAction(cmd *cobra.Command, args []string) error {`
`493`	`484`	`return cobraext.FlagParsingError(err, cobraext.VariantFlagName)`
`494`	`485`	`}`
`495`	`486`
`496`		`- packageRootPath, found, err := packages.FindPackageRoot()`
`497`		`- if !found {`
`498`		`- return errors.New("package root not found")`
`499`		`- }`
	`487`	`+ packageRootPath, err := packages.FindPackageRoot()`
`500`	`488`	`if err != nil {`
`501`	`489`	`return fmt.Errorf("locating package root failed: %w", err)`
`502`	`490`	`}`
`@@ -664,10 +652,7 @@ func testRunnerPolicyCommandAction(cmd *cobra.Command, args []string) error {`
`664`	`652`	`return cobraext.FlagParsingError(fmt.Errorf("coverage format not available: %s", testCoverageFormat), cobraext.TestCoverageFormatFlagName)`
`665`	`653`	`}`
`666`	`654`
`667`		`- packageRootPath, found, err := packages.FindPackageRoot()`
`668`		`- if !found {`
`669`		`- return errors.New("package root not found")`
`670`		`- }`
	`655`	`+ packageRootPath, err := packages.FindPackageRoot()`
`671`	`656`	`if err != nil {`
`672`	`657`	`return fmt.Errorf("locating package root failed: %w", err)`
`673`	`658`	`}`