kinde_sdk 1.2.1 → 1.2.3

data/kinde_api/lib/kinde_api/api_client.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'date'
 require 'json'
 require 'logger'
@@ -21,7 +23,7 @@ module KindeApi
       @config = config
       @user_agent = "OpenAPI-Generator/#{VERSION}/ruby"
       @default_headers = {
-        "Accept-Encoding" => "*",
+        'Accept-Encoding' => '*',
         'Content-Type' => 'application/json',
         'User-Agent' => @user_agent
       }
@@ -39,31 +41,25 @@ module KindeApi
       request = build_request(http_method, path, opts)
       response = request.run
 
-      if @config.debugging
-        @config.logger.debug "HTTP response body ~BEGIN~\n#{response.body}\n~END~\n"
-      end
+      @config.logger.debug "HTTP response body ~BEGIN~\n#{response.body}\n~END~\n" if @config.debugging
 
       unless response.success?
         if response.timed_out?
-          fail ApiError.new('Connection timed out')
-        elsif response.code == 0
+          raise ApiError, 'Connection timed out'
+        elsif response.code.zero?
           # Errors from libcurl will be made visible here
-          fail ApiError.new(:code => 0,
-                            :message => response.return_message)
+          raise ApiError.new(code: 0,
+                             message: response.return_message)
         else
-          fail ApiError.new(:code => response.code,
-                            :response_headers => response.headers,
-                            :response_body => response.body),
-               response.status_message
+          raise ApiError.new(code: response.code,
+                             response_headers: response.headers,
+                             response_body: response.body),
+                response.status_message
         end
       end
 
-      if opts[:return_type]
-        data = deserialize(response, opts[:return_type])
-      else
-        data = nil
-      end
-      return data, response.code, response.headers
+      data = (deserialize(response, opts[:return_type]) if opts[:return_type])
+      [data, response.code, response.headers]
     end
 
     # Builds the HTTP request
@@ -90,28 +86,26 @@ module KindeApi
       _verify_ssl_host = @config.verify_ssl_host ? 2 : 0
 
       req_opts = {
-        :method => http_method,
-        :headers => header_params,
-        :params => query_params,
-        :params_encoding => @config.params_encoding,
-        :timeout => @config.timeout,
-        :ssl_verifypeer => @config.verify_ssl,
-        :ssl_verifyhost => _verify_ssl_host,
-        :sslcert => @config.cert_file,
-        :sslkey => @config.key_file,
-        :verbose => @config.debugging,
-        :followlocation => follow_location
+        method: http_method,
+        headers: header_params,
+        params: query_params,
+        params_encoding: @config.params_encoding,
+        timeout: @config.timeout,
+        ssl_verifypeer: @config.verify_ssl,
+        ssl_verifyhost: _verify_ssl_host,
+        sslcert: @config.cert_file,
+        sslkey: @config.key_file,
+        verbose: @config.debugging,
+        followlocation: follow_location
       }
 
       # set custom cert, if provided
       req_opts[:cainfo] = @config.ssl_ca_cert if @config.ssl_ca_cert
 
-      if [:post, :patch, :put, :delete].include?(http_method)
+      if %i[post patch put delete].include?(http_method)
         req_body = build_request_body(header_params, form_params, opts[:body])
-        req_opts.update :body => req_body
-        if @config.debugging
-          @config.logger.debug "HTTP request body param ~BEGIN~\n#{req_body}\n~END~\n"
-        end
+        req_opts.update body: req_body
+        @config.logger.debug "HTTP request body param ~BEGIN~\n#{req_body}\n~END~\n" if @config.debugging
       end
 
       request = Typhoeus::Request.new(url, req_opts)
@@ -128,16 +122,16 @@ module KindeApi
     def build_request_body(header_params, form_params, body)
       # http form
       if header_params['Content-Type'] == 'application/x-www-form-urlencoded' ||
-          header_params['Content-Type'] == 'multipart/form-data'
+         header_params['Content-Type'] == 'multipart/form-data'
         data = {}
         form_params.each do |key, value|
