scalingo 3.4.0 → 4.0.beta1

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

data/lib/scalingo/regional/addons.rb

@@ -2,136 +2,24 @@ require "scalingo/api/endpoint"
 
 module Scalingo
   class Regional::Addons < API::Endpoint
-    def for(app_id, headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "apps/#{app_id}/addons",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:addons) { response }
-    end
-
-    def find(app_id, addon_id, headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "apps/#{app_id}/addons/#{addon_id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:addon) { response }
-    end
-
-    def provision(app_id, payload = {}, headers = nil, &block)
-      data = {addon: payload}
-
-      response = connection.post(
-        "apps/#{app_id}/addons",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:addon) { response }
-    end
-
-    def update(app_id, addon_id, payload = {}, headers = nil, &block)
-      data = {addon: payload}
-
-      response = connection.patch(
-        "apps/#{app_id}/addons/#{addon_id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:addon) { response }
-    end
-
-    def destroy(app_id, addon_id, headers = nil, &block)
-      data = nil
-
-      response = connection.delete(
-        "apps/#{app_id}/addons/#{addon_id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack { response }
-    end
-
-    def sso(app_id, addon_id, headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "apps/#{app_id}/addons/#{addon_id}/sso",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:addon) { response }
-    end
-
-    def authenticate!(app_id, addon_id, headers = nil, &block)
-      response = token(app_id, addon_id, headers, &block)
-      return response unless response.status == 200
-
-      token = response.data[:token]
-      client.token_holder.authenticate_database_with_bearer_token(
-        addon_id,
-        token,
-        expires_at: Time.now + 1.hour,
-        raise_on_expired_token: client.config.raise_on_expired_token,
-      )
-
-      response
-    end
-
-    def token(app_id, addon_id, headers = nil, &block)
-      data = nil
-
-      response = connection.post(
-        "apps/#{app_id}/addons/#{addon_id}/token",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:addon) { response }
-    end
-
-    def categories(headers = nil, &block)
-      data = nil
-
-      response = connection(fallback_to_guest: true).get(
-        "addon_categories",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:addon_categories) { response }
-    end
-
-    def providers(headers = nil, &block)
-      data = nil
-
-      response = connection(fallback_to_guest: true).get(
-        "addon_providers",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:addon_providers) { response }
+    get :list, "apps/{app_id}/addons"
+    get :find, "apps/{app_id}/addons/{id}"
+    post :create, "apps/{app_id}/addons", root_key: :addon
+    put :update, "apps/{app_id}/addons/{id}", root_key: :addon
+    delete :delete, "apps/{app_id}/addons/{id}"
+    get :sso, "apps/{app_id}/addons/{id}/sso"
+    post :token, "apps/{app_id}/addons/{id}/token"
+    get :categories, "addon_categories", connected: false
+    get :providers, "addon_providers", connected: false
+
+    def database_client_for(app_id:, id:)
+      response = token(app_id: app_id, id: id)
+
+      db_url = Scalingo::Client::URLS.fetch(:database).fetch(client.region)
+
+      db_client = Scalingo::Database.new(db_url, region: client.region)
+      db_client.token = response.body.fetch(:token)
+      db_client
     end
   end
 end

data/lib/scalingo/regional/apps.rb

@@ -2,108 +2,15 @@ require "scalingo/api/endpoint"
 
 module Scalingo
   class Regional::Apps < API::Endpoint
-    def all(headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "apps",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:apps) { response }
-    end
-
-    def find(id, headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "apps/#{id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:app) { response }
-    end
-
-    def create(payload = {}, headers = nil, &block)
-      data = {app: payload}
-
-      dry_run = !!(payload[:dry_run] || payload["dry_run"])
-
-      request_headers = {}
-      request_headers["X-Dry-Run"] = "true" if dry_run
-      request_headers.update(headers) if headers
-
-      response = connection.post(
-        "apps",
-        data,
-        request_headers,
-        &block
-      )
-
-      unpack(:app) { response }
-    end
-
-    def update(id, payload = {}, headers = nil, &block)
-      data = {app: payload}
-
-      response = connection.patch(
-        "apps/#{id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:app) { response }
-    end
-
-    def logs_url(id, headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "apps/#{id}/logs",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:logs_url) { response }
-    end
-
-    def destroy(id, payload = {}, headers = nil, &block)
-      response = connection.delete(
-        "apps/#{id}",
-        payload,
-        headers,
-        &block
-      )
-
-      unpack { response }
-    end
-
-    def rename(id, payload = {}, headers = nil, &block)
-      response = connection.post(
-        "apps/#{id}/rename",
-        payload,
-        headers,
-        &block
-      )
-
-      unpack(:app) { response }
-    end
-
-    def transfer(id, payload = {}, headers = nil, &block)
-      response = connection.patch(
-        "apps/#{id}",
-        payload,
-        headers,
-        &block
-      )
-
-      unpack(:app) { response }
-    end
+    get :list, "apps"
+    get :find, "apps/{id}"
+    post :create, "apps", root_key: :app do |req, params|
+      req.headers["X-Dry-Run"] = "true" if params[:dry_run]
+    end
+    put :update, "apps/{id}", root_key: :app
+    delete :delete, "apps/{id}"
+    get :logs_url, "apps/{id}/logs"
+    post :rename, "apps/{id}/rename"
+    put :transfer, "apps/{id}"
   end
 end

data/lib/scalingo/regional/autoscalers.rb

@@ -2,69 +2,10 @@ require "scalingo/api/endpoint"
 
 module Scalingo
   class Regional::Autoscalers < API::Endpoint
-    def for(app_id, headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "apps/#{app_id}/autoscalers",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:autoscalers) { response }
-    end
-
-    def find(app_id, autoscaler_id, headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "apps/#{app_id}/autoscalers/#{autoscaler_id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:autoscaler) { response }
-    end
-
-    def create(app_id, payload = {}, headers = nil, &block)
-      data = {autoscaler: payload}
-
-      response = connection.post(
-        "apps/#{app_id}/autoscalers",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:autoscaler) { response }
-    end
-
-    def update(app_id, autoscaler_id, payload = {}, headers = nil, &block)
-      data = {autoscaler: payload}
-
-      response = connection.patch(
-        "apps/#{app_id}/autoscalers/#{autoscaler_id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:autoscaler) { response }
-    end
-
-    def destroy(app_id, autoscaler_id, headers = nil, &block)
-      data = nil
-
-      response = connection.delete(
-        "apps/#{app_id}/autoscalers/#{autoscaler_id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack { response }
-    end
+    get :list, "apps/{app_id}/autoscalers"
+    get :find, "apps/{app_id}/autoscalers/{id}"
+    post :create, "apps/{app_id}/autoscalers", root_key: :autoscaler
+    put :update, "apps/{app_id}/autoscalers/{id}", root_key: :autoscaler
+    delete :delete, "apps/{app_id}/autoscalers/{id}"
   end
 end

data/lib/scalingo/regional/collaborators.rb

@@ -2,56 +2,9 @@ require "scalingo/api/endpoint"
 
 module Scalingo
   class Regional::Collaborators < API::Endpoint
-    def for(app_id, headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "apps/#{app_id}/collaborators",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:collaborators) { response }
-    end
-
-    def destroy(app_id, collaborator_id, headers = nil, &block)
-      data = nil
-
-      response = connection.delete(
-        "apps/#{app_id}/collaborators/#{collaborator_id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack { response }
-    end
-
-    def invite(app_id, payload = {}, headers = nil, &block)
-      data = {collaborator: payload}
-
-      response = connection.post(
-        "apps/#{app_id}/collaborators",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:collaborator) { response }
-    end
-
-    def accept(token, headers = nil, &block)
-      data = {token: token}
-
-      response = connection.get(
-        "apps/collaboration",
-        data,
-        headers,
-        &block
-      )
-
-      unpack { response }
-    end
+    get :list, "apps/{app_id}/collaborators"
+    post :create, "apps/{app_id}/collaborators", root_key: "collaborator"
+    delete :delete, "apps/{app_id}/collaborators/{id}"
+    get :accept, "apps/collaboration?token={token}"
   end
 end

data/lib/scalingo/regional/containers.rb

@@ -2,56 +2,9 @@ require "scalingo/api/endpoint"
 
 module Scalingo
   class Regional::Containers < API::Endpoint
-    def for(app_id, headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "apps/#{app_id}/containers",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:containers) { response }
-    end
-
-    def scale(app_id, formation, headers = nil, &block)
-      data = {containers: formation}
-
-      response = connection.post(
-        "apps/#{app_id}/scale",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:containers) { response }
-    end
-
-    def restart(app_id, scope = [], headers = nil, &block)
-      data = {scope: scope}
-
-      response = connection.post(
-        "apps/#{app_id}/restart",
-        data,
-        headers,
-        &block
-      )
-
-      unpack { response }
-    end
-
-    def sizes(headers = nil, &block)
-      data = nil
-
-      response = connection(fallback_to_guest: true).get(
-        "features/container_sizes",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:container_sizes) { response }
-    end
+    get :list, "apps/{app_id}/containers"
+    post :scale, "apps/{app_id}/scale", root_key: :containers
+    post :restart, "apps/{app_id}/restart", root_key: :scope
+    get :sizes, "features/container_sizes"
   end
 end

data/lib/scalingo/regional/deployments.rb

@@ -2,43 +2,8 @@ require "scalingo/api/endpoint"
 
 module Scalingo
   class Regional::Deployments < API::Endpoint
-    def for(app_id, payload = {}, headers = nil, &block)
-      data = payload.compact
-
-      response = connection.get(
-        "apps/#{app_id}/deployments",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:deployments) { response }
-    end
-
-    def find(app_id, deployment_id, headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "apps/#{app_id}/deployments/#{deployment_id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:deployment) { response }
-    end
-
-    def logs(app_id, deployment_id, headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "apps/#{app_id}/deployments/#{deployment_id}/output",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:deployment) { response }
-    end
+    get :list, "apps/{app_id}/deployments{?query*}", optional: [:query]
+    get :find, "apps/{app_id}/deployments/{id}"
+    get :logs, "apps/{app_id}/deployments/{id}/output"
   end
 end

data/lib/scalingo/regional/domains.rb

@@ -2,69 +2,10 @@ require "scalingo/api/endpoint"
 
 module Scalingo
   class Regional::Domains < API::Endpoint
-    def for(app_id, headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "apps/#{app_id}/domains",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:domains) { response }
-    end
-
-    def find(app_id, domain_id, headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "apps/#{app_id}/domains/#{domain_id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:domain) { response }
-    end
-
-    def create(app_id, payload = {}, headers = nil, &block)
-      data = {domain: payload}
-
-      response = connection.post(
-        "apps/#{app_id}/domains",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:domain) { response }
-    end
-
-    def update(app_id, domain_id, payload = {}, headers = nil, &block)
-      data = {domain: payload}
-
-      response = connection.patch(
-        "apps/#{app_id}/domains/#{domain_id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:domain) { response }
-    end
-
-    def destroy(app_id, domain_id, headers = nil, &block)
-      data = nil
-
-      response = connection.delete(
-        "apps/#{app_id}/domains/#{domain_id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack { response }
-    end
+    get :list, "apps/{app_id}/domains"
+    get :find, "apps/{app_id}/domains/{id}"
+    post :create, "apps/{app_id}/domains", root_key: :domain
+    put :update, "apps/{app_id}/domains/{id}", root_key: :domain
+    delete :delete, "apps/{app_id}/domains/{id}"
   end
 end