scalingo 3.5.0 → 4.0.beta1

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

data/lib/scalingo/regional/environment.rb

@@ -2,82 +2,11 @@ require "scalingo/api/endpoint"
 
 module Scalingo
   class Regional::Environment < API::Endpoint
-    def for(app_id, headers = nil, &block)
-      data = nil
-
-      response = connection.get(
-        "apps/#{app_id}/variables",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:variables) { response }
-    end
-
-    def create(app_id, payload = {}, headers = nil, &block)
-      data = {variable: payload}
-
-      response = connection.post(
-        "apps/#{app_id}/variables",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:variable) { response }
-    end
-
-    def update(app_id, variable_id, value, headers = nil, &block)
-      data = {variable: {value: value}}
-
-      response = connection.patch(
-        "apps/#{app_id}/variables/#{variable_id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:variable) { response }
-    end
-
-    def destroy(app_id, variable_id, headers = nil, &block)
-      data = nil
-
-      response = connection.delete(
-        "apps/#{app_id}/variables/#{variable_id}",
-        data,
-        headers,
-        &block
-      )
-
-      unpack { response }
-    end
-
-    def bulk_update(app_id, variables, headers = nil, &block)
-      data = {variables: variables}
-
-      response = connection.put(
-        "apps/#{app_id}/variables",
-        data,
-        headers,
-        &block
-      )
-
-      unpack(:variables) { response }
-    end
-
-    def bulk_destroy(app_id, variable_ids, headers = nil, &block)
-      data = {variable_ids: variable_ids}
-
-      response = connection.delete(
-        "apps/#{app_id}/variables",
-        data,
-        headers,
-        &block
-      )
-
-      unpack { response }
-    end
+    get :list, "apps/{app_id}/variables"
+    post :create, "apps/{app_id}/variables", root_key: :variable
+    put :update, "apps/{app_id}/variables/{id}", root_key: :variable
+    delete :delete, "apps/{app_id}/variables/{id}"
+    put :bulk_update, "apps/{app_id}/variables", root_key: :variables
+    delete :bulk_destroy, "apps/{app_id}/variables", root_key: :variable_ids, params_as_body: true
   end
 end