feat: add zarf prepare lint to perform schema validation

docs/2-the-zarf-cli/100-cli-commands/zarf_prepare_lint.md

@@ -3,6 +3,10 @@
 
 Verifies the package schema
 
+## Synopsis
+
+Verifies the package schema and warns the user if they have variables that won't be evaluated
+
 ```
 zarf prepare lint [ DIRECTORY ] [flags]
 ```

src/cmd/prepare.go

@@ -211,6 +211,7 @@ var lintCmd = &cobra.Command{
 	Args:    cobra.MaximumNArgs(1),
 	Aliases: []string{"l"},
 	Short:   lang.CmdPrepareLintShort,
+	Long:    lang.CmdPrepareLintLong,
 	Run: func(cmd *cobra.Command, args []string) {
 		baseDir := ""
 		if len(args) > 0 {
@@ -219,7 +220,7 @@ var lintCmd = &cobra.Command{
 			var err error
 			baseDir, err = os.Getwd()
 			if err != nil {
-				message.Fatalf(err, lang.CmdPrepareFindImagesErr, err.Error())
+				message.Fatalf(err, lang.CmdPrepareLintErr, err.Error())
 			}
 		}
 		validator, err := lint.ValidateZarfSchema(baseDir)

src/config/lang/english.go

@@ -360,6 +360,8 @@ $ zarf package publish ./path/to/dir oci://my-registry.com/my-namespace
 	CmdPrepareFlagKubeVersion   = "Override the default helm template KubeVersion when performing a package chart template"
 
 	CmdPrepareLintShort = "Verifies the package schema"
+	CmdPrepareLintLong  = "Verifies the package schema and warns the user if they have variables that won't be evaluated"
+	CmdPrepareLintErr   = "Unable to lint package: %s"
 
 	// zarf tools
 	CmdToolsShort = "Collection of additional tools to make airgap easier"

src/pkg/message/message.go

@@ -318,6 +318,28 @@ func Truncate(text string, length int, invert bool) string {
 	return textEscaped
 }
 
+// Table prints a padded table containing the specified header and data
+func Table(header []string, data [][]string) {
+	pterm.Println()
+
+	if len(header) > 0 {
+		header[0] = fmt.Sprintf("     %s", header[0])
+	}
+
+	table := pterm.TableData{
+		header,
+	}
+
+	for _, row := range data {
+		if len(row) > 0 {
+			row[0] = fmt.Sprintf("     %s", row[0])
+		}
+		table = append(table, pterm.TableData{row}...)
+	}
+
+	pterm.DefaultTable.WithHasHeader().WithData(table).Render()
+}
+
 func debugPrinter(offset int, a ...any) {
 	printer := pterm.Debug.WithShowLineNumber(logLevel > 2).WithLineNumberOffset(offset)
 	now := time.Now().Format(time.RFC3339)
@@ -340,25 +362,3 @@ func debugPrinter(offset int, a ...any) {
 func errorPrinter(offset int) *pterm.PrefixPrinter {
 	return pterm.Error.WithShowLineNumber(logLevel > 2).WithLineNumberOffset(offset)
 }
-
-// Table prints a padded table containing the specified header and data
-func Table(header []string, data [][]string) {
-	pterm.Println()
-
-	if len(header) > 0 {
-		header[0] = fmt.Sprintf("     %s", header[0])
-	}
-
-	table := pterm.TableData{
-		header,
-	}
-
-	for _, row := range data {
-		if len(row) > 0 {
-			row[0] = fmt.Sprintf("     %s", row[0])
-		}
-		table = append(table, pterm.TableData{row}...)
-	}
-
-	pterm.DefaultTable.WithHasHeader().WithData(table).Render()
-}

src/pkg/packager/lint/lint.go

@@ -6,9 +6,9 @@ package lint
 
 import (
 	"embed"
-	"errors"
 	"fmt"
 	"path/filepath"
+	"regexp"
 	"strings"
 
 	"github.com/defenseunicorns/zarf/src/pkg/layout"
@@ -17,11 +17,6 @@ import (
 	"github.com/xeipuuv/gojsonschema"
 )
 
-const (
-	validatorInvalidPrefix = "schema is invalid:"
-	validatorWarningPrefix = "zarf schema warning:"
-)
-
 // ZarfSchema is exported so main.go can embed the schema file
 var ZarfSchema embed.FS
 
@@ -35,21 +30,21 @@ func ValidateZarfSchema(path string) (*Validator, error) {
 	validator := Validator{}
 	var err error
 	if err := utils.ReadYaml(filepath.Join(path, layout.ZarfYAML), &validator.typedZarfPackage); err != nil {
-		return &validator, err
+		return nil, err
 	}
 
 	checkForVarInComponentImport(&validator)
 
 	if validator.jsonSchema, err = getSchemaFile(); err != nil {
-		return &validator, err
+		return nil, err
 	}
 
 	if err := utils.ReadYaml(filepath.Join(path, layout.ZarfYAML), &validator.untypedZarfPackage); err != nil {
-		return &validator, err
+		return nil, err
 	}
 
 	if err = validateSchema(&validator); err != nil {
-		return &validator, err
+		return nil, err
 	}
 
 	return &validator, nil
@@ -58,15 +53,28 @@ func ValidateZarfSchema(path string) (*Validator, error) {
 func checkForVarInComponentImport(validator *Validator) {
 	for i, component := range validator.typedZarfPackage.Components {
 		if strings.Contains(component.Import.Path, types.ZarfPackageTemplatePrefix) {
-			validator.addWarning(fmt.Sprintf("component.[%d].import.path will not resolve ZARF_PKG_TMPL_* variables", i))
+			validator.addWarning(fmt.Sprintf(".component.[%d].import.path: Will not resolve ZARF_PKG_TMPL_* variables", i))
 		}
 		if strings.Contains(component.Import.URL, types.ZarfPackageTemplatePrefix) {
-			validator.addWarning(fmt.Sprintf("component.[%d].import.url will not resolve ZARF_PKG_TMPL_* variables", i))
+			validator.addWarning(fmt.Sprintf(".component.[%d].import.url: Will not resolve ZARF_PKG_TMPL_* variables", i))
 		}
 	}
 
 }
 
+func makeFieldPathYqCompat(field string) string {
+	if field == "(root)" {
+		return field
+	}
+	// \b is a metacharacter that will stop at the next non-word character (including .)
+	// https://regex101.com/r/pIRPk0/1
+	re := regexp.MustCompile(`(\b\d+\b)`)
+
+	wrappedField := re.ReplaceAllString(field, "[$1]")
+
+	return fmt.Sprintf(".%s", wrappedField)
+}
+
 func validateSchema(validator *Validator) error {
 	schemaLoader := gojsonschema.NewBytesLoader(validator.jsonSchema)
 	documentLoader := gojsonschema.NewGoLoader(validator.untypedZarfPackage)
@@ -78,7 +86,9 @@ func validateSchema(validator *Validator) error {
 
 	if !result.Valid() {
 		for _, desc := range result.Errors() {
-			validator.addError(errors.New(desc.String()))
+			err := fmt.Errorf(
+				"%s: %s", makeFieldPathYqCompat(desc.Field()), desc.Description())
+			validator.addError(err)
 		}
 	}
 

src/pkg/packager/lint/lint_test.go

@@ -51,7 +51,7 @@ func readAndUnmarshalYaml[T interface{}](t *testing.T, yamlString string) T {
 	var unmarshalledYaml T
 	err := goyaml.Unmarshal([]byte(yamlString), &unmarshalledYaml)
 	if err != nil {
-		t.Errorf("error unmarshalling yaml %v", err)
+		t.Errorf("error unmarshalling yaml: %v", err)
 	}
 	return unmarshalledYaml
 }
@@ -61,7 +61,7 @@ func TestValidateSchema(t *testing.T) {
 		t.Helper()
 		file, err := os.ReadFile("../../../../zarf.schema.json")
 		if err != nil {
-			t.Errorf("error reading file: %s", err)
+			t.Errorf("error reading file: %v", err)
 		}
 		return file
 	}
@@ -79,8 +79,8 @@ func TestValidateSchema(t *testing.T) {
 		validator := Validator{untypedZarfPackage: unmarshalledYaml, jsonSchema: getZarfSchema(t)}
 		err := validateSchema(&validator)
 		require.NoError(t, err)
-		require.EqualError(t, validator.errors[0], "components.0.import: Additional property not-path is not allowed")
-		require.EqualError(t, validator.errors[1], "components.1.import.path: Invalid type. Expected: string, given: integer")
+		require.EqualError(t, validator.errors[0], ".components.[0].import: Additional property not-path is not allowed")
+		require.EqualError(t, validator.errors[1], ".components.[1].import.path: Invalid type. Expected: string, given: integer")
 	})
 
 	t.Run("Template in component import success", func(t *testing.T) {
@@ -94,8 +94,20 @@ func TestValidateSchema(t *testing.T) {
 		unmarshalledYaml := readAndUnmarshalYaml[types.ZarfPackage](t, badZarfPackage)
 		validator := Validator{typedZarfPackage: unmarshalledYaml}
 		checkForVarInComponentImport(&validator)
-		require.Equal(t, validator.warnings[0], "component.[2].import.path will not resolve ZARF_PKG_TMPL_* variables")
-		require.Equal(t, validator.warnings[1], "component.[3].import.url will not resolve ZARF_PKG_TMPL_* variables")
+		require.Equal(t, validator.warnings[0], ".component.[2].import.path: Will not resolve ZARF_PKG_TMPL_* variables")
+		require.Equal(t, validator.warnings[1], ".component.[3].import.url: Will not resolve ZARF_PKG_TMPL_* variables")
 	})
 
+	t.Run("Wrap standalone numbers in bracket", func(t *testing.T) {
+		input := "components12.12.import.path"
+		expected := ".components12.[12].import.path"
+		acutal := makeFieldPathYqCompat(input)
+		require.Equal(t, expected, acutal)
+	})
+
+	t.Run("root doesn't change", func(t *testing.T) {
+		input := "(root)"
+		acutal := makeFieldPathYqCompat(input)
+		require.Equal(t, input, acutal)
+	})
 }

src/pkg/packager/lint/validator.go

@@ -22,8 +22,21 @@ type Validator struct {
 	untypedZarfPackage interface{}
 }
 
-func (v Validator) printWarningTable() {
-	if !v.IsSuccess() {
+// DisplayFormattedMessage message sent to user based on validator results
+func (v Validator) DisplayFormattedMessage() {
+	if !v.hasWarnings() && !v.hasErrors() {
+		message.Success(fmt.Sprintf("Schema validation successful for %q", v.typedZarfPackage.Metadata.Name))
+	}
+	v.printValidationTable()
+}
+
+// IsSuccess returns true if there are not any errors
+func (v Validator) IsSuccess() bool {
+	return !v.hasErrors()
+}
+
+func (v Validator) printValidationTable() {
+	if v.hasWarnings() || v.hasErrors() {
 		header := []string{"Type", "Message"}
 		connectData := [][]string{}
 		for _, warning := range v.warnings {
@@ -38,10 +51,6 @@ func (v Validator) printWarningTable() {
 	}
 }
 
-func (v Validator) getFormatedSuccess() string {
-	return fmt.Sprintf("Schema validation successful for %q", v.typedZarfPackage.Metadata.Name)
-}
-
 func (v Validator) hasWarnings() bool {
 	return len(v.warnings) > 0
 }
@@ -57,18 +66,3 @@ func (v *Validator) addWarning(message string) {
 func (v *Validator) addError(err error) {
 	v.errors = append(v.errors, err)
 }
-
-// IsSuccess returns true if there are not any warnings or errors
-func (v Validator) IsSuccess() bool {
-	return !v.hasWarnings() && !v.hasErrors()
-}
-
-// DisplayFormattedMessage Displays the message to the user with proper warnings, failures, or success
-// Will exit if there are errors
-func (v Validator) DisplayFormattedMessage() {
-	if v.IsSuccess() {
-		message.Success(v.getFormatedSuccess())
-	} else {
-		v.printWarningTable()
-	}
-}

src/test/e2e/12_lint_test.go

@@ -16,8 +16,9 @@ func TestLint(t *testing.T) {
 		path := filepath.Join("src", "test", "packages", "12-lint")
 		_, stderr, err := e2e.Zarf("prepare", "lint", path)
 		require.Error(t, err, "Require an exit code since there was warnings / errors")
-		require.Contains(t, stderr, "components.0.import: Additional property not-path is not allowed")
-		require.Contains(t, stderr, "component.[2].import.path")
+		require.Contains(t, stderr, ".components.[0].import: Additional property not-path is not allowed")
+		require.Contains(t, stderr, "component.[2].import.path: Will not resolve ZARF_PKG_TMPL_* variables")
+		require.Contains(t, stderr, ".variables: Invalid type. Expected: array, given: null")
 	})
 
 	t.Run("zarf test lint success", func(t *testing.T) {

src/test/packages/12-lint/zarf.yaml

@@ -1,7 +1,10 @@
 kind: ZarfInitConfig
 metadata:
   name: init
-  description: Testing bad yaml
+  description1: Testing bad yaml
+
+
+variables:
 
 components:
   - name: first-test-component