resolver.go

Documentation: github.com/go-openapi/spec

     1  package spec
     2  
     3  import (
     4  	"fmt"
     5  
     6  	"github.com/go-openapi/swag"
     7  )
     8  
     9  func resolveAnyWithBase(root interface{}, ref *Ref, result interface{}, options *ExpandOptions) error {
    10  	options = optionsOrDefault(options)
    11  	resolver := defaultSchemaLoader(root, options, nil, nil)
    12  
    13  	if err := resolver.Resolve(ref, result, options.RelativeBase); err != nil {
    14  		return err
    15  	}
    16  
    17  	return nil
    18  }
    19  
    20  // ResolveRefWithBase resolves a reference against a context root with preservation of base path
    21  func ResolveRefWithBase(root interface{}, ref *Ref, options *ExpandOptions) (*Schema, error) {
    22  	result := new(Schema)
    23  
    24  	if err := resolveAnyWithBase(root, ref, result, options); err != nil {
    25  		return nil, err
    26  	}
    27  
    28  	return result, nil
    29  }
    30  
    31  // ResolveRef resolves a reference for a schema against a context root
    32  // ref is guaranteed to be in root (no need to go to external files)
    33  //
    34  // ResolveRef is ONLY called from the code generation module
    35  func ResolveRef(root interface{}, ref *Ref) (*Schema, error) {
    36  	res, _, err := ref.GetPointer().Get(root)
    37  	if err != nil {
    38  		return nil, err
    39  	}
    40  
    41  	switch sch := res.(type) {
    42  	case Schema:
    43  		return &sch, nil
    44  	case *Schema:
    45  		return sch, nil
    46  	case map[string]interface{}:
    47  		newSch := new(Schema)
    48  		if err = swag.DynamicJSONToStruct(sch, newSch); err != nil {
    49  			return nil, err
    50  		}
    51  		return newSch, nil
    52  	default:
    53  		return nil, fmt.Errorf("type: %T: %w", sch, ErrUnknownTypeForReference)
    54  	}
    55  }
    56  
    57  // ResolveParameterWithBase resolves a parameter reference against a context root and base path
    58  func ResolveParameterWithBase(root interface{}, ref Ref, options *ExpandOptions) (*Parameter, error) {
    59  	result := new(Parameter)
    60  
    61  	if err := resolveAnyWithBase(root, &ref, result, options); err != nil {
    62  		return nil, err
    63  	}
    64  
    65  	return result, nil
    66  }
    67  
    68  // ResolveParameter resolves a parameter reference against a context root
    69  func ResolveParameter(root interface{}, ref Ref) (*Parameter, error) {
    70  	return ResolveParameterWithBase(root, ref, nil)
    71  }
    72  
    73  // ResolveResponseWithBase resolves response a reference against a context root and base path
    74  func ResolveResponseWithBase(root interface{}, ref Ref, options *ExpandOptions) (*Response, error) {
    75  	result := new(Response)
    76  
    77  	err := resolveAnyWithBase(root, &ref, result, options)
    78  	if err != nil {
    79  		return nil, err
    80  	}
    81  
    82  	return result, nil
    83  }
    84  
    85  // ResolveResponse resolves response a reference against a context root
    86  func ResolveResponse(root interface{}, ref Ref) (*Response, error) {
    87  	return ResolveResponseWithBase(root, ref, nil)
    88  }
    89  
    90  // ResolvePathItemWithBase resolves response a path item against a context root and base path
    91  func ResolvePathItemWithBase(root interface{}, ref Ref, options *ExpandOptions) (*PathItem, error) {
    92  	result := new(PathItem)
    93  
    94  	if err := resolveAnyWithBase(root, &ref, result, options); err != nil {
    95  		return nil, err
    96  	}
    97  
    98  	return result, nil
    99  }
   100  
   101  // ResolvePathItem resolves response a path item against a context root and base path
   102  //
   103  // Deprecated: use ResolvePathItemWithBase instead
   104  func ResolvePathItem(root interface{}, ref Ref, options *ExpandOptions) (*PathItem, error) {
   105  	return ResolvePathItemWithBase(root, ref, options)
   106  }
   107  
   108  // ResolveItemsWithBase resolves parameter items reference against a context root and base path.
   109  //
   110  // NOTE: stricly speaking, this construct is not supported by Swagger 2.0.
   111  // Similarly, $ref are forbidden in response headers.
   112  func ResolveItemsWithBase(root interface{}, ref Ref, options *ExpandOptions) (*Items, error) {
   113  	result := new(Items)
   114  
   115  	if err := resolveAnyWithBase(root, &ref, result, options); err != nil {
   116  		return nil, err
   117  	}
   118  
   119  	return result, nil
   120  }
   121  
   122  // ResolveItems resolves parameter items reference against a context root and base path.
   123  //
   124  // Deprecated: use ResolveItemsWithBase instead
   125  func ResolveItems(root interface{}, ref Ref, options *ExpandOptions) (*Items, error) {
   126  	return ResolveItemsWithBase(root, ref, options)
   127  }
   128
View as plain text