jsonschema.go

package surveyutils

import (
	"encoding/json"
	"fmt"
	"io"
	"reflect"
	"strconv"
	"strings"

	"github.com/pkg/errors"

	jenkinsv1 "github.com/jenkins-x/jx/pkg/apis/jenkins.io/v1"

	"github.com/jenkins-x/jx/pkg/kube"

	"github.com/jenkins-x/jx/pkg/util"

	"github.com/iancoleman/orderedmap"

	survey "gopkg.in/AlecAivazis/survey.v1"

	"gopkg.in/AlecAivazis/survey.v1/terminal"
)

// Type represents a JSON Schema object type current to https://www.ietf.org/archive/id/draft-handrews-json-schema-validation-01.txt
type Type struct {
	Version          string      `json:"$schema,omitempty"`
	Ref              string      `json:"$ref,omitempty"`
	MultipleOf       *float64    `json:"multipleOf,omitempty"`
	Maximum          *float64    `json:"maximum,omitempty"`
	ExclusiveMaximum *float64    `json:"exclusiveMaximum,omitempty"`
	Minimum          *float64    `json:"minimum,omitempty"`
	ExclusiveMinimum *float64    `json:"exclusiveMinimum,omitempty"`
	MaxLength        *int        `json:"maxLength,omitempty"`
	MinLength        *int        `json:"minLength,omitempty"`
	Pattern          *string     `json:"pattern,omitempty"`
	AdditionalItems  *Type       `json:"additionalItems,omitempty"`
	Items            Items       `json:"items,omitempty"`
	MaxItems         *int        `json:"maxItems,omitempty"`
	MinItems         *int        `json:"minItems,omitempty"`
	UniqueItems      bool        `json:"uniqueItems,omitempty"`
	MaxProperties    *int        `json:"maxProperties,omitempty"`
	MinProperties    *int        `json:"minProperties,omitempty"`
	Required         []string    `json:"required,omitempty"`
	Properties       *Properties `json:"properties,omitempty"`
	// TODO Implement support & tests for PatternProperties
	PatternProperties map[string]*Type `json:"patternProperties,omitempty"`
	// TODO Implement support & tests for AdditionalProperties
	AdditionalProperties *Type `json:"additionalProperties,omitempty"`
	// TODO Implement support & tests for Dependencies
	Dependencies map[string]Dependency `json:"dependencies,omitempty"`
	// TODO Implement support & tests for PropertyNames
	PropertyNames *Type         `json:"propertyNames,omitempty"`
	Enum          []interface{} `json:"enum,omitempty"`
	Type          string        `json:"type,omitempty"`
	// TODO Implement support & tests for If, Then, Else
	// TODO Implement support & tests for All
	AllOf []*Type `json:"allOf,omitempty"`
	// TODO Implement support & tests for AnyOf
	AnyOf []*Type `json:"anyOf,omitempty"`
	// TODO Implement support & tests for OneOf
	OneOf []*Type `json:"oneOf,omitempty"`
	// TODO Implement support & tests for Not
	Not *Type `json:"not,omitempty"`
	// TODO Implement support & tests for Definitions
	Definitions Definitions `json:"definitions,omitempty"`
	// TODO Implement support & tests for Contains
	Contains         *Type        `json:"contains,omitempty"`
	Const            *interface{} `json:"const,omitempty"`
	Title            string       `json:"title,omitempty"`
	Description      string       `json:"description,omitempty"`
	Default          interface{}  `json:"default,omitempty"`
	Format           *string      `json:"format,omitempty"`
	ContentMediaType *string      `json:"contentMediaType,omitempty"`
	ContentEncoding  *string      `json:"contentEncoding,omitempty"`
}

// GeneratedSecret is a secret that is generated from protected input (e.g. password, token)
type GeneratedSecret struct {
	Name  string `json: "name"`
	Key   string `json:"key"`
	Value string `json:"value"`
}

// Definitions hold schema definitions.
type Definitions map[string]*Type

// Dependency is either a Type or an array of strings, and so requires special unmarshaling from JSON
type Dependency struct {
	Type  *Type    `json:-`
	Array []string `json:-`
}

