Class: Gitlab::GrapeOpenapi::Converters::ParameterConverter

Inherits:
Object
  • Object
show all
Includes:
Gitlab::GrapeOpenapi::Concerns::ConstraintApplier, Gitlab::GrapeOpenapi::Concerns::FailFastAnnotatable, Gitlab::GrapeOpenapi::Concerns::LimitResolver, Gitlab::GrapeOpenapi::Concerns::RegexConverter, CoercerResolver
Defined in:
lib/gitlab/grape_openapi/converters/parameter_converter.rb

Constant Summary

Constants included from Gitlab::GrapeOpenapi::Concerns::RegexConverter

Gitlab::GrapeOpenapi::Concerns::RegexConverter::JS_REGEX_TARGET

Constants included from Gitlab::GrapeOpenapi::Concerns::FailFastAnnotatable

Gitlab::GrapeOpenapi::Concerns::FailFastAnnotatable::FAIL_FAST_ANNOTATION

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Gitlab::GrapeOpenapi::Concerns::RegexConverter

#regexp_to_pattern

Methods included from CoercerResolver

#build_coerced_schema, #coercer_mapping_for

Constructor Details

#initialize(name, options:, validations:, route:) ⇒ ParameterConverter

Returns a new instance of ParameterConverter.



19
20
21
22
23
24
 
# File 'lib/gitlab/grape_openapi/converters/parameter_converter.rb', line 19

def initialize(name, options:, validations:, route:)
  @name = name
  @options = options
  @validations = validations
  @route = route # Useful for detecting `in` value.
end

Instance Attribute Details

#name ⇒ Object (readonly)

Returns the value of attribute name.



13
14
15
 
# File 'lib/gitlab/grape_openapi/converters/parameter_converter.rb', line 13

def name
  @name
end

#options ⇒ Object (readonly)

Returns the value of attribute options.



13
14
15
 
# File 'lib/gitlab/grape_openapi/converters/parameter_converter.rb', line 13

def options
  @options
end

#route ⇒ Object (readonly)

Returns the value of attribute route.



13
14
15
 
# File 'lib/gitlab/grape_openapi/converters/parameter_converter.rb', line 13

def route
  @route
end

#validations ⇒ Object (readonly)

Returns the value of attribute validations.



13
14
15
 
# File 'lib/gitlab/grape_openapi/converters/parameter_converter.rb', line 13

def validations
  @validations
end

Class Method Details

.convert(name, options:, route:, validations: []) ⇒ Object 



15
16
17
 
# File 'lib/gitlab/grape_openapi/converters/parameter_converter.rb', line 15

def self.convert(name, options:, route:, validations: [])
  new(name, options: options, validations: validations, route: route).convert
end

Instance Method Details

#add_regex_validations!(schema) ⇒ Object 



118
119
120
121
122
123
124
125
126
127
 
# File 'lib/gitlab/grape_openapi/converters/parameter_converter.rb', line 118

def add_regex_validations!(schema)
  return unless validations

  # Only support one Regex validation per attribute
  validation = validations&.find { |v| v[:validator_class] == Grape::Validations::Validators::RegexpValidator }
  return unless validation

  pattern = regexp_to_pattern(validation[:options])
  schema[:pattern] = pattern if pattern
end

#array_type?(object_type) ⇒ Boolean

Returns:

  • (Boolean) 


110
111
112
 
# File 'lib/gitlab/grape_openapi/converters/parameter_converter.rb', line 110

def array_type?(object_type)
  object_type.include?('[')
end

#build_array_schema ⇒ Object 



98
99
100
101
 
# File 'lib/gitlab/grape_openapi/converters/parameter_converter.rb', line 98

def build_array_schema
  item_type = extract_array_item_type
  { type: 'array', items: { type: item_type } }
end

#build_basic_schema(object_type, object_format) ⇒ Object 



103
104
105
106
107
108
 
# File 'lib/gitlab/grape_openapi/converters/parameter_converter.rb', line 103

def build_basic_schema(object_type, object_format)
  schema = { type: object_type }
  schema[:format] = object_format if object_format
  add_regex_validations!(schema)
  schema
end

#build_enum_schema(object_type) ⇒ Object 



92
93
94
95
96
 
# File 'lib/gitlab/grape_openapi/converters/parameter_converter.rb', line 92

def build_enum_schema(object_type)
  schema = { type: object_type }
  schema[:enum] = options[:values] unless options[:values].is_a?(Proc)
  schema
