Implement half of the CLI

.github/workflows/CI.yml

@@ -18,7 +18,6 @@ jobs:
       - name: GolangCI Lint
         uses: golangci/golangci-lint-action@v6
         with:
-          # TODO: Update this version.
           version: v1.60.2
           args: --out-format=colored-line-number
   test:

README.md

@@ -77,7 +77,7 @@ running Terraform.
 ### Parsing Terraform Configuration Files
 Parsing Terraform files is done using the [HCL package](https://github.com/hashicorp/hcl). Initially, the plan was to use an existing application such as [terraform-docs](https://github.com/terraform-docs/terraform-docs/) to preform the parsing step, but some of the fields of the `variable` block weren't implemented, such as validation rules.
 
-TerraSchema parses each terraform configuration file as a HCL (HashiCorp Configuration Language) file and picks out any blocks which match the definition of an input variable in Terraform. A typical `variable` block looks like this:
+TerraSchema parses each Terraform configuration file as a HCL (HashiCorp Configuration Language) file and picks out any blocks which match the definition of an input variable in Terraform. A typical `variable` block looks like this:
 
 ```hcl
 variable "age" {

cmd/cmd.go

@@ -24,34 +24,30 @@ var (
 	disallowAdditionalProperties bool
 	overwrite                    bool
 	allowEmpty                   bool
+	requireAll                   bool
 	outputStdOut                 bool
 	output                       string
 	input                        string
+
+	errReturned error
 )
 
 // rootCmd is the base command for terraschema
 var rootCmd = &cobra.Command{
-	Use:   "terraschema",
-	Short: "Generate JSON schema from HCL Variable Blocks in a Terraform/OpenTofu module",
-	Long:  `TODO: Long description`,
-	Run: func(cmd *cobra.Command, args []string) {
-		path, err := filepath.Abs(input) // absolute path
-		if err != nil {
-			fmt.Printf("could not get absolute path: %v\n", err)
-			os.Exit(1)
-		}
-		output, err := jsonschema.CreateSchema(path, false)
-		if err != nil {
-			fmt.Printf("error creating schema: %v\n", err)
-			os.Exit(1)
-		}
-		jsonOutput, err := json.MarshalIndent(output, "", "    ")
-		if err != nil {
-			fmt.Printf("error marshalling schema: %v\n", err)
+	Use:     "terraschema",
+	Example: "terraschema -i /path/to/module -o /path/to/schema.json",
+	Short:   "Generate JSON schema from HCL Variable Blocks in a Terraform/OpenTofu module",
+	Long: "TerraSchema is a CLI tool which scans Terraform configuration ('.tf') " +
+		"files, parses a list of variables along with their type and validation rules, and converts " +
+		"them to a schema which complies with JSON Schema Draft-07.\nThe default behaviour is to scan " +
+		"the current directory and output a schema file called 'schema.json' in the same location. " +
+		"\nFor more information see https://github.com/HewlettPackard/terraschema.",
+	Run: runCommand,
+	PostRun: func(cmd *cobra.Command, args []string) {
+		if errReturned != nil {
+			fmt.Printf("error: %v\n", errReturned)
 			os.Exit(1)
 		}
-
-		fmt.Println(string(jsonOutput))
 	},
 }
 
@@ -61,18 +57,72 @@ func Execute() error {
 
 func init() {
 	// TODO: implement
-	rootCmd.Flags().BoolVar(&overwrite, "overwrite", false, "overwrite existing schema file")
+	rootCmd.Flags().BoolVar(&overwrite, "overwrite", false, "allow overwriting an existing file")
 	// TODO: implement
 	rootCmd.Flags().BoolVar(&outputStdOut, "stdout", false,
-		"output schema content to stdout instead of a file and disable error output",
+		"output JSON Schema content to stdout instead of a file and disable error output",
 	)
-	// TODO: implement
+
 	rootCmd.Flags().BoolVar(&disallowAdditionalProperties, "disallow-additional-properties", false,
-		"set additionalProperties to false in the generated schema and in nested objects",
+		"set additionalProperties to false in the JSON Schema and in nested objects",
 	)
+
+	rootCmd.Flags().BoolVar(&allowEmpty, "allow-empty", false,
+		"allow an empty JSON Schema if no variables are found",
+	)
+
+	rootCmd.Flags().BoolVar(&requireAll, "require-all", false,
+		"set all variables to be 'required' in the JSON Schema, even if a default value is specified",
+	)
+
+	rootCmd.Flags().StringVarP(&input, "input", "i", ".",
+		"input folder containing a Terraform module",
+	)
+
 	// TODO: implement
-	rootCmd.Flags().BoolVar(&allowEmpty, "allow-empty", false, "allow empty schema if no variables are found, otherwise error")
-	rootCmd.Flags().StringVarP(&input, "input", "i", ".", "input folder containing .tf files")
-	// TODO: implement
-	rootCmd.Flags().StringVarP(&output, "output", "o", "schema.json", "output file path for schema")
+	rootCmd.Flags().StringVarP(&output, "output", "o", "schema.json",
+		"output path for the JSON Schema file",
+	)
+}
+
+func runCommand(cmd *cobra.Command, args []string) {
+	path, err := filepath.Abs(input) // absolute path
+	if err != nil {
+		errReturned = fmt.Errorf("could not get absolute path for %q: %w", input, err)
+
+		return
+	}
+
+	folder, err := os.Stat(path)
+	if err != nil {
+		errReturned = fmt.Errorf("could not access directory %q: %w", path, err)
+
+		return
+	}
+
+	if !folder.IsDir() {
+		errReturned = fmt.Errorf("input %q is not a directory", path)
+
+		return
+	}
+
+	output, err := jsonschema.CreateSchema(path, jsonschema.CreateSchemaOptions{
+		RequireAll:                requireAll,
+		AllowAdditionalProperties: !disallowAdditionalProperties,
+		AllowEmpty:                allowEmpty,
+	})
+	if err != nil {
+		errReturned = fmt.Errorf("error creating schema: %w", err)
+
+		return
+	}
+
+	jsonOutput, err := json.MarshalIndent(output, "", "    ")
+	if err != nil {
+		errReturned = fmt.Errorf("error marshalling schema: %w", err)
+
+		return
+	}
+
+	fmt.Println(string(jsonOutput))
 }

pkg/jsonschema/json-schema.go

@@ -10,37 +10,52 @@ import (
 	"github.com/HewlettPackard/terraschema/pkg/reader"
 )
 
-func CreateSchema(path string, strict bool) (map[string]any, error) {
+type CreateSchemaOptions struct {
+	RequireAll                bool
+	AllowAdditionalProperties bool
+	AllowEmpty                bool
+}
+
+func CreateSchema(path string, options CreateSchemaOptions) (map[string]any, error) {
 	schemaOut := make(map[string]any)
 
 	varMap, err := reader.GetVarMap(path)
-	// GetVarMaps returns an error if no .tf files are found in the directory. We
-	// ignore this error for now.
-	if err != nil && !errors.Is(err, reader.ErrFilesNotFound) {
-		return schemaOut, fmt.Errorf("error reading tf files at %s: %w", path, err)
+	if err != nil {
+		if errors.Is(err, reader.ErrFilesNotFound) {
+			if options.AllowEmpty {
+				fmt.Printf("Info: no tf files were found in %q, creating empty schema\n", path)
+
+				return schemaOut, nil
+			}
+		} else {
+			return schemaOut, fmt.Errorf("error reading tf files at %q: %w", path, err)
+		}
 	}
 
 	if len(varMap) == 0 {
-		return schemaOut, nil
+		if options.AllowEmpty {
+			return schemaOut, nil
+		} else {
+			return schemaOut, errors.New("no variables found in tf files")
+		}
 	}
 
 	schemaOut["$schema"] = "http://json-schema.org/draft-07/schema#"
 
-	if strict {
-		schemaOut["additionalProperties"] = false
-	} else {
-		schemaOut["additionalProperties"] = true
-	}
+	schemaOut["additionalProperties"] = options.AllowAdditionalProperties
 
 	properties := make(map[string]any)
 	requiredArray := []any{}
 	for name, variable := range varMap {
-		if variable.Required {
+		if variable.Required && !options.RequireAll {
+			requiredArray = append(requiredArray, name)
+		}
+		if options.RequireAll {
 			requiredArray = append(requiredArray, name)
 		}
-		node, err := createNode(name, variable, strict)
+		node, err := createNode(name, variable, options)
 		if err != nil {
-			return schemaOut, fmt.Errorf("error creating node for %s: %w", name, err)
+			return schemaOut, fmt.Errorf("error creating node for %q: %w", name, err)
 		}
 
 		properties[name] = node
@@ -54,16 +69,16 @@ func CreateSchema(path string, strict bool) (map[string]any, error) {
 	return schemaOut, nil
 }
 
-func createNode(name string, v model.TranslatedVariable, strict bool) (map[string]any, error) {
+func createNode(name string, v model.TranslatedVariable, options CreateSchemaOptions) (map[string]any, error) {
 	tc, err := reader.GetTypeConstraint(v.Variable.Type)
 	if err != nil {
-		return nil, fmt.Errorf("getting type constraint for %s: %w", name, err)
+		return nil, fmt.Errorf("getting type constraint for %q: %w", name, err)
 	}
 
 	nullableIsTrue := v.Variable.Nullable != nil && *v.Variable.Nullable
-	node, err := getNodeFromType(name, tc, nullableIsTrue, strict)
+	node, err := getNodeFromType(name, tc, nullableIsTrue, options)
 	if err != nil {
-		return nil, fmt.Errorf("%s: %w", name, err)
+		return nil, fmt.Errorf("%q: %w", name, err)
 	}
 
 	if v.Variable.Default != nil {

pkg/jsonschema/json-schema_test.go

@@ -32,10 +32,14 @@ func TestCreateSchema(t *testing.T) {
 			expected, err := os.ReadFile(filepath.Join(schemaPath, name, "schema.json"))
 			require.NoError(t, err)
 
-			result, err := CreateSchema(filepath.Join(tfPath, name), false)
+			result, err := CreateSchema(filepath.Join(tfPath, name), CreateSchemaOptions{
+				RequireAll:                false,
+				AllowAdditionalProperties: true,
+				AllowEmpty:                true,
+			})
 			require.NoError(t, err)
 
-			var expectedMap map[string]interface{}
+			var expectedMap map[string]any
 			err = json.Unmarshal(expected, &expectedMap)
 			require.NoError(t, err)
 
@@ -283,7 +287,7 @@ func TestSampleInput(t *testing.T) {
 
 			input, err := os.ReadFile(tc.filePath)
 			require.NoError(t, err)
-			var m interface{}
+			var m any
 			err = json.Unmarshal(input, &m)
 			require.NoError(t, err)