-          case value
-          when ::File, ::Array, nil
-            # let typhoeus handle File, Array and nil parameters
-            data[key] = value
-          else
-            data[key] = value.to_s
-          end
+          data[key] = case value
+                      when ::File, ::Array, nil
+                        # let typhoeus handle File, Array and nil parameters
+                        value
+                      else
+                        value.to_s
+                      end
         end
       elsif body
         data = body.is_a?(String) ? body : body.to_json
@@ -165,22 +159,22 @@ module KindeApi
         else
           prefix = 'download-'
         end
-        prefix = prefix + '-' unless prefix.end_with?('-')
+        prefix += '-' unless prefix.end_with?('-')
         encoding = response.body.encoding
-        tempfile = Tempfile.open(prefix, @config.temp_folder_path, encoding: encoding)
+        tempfile = Tempfile.open(prefix, @config.temp_folder_path, encoding:)
         @tempfile = tempfile
       end
       request.on_body do |chunk|
         chunk.force_encoding(encoding)
         tempfile.write(chunk)
       end
-      request.on_complete do |response|
+      request.on_complete do |_response|
         if tempfile
           tempfile.close
           @config.logger.info "Temp file written to #{tempfile.path}, please copy the file to a proper folder "\
                               "with e.g. `FileUtils.cp(tempfile.path, '/new/file/path')` otherwise the temp file "\
                               "will be deleted automatically with GC. It's also recommended to delete the temp file "\
-                              "explicitly with `tempfile.delete`"
+                              'explicitly with `tempfile.delete`'
         end
       end
     end
@@ -196,7 +190,7 @@ module KindeApi
     # @param [String] mime MIME
     # @return [Boolean] True if the MIME is application/json
     def json_mime?(mime)
