scalingo 3.0.0.beta.1

data/lib/scalingo/api/endpoint.rb

@@ -0,0 +1,23 @@
+require "forwardable"
+require "scalingo/api/response"
+
+module Scalingo
+  module API
+    class Endpoint
+      extend Forwardable
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      def_delegator :client, :connection
+
+      private
+
+      def unpack(*args)
+        Response.unpack(*args)
+      end
+    end
+  end
+end

data/lib/scalingo/api/response.rb

@@ -0,0 +1,71 @@
+module Scalingo
+  module API
+    class Response
+      def self.transform_object(object, resource_class: nil)
+        resource_class&.new(object) || object
+      end
+
+      def self.transform_body(body, resource_class: nil)
+        case body
+        when Hash
+          transform_object(body, resource_class: resource_class)
+        when Array
+          body.map { |item| transform_object(item, resource_class: resource_class) }
+        else
+          body
+        end
+      end
+
+      def self.transform_meta(body)
+        if body.present? && body.respond_to?(:key) && body.key?(:meta)
+          body[:meta]
+        end
+      end
+
+      def self.unpack(response, key: nil, resource_class: nil)
+        data = if response.body.respond_to?(:key?) && key.present?
+          response.body[key]
+        else
+          response.body
+        end
+
+        parsed = transform_body(data, resource_class: resource_class)
+        meta = transform_meta(response.body)
+
+        new(
+          status: response.status,
+          headers: response.headers,
+          data: parsed,
+          meta: meta,
+          full_body: response.body,
+        )
+      end
+
+      attr_reader :status, :headers, :data, :full_body, :meta
+
+      def initialize(status:, headers:, data:, full_body:, meta: nil)
+        @status = status
+        @headers = headers
+        @data = data
+        @full_body = full_body
+        @meta = meta
+      end
+
+      def successful?
+        status >= 200 && status < 300
+      end
+
+      def paginated?
+        meta&.dig(:pagination).present?
+      end
+
+      def operation
+        headers[:location]
+      end
+
+      def operation?
+        operation.present
+      end
+    end
+  end
+end

data/lib/scalingo/auth.rb

@@ -0,0 +1,21 @@
+require "scalingo/api/client"
+
+module Scalingo
+  class Auth < API::Client
+    require "scalingo/auth/keys"
+    require "scalingo/auth/scm_integrations"
+    require "scalingo/auth/tokens"
+    require "scalingo/auth/two_factor_auth"
+    require "scalingo/auth/user"
+
+    register_handlers!(
+      keys: Keys,
+      scm_integrations: ScmIntegrations,
+      tokens: Tokens,
+      two_factor_auth: TwoFactorAuth,
+      user: User,
+    )
+
+    alias_method :tfa, :two_factor_auth
+  end
+end

data/lib/scalingo/auth/keys.rb

@@ -0,0 +1,56 @@
+require "scalingo/api/endpoint"
+
+module Scalingo
+  class Auth::Keys < API::Endpoint
+    def all(headers = nil, &block)
+      data = nil
+
+      response = connection.get(
+        "keys",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :keys)
+    end
+
+    def show(id, headers = nil, &block)
+      data = nil
+
+      response = connection.get(
+        "keys/#{id}",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :key)
+    end
+
+    def create(payload, headers = nil, &block)
+      data = {key: payload}
+
+      response = connection.post(
+        "keys",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :key)
+    end
+
+    def destroy(id, headers = nil, &block)
+      data = nil
+      response = connection.delete(
+        "keys/#{id}",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response)
+    end
+  end
+end

data/lib/scalingo/auth/scm_integrations.rb

@@ -0,0 +1,57 @@
+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(response, key: :scm_integrations)
+    end
+
+    def show(id, headers = nil, &block)
+      data = nil
+
+      response = connection.get(
+        "scm_integrations/#{id}",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :scm_integration)
+    end
+
+    def create(payload, headers = nil, &block)
+      data = {scm_integration: payload}
+
+      response = connection.post(
+        "scm_integrations",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :scm_integration)
+    end
+
+    def destroy(id, headers = nil, &block)
+      data = nil
+
+      response = connection.delete(
+        "scm_integrations/#{id}",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response)
+    end
+  end
+end

data/lib/scalingo/auth/tokens.rb