// UnmarshalJSON performs unmarshals Dependency from JSON, required as the json field can be one of two types
func (d *Dependency) UnmarshalJSON(b []byte) error {
	if b[0] == '[' {
		return json.Unmarshal(b, &d.Array)
	}
	return json.Unmarshal(b, d.Type)
}

// Items is a either a Type or a array of types, and so requires special unmarshaling from JSON
type Items struct {
	Types []*Type `json:-`
	Type  *Type   `json:-`
}

// Properties is a set of ordered key-value pairs, as it is ordered it requires special marshaling to/from JSON
type Properties struct {
	*orderedmap.OrderedMap
}

// UnmarshalJSON performs custom Unmarshaling for Properties allowing us to preserve order,
// which is not a standard JSON feature
func (p *Properties) UnmarshalJSON(b []byte) error {
	m := orderedmap.New()
	err := json.Unmarshal(b, &m)
	if err != nil {
		return err
	}
	if p.OrderedMap == nil {
		p.OrderedMap = orderedmap.New()
	}
	for _, k := range m.Keys() {
		v, _ := m.Get(k)
		t := Type{}
		om, ok := v.(orderedmap.OrderedMap)
		if !ok {
			return fmt.Errorf("Unable to cast nested data structure to OrderedMap")
		}
		values := make(map[string]interface{}, 0)
		for _, k1 := range om.Keys() {
			v1, _ := om.Get(k1)
			values[k1] = v1
		}
		err := util.ToStructFromMapStringInterface(values, &t)
		if err != nil {
			return err
		}
		p.Set(k, &t)
	}
	return nil
}

// UnmarshalJSON performs unmarshals Items from JSON, required as the json field can be one of two types
func (t *Items) UnmarshalJSON(b []byte) error {
	if b[0] == '[' {
		return json.Unmarshal(b, &t.Types)
	}
	err := json.Unmarshal(b, &t.Type)
	if err != nil {
		return err
	}
	return nil
}

// JSONSchemaOptions are options for generating values from a schema
type JSONSchemaOptions struct {
	CreateSecret        func(name string, key string, value string) (*jenkinsv1.ResourceReference, error)
	AskExisting         bool
	AutoAcceptDefaults  bool
	NoAsk               bool
	IgnoreMissingValues bool
	In                  terminal.FileReader
	Out                 terminal.FileWriter
	OutErr              io.Writer
}

// GenerateValues examines the schema in schemaBytes, asks a series of questions using in, out and outErr,
// applying validators, returning a generated json file.
// If there are existingValues then those questions will be ignored and the existing value used unless askExisting is
// true. If autoAcceptDefaults is true, then default values will be used automatically.
// If ignoreMissingValues is false then any values which don't have an existing value (
// or a default value if autoAcceptDefaults is true) will cause an error
func (o *JSONSchemaOptions) GenerateValues(schemaBytes []byte, existingValues map[string]interface{}) ([]byte, error) {
	t := Type{}
	err := json.Unmarshal(schemaBytes, &t)
	if err != nil {
		return nil, errors.Wrapf(err, "unmarshaling schema %s", schemaBytes)
	}
	output := orderedmap.New()
	err = o.recurse("", make([]string, 0), make([]string, 0), &t, output, make([]survey.Validator, 0), existingValues)
	if err != nil {
		return nil, errors.WithStack(err)
	}
	// move the output up a level
	if root, ok := output.Get(""); ok {
		bytes, err := json.Marshal(root)
		if err != nil {
			return nil, errors.WithStack(err)
		}
		return bytes, nil
	}
	return make([]byte, 0), fmt.Errorf("unable to find root element in %v", output)

}

