scalingo 3.5.0 → 4.0.beta2

data/lib/scalingo/auth/scm_integrations.rb

@@ -2,56 +2,9 @@ require "scalingo/api/endpoint"
 
 module Scalingo
   class Auth::ScmIntegrations < API::Endpoint
-    def all(headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "scm_integrations",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:scm_integrations) { response }
-    end
-
-    def show(id, headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "scm_integrations/#{id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:scm_integration) { response }
-    end
-
-    def create(payload, headers = nil, &block)
-      data = {scm_integration: payload}
-
-      response = connection.post(
-        "scm_integrations",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:scm_integration) { response }
-    end
-
-    def destroy(id, headers = nil, &block)
-      data = nil
-
-      response = connection.delete(
-        "scm_integrations/#{id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack { response }
-    end
+    get :list, "scm_integrations"
+    get :find, "scm_integrations/{id}"
+    post :create, "scm_integrations", root_key: :scm_integration
+    delete :delete, "scm_integrations/{id}"
   end
 end

data/lib/scalingo/auth/tokens.rb

@@ -2,77 +2,10 @@ require "scalingo/api/endpoint"
 
 module Scalingo
   class Auth::Tokens < API::Endpoint
-    def exchange(token, headers = nil, &block)
-      data = nil
-
-      authorization = Faraday::Utils.basic_header_from("", token)
-
-      request_headers = {
-        Faraday::Request::Authorization::KEY => authorization
-      }
-
-      request_headers.update(headers) if headers
-
-      response = client.unauthenticated_connection.post(
-        "tokens/exchange",
-        data,
-        request_headers,
-        &block
-      )
-
-      unpack { response }
-    end
-
-    def all(headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "tokens",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:tokens) { response }
-    end
-
-    def create(payload, headers = nil, &block)
-      data = {token: payload}
-
-      response = connection.post(
-        "tokens",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:token) { response }
-    end
-
-    def renew(id, headers = nil, &block)
-      data = nil
-
-      response = connection.patch(
-        "tokens/#{id}/renew",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:token) { response }
-    end
-
-    def destroy(id, headers = nil, &block)
-      data = nil
-
-      response = connection.delete(
-        "tokens/#{id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack { response }
-    end
+    get :list, "tokens"
+    post :create, "tokens", root_key: :token
+    delete :delete, "tokens/{id}"
+    post :exchange, "tokens/exchange", connected: false
+    put :renew, "tokens/{id}/renew"
   end
 end

data/lib/scalingo/auth/two_factor_auth.rb

@@ -2,60 +2,9 @@ require "scalingo/api/endpoint"
 
 module Scalingo
   class Auth::TwoFactorAuth < API::Endpoint
-    TOTP_PROVIDER = "totp"
-    DEFAULT_PROVIDER = TOTP_PROVIDER
-    SUPPORTED_PROVIDERS = [TOTP_PROVIDER]
-
-    def status(headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "client/tfa",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:tfa) { response }
-    end
-
-    def initiate(provider = DEFAULT_PROVIDER, headers = nil, &block)
-      data = {tfa: {provider: provider}}
-
-      response = connection.post(
-        "client/tfa",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:tfa) { response }
-    end
-
-    def validate(attempt, headers = nil, &block)
-      data = {tfa: {attempt: attempt}}
-
-      response = connection.post(
-        "client/tfa/validate",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:tfa) { response }
-    end
-
-    def disable(headers = nil, &block)
-      data = nil
-
-      response = connection.delete(
-        "client/tfa",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:tfa) { response }
-    end
+    get :status, "client/tfa"
+    post :initiate, "client/tfa", root_key: :tfa
+    post :validate, "client/tfa/validate", root_key: :tfa
+    delete :disable, "client/tfa"
   end
 end

data/lib/scalingo/auth/user.rb

@@ -2,43 +2,8 @@ require "scalingo/api/endpoint"
 
 module Scalingo
   class Auth::User < API::Endpoint
-    def self(headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "users/self",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:user) { response }
-    end
-
-    def update(payload, headers = nil, &block)
-      data = {user: payload}
-
-      response = connection.put(
-        "users/account",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:user) { response }
-    end
-
-    def stop_free_trial(headers = nil, &block)
-      data = nil
-
-      response = connection.post(
-        "users/stop_free_trial",
-        data,
-        headers,
-        &block
-      )
-
-      unpack { response }
-    end
+    get :find, "users/self"
+    put :update, "users/account", root_key: :user
+    post :stop_free_trial, "users/stop_free_trial"
   end
 end

data/lib/scalingo/bearer_token.rb

@@ -1,14 +1,16 @@
+require "jwt"
+
 module Scalingo
   class BearerToken
     attr_reader :expires_at
-    attr_writer :raise_on_expired
 
-    def initialize(value, expires_at: nil, raise_on_expired: false)
+    def initialize(value)
       @value = value
-      @expires_at = expires_at if expires_at
-      @raise_on_expired = raise_on_expired
+
+      read_expiration!
     end
 
+    # :nocov:
     def inspect
       str = "<#{self.class}:0x#{object_id.to_s(16)} "
 
@@ -23,19 +25,24 @@ module Scalingo
       str << %(value:"#{value}">)
       str
     end
-
-    def raise_on_expired?
-      @raise_on_expired
-    end
+    # :nocov:
 
     def expired?
       expires_at && expires_at <= Time.now
     end
 
     def value
-      raise Error::ExpiredToken if expired? && raise_on_expired?
+      raise Error::ExpiredToken if expired?
 
       @value
     end
+
+    private
+
+    def read_expiration!
+      payload, _ = JWT.decode(@value, nil, false)
+
+      @expires_at = Time.at(payload["exp"]) if payload["exp"]
+    end
   end
 end

data/lib/scalingo/billing/profile.rb

@@ -2,45 +2,8 @@ require "scalingo/api/endpoint"
 
 module Scalingo
   class Billing::Profile < API::Endpoint
-    def show(headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "profile",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:profile) { response }
-    end
-
-    def create(payload = {}, headers = nil, &block)
-      data = {profile: payload}
-
-      response = connection.post(
-        "profiles",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:profile) { response }
-    end
-
-    def update(id, payload = {}, headers = nil, &block)
-      data = {profile: payload}
-
-      response = connection.put(
-        "profiles/#{id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:profile) { response }
-    end
-
-    alias_method :self, :show
+    get :find, "profile"
+    post :create, "profiles", root_key: :profile
+    put :update, "profiles/{id}", root_key: :profile
   end
 end

data/lib/scalingo/client.rb

@@ -2,53 +2,43 @@ require "scalingo/core_client"
 require "scalingo/auth"
 require "scalingo/billing"
 require "scalingo/regional"
-require "scalingo/regional_database"
+require "scalingo/database"
 
 module Scalingo
   class Client < CoreClient
+    URLS = {
+      auth: "https://auth.scalingo.com/v1",
+      billing: "https://cashmachine.scalingo.com",
+      regional: {
+        osc_fr1: "https://api.osc-fr1.scalingo.com/v1",
+        osc_secnum_fr1: "https://api.osc-secnum-fr1.scalingo.com/v1"
+      },
+      database: {
+        osc_fr1: "https://db-api.osc-fr1.scalingo.com/api",
+        osc_secnum_fr1: "https://db-api.osc-secnum-fr1.scalingo.com/api"
+      }
+    }
+
     ## API clients
     def auth
-      @auth ||= Auth.new(
-        "https://auth.scalingo.com/v1",
-        scalingo: self
-      )
+      @auth ||= Auth.new(URLS[:auth], scalingo: self)
     end
 
     def billing
-      @billing ||= Billing.new(
-        "https://cashmachine.scalingo.com",
-        scalingo: self
-      )
+      @billing ||= Billing.new(URLS[:billing], scalingo: self)
     end
 
     def osc_fr1
-      @osc_fr1 ||= Regional.new(
-        "https://api.osc-fr1.scalingo.com/v1",
-        scalingo: self
-      )
+      @osc_fr1 ||= Regional.new(URLS[:regional][:osc_fr1], scalingo: self, region: :osc_fr1)
     end
-    alias_method :apps_api_osc_fr1, :osc_fr1
 
     def osc_secnum_fr1
-      @osc_secnum_fr1 ||= Regional.new(
-        "https://api.osc-secnum-fr1.scalingo.com/v1",
-        scalingo: self
-      )
-    end
-    alias_method :apps_api_osc_secnum_fr1, :osc_secnum_fr1
-
-    def db_api_osc_fr1
-      @db_api_osc_fr1 ||= RegionalDatabase.new(
-        "https://db-api.osc-fr1.scalingo.com/api",
-        scalingo: self
-      )
+      @osc_secnum_fr1 ||= Regional.new(URLS[:regional][:osc_secnum_fr1], scalingo: self, region: :osc_secnum_fr1)
     end
 
-    def db_api_osc_secnum_fr1
-      @db_api_osc_secnum_fr1 ||= RegionalDatabase.new(
-        "https://db-api.osc-secnum-fr1.scalingo.com/api",
-        scalingo: self
-      )
+    ## Helpers
+    def self
+      auth.user.find
     end
   end
 end

data/lib/scalingo/configuration.rb

@@ -1,37 +1,16 @@
 require "active_support"
 require "active_support/core_ext/numeric/time"
 require "scalingo/version"
-require "ostruct"
 
 module Scalingo
   class Configuration
     ATTRIBUTES = [
-      # URL to the authentication API
-      # :auth,
-
-      # URL to the billing API
-      # :billing,
-
-      # List of regions under the form {"region_id": root_url}
-      # :regions,
-
       # Default region. Must match a key in `regions`
       :default_region,
 
       # Configure the User Agent header
       :user_agent,
 
-      # For how long is a bearer token considered valid (it will raise passed this delay).
-      # Set to nil to never raise.
-      :exchanged_token_validity,
-
-      # Raise an exception when trying to use an authenticated connection without a bearer token set
-      # Having this setting to true prevents performing requests that would fail due to lack of authentication headers.
-      :raise_on_missing_authentication,
-
-      # Raise an exception when the bearer token in use is supposed to be invalid
-      :raise_on_expired_token,
-
       # These headers will be added to every request. Individual methods may override them.
       # This should be a hash or a callable object that returns a hash.
       :additional_headers,
@@ -46,9 +25,6 @@ module Scalingo
       new(
         default_region: :osc_fr1,
         user_agent: "Scalingo Ruby Client v#{Scalingo::VERSION}",
-        exchanged_token_validity: 1.hour,
-        raise_on_missing_authentication: true,
-        raise_on_expired_token: false,
         additional_headers: {}
       )
     end

data/lib/scalingo/core_client.rb

@@ -14,6 +14,7 @@ module Scalingo
       @config = Configuration.new(attributes, Scalingo.config)
     end
 
+    # :nocov:
     def inspect
       str = %(<#{self.class}:0x#{object_id.to_s(16)} version:"#{Scalingo::VERSION}" authenticated:)
 
@@ -26,6 +27,7 @@ module Scalingo
       str << ">"
       str
     end
+    # :nocov:
 
     ## Sub-clients accessors
     def auth
@@ -40,12 +42,8 @@ module Scalingo
       public_send(name || config.default_region)
     end
 
-    def database_region(name = nil)
-      public_send(name || "db_api_#{config.default_region}")
-    end
-
     ## Authentication helpers / Token management
-    def authenticate_with(access_token: nil, bearer_token: nil, expires_at: nil)
+    def authenticate_with(access_token: nil, bearer_token: nil)
       if !access_token && !bearer_token
         raise ArgumentError, "You must supply one of `access_token` or `bearer_token`"
       end
@@ -54,31 +52,16 @@ module Scalingo
         raise ArgumentError, "You cannot supply both `access_token` and `bearer_token`"
       end
 
-      if expires_at && !bearer_token
-        raise ArgumentError, "`expires_at` can only be used with `bearer_token`. `access_token` have a 1 hour expiration."
-      end
-
       if access_token
-        expiration = Time.now + config.exchanged_token_validity
-        response = auth.tokens.exchange(access_token)
-
-        if response.successful?
-          self.token = BearerToken.new(
-            response.data[:token],
-            expires_at: expiration,
-            raise_on_expired: config.raise_on_expired_token
-          )
-        end
-
-        return response.successful?
+        response = auth.tokens.exchange(basic: {password: access_token})
+
+        self.token = response.body if response.success?
+
+        return response.success?
       end
 
       if bearer_token
-        authenticate_with_bearer_token(
-          bearer_token,
-          expires_at: expires_at,
-          raise_on_expired_token: config.raise_on_expired_token
-        )
+        self.token = bearer_token
 
         true
       end
@@ -105,8 +88,5 @@ module Scalingo
     def_delegator :region, :notifiers
     def_delegator :region, :operations
     def_delegator :region, :scm_repo_links
-
-    def_delegator :database_region, :databases
-    def_delegator :database_region, :backups
   end
 end

data/lib/scalingo/database/backups.rb

@@ -0,0 +1,9 @@
+require "scalingo/api/endpoint"
+
+module Scalingo
+  class Database::Backups < API::Endpoint
+    get :list, "databases/{addon_id}/backups"
+    post :create, "databases/{addon_id}/backups"
+    get :archive, "databases/{addon_id}/backups/{id}/archive"
+  end
+end

data/lib/scalingo/database/databases.rb

@@ -0,0 +1,8 @@
+require "scalingo/api/endpoint"
+
+module Scalingo
+  class Database::Databases < API::Endpoint
+    get :find, "databases/{id}"
+    post :upgrade, "databases/{id}/upgrade"
+  end
+end

data/lib/scalingo/{regional_database.rb → database.rb}

@@ -1,9 +1,9 @@
 require "scalingo/api/client"
 
 module Scalingo
-  class RegionalDatabase < API::Client
-    require "scalingo/regional_database/databases"
-    require "scalingo/regional_database/backups"
+  class Database < API::Client
+    require "scalingo/database/databases"
+    require "scalingo/database/backups"
 
     register_handlers!(
       databases: Databases,

data/lib/scalingo/faraday/extract_meta.rb

@@ -0,0 +1,33 @@
+require "faraday"
+
+module Scalingo
+  class ExtractMeta < Faraday::Middleware
+    def on_complete(env)
+      return unless env.body.is_a?(Hash)
+
+      extract_metadata(env)
+      extract_cursor_metadata(env)
+    end
+
+    private
+
+    def extract_metadata(env)
+      return unless env.body[:meta]
+
+      env[:response_meta] = env.body.delete(:meta)
+    end
+
+    def extract_cursor_metadata(env)
+      return unless env.body.key?(:next_cursor)
+
+      env[:response_meta] = {
+        cursor_pagination: {
+          next_cursor: env.body.delete(:next_cursor),
+          has_more: env.body.delete(:has_more)
+        }.compact
+      }
+    end
+  end
+end
+
+Faraday::Response.register_middleware(extract_meta: Scalingo::ExtractMeta)

data/lib/scalingo/faraday/extract_root_value.rb

@@ -0,0 +1,18 @@
+require "faraday"
+
+module Scalingo
+  class ExtractRootValue < Faraday::Middleware
+    def on_complete(env)
+      # We only want to unpack the response for successful responses
+      return unless env.response.success?
+
+      # Only hash-like objects are relevant to "unpack"
+      return unless env.body.is_a?(Hash)
+
+      # Dig the root key if it's the only remaining key in the body
+      env.body = env.body.values.first if env.body.size == 1
+    end
+  end
+end
+
+Faraday::Response.register_middleware(extract_root_value: Scalingo::ExtractRootValue)

data/lib/scalingo/faraday/response.rb

@@ -0,0 +1,36 @@
+require "faraday"
+require "faraday/response"
+
+# Note: the file is scalingo/faraday/response but we're reopning Faraday::Response:
+# we define additional methods for Faraday::Response in order to enhance expressiveness
+module Faraday
+  class Response
+    def meta
+      env[:response_meta]
+    end
+
+    def meta?
+      meta.present?
+    end
+
+    def pagination
+      return unless meta?
+
+      meta[:pagination]
+    end
+
+    def paginated?
+      pagination.present?
+    end
+
+    def cursor_pagination
+      return unless meta?
+
+      meta[:cursor_pagination]
+    end
+
+    def cursor_paginated?
+      cursor_pagination.present?
+    end
+  end
+end