speakeasy_rubygems_tp_sample 0.0.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +7 -0
- data/lib/crystalline/enum.rbi +17 -0
- data/lib/crystalline/metadata_fields.rb +265 -0
- data/lib/crystalline/module.rb +188 -0
- data/lib/crystalline/types.rb +170 -0
- data/lib/crystalline/utils.rb +69 -0
- data/lib/crystalline.rb +13 -0
- data/lib/open_api_sdk/models/callbacks.rb +12 -0
- data/lib/open_api_sdk/models/components/pet.rb +34 -0
- data/lib/open_api_sdk/models/components/pet.rbi +20 -0
- data/lib/open_api_sdk/models/components.rb +12 -0
- data/lib/open_api_sdk/models/errors/apierror.rb +39 -0
- data/lib/open_api_sdk/models/errors/apierror.rbi +27 -0
- data/lib/open_api_sdk/models/errors.rb +12 -0
- data/lib/open_api_sdk/models/operations/listpets_response.rb +51 -0
- data/lib/open_api_sdk/models/operations/listpets_response.rbi +32 -0
- data/lib/open_api_sdk/models/operations.rb +12 -0
- data/lib/open_api_sdk/petstore.rb +223 -0
- data/lib/open_api_sdk/sdk_hooks/hooks.rb +99 -0
- data/lib/open_api_sdk/sdk_hooks/registration.rb +34 -0
- data/lib/open_api_sdk/sdk_hooks/types.rb +180 -0
- data/lib/open_api_sdk/sdkconfiguration.rb +97 -0
- data/lib/open_api_sdk/sdkconfiguration.rbi +77 -0
- data/lib/open_api_sdk/utils/forms.rb +232 -0
- data/lib/open_api_sdk/utils/headers.rb +84 -0
- data/lib/open_api_sdk/utils/query_params.rb +167 -0
- data/lib/open_api_sdk/utils/request_bodies.rb +79 -0
- data/lib/open_api_sdk/utils/retries.rb +139 -0
- data/lib/open_api_sdk/utils/security.rb +158 -0
- data/lib/open_api_sdk/utils/url.rb +124 -0
- data/lib/open_api_sdk/utils/utils.rb +245 -0
- data/lib/speakeasy_rubygems_tp_sample.rb +25 -0
- metadata +290 -0
|
@@ -0,0 +1,167 @@
|
|
|
1
|
+
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
# typed: true
|
|
4
|
+
# frozen_string_literal: true
|
|
5
|
+
|
|
6
|
+
require "date"
|
|
7
|
+
require "base64"
|
|
8
|
+
require "sorbet-runtime"
|
|
9
|
+
|
|
10
|
+
module OpenApiSDK
|
|
11
|
+
module Utils
|
|
12
|
+
extend T::Sig
|
|
13
|
+
|
|
14
|
+
sig {
|
|
15
|
+
params(
|
|
16
|
+
clazz: ::Object,
|
|
17
|
+
query_params: ::Object,
|
|
18
|
+
url_override: T.nilable(::String),
|
|
19
|
+
gbls: T.nilable(T::Hash[::Symbol, T::Hash[::Symbol, T::Hash[::Symbol, ::Object]]])
|
|
20
|
+
)
|
|
21
|
+
.returns(T::Hash[T.any(::String, ::Symbol), T::Array[::String]])
|
|
22
|
+
}
|
|
23
|
+
def self.get_query_params(clazz, query_params, url_override = nil, gbls = nil)
|
|
24
|
+
parsed_params = T.let({}, T::Hash[T.any(::String, ::Symbol), T::Array[::String]])
|
|
25
|
+
if !url_override.nil?
|
|
26
|
+
parsed_url = ::URI.parse(url_override)
|
|
27
|
+
::URI.decode_www_form(parsed_url.query.to_s).each do |key, value|
|
|
28
|
+
parsed_params[key] ||= []
|
|
29
|
+
T.must(parsed_params[key]) << value
|
|
30
|
+
end
|
|
31
|
+
end
|
|
32
|
+
|
|
33
|
+
params = T.let({}, T::Hash[T.any(::String, ::Symbol), T::Array[::String]])
|
|
34
|
+
T.unsafe(clazz).fields.each do |f|
|
|
35
|
+
request_metadata = f.metadata[:request]
|
|
36
|
+
next if !request_metadata.nil?
|
|
37
|
+
|
|
38
|
+
metadata = f.metadata[:query_param]
|
|
39
|
+
next if metadata.nil?
|
|
40
|
+
|
|
41
|
+
param_name = f.name
|
|
42
|
+
value = query_params&.send(param_name.to_sym)
|
|
43
|
+
value = _populate_from_globals(param_name, value, "queryParam", gbls)
|
|
44
|
+
|
|
45
|
+
f_name = metadata[:field_name]
|
|
46
|
+
serialization = metadata.fetch(:serialization, "")
|
|
47
|
+
if serialization != ""
|
|
48
|
+
params = params.merge(
|
|
49
|
+
_get_serialized_params(
|
|
50
|
+
metadata,
|
|
51
|
+
f_name,
|
|
52
|
+
value
|
|
53
|
+
)
|
|
54
|
+
)
|
|
55
|
+
else
|
|
56
|
+
style = metadata.fetch(:style, "form")
|
|
57
|
+
case style
|
|
58
|
+
when "deepObject"
|
|
59
|
+
params = params.merge(
|
|
60
|
+
_get_deep_object_query_params(
|
|
61
|
+
metadata,
|
|
62
|
+
f_name,
|
|
63
|
+
value
|
|
64
|
+
)
|
|
65
|
+
)
|
|
66
|
+
when "form"
|
|
67
|
+
params = params.merge(
|
|
68
|
+
_get_delimited_query_params(
|
|
69
|
+
metadata,
|
|
70
|
+
f_name,
|
|
71
|
+
value,
|
|
72
|
+
","
|
|
73
|
+
)
|
|
74
|
+
)
|
|
75
|
+
when "pipeDelimited"
|
|
76
|
+
params = params.merge(
|
|
77
|
+
_get_delimited_query_params(
|
|
78
|
+
metadata,
|
|
79
|
+
f_name,
|
|
80
|
+
value,
|
|
81
|
+
"|"
|
|
82
|
+
)
|
|
83
|
+
)
|
|
84
|
+
else
|
|
85
|
+
raise ::StandardError, "not yet implemented"
|
|
86
|
+
end
|
|
87
|
+
end
|
|
88
|
+
end
|
|
89
|
+
|
|
90
|
+
params.merge(parsed_params)
|
|
91
|
+
end
|
|
92
|
+
|
|
93
|
+
sig do
|
|
94
|
+
params(metadata: T::Hash[::Symbol, ::String], field_name: ::String, obj: ::Object)
|
|
95
|
+
.returns(T::Hash[T.any(::String, ::Symbol), T::Array[::String]])
|
|
96
|
+
end
|
|
97
|
+
def self._get_deep_object_query_params(metadata, field_name, obj)
|
|
98
|
+
params = T.let({}, T::Hash[T.any(::String, ::Symbol), T::Array[::String]])
|
|
99
|
+
|
|
100
|
+
return params if obj.nil?
|
|
101
|
+
|
|
102
|
+
if obj.respond_to?(:fields)
|
|
103
|
+
T.unsafe(obj).fields.each do |obj_field|
|
|
104
|
+
obj_param_metadata = obj_field.metadata[:query_param]
|
|
105
|
+
next if obj_param_metadata.nil?
|
|
106
|
+
|
|
107
|
+
val = obj.send(obj_field.name)
|
|
108
|
+
next if val.nil?
|
|
109
|
+
|
|
110
|
+
key = "#{metadata.fetch(:field_name, field_name)}[#{obj_param_metadata.fetch(:field_name, obj_field.name)}]"
|
|
111
|
+
if val.is_a?(::Array)
|
|
112
|
+
val.each do |v|
|
|
113
|
+
next if v.nil?
|
|
114
|
+
|
|
115
|
+
params[key] = [] if !params.include?(key)
|
|
116
|
+
|
|
117
|
+
T.must(params[key]) << val_to_string(v)
|
|
118
|
+
end
|
|
119
|
+
else
|
|
120
|
+
params[key] = [val_to_string(val)]
|
|
121
|
+
end
|
|
122
|
+
end
|
|
123
|
+
elsif obj.is_a?(::Hash)
|
|
124
|
+
obj.each do |key, value|
|
|
125
|
+
next if value.nil?
|
|
126
|
+
|
|
127
|
+
param_key = "#{metadata.fetch(:field_name, field_name)}[#{key}]"
|
|
128
|
+
if value.is_a?(::Array)
|
|
129
|
+
value.each do |val|
|
|
130
|
+
next if val.nil?
|
|
131
|
+
|
|
132
|
+
params[param_key] = [] if !params.include?(param_key)
|
|
133
|
+
|
|
134
|
+
T.must(params[param_key]).append(val_to_string(val))
|
|
135
|
+
end
|
|
136
|
+
else
|
|
137
|
+
params[param_key] = [val_to_string(value)]
|
|
138
|
+
end
|
|
139
|
+
end
|
|
140
|
+
end
|
|
141
|
+
|
|
142
|
+
params
|
|
143
|
+
end
|
|
144
|
+
|
|
145
|
+
sig do
|
|
146
|
+
params(metadata: T::Hash[::Symbol, ::String], field_name: ::String, obj: ::Object, delimiter: ::String)
|
|
147
|
+
.returns(T::Hash[T.any(::String, ::Symbol), T::Array[::String]])
|
|
148
|
+
end
|
|
149
|
+
def self._get_delimited_query_params(metadata, field_name, obj, delimiter)
|
|
150
|
+
get_query_param_field_name = lambda do |obj_field|
|
|
151
|
+
obj_param_metadata = obj_field.metadata[:query_param]
|
|
152
|
+
|
|
153
|
+
return {} if obj_param_metadata.nil?
|
|
154
|
+
|
|
155
|
+
return obj_param_metadata.fetch(:field_name, obj_field.name)
|
|
156
|
+
end
|
|
157
|
+
|
|
158
|
+
_populate_form(
|
|
159
|
+
field_name,
|
|
160
|
+
T.cast(metadata.fetch(:explode, true), T::Boolean),
|
|
161
|
+
obj,
|
|
162
|
+
delimiter,
|
|
163
|
+
&get_query_param_field_name
|
|
164
|
+
)
|
|
165
|
+
end
|
|
166
|
+
end
|
|
167
|
+
end
|
|
@@ -0,0 +1,79 @@
|
|
|
1
|
+
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
# typed: true
|
|
4
|
+
# frozen_string_literal: true
|
|
5
|
+
|
|
6
|
+
require "cgi"
|
|
7
|
+
require "date"
|
|
8
|
+
require "base64"
|
|
9
|
+
require "sorbet-runtime"
|
|
10
|
+
|
|
11
|
+
module OpenApiSDK
|
|
12
|
+
module Utils
|
|
13
|
+
extend T::Sig
|
|
14
|
+
|
|
15
|
+
SERIALIZATION_METHOD_TO_CONTENT_TYPE = {
|
|
16
|
+
'json': "application/json",
|
|
17
|
+
'form': "application/x-www-form-urlencoded",
|
|
18
|
+
'multipart': "multipart/form-data",
|
|
19
|
+
'raw': "application/octet-stream",
|
|
20
|
+
'string': "text/plain"
|
|
21
|
+
}.freeze
|
|
22
|
+
|
|
23
|
+
sig do
|
|
24
|
+
params(
|
|
25
|
+
request: ::Object,
|
|
26
|
+
nullable: T::Boolean,
|
|
27
|
+
optional: T::Boolean,
|
|
28
|
+
request_field_name: ::Symbol,
|
|
29
|
+
serialization_method: ::Symbol
|
|
30
|
+
)
|
|
31
|
+
.returns([::String, ::Object, T.nilable(T::Array[T::Array[T.any(T::Array[T.nilable(::String)], ::String)]])])
|
|
32
|
+
end
|
|
33
|
+
def self.serialize_request_body(request, nullable, optional, request_field_name, serialization_method)
|
|
34
|
+
return ["", nil, nil] if request.nil? && !nullable && optional
|
|
35
|
+
|
|
36
|
+
if !request.respond_to?(:fields) || !request.respond_to?(request_field_name)
|
|
37
|
+
return serialize_content_type(SERIALIZATION_METHOD_TO_CONTENT_TYPE[serialization_method], request)
|
|
38
|
+
end
|
|
39
|
+
|
|
40
|
+
request_metadata = T.let(nil, T.nilable(T::Array[T::Array[T.any(T::Array[T.nilable(::String)], ::String)]]))
|
|
41
|
+
T.unsafe(request).fields.each do |f|
|
|
42
|
+
if f.name == request_field_name
|
|
43
|
+
request_metadata = f.metadata[:request]
|
|
44
|
+
break
|
|
45
|
+
end
|
|
46
|
+
end
|
|
47
|
+
|
|
48
|
+
if request_metadata.nil?
|
|
49
|
+
# Field name collision: model has a field matching request_field_name but without :request metadata.
|
|
50
|
+
# Serialize the entire object as the request body.
|
|
51
|
+
return serialize_content_type(SERIALIZATION_METHOD_TO_CONTENT_TYPE[serialization_method], request)
|
|
52
|
+
end
|
|
53
|
+
|
|
54
|
+
request_val = request.send(request_field_name)
|
|
55
|
+
return ["", nil, nil] if request_val.nil?
|
|
56
|
+
|
|
57
|
+
serialize_content_type(
|
|
58
|
+
request_metadata.fetch(:media_type, "application/octet-stream"),
|
|
59
|
+
request_val
|
|
60
|
+
)
|
|
61
|
+
end
|
|
62
|
+
|
|
63
|
+
sig do
|
|
64
|
+
params(media_type: ::String, request: ::Object)
|
|
65
|
+
.returns([::String, ::Object, T.nilable(T::Array[T::Array[T.any(T::Array[T.nilable(::String)], ::String)]])])
|
|
66
|
+
end
|
|
67
|
+
def self.serialize_content_type(media_type, request)
|
|
68
|
+
if media_type.match("^(application|text)\\/([^+]+\\+)*json.*")
|
|
69
|
+
return media_type, ::Crystalline.to_json(request), nil
|
|
70
|
+
end
|
|
71
|
+
|
|
72
|
+
return serialize_multipart_form(media_type, request) if media_type.match("^multipart\\/.*")
|
|
73
|
+
return media_type, serialize_form_data(request), nil if media_type.match("^application\\/x-www-form-urlencoded.*")
|
|
74
|
+
return media_type, request, nil if request.is_a?(::String) || request.is_a?(::Array)
|
|
75
|
+
|
|
76
|
+
raise ::StandardError, "invalid request body type #{request.class} for mediaType #{media_type}"
|
|
77
|
+
end
|
|
78
|
+
end
|
|
79
|
+
end
|
|
@@ -0,0 +1,139 @@
|
|
|
1
|
+
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
# typed: true
|
|
4
|
+
# frozen_string_literal: true
|
|
5
|
+
|
|
6
|
+
require "faraday/retry"
|
|
7
|
+
require "time"
|
|
8
|
+
require "sorbet-runtime"
|
|
9
|
+
|
|
10
|
+
module OpenApiSDK
|
|
11
|
+
module Utils
|
|
12
|
+
class BackoffStrategy
|
|
13
|
+
extend T::Sig
|
|
14
|
+
|
|
15
|
+
sig { returns(T.nilable(::Float)) }
|
|
16
|
+
attr_accessor :exponent
|
|
17
|
+
|
|
18
|
+
sig { returns(T.nilable(::Integer)) }
|
|
19
|
+
attr_accessor :initial_interval
|
|
20
|
+
|
|
21
|
+
sig { returns(T.nilable(::Integer)) }
|
|
22
|
+
attr_accessor :max_elapsed_time
|
|
23
|
+
|
|
24
|
+
sig { returns(T.nilable(::Integer)) }
|
|
25
|
+
attr_accessor :max_interval
|
|
26
|
+
|
|
27
|
+
sig do
|
|
28
|
+
params(
|
|
29
|
+
exponent: T.nilable(::Float),
|
|
30
|
+
initial_interval: T.nilable(::Integer),
|
|
31
|
+
max_elapsed_time: T.nilable(::Integer),
|
|
32
|
+
max_interval: T.nilable(::Integer)
|
|
33
|
+
)
|
|
34
|
+
.void
|
|
35
|
+
end
|
|
36
|
+
def initialize(exponent: nil, initial_interval: nil, max_elapsed_time: nil, max_interval: nil)
|
|
37
|
+
@exponent = T.let(exponent, T.nilable(::Float))
|
|
38
|
+
@initial_interval = T.let(initial_interval, T.nilable(::Integer))
|
|
39
|
+
@max_elapsed_time = T.let(max_elapsed_time, T.nilable(::Integer))
|
|
40
|
+
@max_interval = T.let(max_interval, T.nilable(::Integer))
|
|
41
|
+
end
|
|
42
|
+
end
|
|
43
|
+
|
|
44
|
+
class RetryConfig
|
|
45
|
+
extend T::Sig
|
|
46
|
+
|
|
47
|
+
sig { returns(T.nilable(BackoffStrategy)) }
|
|
48
|
+
attr_accessor :backoff
|
|
49
|
+
|
|
50
|
+
sig { returns(T.nilable(T::Boolean)) }
|
|
51
|
+
attr_accessor :retry_connection_errors
|
|
52
|
+
|
|
53
|
+
sig { returns(T.nilable(::String)) }
|
|
54
|
+
attr_accessor :strategy
|
|
55
|
+
|
|
56
|
+
sig do
|
|
57
|
+
params(
|
|
58
|
+
backoff: T.nilable(BackoffStrategy),
|
|
59
|
+
retry_connection_errors: T.nilable(T::Boolean),
|
|
60
|
+
strategy: T.nilable(::String)
|
|
61
|
+
)
|
|
62
|
+
.void
|
|
63
|
+
end
|
|
64
|
+
def initialize(backoff: nil, retry_connection_errors: nil, strategy: nil)
|
|
65
|
+
@backoff = T.let(backoff, T.nilable(BackoffStrategy))
|
|
66
|
+
@retry_connection_errors = T.let(retry_connection_errors, T.nilable(T::Boolean))
|
|
67
|
+
@strategy = T.let(strategy, T.nilable(::String))
|
|
68
|
+
end
|
|
69
|
+
|
|
70
|
+
sig { params(initial_time: ::Time).returns(::Hash) }
|
|
71
|
+
def to_faraday_retry_options(initial_time:)
|
|
72
|
+
retry_options = {
|
|
73
|
+
# must overwrite default max of 2 retries and it must be positive
|
|
74
|
+
max: 1_000_000_000,
|
|
75
|
+
# ensure all HTTP methods are retried, especially via retry_if
|
|
76
|
+
methods: []
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
if @retry_connection_errors
|
|
80
|
+
retry_options[:exceptions] = Faraday::Retry::Middleware::DEFAULT_EXCEPTIONS + [Faraday::ConnectionFailed]
|
|
81
|
+
end
|
|
82
|
+
|
|
83
|
+
if @strategy == "backoff" && @backoff
|
|
84
|
+
retry_options[:backoff_factor] = @backoff.exponent unless @backoff.exponent.nil?
|
|
85
|
+
retry_options[:interval] = (@backoff.initial_interval.to_f / 1000) unless @backoff.initial_interval.nil?
|
|
86
|
+
retry_options[:max_interval] = (@backoff.max_interval.to_f / 1000) unless @backoff.max_interval.nil?
|
|
87
|
+
|
|
88
|
+
unless @backoff.max_elapsed_time.nil?
|
|
89
|
+
stop_time = initial_time + (@backoff.max_elapsed_time.to_f / 1000)
|
|
90
|
+
retry_options[:retry_if] = -> (_env, _exc) { ::Time.now < stop_time }
|
|
91
|
+
end
|
|
92
|
+
|
|
93
|
+
end
|
|
94
|
+
|
|
95
|
+
retry_options
|
|
96
|
+
end
|
|
97
|
+
end
|
|
98
|
+
|
|
99
|
+
class RetryMiddleware < Faraday::Retry::Middleware
|
|
100
|
+
extend T::Sig
|
|
101
|
+
|
|
102
|
+
sig { params(retries: T.untyped, env: T.untyped).returns(T.untyped) }
|
|
103
|
+
def calculate_sleep_amount(retries, env)
|
|
104
|
+
retry_after = [calculate_retry_after(env), calculate_rate_limit_reset(env)].compact.max
|
|
105
|
+
retry_interval = calculate_retry_interval(retries)
|
|
106
|
+
return retry_interval if retry_after.nil?
|
|
107
|
+
|
|
108
|
+
# unlike the stock middleware, cap server delays at max_interval rather
|
|
109
|
+
# than abandoning the retry
|
|
110
|
+
[[retry_after, @options.max_interval].min, retry_interval].max
|
|
111
|
+
end
|
|
112
|
+
|
|
113
|
+
private
|
|
114
|
+
|
|
115
|
+
sig { params(env: T.untyped).returns(T.untyped) }
|
|
116
|
+
def calculate_retry_after(env)
|
|
117
|
+
response_headers = env[:response_headers]
|
|
118
|
+
return unless response_headers
|
|
119
|
+
|
|
120
|
+
ms_value = response_headers["retry-after-ms"]
|
|
121
|
+
return ms_value.to_f / 1000 if ms_value&.match?(/\A\s*\d+\s*\z/)
|
|
122
|
+
|
|
123
|
+
value = response_headers["retry-after"]
|
|
124
|
+
return if value.nil? || value.strip.empty?
|
|
125
|
+
return value.to_f if value.match?(/\A\s*\d+\s*\z/)
|
|
126
|
+
|
|
127
|
+
begin
|
|
128
|
+
::Time.httpdate(value) - ::Time.now
|
|
129
|
+
rescue ::ArgumentError
|
|
130
|
+
begin
|
|
131
|
+
::Time.iso8601(value) - ::Time.now
|
|
132
|
+
rescue ::ArgumentError
|
|
133
|
+
nil
|
|
134
|
+
end
|
|
135
|
+
end
|
|
136
|
+
end
|
|
137
|
+
end
|
|
138
|
+
end
|
|
139
|
+
end
|
|
@@ -0,0 +1,158 @@
|
|
|
1
|
+
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
# typed: true
|
|
4
|
+
# frozen_string_literal: true
|
|
5
|
+
|
|
6
|
+
require "cgi"
|
|
7
|
+
require "date"
|
|
8
|
+
require "base64"
|
|
9
|
+
require "sorbet-runtime"
|
|
10
|
+
|
|
11
|
+
module OpenApiSDK
|
|
12
|
+
module Utils
|
|
13
|
+
extend T::Sig
|
|
14
|
+
|
|
15
|
+
sig { params(req: Faraday::Request, security: ::Object, allowed_fields: T.nilable(T::Array[::Symbol])).void }
|
|
16
|
+
def self.configure_request_security(req, security, allowed_fields = nil)
|
|
17
|
+
return if security.nil?
|
|
18
|
+
|
|
19
|
+
sec_fields = if allowed_fields.nil?
|
|
20
|
+
T.unsafe(security).fields
|
|
21
|
+
else
|
|
22
|
+
allowed_fields.filter_map { |name| T.unsafe(security).fields.find { |f| f.name == name } }
|
|
23
|
+
end
|
|
24
|
+
|
|
25
|
+
sec_fields.each do |sec_field|
|
|
26
|
+
value = security.send(sec_field.name)
|
|
27
|
+
next if value.nil?
|
|
28
|
+
|
|
29
|
+
metadata = sec_field.metadata[:security]
|
|
30
|
+
next if metadata.nil?
|
|
31
|
+
|
|
32
|
+
if metadata[:option]
|
|
33
|
+
_parse_security_option(req, value)
|
|
34
|
+
break unless metadata[:composite]
|
|
35
|
+
end
|
|
36
|
+
|
|
37
|
+
next unless metadata[:scheme]
|
|
38
|
+
|
|
39
|
+
# Special case for basic auth which could be a flattened struct
|
|
40
|
+
if metadata[:sub_type] == "basic" && !value.respond_to?(:fields)
|
|
41
|
+
_parse_security_scheme(req, metadata, security)
|
|
42
|
+
else
|
|
43
|
+
_parse_security_scheme(req, metadata, value)
|
|
44
|
+
end
|
|
45
|
+
|
|
46
|
+
break unless metadata[:composite]
|
|
47
|
+
end
|
|
48
|
+
end
|
|
49
|
+
|
|
50
|
+
sig { params(req: Faraday::Request, option: ::Object).void }
|
|
51
|
+
def self._parse_security_option(req, option)
|
|
52
|
+
# Check if this option uses basic auth (needs the whole object, not individual fields)
|
|
53
|
+
first_field = T.unsafe(option).fields.first
|
|
54
|
+
if first_field
|
|
55
|
+
first_meta = first_field.metadata[:security]
|
|
56
|
+
if first_meta && first_meta[:type] == "http" && first_meta[:sub_type] == "basic"
|
|
57
|
+
_parse_security_scheme(req, first_meta, option)
|
|
58
|
+
return
|
|
59
|
+
end
|
|
60
|
+
end
|
|
61
|
+
|
|
62
|
+
T.unsafe(option).fields.each do |opt_field|
|
|
63
|
+
metadata = opt_field.metadata[:security]
|
|
64
|
+
next if metadata.nil? || !metadata.include?(:scheme)
|
|
65
|
+
|
|
66
|
+
_parse_security_scheme(req, metadata, option.send(opt_field.name))
|
|
67
|
+
end
|
|
68
|
+
end
|
|
69
|
+
|
|
70
|
+
sig { params(req: Faraday::Request, scheme_metadata: T::Hash[::Symbol, ::String], scheme: ::Object).void }
|
|
71
|
+
def self._parse_security_scheme(req, scheme_metadata, scheme)
|
|
72
|
+
scheme_type = scheme_metadata[:type]
|
|
73
|
+
sub_type = scheme_metadata[:sub_type]
|
|
74
|
+
|
|
75
|
+
if scheme.respond_to?(:fields)
|
|
76
|
+
if scheme_type == "http" && sub_type == "basic"
|
|
77
|
+
_parse_basic_auth_scheme(req, scheme)
|
|
78
|
+
return
|
|
79
|
+
end
|
|
80
|
+
|
|
81
|
+
T.unsafe(scheme).fields.each do |field|
|
|
82
|
+
metadata = field.metadata[:security]
|
|
83
|
+
next if metadata.nil? || metadata[:field_name].nil?
|
|
84
|
+
|
|
85
|
+
value = scheme.send(field.name)
|
|
86
|
+
_parse_security_scheme_value(req, scheme_metadata, metadata, T.cast(value, ::String))
|
|
87
|
+
end
|
|
88
|
+
else
|
|
89
|
+
_parse_security_scheme_value(req, scheme_metadata, scheme_metadata, T.cast(scheme, ::String))
|
|
90
|
+
end
|
|
91
|
+
end
|
|
92
|
+
|
|
93
|
+
sig do
|
|
94
|
+
params(
|
|
95
|
+
req: Faraday::Request,
|
|
96
|
+
scheme_metadata: T::Hash[::Symbol, ::String],
|
|
97
|
+
security_metadata: T::Hash[::Symbol, ::String],
|
|
98
|
+
value: ::String
|
|
99
|
+
)
|
|
100
|
+
.void
|
|
101
|
+
end
|
|
102
|
+
def self._parse_security_scheme_value(req, scheme_metadata, security_metadata, value)
|
|
103
|
+
scheme_type = scheme_metadata[:type]
|
|
104
|
+
sub_type = scheme_metadata[:sub_type]
|
|
105
|
+
|
|
106
|
+
header_name = security_metadata[:field_name]
|
|
107
|
+
|
|
108
|
+
case scheme_type
|
|
109
|
+
when "apiKey"
|
|
110
|
+
case sub_type
|
|
111
|
+
when "header"
|
|
112
|
+
req.headers[header_name] = value
|
|
113
|
+
when "query"
|
|
114
|
+
req.params[header_name] = value
|
|
115
|
+
when "cookie"
|
|
116
|
+
req.headers["Cookie"][header_name] = value
|
|
117
|
+
else
|
|
118
|
+
raise ::StandardError, "not supported"
|
|
119
|
+
end
|
|
120
|
+
|
|
121
|
+
when "openIdConnect"
|
|
122
|
+
req.headers[header_name] = value.downcase.start_with?("bearer ") ? value : "Bearer #{value}"
|
|
123
|
+
when "oauth2"
|
|
124
|
+
req.headers[header_name] = value.downcase.start_with?("bearer ") ? value : "Bearer #{value}"
|
|
125
|
+
when "http"
|
|
126
|
+
if sub_type == "bearer"
|
|
127
|
+
req.headers[header_name] = value.downcase.start_with?("bearer ") ? value : "Bearer #{value}"
|
|
128
|
+
elsif sub_type != "custom"
|
|
129
|
+
raise ::StandardError, "not supported"
|
|
130
|
+
end
|
|
131
|
+
else
|
|
132
|
+
raise ::StandardError, "not supported"
|
|
133
|
+
end
|
|
134
|
+
end
|
|
135
|
+
|
|
136
|
+
sig { params(req: Faraday::Request, scheme: ::Object).void }
|
|
137
|
+
def self._parse_basic_auth_scheme(req, scheme)
|
|
138
|
+
username = T.let("", ::String)
|
|
139
|
+
password = T.let("", ::String)
|
|
140
|
+
|
|
141
|
+
T.unsafe(scheme).fields.each do |scheme_field|
|
|
142
|
+
metadata = scheme_field.metadata[:security]
|
|
143
|
+
next if metadata.nil? || !metadata.include?(:field_name)
|
|
144
|
+
|
|
145
|
+
field_name = metadata[:field_name]
|
|
146
|
+
value = scheme.send(scheme_field.name)
|
|
147
|
+
|
|
148
|
+
username = T.let(value, ::String) if field_name == "username"
|
|
149
|
+
password = T.let(value, ::String) if field_name == "password"
|
|
150
|
+
end
|
|
151
|
+
|
|
152
|
+
data = "#{username}:#{password}".encode
|
|
153
|
+
# Use strict_encode, because encode adds newlines after 60 chars
|
|
154
|
+
# https://docs.ruby-lang.org/en/3.0/Base64.html#method-i-encode64
|
|
155
|
+
req.headers["Authorization"] = "Basic #{::Base64.strict_encode64(data)}"
|
|
156
|
+
end
|
|
157
|
+
end
|
|
158
|
+
end
|
|
@@ -0,0 +1,124 @@
|
|
|
1
|
+
# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
|
|
2
|
+
|
|
3
|
+
# typed: true
|
|
4
|
+
# frozen_string_literal: true
|
|
5
|
+
|
|
6
|
+
require "faraday/retry"
|
|
7
|
+
require "sorbet-runtime"
|
|
8
|
+
|
|
9
|
+
module OpenApiSDK
|
|
10
|
+
module Utils
|
|
11
|
+
sig {
|
|
12
|
+
params(
|
|
13
|
+
clazz: ::Object,
|
|
14
|
+
server_url: ::String,
|
|
15
|
+
path: ::String,
|
|
16
|
+
path_params: ::Object,
|
|
17
|
+
gbls: T.nilable(T::Hash[::Symbol, T::Hash[::Symbol, T::Hash[::Symbol, ::Object]]])
|
|
18
|
+
)
|
|
19
|
+
.returns(::String)
|
|
20
|
+
}
|
|
21
|
+
def self.generate_url(clazz, server_url, path, path_params, gbls = nil)
|
|
22
|
+
T.unsafe(clazz).fields.each do |f|
|
|
23
|
+
param_metadata = f.metadata[:path_param]
|
|
24
|
+
next if param_metadata.nil?
|
|
25
|
+
|
|
26
|
+
if param_metadata.fetch(:style, "simple") == "simple"
|
|
27
|
+
param = path_params.send(f.name) if !path_params.nil?
|
|
28
|
+
param = _populate_from_globals(f.name, param, "pathParam", gbls)
|
|
29
|
+
end
|
|
30
|
+
|
|
31
|
+
f_name = param_metadata.fetch(:field_name, f.name)
|
|
32
|
+
serialization = param_metadata.fetch(:serialization, "")
|
|
33
|
+
if serialization != ""
|
|
34
|
+
serialized_params = _get_serialized_params(param_metadata, f_name, param)
|
|
35
|
+
serialized_params.each do |k, v|
|
|
36
|
+
path = path.gsub("{#{k}}", v.join(", "))
|
|
37
|
+
end
|
|
38
|
+
else
|
|
39
|
+
if param.is_a?(::Array)
|
|
40
|
+
pp_vals = []
|
|
41
|
+
param.each do |pp_val|
|
|
42
|
+
pp_vals.append(pp_val.to_s)
|
|
43
|
+
end
|
|
44
|
+
|
|
45
|
+
path = path.gsub("{#{param_metadata.fetch(:field_name, f.name)}}", pp_vals.join(","))
|
|
46
|
+
elsif param.is_a?(::Hash)
|
|
47
|
+
pp_vals = []
|
|
48
|
+
param.each do |pp_key, pp_val|
|
|
49
|
+
value = val_to_string(pp_val)
|
|
50
|
+
|
|
51
|
+
if param_metadata.fetch(:explode, false)
|
|
52
|
+
pp_vals.append("#{pp_key}=#{value}")
|
|
53
|
+
else
|
|
54
|
+
pp_vals.append("#{pp_key},#{value}")
|
|
55
|
+
end
|
|
56
|
+
end
|
|
57
|
+
|
|
58
|
+
path = path.gsub("{#{param_metadata.fetch(:field_name, f.name)}}", pp_vals.join(","))
|
|
59
|
+
elsif param.class.include?(::Crystalline::MetadataFields)
|
|
60
|
+
pp_vals = []
|
|
61
|
+
attrs = T
|
|
62
|
+
.unsafe(param)
|
|
63
|
+
.fields
|
|
64
|
+
.filter { |field| field.name && param.respond_to?(field.name.to_sym) }
|
|
65
|
+
.map(&:name)
|
|
66
|
+
attrs.each do |attr|
|
|
67
|
+
field = T.unsafe(param).field(attr)
|
|
68
|
+
|
|
69
|
+
param_value_metadata = field.metadata[:path_param]
|
|
70
|
+
|
|
71
|
+
next if param_value_metadata.nil?
|
|
72
|
+
|
|
73
|
+
parm_name = param_value_metadata.fetch(:field_name, f.name)
|
|
74
|
+
|
|
75
|
+
param_field_val = param.send(attr)
|
|
76
|
+
|
|
77
|
+
if param_field_val.class.respond_to?(:enums)
|
|
78
|
+
param_field_val = param_field_val.serialize
|
|
79
|
+
elsif param_field_val.is_a?(::DateTime)
|
|
80
|
+
param_field_val = param_field_val.strftime("%Y-%m-%dT%H:%M:%S.%NZ")
|
|
81
|
+
end
|
|
82
|
+
|
|
83
|
+
if !field.nil? && ::Crystalline::Utils.nilable?(field.type) && param_field_val.nil?
|
|
84
|
+
next
|
|
85
|
+
elsif param_metadata.fetch(:explode, false)
|
|
86
|
+
pp_vals.append("#{parm_name}=#{param_field_val}")
|
|
87
|
+
else
|
|
88
|
+
pp_vals.append("#{parm_name},#{param_field_val}")
|
|
89
|
+
end
|
|
90
|
+
end
|
|
91
|
+
|
|
92
|
+
path = path.gsub("{#{param_metadata.fetch(:field_name, f.name)}}", pp_vals.join(","))
|
|
93
|
+
else
|
|
94
|
+
path = path.gsub("{#{param_metadata.fetch(:field_name, f.name)}}", _encode_path_param(val_to_string(param)))
|
|
95
|
+
end
|
|
96
|
+
end
|
|
97
|
+
end
|
|
98
|
+
|
|
99
|
+
server_url.delete_suffix("/") + path
|
|
100
|
+
end
|
|
101
|
+
|
|
102
|
+
# Percent-encode characters that are invalid in URI path segments
|
|
103
|
+
sig { params(value: ::String).returns(::String) }
|
|
104
|
+
def self._encode_path_param(value)
|
|
105
|
+
value.gsub(/[<>{}\[\]|\\^`\s?#%]/) { |c| format("%%%02X", c.ord) }
|
|
106
|
+
end
|
|
107
|
+
|
|
108
|
+
sig { params(url_with_params: ::String, params: T::Hash[::Symbol, T.any(::String, T::Enum)]).returns(::String) }
|
|
109
|
+
def self.template_url(url_with_params, params)
|
|
110
|
+
params.each do |key, value|
|
|
111
|
+
if value.class.respond_to?(:enums)
|
|
112
|
+
val_str = T.cast(value, T::Enum).serialize
|
|
113
|
+
else
|
|
114
|
+
val_str = value
|
|
115
|
+
end
|
|
116
|
+
|
|
117
|
+
url_with_params = url_with_params.gsub("{#{key}}", val_str)
|
|
118
|
+
end
|
|
119
|
+
|
|
120
|
+
url_with_params
|
|
121
|
+
end
|
|
122
|
+
|
|
123
|
+
end
|
|
124
|
+
end
|