func (o *JSONSchemaOptions) recurse(name string, prefixes []string, requiredFields []string, t *Type, output *orderedmap.OrderedMap,
	additionalValidators []survey.Validator, existingValues map[string]interface{}) error {
	required := util.Contains(requiredFields, name)
	if name != "" {
		prefixes = append(prefixes, name)
	}
	if t.ContentEncoding != nil {
		return fmt.Errorf("contentEncoding is not supported for %s", name)
		// TODO support contentEncoding
	}
	if t.ContentMediaType != nil {
		return fmt.Errorf("contentMediaType is not supported for %s", name)
		// TODO support contentMediaType
	}

	switch t.Type {
	case "null":
		output.Set(name, nil)
	case "boolean":
		validators := []survey.Validator{
			EnumValidator(t.Enum),
			RequiredValidator(required),
			BoolValidator(),
		}
		validators = append(validators, additionalValidators...)
		err := o.handleBasicProperty(name, prefixes, validators, t, output, existingValues)
		if err != nil {
			return err
		}
	case "object":
		if t.AdditionalProperties != nil {
			return fmt.Errorf("additionalProperties is not supported for %s", name)
		}
		if len(t.PatternProperties) > 0 {
			return fmt.Errorf("patternProperties is not supported for %s", name)
		}
		if len(t.Dependencies) > 0 {
			return fmt.Errorf("dependencies is not supported for %s", name)
		}
		if t.PropertyNames != nil {
			return fmt.Errorf("propertyNames is not supported for %s", name)
		}
		if t.Const != nil {
			return fmt.Errorf("const is not supported for %s", name)
			// TODO support const
		}
		if t.Properties != nil {
			for valid := false; !valid; {
				result := orderedmap.New()
				duringValidators := make([]survey.Validator, 0)
				postValidators := []survey.Validator{
					// These validators are run after the processing of the properties
					MinPropertiesValidator(t.MinProperties, result, name),
					EnumValidator(t.Enum),
					MaxPropertiesValidator(t.MaxProperties, result, name),
				}
				for _, n := range t.Properties.Keys() {
					v, _ := t.Properties.Get(n)
					property := v.(*Type)
					var nestedExistingValues map[string]interface{}
					if name == "" {
						// This is the root element
						nestedExistingValues = existingValues
					} else if v, ok := existingValues[name]; ok {
						var err error
						nestedExistingValues, err = util.AsMapOfStringsIntefaces(v)
						if err != nil {
							return errors.Wrapf(err, "converting key %s from %v to map[string]interface{}", name, existingValues)
						}
					}
					err := o.recurse(n, prefixes, t.Required, property, result, duringValidators, nestedExistingValues)
					if err != nil {
						return err
					}
				}
				valid = true
				for _, v := range postValidators {
					err := v(result)
					if err != nil {
						str := fmt.Sprintf("Sorry, your reply was invalid: %s", err.Error())
						_, err1 := o.Out.Write([]byte(str))
						if err1 != nil {
							return err1
						}
						valid = false
					}
				}
				if valid {
					output.Set(name, result)
				}
			}
		}
	case "array":
		if t.Const != nil {
			return fmt.Errorf("const is not supported for %s", name)
			// TODO support const
		}
		if t.Contains != nil {
			return fmt.Errorf("contains is not supported for %s", name)
			// TODO support contains
		}
		if t.AdditionalItems != nil {
			return fmt.Errorf("additionalItems is not supported for %s", name)
			// TODO support additonalItems
		}
		err := o.handleArrayProperty(name, t, output, existingValues)
		if err != nil {
			return err
		}
	case "number":
		validators := additionalValidators
		validators = append(validators, FloatValidator())
		err := o.handleBasicProperty(name, prefixes, numberValidator(required, validators, t), t, output, existingValues)
		if err != nil {
			return err
		}
	case "string":
		validators := []survey.Validator{
			EnumValidator(t.Enum),
			MinLengthValidator(t.MinLength),
			MaxLengthValidator(t.MaxLength),
			RequiredValidator(required),
			PatternValidator(t.Pattern),
		}
		// Custom format support for password

		// Defined Format validation
		if t.Format != nil {
			format := util.DereferenceString(t.Format)
			switch format {
			case "date-time":
				validators = append(validators, DateTimeValidator())
			case "date":
				validators = append(validators, DateValidator())
			case "time":
				validators = append(validators, TimeValidator())
			case "email", "idn-email":
				validators = append(validators, EmailValidator())
			case "hostname", "idn-hostname":
				validators = append(validators, HostnameValidator())
			case "ipv4":
				validators = append(validators, Ipv4Validator())
			case "ipv6":
				validators = append(validators, Ipv6Validator())
			case "uri":
				validators = append(validators, URIValidator())
			case "uri-reference":
				validators = append(validators, URIReferenceValidator())
			case "iri":
				return fmt.Errorf("iri defined format not supported")
			case "iri-reference":
				return fmt.Errorf("iri-reference defined format not supported")
			case "uri-template":
				return fmt.Errorf("uri-template defined format not supported")
			case "json-pointer":
				validators = append(validators, JSONPointerValidator())
			case "relative-json-pointer":
				return fmt.Errorf("relative-json-pointer defined format not supported")
			case "regex":
				return fmt.Errorf("regex defined format not supported, use pattern keyword")
			}
		}
		validators = append(validators, additionalValidators...)
		err := o.handleBasicProperty(name, prefixes, validators, t, output, existingValues)
		if err != nil {
			return err
		}
	case "integer":
		validators := additionalValidators
		validators = append(validators, IntegerValidator())
		err := o.handleBasicProperty(name, prefixes, numberValidator(required, validators, t), t, output,
			existingValues)
		if err != nil {
			return err
		}
	}

	return nil
}

