OXIESEC PANEL

Name	Size	Modified	Perms	Actions
📁 ..	-	12/05/2024 09:52:20 PM	rwxr-xr-x
📄 .codecov.yml	66 bytes	12/05/2024 09:52:20 PM	r--r--r--	Delete
📄 .gitattributes	18 bytes	12/05/2024 09:52:20 PM	r--r--r--	Delete
📁 .github	-	12/05/2024 09:52:20 PM	r-xr-xr-x
📄 .gitignore	50 bytes	12/05/2024 09:52:20 PM	r--r--r--	Delete
📄 .golangci.yml	952 bytes	12/05/2024 09:52:20 PM	r--r--r--	Delete
📄 CODE_OF_CONDUCT.md	3.16 KB	12/05/2024 09:52:20 PM	r--r--r--	Delete
📄 LICENSE	11.09 KB	12/05/2024 09:52:20 PM	r--r--r--	Delete
📄 README.md	1.59 KB	12/05/2024 09:52:20 PM	r--r--r--	Delete
📄 analyzer.go	29.28 KB	12/05/2024 09:52:20 PM	r--r--r--	Delete
📄 analyzer_test.go	29.63 KB	12/05/2024 09:52:20 PM	r--r--r--	Delete
📄 debug.go	762 bytes	12/05/2024 09:52:20 PM	r--r--r--	Delete
📄 doc.go	1.58 KB	12/05/2024 09:52:20 PM	r--r--r--	Delete
📄 fixer.go	2.29 KB	12/05/2024 09:52:20 PM	r--r--r--	Delete
📄 fixer_test.go	3.32 KB	12/05/2024 09:52:20 PM	r--r--r--	Delete
📁 fixtures	-	12/05/2024 09:52:20 PM	r-xr-xr-x
📄 flatten.go	24.63 KB	12/05/2024 09:52:20 PM	r--r--r--	Delete
📄 flatten_name.go	7.46 KB	12/05/2024 09:52:20 PM	r--r--r--	Delete
📄 flatten_name_test.go	16.63 KB	12/05/2024 09:52:20 PM	r--r--r--	Delete
📄 flatten_options.go	2.59 KB	12/05/2024 09:52:20 PM	r--r--r--	Delete
📄 flatten_test.go	44.61 KB	12/05/2024 09:52:20 PM	r--r--r--	Delete
📄 go.mod	827 bytes	12/05/2024 09:52:20 PM	r--r--r--	Delete
📄 go.sum	7.1 KB	12/05/2024 09:52:20 PM	r--r--r--	Delete
📁 internal	-	12/05/2024 09:52:20 PM	r-xr-xr-x
📄 mixin.go	12.03 KB	12/05/2024 09:52:20 PM	r--r--r--	Delete
📄 mixin_test.go	3.92 KB	12/05/2024 09:52:20 PM	r--r--r--	Delete
📄 schema.go	6.5 KB	12/05/2024 09:52:20 PM	r--r--r--	Delete
📄 schema_test.go	11.58 KB	12/05/2024 09:52:20 PM	r--r--r--	Delete

Editing: schema.go

package analysis

import (
	"fmt"

"github.com/go-openapi/spec"
	"github.com/go-openapi/strfmt"
)

// SchemaOpts configures the schema analyzer
type SchemaOpts struct {
	Schema   *spec.Schema
	Root     interface{}
	BasePath string
	_        struct{}
}

// Schema analysis, will classify the schema according to known
// patterns.
func Schema(opts SchemaOpts) (*AnalyzedSchema, error) {
	if opts.Schema == nil {
		return nil, fmt.Errorf("no schema to analyze")
	}

a := &AnalyzedSchema{
		schema:   opts.Schema,
		root:     opts.Root,
		basePath: opts.BasePath,
	}

a.initializeFlags()
	a.inferKnownType()
	a.inferEnum()
	a.inferBaseType()

if err := a.inferMap(); err != nil {
		return nil, err
	}
	if err := a.inferArray(); err != nil {
		return nil, err
	}

a.inferTuple()

if err := a.inferFromRef(); err != nil {
		return nil, err
	}

a.inferSimpleSchema()

return a, nil
}

// AnalyzedSchema indicates what the schema represents
type AnalyzedSchema struct {
	schema   *spec.Schema
	root     interface{}
	basePath string

hasProps           bool
	hasAllOf           bool
	hasItems           bool
	hasAdditionalProps bool
	hasAdditionalItems bool
	hasRef             bool

IsKnownType      bool
	IsSimpleSchema   bool
	IsArray          bool
	IsSimpleArray    bool
	IsMap            bool
	IsSimpleMap      bool
	IsExtendedObject bool
	IsTuple          bool
	IsTupleWithExtra bool
	IsBaseType       bool
	IsEnum           bool
}

// Inherits copies value fields from other onto this schema
func (a *AnalyzedSchema) inherits(other *AnalyzedSchema) {
	if other == nil {
		return
	}
	a.hasProps = other.hasProps
	a.hasAllOf = other.hasAllOf
	a.hasItems = other.hasItems
	a.hasAdditionalItems = other.hasAdditionalItems
	a.hasAdditionalProps = other.hasAdditionalProps
	a.hasRef = other.hasRef

a.IsKnownType = other.IsKnownType
	a.IsSimpleSchema = other.IsSimpleSchema
	a.IsArray = other.IsArray
	a.IsSimpleArray = other.IsSimpleArray
	a.IsMap = other.IsMap
	a.IsSimpleMap = other.IsSimpleMap
	a.IsExtendedObject = other.IsExtendedObject
	a.IsTuple = other.IsTuple
	a.IsTupleWithExtra = other.IsTupleWithExtra
	a.IsBaseType = other.IsBaseType
	a.IsEnum = other.IsEnum
}