end

#build_range_schema(object_type) ⇒ Object 



83
84
85
86
87
88
89
90
 
# File 'lib/gitlab/grape_openapi/converters/parameter_converter.rb', line 83

def build_range_schema(object_type)
  range = options[:values]
  schema = { type: object_type }

  schema[:minimum] = range.begin if range.begin
  schema[:maximum] = range.end if range.end
  schema
end

#build_simple_array_schema ⇒ Object 



67
68
69
70
 
# File 'lib/gitlab/grape_openapi/converters/parameter_converter.rb', line 67

def build_simple_array_schema
  item_type = options[:type].to_s.delete('[').delete(']')
  { type: 'array', items: { type: TypeResolver.resolve_type(item_type) } }
end

#build_union_schema(object_type) ⇒ Object 



72
73
74
75
76
77
78
79
80
81
 
# File 'lib/gitlab/grape_openapi/converters/parameter_converter.rb', line 72

def build_union_schema(object_type)
  types = object_type[1..-2].split(", ")
  members = types.map { |type| TypeResolver.resolve_union_member(type) }
  schema = TypeResolver.union_schema(members)
  members = schema.values.first
  # Unlike `default:`, enum stays inline: it needs per-member type dispatch
  # (coercing values to each member's type) that a generic post-step cannot do.
  apply_union_enum!(members)
  schema
end

#coercer_mapping ⇒ Object 



34
35
36
 
# File 'lib/gitlab/grape_openapi/converters/parameter_converter.rb', line 34

def coercer_mapping
  @coercer_mapping ||= coercer_mapping_for(validations)
end

#convert ⇒ Object 



129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
 
# File 'lib/gitlab/grape_openapi/converters/parameter_converter.rb', line 129

def convert
  # For requests that can have a request body (POST, PUT, PATCH, etc.), only return a param if it's in the path,
  # otherwise it'll be a body parameter and shouldn't be included as a query parameter.
  # GET and DELETE requests don't have request bodies, so all their parameters are included.
  method = route.request_method
  return nil if method != 'GET' && method != 'DELETE' && in_value != 'path'
  return nil if options.dig(:documentation, :hidden)

  annotated = options.dup
  if options[:desc] && fail_fast_in_validations?(validations)
    annotated[:desc] = annotate_fail_fast(options[:desc])
  end

  annotated[:desc] ||= route_param_desc

  param = Gitlab::GrapeOpenapi::Models::Parameter.new(
    name,
    options: annotated,
    schema: schema,
    in_value: in_value
  )

  mapping = coercer_mapping
  return param unless mapping

  param.style = mapping[:style] if mapping[:style]
  param.explode = mapping[:explode] if mapping.key?(:explode)
  param
end

#example ⇒ Object 



30
31
32
 
# File 'lib/gitlab/grape_openapi/converters/parameter_converter.rb', line 30

def example
  @options.dig(:documentation, :example)
end

#extract_array_item_type ⇒ Object 



114
115
116
 
# File 'lib/gitlab/grape_openapi/converters/parameter_converter.rb', line 114

def extract_array_item_type
  options[:type].delete('[').delete(']').downcase
end

#in_value ⇒ Object 



26
27
28
 
# File 'lib/gitlab/grape_openapi/converters/parameter_converter.rb', line 26

def in_value
  path_parameter_names.include?(name.to_s) ? 'path' : 'query'
end

#schema ⇒ Object 



38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/gitlab/grape_openapi/converters/parameter_converter.rb', line 38

def schema
  object_type = TypeResolver.resolve_type(options[:type]) || 'string'
  object_format = TypeResolver.resolve_format(nil, options[:type])
  type_str = options[:type].to_s

  mapping = coercer_mapping
  built_schema = if mapping
                   build_coerced_schema(mapping)
                 elsif type_str.start_with?('[') && type_str.exclude?(',')
                   build_simple_array_schema
                 elsif type_str.start_with?('[')
                   build_union_schema(object_type)
                 elsif options[:values].is_a?(Range)
                   build_range_schema(object_type)
                 elsif options[:values]
                   build_enum_schema(object_type)
                 elsif array_type?(object_type)
                   build_array_schema
                 else
                   build_basic_schema(object_type, object_format)
                 end

  apply_allow_blank(built_schema)
  apply_limit!(built_schema, validations)
  apply_array_enum!(built_schema, options[:values])
  apply_default!(built_schema, options[:default], example: example)
  built_schema
end