chaff

type DocumentFetchOptions struct {
	// HTTP Fetch Options
	HTTPFetchOptions HTTPFetchOptions

	// File System Fetch Options
	FileSystemFetchOptions FileSystemFetchOptions
}

type FileSystemFetchOptions struct {
	// If go-chaff is allowed to access the file system to resolve schema references
	//    THIS SHOULD BE DISABLED UNLESS YOU REALLY REALLY NEED IT
	//    Please if doing so, limit the AllowedPaths field as much as possible )
	Enabled bool

	// Overrides allowOutsideCwd to specifically allow for access to a list of paths schemas might reference
	// relative paths will be resolved against the current working directory at the time the parser is initialized
	// Symlinks that resolve to outside of the allowed paths will still be blocked
	AllowedPaths []string

	// Failsafe to prevent directory traversal attacks
	AllowOutsideCwd bool
}

type Generator interface {
	fmt.Stringer
	Generate(*GeneratorOptions) interface{}
}

type GeneratorOptions struct {
	// The source of randomness to use for the given generation.
	// Please note that some parts of the generators use different sources of randomness.
	// ("regex" generation and "format" strings)
	Rand *rand.RandUtil

	// The default minimum number value
	DefaultNumberMinimum int

	// The default maximum number value
	DefaultNumberMaximum int

	// The default minimum String length
	DefaultStringMinLength int

	// The default maximum String length
	DefaultStringMaxLength int

	// The default minimum array length
	DefaultArrayMinItems int

	// The default maximum array length
	// This will be set min + this inf the event a minimum value is set
	DefaultArrayMaxItems int

	// The default minimum object properties (Will be ignored if there are fewer properties available)
	DefaultObjectMinProperties int

	// The default maximum object properties (Will be ignored if there are fewer properties available)
	DefaultObjectMaxProperties int

	// The maximum number of references to resolve at once (Default: 10)
	MaximumReferenceDepth int

	// In the event that schemas are recursive there is a good chance the generator
	// can run forever. This option will bypass the check for cyclic references
	// Please defer to the MaximumReferenceDepth option if possible when using this
	BypassCyclicReferenceCheck bool

	// Used to keep track of references during a resolution cycle (Used internally and can be ignored)
	ReferenceResolver referenceResolver

	// Though technically in some cases a schema may allow for additional
	// values it might not always be desireable. this option suppresses fallback_n values
	// so that they will only appear to make up a "minimum value" forces them to
	SuppressFallbackValues bool

	// The maximum number of times to attempt to generate a unique value
	// when using unique* constraints in schemas
	MaximumUniqueGeneratorAttempts int

	// The maximum number of times to attempt to satisfy "if" statements
	// before giving up
	MaximumIfAttempts int

	// The maximum number of times to attempt to satisfy "oneOf" statements
	// before giving up
	MaximumOneOfAttempts int

	// The maximum number of steps to take when generating a value
	// after which the the generator will begin to do the "bare minimum" to generate a value
	MaximumGenerationSteps int

	// The maximum number of steps to take before giving up entirely and aborting generation
	// This is a hard cap on generation steps to prevent extremely long generation times
	CutoffGenerationSteps int
	// contains filtered or unexported fields
}

type HTTPFetchOptions struct {
	// If go-chaff is allowed to make HTTP requests to resolve schema references
	Enabled bool

	// Allowed hosts to fetch from (If empty, all hosts are allowed)
	AllowedHosts []string

	// Allow insecure connections (http)
	AllowInsecure bool
}

type ParserOptions struct {
	// Options for the regex generator used for generating strings with the "pattern property"
	RegexStringOptions *regen.GeneratorArgs

	// Options for the regex generator used for pattern properties
	RegexPatternPropertyOptions *regen.GeneratorArgs

	// Parser fetch configurations for external document fetching
	DocumentFetchOptions DocumentFetchOptions

	// Base path to resolve relative document references against for $ref resolution when fetching external documents
	RelativeTo string
}

type RootGenerator struct {
	Generator Generator
	// For any "$defs"
	Defs map[string]Generator
	// For any "definitions"
	Definitions map[string]Generator
	// Metadata related to parser operations
	Metadata *parserMetadata
}