supabase-rb 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1640366f383a39fbba5df993fe27d204981f99672377fc6982403b4259f6cd81
+  data.tar.gz: d332d7b5a8c3bd0f698263988a8c949c132dbbe51908007b7bf5321d8e53a22b
+SHA512:
+  metadata.gz: 11f501920c972f3dde5fee01049df4f95fd2aaff1ff6bc2e29c093e8f4c61671900e9caab52e9b870fa86a430a05d0cdbfaf5c4e957e418a389397cfd4ec941f
+  data.tar.gz: 582991118f05d8171764efa5788d97234c013f8f7eacc84eefe903959068f20a7d083eaf09ead84a4dc76d225a318c6d69e70b96654f97e0254d184a13bbec39

data/lib/supabase/README.md

@@ -0,0 +1,90 @@
+# `supabase-rb`
+
+Ruby client for [Supabase](https://supabase.com). Umbrella gem that exposes
+Auth, PostgREST, Storage, Edge Functions, and Realtime through a single
+`Supabase.create_client` factory.
+
+- Documentation: [supabase.com/docs](https://supabase.com/docs/reference)
+- Source: [github.com/supabase-ruby/supabase-rb](https://github.com/supabase-ruby/supabase-rb)
+
+## Installation
+
+```ruby
+gem "supabase-rb"
+```
+
+Then `bundle install`. (Requires Ruby >= 3.0.) The Ruby require path is
+`require "supabase"` — only the gem name differs.
+
+## Usage
+
+```ruby
+require "supabase"
+
+client = Supabase.create_client(
+  supabase_url: ENV["SUPABASE_URL"],
+  supabase_key: ENV["SUPABASE_ANON_KEY"]
+)
+
+# Auth
+client.auth.sign_in_with_password(email: "user@example.com", password: "pw")
+
+# PostgREST
+users = client.from("users").select("id, name").eq("status", "active").execute
+
+# Storage
+client.storage.from("avatars").upload("user1.png", File.binread("user1.png"),
+                                       content_type: "image/png")
+
+# Edge Functions
+result = client.functions.invoke("hello-world", body: { name: "Ada" })
+
+# Realtime (you bring the WebSocket transport — see supabase-realtime)
+channel = client.realtime.channel("realtime:public:users")
+channel.on_postgres_changes("INSERT", schema: "public", table: "users") { |p| puts p }
+```
+
+Pass `async: true` to swap Auth / PostgREST / Storage / Functions into their
+async variants (Realtime stays sync):
+
+```ruby
+require "async"
+
+async_client = Supabase.create_client(
+  supabase_url: ENV["SUPABASE_URL"],
+  supabase_key: ENV["SUPABASE_ANON_KEY"],
+  async: true
+)
+
+Async do |task|
+  jobs = user_ids.map do |id|
+    task.async { async_client.from("users").select("*").eq("id", id).execute }
+  end
+  jobs.map(&:wait)
+end
+```
+
+`client.set_auth(jwt)` rotates the `Authorization` header across every
+sub-client at once — useful after `auth.sign_in` returns a fresh user JWT.
+
+## URL routing
+
+Sub-client URLs are derived from the project URL:
+
+| Sub-client | URL |
+|---|---|
+| Auth      | `<project>/auth/v1` |
+| PostgREST | `<project>/rest/v1` |
+| Storage   | `<project>/storage/v1` |
+| Functions | `<project>/functions/v1` |
+| Realtime  | `wss://<host>/realtime/v1/websocket` |
+
+## Modules
+
+`supabase-rb` packages every module in one gem. Per-module references:
+
+- [Auth](auth/README.md)
+- [PostgREST](postgrest/README.md)
+- [Storage](storage/README.md)
+- [Edge Functions](functions/README.md)
+- [Realtime](realtime/README.md)

data/lib/supabase/auth/README.md

@@ -0,0 +1,172 @@
+# `supabase-auth`
+
+Ruby client for [Supabase Auth](https://supabase.com/docs/guides/auth)
+(GoTrue). Sign-in flows, session management, MFA, JWT verification, OAuth,
+and admin user management. Mirrors the public surface of
+[`supabase_auth`](https://github.com/supabase/supabase-py/tree/main/src/auth)
+in Python.
+
+- Source: [github.com/supabase-rb/client](https://github.com/supabase-rb/client)
+- RubyGems: [rubygems.org/gems/supabase-auth](https://rubygems.org/gems/supabase-auth)
+
+## Installation
+
+```ruby
+gem "supabase-auth"
+```
+
+Then `bundle install`. (Requires Ruby >= 3.0.)
+
+## Usage
+
+```ruby
+require "supabase/auth"
+
+client = Supabase::Auth::Client.new(
+  url: "https://your-project.supabase.co/auth/v1",
+  headers: { "apiKey" => "your-anon-key" }
+)
+
+response = client.sign_in_with_password(email: "user@example.com", password: "pw")
+session  = client.get_session
+user     = client.get_user
+```
+
+### Sign-in methods
+
+```ruby
+client.sign_in_with_password(email:, password:)
+client.sign_in_with_otp(email:)             # magic link
+client.sign_in_with_otp(phone:)             # SMS OTP
+client.sign_in_with_oauth(provider: "google")
+client.sign_in_with_sso(domain: "company.com")
+client.sign_in_with_id_token(provider:, token:)
+client.sign_in_anonymously
+client.sign_out
+```
+
+### Session lifecycle
+
+```ruby
+client.set_session("access_token", "refresh_token")
+client.refresh_session
+client.exchange_code_for_session(auth_code: "code")   # PKCE
+
+subscription = client.on_auth_state_change { |event, session| ... }
+subscription.unsubscribe.call
+```
+
+Events: `SIGNED_IN`, `SIGNED_OUT`, `TOKEN_REFRESHED`, `USER_UPDATED`,
+`MFA_CHALLENGE_VERIFIED`, `PASSWORD_RECOVERY`.
+
+### MFA
+
+```ruby
+enrolled  = client.mfa.enroll(factor_type: "totp")
+challenge = client.mfa.challenge(factor_id: enrolled["id"])
+client.mfa.verify(factor_id: enrolled["id"], challenge_id: challenge.id, code: "123456")
+
+client.mfa.challenge_and_verify(factor_id: enrolled["id"], code: "123456")
+client.mfa.get_authenticator_assurance_level
+client.mfa.list_factors
+client.mfa.unenroll(factor_id: enrolled["id"])
+```
+
+### JWT verification
+
+```ruby
+claims = client.get_claims(jwt: "eyJhbG...")
+claims.claims   # decoded payload
+claims.headers  # JWT headers
+```
+
+Supports HS256, RS256, ES256, PS256+ (and their 384/512 variants).
+
+### Admin API
+
+```ruby
+admin = Supabase::Auth::AdminApi.new(
+  url: "https://your-project.supabase.co/auth/v1",
+  headers: { "Authorization" => "Bearer #{service_role}", "apiKey" => service_role }
+)
+
+admin.create_user(email:, password:)
+admin.list_users(page: 1, per_page: 50)
+admin.invite_user_by_email("user@example.com")
+admin.generate_link(type: "signup", email:, password:)
+
+# OAuth 2.1 client administration (when the OAuth server feature is enabled)
+admin.oauth.create_client(client_name:, redirect_uris:)
+admin.oauth.list_clients(page: 1, per_page: 20)
+admin.oauth.regenerate_client_secret("client-uuid")
+```
+
+### Async variant
+
+```ruby
+require "supabase/auth/async"
+
+async_client = Supabase::Auth::Async::Client.new(
+  url: "https://your-project.supabase.co/auth/v1",
+  headers: { "apiKey" => "your-anon-key" }
+)
+
+Async do
+  user = async_client.get_user
+end
+```
+
+Built on [`async-http-faraday`](https://github.com/socketry/async-http-faraday).
+Loaded only when you `require "supabase/auth/async"` so sync-only users pay
+zero cost.
+
+### Constructor options
+
+```ruby
+Supabase::Auth::Client.new(
+  url:                   "...",
+  headers:               { "apiKey" => "..." },
+  auto_refresh_token:    true,
+  persist_session:       true,
+  detect_session_in_url: true,
+  flow_type:             "implicit",   # or "pkce"
+  storage:               custom_storage
+)
+```
+
+## Ruby-specific additions
+
+The Ruby port carries two intentional enhancements over `supabase_auth` (py),
+documented here so they don't get "fixed" to match Python.
+
+### `AuthPKCEError`
+
+`Supabase::Auth::Errors::AuthPKCEError` is a dedicated exception for
+PKCE-flow failures (missing or invalid `code_verifier` during
+`exchange_code_for_session`). Python raises a generic `AuthError`; the
+dedicated class gives callers a precise `rescue` target.
+
+### Explicit JWT algorithm → digest mapping
+
+`Supabase::Auth::Client::ALG_TO_DIGEST` is a frozen lookup table:
+
+```ruby
+ALG_TO_DIGEST = {
+  "RS256" => "SHA256", "RS384" => "SHA384", "RS512" => "SHA512",
+  "ES256" => "SHA256", "ES384" => "SHA384", "ES512" => "SHA512",
+  "PS256" => "SHA256", "PS384" => "SHA384", "PS512" => "SHA512"
+}.freeze
+```
+
+Python resolves algorithms dynamically via `PyJWT.get_algorithm_by_name`.
+The Ruby table makes the supported set readable in one place and fails fast
+(`AuthInvalidJwtError`) on unsupported `alg` values.
+
+## Development
+
+Integration tests need the GoTrue stack on ports 9996–9999:
+
+```bash
+docker compose -f infra/docker-compose.yml up -d
+bundle exec rspec spec/supabase/auth/ spec/client_spec.rb spec/admin_api_spec.rb
+```

data/lib/supabase/auth/admin_api.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Supabase
+  module Auth
+    # Admin API for managing users with a service role key.
+    # Provides CRUD operations on users, link generation, and MFA management.
+    class AdminApi < Api
+      # @return [AdminOAuthApi] OAuth 2.1 client administration accessor
+      attr_reader :oauth
+
+      # @param url [String] The GoTrue API base URL
+      # @param headers [Hash] Headers including Authorization bearer token
+      # @param http_client [Faraday::Connection, nil] Optional custom Faraday client
+      # @param verify [Boolean] Verify TLS certificates (default true)
+      # @param proxy [String, nil] HTTP proxy URL
+      # @param timeout [Numeric, nil] Per-request timeout in seconds
+      def initialize(url:, headers: {}, http_client: nil, verify: true, proxy: nil, timeout: nil)
+        super(url: url, headers: headers, http_client: http_client, verify: verify, proxy: proxy, timeout: timeout)
+        @oauth = AdminOAuthApi.new(self)
+      end
+
+      # Creates a new user via the admin API.
+      # @param attributes [Hash] user attributes (email, password, user_metadata, app_metadata, etc.)
+      # @return [Types::UserResponse]
+      def create_user(attributes)
+        data = post("admin/users", body: attributes)
+        Helpers.parse_user_response(data)
+      end
+
+      # Lists all users.
+      # @param page [Integer, nil] page number
+      # @param per_page [Integer, nil] users per page
+      # @return [Array<Types::User>]
+      def list_users(page: nil, per_page: nil)
+        params = {}
+        params[:page] = page if page
+        params[:per_page] = per_page if per_page
+        data = get("admin/users", params: params)
+        users = data["users"] || []
+        users.map { |u| Types::User.from_hash(u) }
+      end
+
+      # Gets a user by their ID.
+      # @param uid [String] user UUID
+      # @return [Types::UserResponse]
+      # @raise [ArgumentError] if uid is not a valid UUID
+      def get_user_by_id(uid)
+        _validate_uuid(uid)
+        data = get("admin/users/#{uid}")
+        Helpers.parse_user_response(data)
+      end
+
+      # Updates a user by their ID.
+      # @param uid [String] user UUID
+      # @param attributes [Hash] attributes to update
+      # @return [Types::UserResponse]
+      # @raise [ArgumentError] if uid is not a valid UUID
+      def update_user_by_id(uid, attributes)
+        _validate_uuid(uid)
+        data = put("admin/users/#{uid}", body: attributes)
+        Helpers.parse_user_response(data)
+      end
+
+      # Deletes a user by their ID.
+      # @param uid [String] user UUID
+      # @param should_soft_delete [Boolean] soft delete instead of hard delete
+      # @raise [ArgumentError] if uid is not a valid UUID
+      def delete_user(uid, should_soft_delete: false)
+        _validate_uuid(uid)
+        _request("DELETE", "admin/users/#{uid}", body: { should_soft_delete: should_soft_delete })
+      end
+
+      # Generates email links and OTPs.
+      def generate_link(params)
+        options = params[:options] || params["options"] || {}
+        body = {
+          type: params[:type] || params["type"],
+          email: params[:email] || params["email"],
+          password: params[:password] || params["password"],
+          new_email: params[:new_email] || params["new_email"],
+          data: options[:data] || options["data"]
+        }
+        redirect_to = options[:redirect_to] || options["redirect_to"]
+        query = {}
+        query["redirect_to"] = redirect_to if redirect_to
+        data = post("admin/generate_link", body: body, params: query)
+        Helpers.parse_link_response(data)
+      end
+
+      # Invites a user by email.
+      def invite_user_by_email(email, options = {})
+        body = { email: email, data: options[:data] || options["data"] }
+        redirect_to = options[:redirect_to] || options["redirect_to"]
+        query = {}
+        query["redirect_to"] = redirect_to if redirect_to
+        data = post("invite", body: body, params: query)
+        Helpers.parse_user_response(data)
+      end
+
+      # Signs out a user by revoking their session via the admin API.
+      def sign_out(access_token, scope = "global")
+        _request("POST", "logout", jwt: access_token, params: { "scope" => scope }, no_resolve_json: true)
+      end
+
+      # Lists MFA factors for a user (admin).
+      # @param params [Hash] :user_id (required)
+      # @return [Types::AuthMFAAdminListFactorsResponse]
+      def _list_factors(params)
+        user_id = params[:user_id] || params["user_id"]
+        _validate_uuid(user_id)
+        data = get("admin/users/#{user_id}/factors")
+        Types::AuthMFAAdminListFactorsResponse.from_hash(data)
+      end
+
+      # Deletes an MFA factor for a user (admin).
+      # @param params [Hash] :user_id and :id (both required)
+      # @return [Types::AuthMFAAdminDeleteFactorResponse]
+      def _delete_factor(params)
+        user_id = params[:user_id] || params["user_id"]
+        factor_id = params[:id] || params["id"]
+        _validate_uuid(user_id)
+        _validate_uuid(factor_id)
+        data = delete("admin/users/#{user_id}/factors/#{factor_id}")
+        Types::AuthMFAAdminDeleteFactorResponse.from_hash(data)
+      end
+
+      # Lists OAuth clients with optional pagination. Only relevant when the OAuth 2.1
+      # server is enabled in Supabase Auth.
+      # @param params [Hash, Types::PageParams, nil] optional :page and :per_page
+      # @return [Types::OAuthClientListResponse]
+      def _list_oauth_clients(params = nil)
+        query = {}
+        if params
+          page = params[:page] || params["page"]
+          per_page = params[:per_page] || params["per_page"]
+          query[:page] = page if page
+          query[:per_page] = per_page if per_page
+        end
+
+        response = _request("GET", "admin/oauth/clients", params: query, no_resolve_json: true)
+        body = response.body.is_a?(String) ? JSON.parse(response.body) : (response.body || {})
+        result = Types::OAuthClientListResponse.from_hash(body)
+
+        total = response.headers["x-total-count"] || response.headers["X-Total-Count"]
+        result.total = total.to_i if total
+
+        links = response.headers["link"] || response.headers["Link"]
+        if links
+          links.split(",").each do |link|
+            parts = link.split(";")
+            next unless parts.length >= 2
+
+            page_match = parts[0].split("page=")
+            next unless page_match.length >= 2
+
+            page_num = page_match[1].split("&")[0].sub(/>$/, "").to_i
+            rel = parts[1].split("=")[1].to_s.delete('"').strip
+            case rel
+            when "next" then result.next_page = page_num
+            when "last" then result.last_page = page_num
+            end
+          end
+        end
+
+        result
+      end
+
+      # Creates a new OAuth client. Only relevant when the OAuth 2.1 server is enabled.
+      # @param params [Hash] OAuth client attributes (client_name, redirect_uris, etc.)
+      # @return [Types::OAuthClientResponse]
+      def _create_oauth_client(params)
+        data = post("admin/oauth/clients", body: params)
+        Types::OAuthClientResponse.new(client: Types::OAuthClient.from_hash(data))
+      end
+
+      # Gets details of a specific OAuth client.
+      # @param client_id [String] OAuth client UUID
+      # @return [Types::OAuthClientResponse]
+      # @raise [ArgumentError] if client_id is not a valid UUID
+      def _get_oauth_client(client_id)
+        _validate_uuid(client_id)
+        data = get("admin/oauth/clients/#{client_id}")
+        Types::OAuthClientResponse.new(client: Types::OAuthClient.from_hash(data))
+      end
+
+      # Updates an OAuth client.
+      # @param client_id [String] OAuth client UUID
+      # @param params [Hash] attributes to update
+      # @return [Types::OAuthClientResponse]
+      # @raise [ArgumentError] if client_id is not a valid UUID
+      def _update_oauth_client(client_id, params)
+        _validate_uuid(client_id)
+        data = put("admin/oauth/clients/#{client_id}", body: params)
+        Types::OAuthClientResponse.new(client: Types::OAuthClient.from_hash(data))
+      end
+
+      # Deletes an OAuth client.
+      # @param client_id [String] OAuth client UUID
+      # @raise [ArgumentError] if client_id is not a valid UUID
+      def _delete_oauth_client(client_id)
+        _validate_uuid(client_id)
+        _request("DELETE", "admin/oauth/clients/#{client_id}")
+      end
+
+      # Regenerates the secret for an OAuth client.
+      # @param client_id [String] OAuth client UUID
+      # @return [Types::OAuthClientResponse]
+      # @raise [ArgumentError] if client_id is not a valid UUID
+      def _regenerate_oauth_client_secret(client_id)
+        _validate_uuid(client_id)
+        data = post("admin/oauth/clients/#{client_id}/regenerate_secret")
+        Types::OAuthClientResponse.new(client: Types::OAuthClient.from_hash(data))
+      end
+    end
+  end
+end

data/lib/supabase/auth/admin_oauth_api.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Supabase
+  module Auth
+    # OAuth 2.1 client administration. Mirrors supabase-py's SyncGoTrueAdminOAuthAPI.
+    # Only relevant when the OAuth 2.1 server is enabled in Supabase Auth.
+    # Accessed via {AdminApi#oauth}; delegates to the underscored implementations on AdminApi.
+    class AdminOAuthApi
+      # @param admin [AdminApi]
+      def initialize(admin)
+        @admin = admin
+      end
+
+      # @param params [Hash, Types::PageParams, nil] optional :page / :per_page
+      # @return [Types::OAuthClientListResponse]
+      def list_clients(params = nil)
+        @admin._list_oauth_clients(params)
+      end
+
+      # @param params [Hash] new client attributes (client_name, redirect_uris, etc.)
+      # @return [Types::OAuthClientResponse]
+      def create_client(params)
+        @admin._create_oauth_client(params)
+      end
+
+      # @param client_id [String] OAuth client UUID
+      # @return [Types::OAuthClientResponse]
+      def get_client(client_id)
+        @admin._get_oauth_client(client_id)
+      end
+
+      # @param client_id [String] OAuth client UUID
+      # @param params [Hash] attributes to update
+      # @return [Types::OAuthClientResponse]
+      def update_client(client_id, params)
+        @admin._update_oauth_client(client_id, params)
+      end
+
+      # @param client_id [String] OAuth client UUID
+      def delete_client(client_id)
+        @admin._delete_oauth_client(client_id)
+      end
+
+      # @param client_id [String] OAuth client UUID
+      # @return [Types::OAuthClientResponse] response with rotated client_secret
+      def regenerate_client_secret(client_id)
+        @admin._regenerate_oauth_client_secret(client_id)
+      end
+    end
+  end
+end

data/lib/supabase/auth/api.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module Supabase
+  module Auth
+    class Api
+      CONTENT_TYPE = "application/json;charset=UTF-8"
+      UUID_REGEX = /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i
+
+      attr_reader :url, :headers
+
+      # @param url [String] The GoTrue API base URL
+      # @param headers [Hash] Default headers to include on every request (e.g., apikey)
+      # @param http_client [Faraday::Connection, nil] Optional custom Faraday client
+      # @param verify [Boolean] Verify TLS certificates (default true)
+      # @param proxy [String, nil] HTTP proxy URL
+      # @param timeout [Numeric, nil] Per-request timeout in seconds
+      def initialize(url:, headers: {}, http_client: nil, verify: true, proxy: nil, timeout: nil)
+        @url = url
+        @headers = headers
+        @http_client = http_client
+        @verify = verify
+        @proxy = proxy
+        @timeout = timeout
+      end
+
+      # Central HTTP dispatch method. Builds URL, merges headers (including API version
+      # and Authorization), handles redirect_to as query param, parses JSON, applies
+      # optional transform, and maps errors via Helpers.handle_exception.
+      #
+      # @param method [String, Symbol] HTTP method (GET, POST, PUT, DELETE)
+      # @param path [String] Request path (relative to base URL)
+      # @param jwt [String, nil] Bearer token for Authorization header
+      # @param body [Hash, nil] Request body (serialized to JSON)
+      # @param params [Hash] Query parameters
+      # @param headers [Hash] Additional headers for this request
+      # @param redirect_to [String, nil] If present, added as redirect_to query param
+      # @param xform [Proc, nil] Optional transform function applied to parsed response
+      # @param no_resolve_json [Boolean] If true, return raw Faraday::Response
+      # @return [Hash, Object] Parsed JSON response, transformed result, or raw response
+      def _request(method, path, jwt: nil, body: nil, params: {}, headers: {}, redirect_to: nil, xform: nil, no_resolve_json: false)
+        merged_headers = @headers.merge(headers)
+        merged_headers["Content-Type"] ||= CONTENT_TYPE
+        merged_headers[Constants::API_VERSION_HEADER_NAME] ||= Constants::API_VERSIONS.keys.last
+        merged_headers["Authorization"] = "Bearer #{jwt}" if jwt
+
+        query = params.dup
+        query["redirect_to"] = redirect_to if redirect_to
+
+        full_path = build_path(path)
+        json_body = body ? JSON.generate(body) : nil
+
+        response = connection.run_request(method.to_s.downcase.to_sym, full_path, json_body, merged_headers) do |req|
+          req.params.update(query) unless query.empty?
+        end
+
+        result = no_resolve_json ? response : parse_response(response)
+
+        xform ? xform.call(result) : result
+      rescue Faraday::Error => e
+        raise Helpers.handle_exception(e)
+      rescue StandardError => e
+        raise Helpers.handle_exception(e)
+      end
+
+      # @param id [String] UUID to validate
+      # @raise [ArgumentError] if not a valid UUID format
+      def _validate_uuid(id)
+        unless id.is_a?(String) && id.match?(UUID_REGEX)
+          raise ArgumentError, "Invalid id, '#{id}' is not a valid uuid"
+        end
+      end
+
+      # Convenience methods that delegate to _request
+
+      def get(path, headers: {}, params: {})
+        _request(:get, path, headers: headers, params: params)
+      end
+
+      def post(path, body: {}, headers: {}, params: {})
+        _request(:post, path, body: body, headers: headers, params: params)
+      end
+
+      def put(path, body: {}, headers: {}, params: {})
+        _request(:put, path, body: body, headers: headers, params: params)
+      end
+
+      def delete(path, headers: {}, params: {})
+        _request(:delete, path, headers: headers, params: params)
+      end
+
+      private
+
+      def connection
+        @connection ||= @http_client || build_connection
+      end
+
+      def build_connection
+        Faraday.new(url: @url, ssl: { verify: @verify }, proxy: @proxy) do |f|
+          f.response :raise_error
+          if @timeout
+            f.options.timeout = @timeout
+            f.options.open_timeout = @timeout
+          end
+          f.adapter Faraday.default_adapter
+        end
+      end
+
+      def build_path(path)
+        base_path = URI.parse(@url).path.chomp("/")
+        "#{base_path}/#{path.sub(%r{^/}, '')}"
+      end
+
+      def parse_response(response)
+        return {} if response.body.nil? || response.body.empty?
+
+        JSON.parse(response.body)
+      rescue JSON::ParserError
+        {}
+      end
+    end
+  end
+end