feature: add AdditionalProperties to schemaRoot

Signed-off-by: Aleksandar Stojanov <me@fnd.works>

Author: losisin

README.md

@@ -98,6 +98,8 @@ usage: helm schema [-input STR] [-draft INT] [-output STR]
 	Multiple yaml files as inputs (comma-separated)
  -output string
 	Output file path (default "values.schema.json")
+ -schemaRoot.additionalProperties value
+	JSON schema additional properties (true/false)
  -schemaRoot.description string
 	JSON schema description
  -schemaRoot.id string

pkg/cmd.go

@@ -22,6 +22,7 @@ func ParseFlags(progname string, args []string) (config *Config, output string,
 flags.StringVar(&conf.SchemaRoot.ID, "schemaRoot.id", "", "JSON schema ID")
 flags.StringVar(&conf.SchemaRoot.Title, "schemaRoot.title", "", "JSON schema title")
 flags.StringVar(&conf.SchemaRoot.Description, "schemaRoot.description", "", "JSON schema description")
+flags.Var(&conf.SchemaRoot.AdditionalProperties, "schemaRoot.additionalProperties", "JSON schema additional properties (true/false)")
 
 err = flags.Parse(args)
 if err != nil {

pkg/cmd_test.go

@@ -71,6 +71,7 @@ func TestParseFlagsFail(t *testing.T) {
 {[]string{"-input"}, "flag needs an argument"},
 {[]string{"-draft", "foo"}, "invalid value"},
 {[]string{"-foo"}, "flag provided but not defined"},
+{[]string{"-schemaRoot.additionalProperties", "null"}, "invalid boolean value"},
 }
 
 for _, tt := range tests {

pkg/generator.go

@@ -82,6 +82,10 @@ func GenerateJsonSchema(config *Config) error {
 }
 jsonSchemaMap["$schema"] = schemaURL // Include the schema draft version
 
+if config.SchemaRoot.AdditionalProperties.IsSet() {
+jsonSchemaMap["additionalProperties"] = config.SchemaRoot.AdditionalProperties.Value()
+}
+
 // If validation is successful, marshal the schema and save to the file
 jsonBytes, err := json.MarshalIndent(jsonSchemaMap, "", indentString)
 if err != nil {

pkg/generator_test.go

@@ -3,6 +3,7 @@ package pkg
 import (
 "encoding/json"
 "errors"
+"fmt"
 "os"
 "testing"
 
@@ -132,3 +133,72 @@ func TestGenerateJsonSchema_Errors(t *testing.T) {
 })
 }
 }
+func TestGenerateJsonSchema_AdditionalProperties(t *testing.T) {
+tests := []struct {
+name string
+additionalPropertiesSet bool
+additionalProperties bool
+expected interface{}
+}{
+{
+name: "AdditionalProperties set to true",
+additionalPropertiesSet: true,
+additionalProperties: true,
+expected: true,
+},
+{
+name: "AdditionalProperties set to false",
+additionalPropertiesSet: true,
+additionalProperties: false,
+expected: false,
+},
+{
+name: "AdditionalProperties not set",
+additionalPropertiesSet: false,
+expected: nil,
+},
+}
+
+for _, tt := range tests {
+t.Run(tt.name, func(t *testing.T) {
+additionalPropertiesFlag := &BoolFlag{}
+if tt.additionalPropertiesSet {
+if err := additionalPropertiesFlag.Set(fmt.Sprintf("%t", tt.additionalProperties)); err != nil {
+t.Fatalf("Failed to set additionalPropertiesFlag: %v", err)
+}
+}
+
+config := &Config{
+input: []string{"../testdata/empty.yaml"},
+outputPath: "../testdata/empty.schema.json",
+draft: 2020,
+indent: 4,
+SchemaRoot: SchemaRoot{
+ID: "",
+Title: "",
+Description: "",
+AdditionalProperties: *additionalPropertiesFlag,
+},
+}
+
+err := GenerateJsonSchema(config)
+assert.NoError(t, err)
+
+generatedBytes, err := os.ReadFile(config.outputPath)
+assert.NoError(t, err)
+
+var generatedSchema map[string]interface{}
+err = json.Unmarshal(generatedBytes, &generatedSchema)
+assert.NoError(t, err)
+
+if tt.expected == nil {
+_, exists := generatedSchema["additionalProperties"]
+assert.False(t, exists, "additionalProperties should not be present in the generated schema")
+} else {
+assert.Equal(t, tt.expected, generatedSchema["additionalProperties"], "additionalProperties value mismatch")
+}
+
+os.Remove(config.outputPath)
+})
+}
+}

pkg/utils.go

@@ -1,12 +1,17 @@
 package pkg
 
-import "strings"
+import (
+"errors"
+"fmt"
+"strings"
+)
 
 // SchemaRoot struct defines root object of schema
 type SchemaRoot struct {
-ID string
-Title string
-Description string
+ID string
+Title string
+Description string
+AdditionalProperties BoolFlag
 }
 
 // Save values of parsed flags in Config
@@ -36,6 +41,41 @@ func (m *multiStringFlag) Set(value string) error {
 return nil
 }
 
+// Custom BoolFlag type that tracks if it was explicitly set
+type BoolFlag struct {
+set bool
+value bool
+}
+
+func (b *BoolFlag) String() string {
+if b.set {
+return fmt.Sprintf("%t", b.value)
+}
+return "not set"
+}
+
+func (b *BoolFlag) Set(value string) error {
+if value == "true" {
+b.value = true
+} else if value == "false" {
+b.value = false
+} else {
+return errors.New("invalid boolean value")
+}
+b.set = true
+return nil
+}
+
+// Accessor method to check if the flag was explicitly set
+func (b *BoolFlag) IsSet() bool {
+return b.set
+}
+
+// Accessor method to get the value of the flag
+func (b *BoolFlag) Value() bool {
+return b.value
+}
+
 func uniqueStringAppend(dest []string, src ...string) []string {
 existingItems := make(map[string]bool)
 for _, item := range dest {

pkg/utils_test.go

@@ -1,6 +1,7 @@
 package pkg
 
 import (
+"errors"
 "reflect"
 "testing"
 )
@@ -140,3 +141,106 @@ func TestUniqueStringAppend(t *testing.T) {
 })
 }
 }
+
+func TestBoolFlag_String(t *testing.T) {
+tests := []struct {
+name string
+set bool
+value bool
+expected string
+}{
+{"Unset flag", false, false, "not set"},
+{"Set flag to true", true, true, "true"},
+{"Set flag to false", true, false, "false"},
+}
+
+for _, tt := range tests {
+t.Run(tt.name, func(t *testing.T) {
+b := &BoolFlag{
+set: tt.set,
+value: tt.value,
+}
+if got := b.String(); got != tt.expected {
+t.Errorf("BoolFlag.String() = %v, want %v", got, tt.expected)
+}
+})
+}
+}
+
+func TestBoolFlag_Set(t *testing.T) {
+tests := []struct {
+name string
+input string
+expectedSet bool
+expectedValue bool
+expectedErr error
+}{
+{"Set true", "true", true, true, nil},
+{"Set false", "false", true, false, nil},
+{"Set invalid", "invalid", false, false, errors.New("invalid boolean value")},
+}
+
+for _, tt := range tests {
+t.Run(tt.name, func(t *testing.T) {
+b := &BoolFlag{}
+err := b.Set(tt.input)
+if (err != nil) != (tt.expectedErr != nil) {
+t.Errorf("BoolFlag.Set() error = %v, expectedErr %v", err, tt.expectedErr)
+return
+}
+if err != nil && err.Error() != tt.expectedErr.Error() {
+t.Errorf("BoolFlag.Set() error = %v, expectedErr %v", err, tt.expectedErr)
+}
+if b.set != tt.expectedSet {
+t.Errorf("BoolFlag.set = %v, expected %v", b.set, tt.expectedSet)
+}
+if b.value != tt.expectedValue {
+t.Errorf("BoolFlag.value = %v, expected %v", b.value, tt.expectedValue)
+}
+})
+}
+}
+
+func TestBoolFlag_IsSet(t *testing.T) {
+tests := []struct {
+name string
+set bool
+expected bool
+}{
+{"Flag is not set", false, false},
+{"Flag is set", true, true},
+}
+
+for _, tt := range tests {
+t.Run(tt.name, func(t *testing.T) {
+b := &BoolFlag{
+set: tt.set,
+}
+if got := b.IsSet(); got != tt.expected {
+t.Errorf("BoolFlag.IsSet() = %v, want %v", got, tt.expected)
+}
+})
+}
+}
+
+func TestBoolFlag_GetValue(t *testing.T) {
+tests := []struct {
+name string
+value bool
+expected bool
+}{
+{"Flag value is false", false, false},
+{"Flag value is true", true, true},
+}
+
+for _, tt := range tests {
+t.Run(tt.name, func(t *testing.T) {
+b := &BoolFlag{
+value: tt.value,
+}
+if got := b.Value(); got != tt.expected {
+t.Errorf("BoolFlag.GetValue() = %v, want %v", got, tt.expected)
+}
+})
+}
+}