@@ -0,0 +1,78 @@
+require "scalingo/api/endpoint"
+
+module Scalingo
+  class Auth::Tokens < API::Endpoint
+    def exchange(token, headers = nil, &block)
+      data = nil
+
+      authorization = Faraday::Request::BasicAuthentication.header("", 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(response, key: :tokens)
+    end
+
+    def create(payload, headers = nil, &block)
+      data = {token: payload}
+
+      response = connection.post(
+        "tokens",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :token)
+    end
+
+    def renew(id, headers = nil, &block)
+      data = nil
+
+      response = connection.patch(
+        "tokens/#{id}/renew",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :token)
+    end
+
+    def destroy(id, headers = nil, &block)
+      data = nil
+
+      response = connection.delete(
+        "tokens/#{id}",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response)
+    end
+  end
+end

data/lib/scalingo/auth/two_factor_auth.rb

@@ -0,0 +1,61 @@
+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(response, key: :tfa)
+    end
+
+    def initiate(provider = DEFAULT_PROVIDER, headers = nil, &block)
+      data = {tfa: {provider: provider}}
+
+      response = connection.post(
+        "client/tfa",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :tfa)
+    end
+
+    def validate(attempt, headers = nil, &block)
+      data = {tfa: {attempt: attempt}}
+
+      response = connection.post(
+        "client/tfa/validate",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :tfa)
+    end
+
+    def disable(headers = nil, &block)
+      data = nil
+
+      response = connection.delete(
+        "client/tfa",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :tfa)
+    end
+  end
+end

data/lib/scalingo/auth/user.rb

@@ -0,0 +1,31 @@
+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(response, key: :user)
+    end
+
+    def update(payload, headers = nil, &block)
+      data = {user: payload}
+
+      response = connection.put(
+        "users/account",
+        data,
+        headers,
+        &block
+      )
+
+      unpack(response, key: :user)
+    end
+  end
+end

data/lib/scalingo/bearer_token.rb

@@ -0,0 +1,20 @@
+module Scalingo
+  class BearerToken
+    attr_reader :expires_in
+
+    def initialize(value, expires_in: nil)
+      @value = value
+      @expires_in = expires_in if expires_in
+    end
+
+    def expired?
+      expires_in && expires_in <= Time.now
+    end
+
+    def value
+      raise Error::ExpiredToken if expired? && Scalingo.config.raise_on_expired_token
+
+      @value
+    end
+  end
+end

data/lib/scalingo/client.rb

@@ -0,0 +1,105 @@
+require "forwardable"
+require "faraday"
+require "faraday_middleware"
+require "scalingo/bearer_token"
+require "scalingo/errors"
+require "scalingo/auth"
+require "scalingo/regional"
+
+module Scalingo
+  class Client
+    extend Forwardable
+
+    ## Authentication helpers / Token management
+    attr_reader :token
+
+    def token=(input)
+      @token = input.is_a?(BearerToken) ? input : BearerToken.new(input.to_s)
+    end
+
+    def authenticated?
+      token.present? && !token.expired?
+    end
+
+    def authenticate_with(access_token: nil, bearer_token: nil, expires_in: nil)
+      if !access_token && !bearer_token
+        raise ArgumentError, "You must supply one of `access_token` or `bearer_token`"
+      end
+
+      if access_token && bearer_token
+        raise ArgumentError, "You cannot supply both `access_token` and `bearer_token`"
+      end
+
+      if expires_in && !bearer_token
+        raise ArgumentError, "`expires_in` can only be used with `bearer_token`. `access_token` have a 1 hour expiration."
+      end
+
+      if access_token
+        expiration = Time.now + Scalingo.config.exchanged_token_validity
+        response = auth.tokens.exchange(access_token)
+
+        if response.successful?
+          self.token = BearerToken.new(
+            response.data[:token],
+            expires_in: expiration,
+          )
+        end
+
+        return response.successful?
+      end
+
+      if bearer_token
+        self.token = expires_in ? BearerToken.new(bearer_token.to_s, expires_in: expires_in) : bearer_token
+      end
+    end
+
+    ## API clients
+    def auth
+      @auth ||= Auth.new(self, Scalingo.config.urls.auth)
+    end
+
+    def region
+      public_send(Scalingo.config.default_region)
+    end
+
+    Scalingo.config.regions.each do |region|
+      if Scalingo.config.urls[region].blank?
+        raise ArgumentError, "Scalingo: no url configured for region #{region}"
+      end
+
+      define_method(region) do
+        region_client = instance_variable_get :"@#{region}"
+
+        unless region_client
+          region_client = Regional.new(self, Scalingo.config.urls[region])
+
+          instance_variable_set :"@#{region}", region_client
+        end
+
+        region_client
+      end
+    end
+
+    ## Delegations
+    def_delegator :auth, :keys
+    def_delegator :auth, :scm_integrations
+    def_delegator :auth, :tokens
+    def_delegator :auth, :two_factor_auth
+    def_delegator :auth, :tfa
+    def_delegator :auth, :user
+
+    def_delegator :region, :addons
+    def_delegator :region, :apps
+    def_delegator :region, :collaborators
+    def_delegator :region, :containers
+    def_delegator :region, :deployments
+    def_delegator :region, :domains
+    def_delegator :region, :environment
+    def_delegator :region, :events
+    def_delegator :region, :logs
+    def_delegator :region, :metrics
+    def_delegator :region, :notifiers
+    def_delegator :region, :operations
+    def_delegator :region, :scm_repo_links
+  end
+end