func (a *AnalyzedSchema) inferFromRef() error {
	if a.hasRef {
		sch := new(spec.Schema)
		sch.Ref = a.schema.Ref
		err := spec.ExpandSchema(sch, a.root, nil)
		if err != nil {
			return err
		}
		rsch, err := Schema(SchemaOpts{
			Schema:   sch,
			Root:     a.root,
			BasePath: a.basePath,
		})
		if err != nil {
			// NOTE(fredbi): currently the only cause for errors is
			// unresolved ref. Since spec.ExpandSchema() expands the
			// schema recursively, there is no chance to get there,
			// until we add more causes for error in this schema analysis.
			return err
		}
		a.inherits(rsch)
	}

return nil
}

func (a *AnalyzedSchema) inferSimpleSchema() {
	a.IsSimpleSchema = a.IsKnownType || a.IsSimpleArray || a.IsSimpleMap
}

func (a *AnalyzedSchema) inferKnownType() {
	tpe := a.schema.Type
	format := a.schema.Format
	a.IsKnownType = tpe.Contains("boolean") ||
		tpe.Contains("integer") ||
		tpe.Contains("number") ||
		tpe.Contains("string") ||
		(format != "" && strfmt.Default.ContainsName(format)) ||
		(a.isObjectType() && !a.hasProps && !a.hasAllOf && !a.hasAdditionalProps && !a.hasAdditionalItems)
}

func (a *AnalyzedSchema) inferMap() error {
	if !a.isObjectType() {
		return nil
	}

hasExtra := a.hasProps || a.hasAllOf
	a.IsMap = a.hasAdditionalProps && !hasExtra
	a.IsExtendedObject = a.hasAdditionalProps && hasExtra

if !a.IsMap {
		return nil
	}

// maps
	if a.schema.AdditionalProperties.Schema != nil {
		msch, err := Schema(SchemaOpts{
			Schema:   a.schema.AdditionalProperties.Schema,
			Root:     a.root,
			BasePath: a.basePath,
		})
		if err != nil {
			return err
		}
		a.IsSimpleMap = msch.IsSimpleSchema
	} else if a.schema.AdditionalProperties.Allows {
		a.IsSimpleMap = true
	}

return nil
}

func (a *AnalyzedSchema) inferArray() error {
	// an array has Items defined as an object schema, otherwise we qualify this JSON array as a tuple
	// (yes, even if the Items array contains only one element).
	// arrays in JSON schema may be unrestricted (i.e no Items specified).
	// Note that arrays in Swagger MUST have Items. Nonetheless, we analyze unrestricted arrays.
	//
	// NOTE: the spec package misses the distinction between:
	// items: [] and items: {}, so we consider both arrays here.
	a.IsArray = a.isArrayType() && (a.schema.Items == nil || a.schema.Items.Schemas == nil)
	if a.IsArray && a.hasItems {
		if a.schema.Items.Schema != nil {
			itsch, err := Schema(SchemaOpts{
				Schema:   a.schema.Items.Schema,
				Root:     a.root,
				BasePath: a.basePath,
			})
			if err != nil {
				return err
			}

a.IsSimpleArray = itsch.IsSimpleSchema
		}
	}

if a.IsArray && !a.hasItems {
		a.IsSimpleArray = true
	}

return nil
}

func (a *AnalyzedSchema) inferTuple() {
	tuple := a.hasItems && a.schema.Items.Schemas != nil
	a.IsTuple = tuple && !a.hasAdditionalItems
	a.IsTupleWithExtra = tuple && a.hasAdditionalItems
}

func (a *AnalyzedSchema) inferBaseType() {
	if a.isObjectType() {
		a.IsBaseType = a.schema.Discriminator != ""
	}
}

func (a *AnalyzedSchema) inferEnum() {
	a.IsEnum = len(a.schema.Enum) > 0
}

func (a *AnalyzedSchema) initializeFlags() {
	a.hasProps = len(a.schema.Properties) > 0
	a.hasAllOf = len(a.schema.AllOf) > 0
	a.hasRef = a.schema.Ref.String() != ""

a.hasItems = a.schema.Items != nil &&
		(a.schema.Items.Schema != nil || len(a.schema.Items.Schemas) > 0)

a.hasAdditionalProps = a.schema.AdditionalProperties != nil &&
		(a.schema.AdditionalProperties.Schema != nil || a.schema.AdditionalProperties.Allows)

a.hasAdditionalItems = a.schema.AdditionalItems != nil &&
		(a.schema.AdditionalItems.Schema != nil || a.schema.AdditionalItems.Allows)
}

func (a *AnalyzedSchema) isObjectType() bool {
	return !a.hasRef && (a.schema.Type == nil || a.schema.Type.Contains("") || a.schema.Type.Contains("object"))
}

func (a *AnalyzedSchema) isArrayType() bool {
	return !a.hasRef && (a.schema.Type != nil && a.schema.Type.Contains("array"))
}

// isAnalyzedAsComplex determines if an analyzed schema is eligible to flattening (i.e. it is "complex").
//
// Complex means the schema is any of:
//   - a simple type (primitive)
//   - an array of something (items are possibly complex ; if this is the case, items will generate a definition)
//   - a map of something (additionalProperties are possibly complex ; if this is the case, additionalProperties will
//     generate a definition)
func (a *AnalyzedSchema) isAnalyzedAsComplex() bool {
	return !a.IsSimpleSchema && !a.IsArray && !a.IsMap
}