// According to the spec, "An instance validates successfully against this keyword if its value
// is equal to the value of the keyword." which we interpret for questions as "this is the value of this keyword"
func (o *JSONSchemaOptions) handleConst(name string, validators []survey.Validator, t *Type, output *orderedmap.OrderedMap) error {
	message := fmt.Sprintf("Do you want to set %s to %v", name, *t.Const)
	help := ""
	if t.Title != "" {
		message = t.Title
	}
	if t.Description != "" {
		help = t.Description
	}
	prompt := &survey.Confirm{
		Help:    help,
		Message: message,
		Default: true,
	}
	answer := false
	surveyOpts := survey.WithStdio(o.In, o.Out, o.OutErr)
	validator := survey.ComposeValidators(validators...)

	err := survey.AskOne(prompt, &answer, NoopValidator(), surveyOpts)
	if err != nil {
		return err
	}
	err = validator(t.Const)
	if answer {
		constAsString := fmt.Sprintf("%v", *t.Const)
		v, err := convertAnswer(constAsString, t.Type)
		if err != nil {
			return err
		}
		output.Set(name, v)
	}
	return nil
}

func (o *JSONSchemaOptions) handleArrayProperty(name string, t *Type, output *orderedmap.OrderedMap,
	existingValues map[string]interface{}) error {
	results := make([]interface{}, 0)

	validators := []survey.Validator{
		MaxItemsValidator(t.MaxItems, results),
		UniqueItemsValidator(results),
		MinItemsValidator(t.MinItems, results),
		EnumValidator(t.Enum),
	}
	// Normally arrays are used to create a multi-select list
	// Note that this only supports basic types at the moment
	if t.Items.Type != nil && t.Items.Type.Enum != nil {
		if t.Items.Type.Type == "null" {
			output.Set(name, nil)
			return nil
		} else if !util.Contains([]string{"string", "boolean", "number", "integer"}, t.Items.Type.Type) {
			return fmt.Errorf("type %s is not supported for array %s", t.Items.Type.Type, name)
			// TODO support other types
		}
		message := fmt.Sprintf("Select values for %s", name)
		help := ""
		ask := true
		var defaultValue []string
		autoAcceptMessage := ""
		if value, ok := existingValues[name]; ok {
			if !o.AskExisting {
				ask = false
			}
			existingString, err := util.AsString(value)
			existingArray, err1 := util.AsSliceOfStrings(value)
			if err != nil && err1 != nil {
				v := reflect.ValueOf(value)
				v = reflect.Indirect(v)
				return fmt.Errorf("Cannot convert %v (%v) to string or []string", v.Type(), value)
			}
			if existingString != "" {
				defaultValue = []string{
					existingString,
				}
			} else {
				defaultValue = existingArray
			}
			autoAcceptMessage = "Automatically accepted existing value"
		} else if t.Default != nil {
			if o.AutoAcceptDefaults {
				ask = false
				autoAcceptMessage = "Automatically accepted default value"
			}
			defaultString, err := util.AsString(t.Default)
			defaultArray, err1 := util.AsSliceOfStrings(t.Default)
			if err != nil && err1 != nil {
				v := reflect.ValueOf(t.Default)
				v = reflect.Indirect(v)
				return fmt.Errorf("Cannot convert %value (%value) to string or []string", v.Type(), t.Default)
			}
			if defaultString != "" {
				defaultValue = []string{
					defaultString,
				}
			} else {
				defaultValue = defaultArray
			}
		}
		if o.NoAsk {
			ask = false
		}

		options := make([]string, 0)
		if t.Title != "" {
			message = t.Title
		}
		if t.Description != "" {
			help = t.Description
		}
		for _, e := range t.Items.Type.Enum {
			options = append(options, fmt.Sprintf("%value", e))
		}

		answer := make([]string, 0)
		surveyOpts := survey.WithStdio(o.In, o.Out, o.OutErr)
		// TODO^^^ Apply correct validators for type
		validator := survey.ComposeValidators(validators...)

		if ask {
			prompt := &survey.MultiSelect{
				Default: defaultValue,
				Help:    help,
				Message: message,
				Options: options,
			}
			err := survey.AskOne(prompt, &answer, validator, surveyOpts)
			if err != nil {
				return err
			}
		} else {
			answer = defaultValue
			msg := fmt.Sprintf("%s %s [%s]\n", message, util.ColorInfo(answer), autoAcceptMessage)
			_, err := fmt.Fprint(terminal.NewAnsiStdout(o.Out), msg)
			if err != nil {
				return errors.Wrapf(err, "writing %s to console", msg)
			}
		}

		for _, a := range answer {
			v, err := convertAnswer(a, t.Items.Type.Type)
			// An error is a genuine error as we've already done type validation
			if err != nil {
				return err
			}
			results = append(results, v)
		}
	}

	output.Set(name, results)
	return nil
}