-      prepared_mime = mime.to_s.downcase.strip.split(";")[0]
+      prepared_mime = mime.to_s.downcase.strip.split(';')[0]
       result = %w[*/* application/json text/plain].find { |i| i == prepared_mime }
       result != nil
     end
@@ -220,16 +214,14 @@ module KindeApi
       # ensuring a default content type
       content_type = response.headers['Content-Type'] || 'application/json'
 
-      fail "Content-Type is not supported: #{content_type}" unless json_mime?(content_type)
+      raise "Content-Type is not supported: #{content_type}" unless json_mime?(content_type)
 
       begin
-        data = JSON.parse("[#{body}]", :symbolize_names => true)[0]
+        data = JSON.parse("[#{body}]", symbolize_names: true)[0]
       rescue JSON::ParserError => e
-        if %w(String Date Time).include?(return_type)
-          data = body
-        else
-          raise e
-        end
+        raise e unless %w[String Date Time].include?(return_type)
+
+        data = body
       end
 
       convert_to_type data, return_type
@@ -241,6 +233,7 @@ module KindeApi
     # @return [Mixed] Data in a particular type
     def convert_to_type(data, return_type)
       return nil if data.nil?
+
       case return_type
       when 'String'
         data.to_s
@@ -261,11 +254,11 @@ module KindeApi
         data
       when /\AArray<(.+)>\z/
         # e.g. Array<Pet>
-        sub_type = $1
+        sub_type = ::Regexp.last_match(1)
         data.map { |item| convert_to_type(item, sub_type) }
-      when /\AHash\<String, (.+)\>\z/
+      when /\AHash<String, (.+)>\z/
         # e.g. Hash<String, Integer>
-        sub_type = $1
+        sub_type = ::Regexp.last_match(1)
         {}.tap do |hash|
           data.each { |k, v| hash[k] = convert_to_type(v, sub_type) }
         end
@@ -282,12 +275,12 @@ module KindeApi
     # @param [String] filename the filename to be sanitized
     # @return [String] the sanitized filename
     def sanitize_filename(filename)
-      filename.gsub(/.*[\/\\]/, '')
+      filename.gsub(%r{.*[/\\]}, '')
     end
 
-    def build_request_url(path, opts = {})
+    def build_request_url(path, _opts = {})
       # Add leading and trailing slashes to path
-      path = "/#{path}".gsub(/\/+/, '/')
+      path = "/#{path}".gsub(%r{/+}, '/')
       @config.base_url + path
     end
 
@@ -300,10 +293,11 @@ module KindeApi
       Array(auth_names).each do |auth_name|
         auth_setting = @config.auth_settings[auth_name]
         next unless auth_setting
+
         case auth_setting[:in]
         when 'header' then header_params[auth_setting[:key]] = auth_setting[:value]
         when 'query'  then query_params[auth_setting[:key]] = auth_setting[:value]
-        else fail ArgumentError, 'Authentication token must be in `query` or `header`'
+        else raise ArgumentError, 'Authentication token must be in `query` or `header`'
         end
       end
     end
@@ -321,6 +315,7 @@ module KindeApi
     # @return [String] the Accept header (e.g. application/json)
     def select_header_accept(accepts)
       return nil if accepts.nil? || accepts.empty?
+
       # use JSON when present, otherwise use all of the provided
       json_accept = accepts.find { |s| json_mime?(s) }
       json_accept || accepts.join(',')
@@ -332,6 +327,7 @@ module KindeApi
     def select_header_content_type(content_types)
       # return nil by default
       return if content_types.nil? || content_types.empty?
+
       # use JSON when present, otherwise use the first one
       json_content_type = content_types.find { |s| json_mime?(s) }
       json_content_type || content_types.first
@@ -342,12 +338,12 @@ module KindeApi
     # @return [String] JSON string representation of the object
     def object_to_http_body(model)
       return model if model.nil? || model.is_a?(String)
-      local_body = nil
-      if model.is_a?(Array)
-        local_body = model.map { |m| object_to_hash(m) }
-      else
-        local_body = object_to_hash(model)
-      end
+
+      local_body = if model.is_a?(Array)
+                     model.map { |m| object_to_hash(m) }
+                   else
+                     object_to_hash(model)
+                   end
       local_body.to_json
     end
 
@@ -378,7 +374,7 @@ module KindeApi
         # return the array directly as typhoeus will handle it as expected
         param
       else
-        fail "unknown collection format: #{collection_format.inspect}"
+        raise "unknown collection format: #{collection_format.inspect}"
       end
     end
   end

data/kinde_api/lib/kinde_api/api_error.rb

@@ -1,14 +1,14 @@
-=begin
-#Kinde Management API
-
-#Provides endpoints to manage your Kinde Businesses
-
-The version of the OpenAPI document: 1
-Contact: support@kinde.com
-Generated by: https://openapi-generator.tech
-OpenAPI Generator version: 6.4.0
-
-=end
+# frozen_string_literal: true
+
+# #Kinde Management API
+#
+# Provides endpoints to manage your Kinde Businesses
+#
+# The version of the OpenAPI document: 1
+# Contact: support@kinde.com
+# Generated by: https://openapi-generator.tech
+# OpenAPI Generator version: 7.0.0-SNAPSHOT
+#
 
 module KindeApi
   class ApiError < StandardError
@@ -42,11 +42,11 @@ module KindeApi
     end
 
     def message
-      if @message.nil?
-        msg = "Error message: the server returns an error"
-      else
-        msg = @message
-      end
+      msg = if @message.nil?
+              'Error message: the server returns an error'
+            else
+              @message
+            end
 
       msg += "\nHTTP status code: #{code}" if code
       msg += "\nResponse headers: #{response_headers}" if response_headers

data/kinde_api/lib/kinde_api/configuration.rb

@@ -1,14 +1,14 @@
-=begin
-#Kinde Management API
-
-#Provides endpoints to manage your Kinde Businesses
-
-The version of the OpenAPI document: 1
-Contact: support@kinde.com
-Generated by: https://openapi-generator.tech
-OpenAPI Generator version: 6.4.0
-
-=end
+# frozen_string_literal: true
+
+# #Kinde Management API
+#
+# Provides endpoints to manage your Kinde Businesses
+#
+# The version of the OpenAPI document: 1
+# Contact: support@kinde.com
+# Generated by: https://openapi-generator.tech
+# OpenAPI Generator version: 6.4.0
+#
 
 module KindeApi
   class Configuration
@@ -126,9 +126,7 @@ module KindeApi
     # https://github.com/typhoeus/ethon/blob/master/lib/ethon/easy/queryable.rb#L96
     attr_accessor :params_encoding
 
-    attr_accessor :inject_format
-
-    attr_accessor :force_ending_format
+    attr_accessor :inject_format, :force_ending_format
 
     def initialize
       @scheme = 'https'
@@ -146,7 +144,7 @@ module KindeApi
       @debugging = false
       @inject_format = false
       @force_ending_format = false
-      @logger = defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
+      @logger = defined?(Rails) ? Rails.logger : Logger.new($stdout)
 
       yield(self) if block_given?
     end
@@ -162,17 +160,17 @@ module KindeApi
 
     def scheme=(scheme)
       # remove :// from scheme
-      @scheme = scheme.sub(/:\/\//, '')
+      @scheme = scheme.sub(%r{://}, '')
     end
 
     def host=(host)
       # remove http(s):// and anything after a slash
-      @host = host.sub(/https?:\/\//, '').split('/').first
+      @host = host.sub(%r{https?://}, '').split('/').first
     end
 
     def base_path=(base_path)
       # Add leading and trailing slashes to base_path
-      @base_path = "/#{base_path}".gsub(/\/+/, '/')
+      @base_path = "/#{base_path}".gsub(%r{/+}, '/')
       @base_path = '' if @base_path == '/'
     end
 
@@ -196,12 +194,13 @@ module KindeApi
     # Gets access_token using access_token_getter or uses the static access_token
     def access_token_with_refresh
       return access_token if access_token_getter.nil?
+
       access_token_getter.call
     end
 
     # Gets Basic Auth token string
     def basic_auth_token
-      'Basic ' + ["#{username}:#{password}"].pack('m').delete("\r\n")
+      "Basic #{["#{username}:#{password}"].pack('m').delete("\r\n")}"
     end
 
     # Returns Auth Settings hash for api client.

data/kinde_api/lib/kinde_api/models/add_apis_request.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+# #Kinde Management API
+#
+# Provides endpoints to manage your Kinde Businesses
+#
+# The version of the OpenAPI document: 1
+# Contact: support@kinde.com
+# Generated by: https://openapi-generator.tech
+# OpenAPI Generator version: 7.0.0-SNAPSHOT
+#
+
+require 'date'
+require 'time'
+
+module KindeApi
+  class AddAPIsRequest
+    attr_accessor :name, :audience
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        'name': :name,
+        'audience': :audience
+      }
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        'name': :String,
+        'audience': :String
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      unless attributes.is_a?(Hash)
+        raise ArgumentError,
+              'The input argument (attributes) must be a hash in `KindeApi::AddAPIsRequest` initialize method'
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) do |(k, v), h|
+        unless self.class.attribute_map.key?(k.to_sym)
+          raise ArgumentError,
+                "`#{k}` is not a valid attribute in `KindeApi::AddAPIsRequest`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
+        end
+
+        h[k.to_sym] = v
+      end
+
+      self.name = attributes[:name] if attributes.key?(:name)
+
+      return unless attributes.key?(:audience)
+
+      self.audience = attributes[:audience]
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = []
+      invalid_properties.push('invalid value for "name", name cannot be nil.') if @name.nil?
+
+      invalid_properties.push('invalid value for "audience", audience cannot be nil.') if @audience.nil?
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      return false if @name.nil?
+      return false if @audience.nil?
+
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(other)
+      return true if equal?(other)
+
+      self.class == other.class &&
+        name == other.name &&
+        audience == other.audience
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(other)
+      self == other
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [name, audience].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      new.build_from_hash(attributes)
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+
+      attributes = attributes.transform_keys(&:to_sym)
+      self.class.openapi_types.each_pair do |key, type|
+        if attributes[self.class.attribute_map[key]].nil? && self.class.openapi_nullable.include?(key)
+          send("#{key}=", nil)
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            send("#{key}=", attributes[self.class.attribute_map[key]].map do |v|
+                              _deserialize(::Regexp.last_match(1), v)
+                            end)
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :Time
+        Time.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :Boolean
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        # models (e.g. Pet) or oneOf
+        klass = KindeApi.const_get(type)
+        klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end