func convertAnswer(answer string, t string) (interface{}, error) {
	if t == "number" {
		return strconv.ParseFloat(answer, 64)
	} else if t == "integer" {
		return strconv.Atoi(answer)
	} else if t == "boolean" {
		return strconv.ParseBool(answer)
	} else {
		return answer, nil
	}
}

func (o *JSONSchemaOptions) handleBasicProperty(name string, prefixes []string, validators []survey.Validator, t *Type,
	output *orderedmap.OrderedMap, existingValues map[string]interface{}) error {
	if t.Const != nil {
		return o.handleConst(name, validators, t, output)
	}

	ask := true
	defaultValue := ""
	autoAcceptMessage := ""
	if v, ok := existingValues[name]; ok {
		if !o.AskExisting {
			ask = false
		}
		defaultValue = fmt.Sprintf("%v", v)
		autoAcceptMessage = "Automatically accepted existing value"
	} else if t.Default != nil {
		if o.AutoAcceptDefaults {
			ask = false
			autoAcceptMessage = "Automatically accepted default value"
		}
		defaultValue = fmt.Sprintf("%v", t.Default)
	}
	if o.NoAsk {
		ask = false
	}

	var result interface{}
	message := fmt.Sprintf("Enter a value for %s", name)
	help := ""
	if t.Title != "" {
		message = t.Title
	}
	if t.Description != "" {
		help = t.Description
	}

	if !ask && !o.IgnoreMissingValues && defaultValue == "" {
		return fmt.Errorf("no existing or default value in answer to question %s", message)
	}

	surveyOpts := survey.WithStdio(o.In, o.Out, o.OutErr)
	validator := survey.ComposeValidators(validators...)
	// Ask the question
	// Custom format support for passwords
	storeAsSecret := false
	if util.DereferenceString(t.Format) == "password" || util.DereferenceString(t.Format) == "token" {
		storeAsSecret = true
		// Secret input
		prompt := &survey.Password{
			Message: message,
			Help:    help,
		}

		var answer string
		var err error
		if ask {
			err := survey.AskOne(prompt, &answer, validator, surveyOpts)
			if err != nil {
				return err
			}
		} else {
			answer = defaultValue
			msg := fmt.Sprintf("%s %s [%s]\n", message, util.ColorInfo(answer), autoAcceptMessage)
			_, err := fmt.Fprint(terminal.NewAnsiStdout(o.Out), msg)
			if err != nil {
				return errors.Wrapf(err, "writing %s to console", msg)
			}
		}
		if answer != "" {
			result, err = convertAnswer(answer, t.Type)
			if err != nil {
				return errors.Wrapf(err, "error converting answer %s to type %s", answer, t.Type)
			}
		}
	} else if t.Enum != nil {
		// Support for selects
		names := make([]string, 0)
		for _, e := range t.Enum {
			names = append(names, fmt.Sprintf("%v", e))
		}
		prompt := &survey.Select{
			Message: message,
			Options: names,
			Default: defaultValue,
			Help:    help,
		}
		if ask {
			err := survey.AskOne(prompt, &result, validator, surveyOpts)
			if err != nil {
				return err
			}
		} else {
			result = defaultValue
			msg := fmt.Sprintf("%s %s [%s]\n", message, util.ColorInfo(result), autoAcceptMessage)
			_, err := fmt.Fprint(terminal.NewAnsiStdout(o.Out), msg)
			if err != nil {
				return errors.Wrapf(err, "writing %s to console", msg)
			}
		}
	} else if t.Type == "boolean" {
		// Confirm dialog
		var d bool
		var err error
		if defaultValue != "" {
			d, err = strconv.ParseBool(defaultValue)
			if err != nil {
				return err
			}
		}

		var answer bool
		prompt := &survey.Confirm{
			Message: message,
			Help:    help,
			Default: d,
		}

		if ask {
			err = survey.AskOne(prompt, &answer, validator, surveyOpts)
			if err != nil {
				return errors.Wrapf(err, "error asking user %s using validators %v", message, validators)
			}
		} else {
			answer = d
			msg := fmt.Sprintf("%s %s [%s]\n", message, util.ColorInfo(answer), autoAcceptMessage)
			_, err := fmt.Fprint(terminal.NewAnsiStdout(o.Out), msg)
			if err != nil {
				return errors.Wrapf(err, "writing %s to console", msg)
			}
		}
		result = answer
	} else {
		// Basic input
		prompt := &survey.Input{
			Message: message,
			Default: defaultValue,
			Help:    help,
		}
		var answer string
		var err error
		if ask {
			err = survey.AskOne(prompt, &answer, validator, surveyOpts)
			if err != nil {
				return errors.Wrapf(err, "error asking user %s using validators %v", message, validators)
			}
		} else {
			answer = defaultValue
			msg := fmt.Sprintf("%s %s [%s]\n", message, util.ColorInfo(answer), autoAcceptMessage)
			_, err := fmt.Fprint(terminal.NewAnsiStdout(o.Out), msg)
			if err != nil {
				return errors.Wrapf(err, "writing %s to console", msg)
			}
		}
		if answer != "" {
			result, err = convertAnswer(answer, t.Type)
		}
		if err != nil {
			return errors.Wrapf(err, "error converting result %s to type %s", answer, t.Type)
		}
	}

	if storeAsSecret {
		secretName := kube.ToValidName(strings.Join(append(prefixes, "secret"), "-"))
		value, err := util.AsString(result)
		if err != nil {
			return err
		}
		secretReference, err := o.CreateSecret(secretName, util.DereferenceString(t.Format), value)
		if err != nil {
			return err
		}
		output.Set(name, secretReference)
	} else if result != nil {
		// Write the value to the output
		output.Set(name, result)
	}
	return nil
}

func numberValidator(required bool, additonalValidators []survey.Validator, t *Type) []survey.Validator {
	validators := []survey.Validator{EnumValidator(t.Enum),
		MultipleOfValidator(t.MultipleOf),
		RequiredValidator(required),
		MinValidator(t.Minimum, false),
		MinValidator(t.ExclusiveMinimum, true),
		MaxValidator(t.Maximum, false),
		MaxValidator(t.ExclusiveMaximum, true),
	}
	return append(validators, additonalValidators...)
}