uploadcare-ruby 2.1.1 → 3.1.0.pre.rc1

data/lib/uploadcare/client/multipart_upload_client.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'client/multipart_upload/chunks_client'
+require_relative 'upload_client'
+
+module Uploadcare
+  module Client
+    # Client for multipart uploads
+    #
+    # @see https://uploadcare.com/api-refs/upload-api/#tag/Upload
+    class MultipartUploaderClient < UploadClient
+      include MultipartUpload
+
+      # Upload a big file by splitting it into parts and sending those parts into assigned buckets
+      # object should be File
+      def upload(object, store: false)
+        response = upload_start(object, store: store)
+        return response unless response.success[:parts] && response.success[:uuid]
+
+        links = response.success[:parts]
+        uuid = response.success[:uuid]
+        ChunksClient.new.upload_chunks(object, links)
+        upload_complete(uuid)
+      end
+
+      # Asks Uploadcare server to create a number of storage bin for uploads
+      def upload_start(object, store: false)
+        body = HTTP::FormData::Multipart.new(
+          Param::Upload::UploadParamsGenerator.call(store).merge(multiupload_metadata(object))
+        )
+        post(path: 'multipart/start/',
+             headers: { 'Content-type': body.content_type },
+             body: body)
+      end
+
+      # When every chunk is uploaded, ask Uploadcare server to finish the upload
+      def upload_complete(uuid)
+        body = HTTP::FormData::Multipart.new(
+          {
+            'UPLOADCARE_PUB_KEY': Uploadcare.config.public_key,
+            'uuid': uuid
+          }
+        )
+        post(path: 'multipart/complete/', body: body, headers: { 'Content-type': body.content_type })
+      end
+
+      private
+
+      def multiupload_metadata(file)
+        filename = file.original_filename if file.respond_to?(:original_filename)
+        mime_type = file.content_type if file.respond_to?(:content_type)
+        options = { filename: filename, content_type: mime_type }.compact
+        file = HTTP::FormData::File.new(file, options)
+        {
+          filename: file.filename,
+          size: file.size,
+          content_type: file.content_type
+        }
+      end
+
+      alias api_struct_post post
+      def post(**args)
+        handle_throttling { api_struct_post(**args) }
+      end
+    end
+  end
+end

data/lib/uploadcare/client/project_client.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Uploadcare
+  module Client
+    # API client for getting project info
+    # @see https://uploadcare.com/docs/api_reference/rest/handling_projects/
+    class ProjectClient < RestClient
+      # get information about current project
+      # current project is determined by public and private key combination
+      # @see https://uploadcare.com/api-refs/rest-api/v0.5.0/#tag/Project
+      def show
+        get(uri: '/project/')
+      end
+
+      alias project show
+    end
+  end
+end

data/lib/uploadcare/client/rest_client.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative 'rest_client'
+require 'api_struct'
+require 'uploadcare/concern/error_handler'
+require 'uploadcare/concern/throttle_handler'
+require 'param/authentication_header'
+
+module Uploadcare
+  module Client
+    # @abstract
+    # General client for signed REST requests
+    class RestClient < ApiStruct::Client
+      include Uploadcare::Concerns::ErrorHandler
+      include Uploadcare::Concerns::ThrottleHandler
+      include Exception
+
+      alias api_struct_delete delete
+      alias api_struct_get get
+      alias api_struct_post post
+      alias api_struct_put put
+
+      # Send request with authentication header
+      #
+      # Handle throttling as well
+      def request(uri:, method: 'GET', **options)
+        request_headers = Param::AuthenticationHeader.call(method: method.upcase, uri: uri,
+                                                           content_type: headers[:'Content-type'], **options)
+        handle_throttling do
+          send("api_struct_#{method.downcase}", path: remove_trailing_slash(uri),
+                                                headers: request_headers, body: options[:content])
+        end
+      end
+
+      def get(**options)
+        request(method: 'GET', **options)
+      end
+
+      def post(**options)
+        request(method: 'POST', **options)
+      end
+
+      def put(**options)
+        request(method: 'PUT', **options)
+      end
+
+      def delete(**options)
+        request(method: 'DELETE', **options)
+      end
+
+      def api_root
+        Uploadcare.config.rest_api_root
+      end
+
+      def headers
+        {
+          'Content-type': 'application/json',
+          'Accept': 'application/vnd.uploadcare-v0.5+json',
+          'User-Agent': Uploadcare::Param::UserAgent.call
+        }
+      end
+
+      private
+
+      def remove_trailing_slash(str)
+        str.gsub(%r{^/}, '')
+      end
+
+      def default_params
+        {}
+      end
+    end
+  end
+end

data/lib/uploadcare/client/rest_group_client.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'rest_client'
+
+module Uploadcare
+  module Client
+    # @see https://uploadcare.com/api-refs/rest-api/v0.5.0/#tag/Group/paths/~1groups~1%3Cuuid%3E~1storage~1/put
+    class RestGroupClient < RestClient
+      # store all files in a group
+      # @see https://uploadcare.com/api-refs/rest-api/v0.5.0/#tag/Group/paths/~1groups~1%3Cuuid%3E~1storage~1/put
+      def store(uuid)
+        put(uri: "/groups/#{uuid}/storage/")
+      end
+
+      # return paginated list of groups
+      # @see https://uploadcare.com/api-refs/rest-api/v0.5.0/#operation/groupsList
+      def list(options = {})
+        query = options.empty? ? '' : "?#{URI.encode_www_form(options)}"
+        get(uri: "/groups/#{query}")
+      end
+    end
+  end
+end

data/lib/uploadcare/client/upload_client.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'api_struct'
+require 'param/user_agent'
+require 'uploadcare/concern/error_handler'
+require 'uploadcare/concern/throttle_handler'
+
+module Uploadcare
+  module Client
+    # @abstract
+    #
+    # Headers and helper methods for clients working with upload API
+    # @see https://uploadcare.com/docs/api_reference/upload/
+    class UploadClient < ApiStruct::Client
+      include Concerns::ErrorHandler
+      include Concerns::ThrottleHandler
+      include Exception
+
+      def api_root
+        Uploadcare.config.upload_api_root
+      end
+
+      def headers
+        {
+          'User-Agent': Uploadcare::Param::UserAgent.call
+        }
+      end
+
+      private
+
+      def default_params
+        {}
+      end
+    end
+  end
+end

data/lib/uploadcare/client/uploader_client.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative 'upload_client'
+require 'retries'
+require 'param/upload/upload_params_generator'
+
+module Uploadcare
+  module Client
+    # This is client for general uploads
+    #
+    # @see https://uploadcare.com/api-refs/upload-api/#tag/Upload
+    class UploaderClient < UploadClient
+      # @see https://uploadcare.com/api-refs/upload-api/#operation/baseUpload
+
+      def upload_many(arr, **options)
+        body = upload_many_body(arr, **options)
+        post(path: 'base/',
+             headers: { 'Content-type': body.content_type },
+             body: body)
+      end
+
+      # syntactic sugar for upload_many
+      # There is actual upload method for one file, but it is redundant
+
+      def upload(file, **options)
+        upload_many([file], **options)
+      end
+
+      # Upload files from url
+      # @see https://uploadcare.com/api-refs/upload-api/#operation/fromURLUpload
+      # options:
+      # - check_URL_duplicates
+      # - filename
+      # - save_URL_duplicates
+      # - async - returns upload token instead of upload data
+      def upload_from_url(url, **options)
+        body = upload_from_url_body(url, **options)
+        token_response = post(path: 'from_url/', headers: { 'Content-type': body.content_type }, body: body)
+        return token_response if options[:async]
+
+        uploaded_response = poll_upload_response(token_response.success[:token])
+        return uploaded_response if uploaded_response.success[:status] == 'error'
+
+        Dry::Monads::Success(files: [uploaded_response.success])
+      end
+
+      private
+
+      alias api_struct_post post
+      def post(**args)
+        handle_throttling { api_struct_post(**args) }
+      end
+
+      def poll_upload_response(token)
+        with_retries(max_tries: Uploadcare.config.max_request_tries,
+                     base_sleep_seconds: Uploadcare.config.base_request_sleep,
+                     max_sleep_seconds: Uploadcare.config.max_request_sleep) do
+          response = get_status_response(token)
+          raise RequestError if %w[progress waiting unknown].include?(response.success[:status])
+
+          response
+        end
+      end
+
+      # Check upload status
+      #
+      # @see https://uploadcare.com/api-refs/upload-api/#operation/fromURLUploadStatus
+      def get_status_response(token)
+        query_params = { token: token }
+        get(path: 'from_url/status/', params: query_params)
+      end
+
+      # Prepares body for upload_many method
+      def upload_many_body(arr, **options)
+        files_formdata = arr.map do |file|
+          [HTTP::FormData::File.new(file).filename,
+           form_data_for(file)]
+        end.to_h
+        p Param::Upload::UploadParamsGenerator.call(options[:store]).merge(files_formdata)
+        HTTP::FormData::Multipart.new(
+          Param::Upload::UploadParamsGenerator.call(options[:store]).merge(files_formdata)
+        )
+      end
+
+      def form_data_for(file)
+        filename = file.original_filename if file.respond_to?(:original_filename)
+        mime_type = file.content_type if file.respond_to?(:content_type)
+        options = { filename: filename, content_type: mime_type }.compact
+        HTTP::FormData::File.new(file, options)
+      end
+
+      STORE_VALUES = {
+        true => '1',
+        false => '0'
+      }.freeze
+
+      # Prepare upload_from_url initial request body
+      def upload_from_url_body(url, **options)
+        HTTP::FormData::Multipart.new(
+          options.merge(
+            'pub_key' => Uploadcare.config.public_key,
+            'source_url' => url,
+            'store' => STORE_VALUES[options[:store]]
+          )
+        )
+      end
+    end
+  end
+end

data/lib/uploadcare/client/webhook_client.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'rest_client'
+
+module Uploadcare
+  module Client
+    # client for webhook management
+    # @see https://uploadcare.com/api-refs/rest-api/v0.5.0/#tag/Webhook
+    class WebhookClient < RestClient
+      # Create webhook
+      # @see https://uploadcare.com/docs/api_reference/rest/webhooks/#subscribe
+      def create(options = {})
+        body = {
+          'target_url': options[:target_url],
+          'event': options[:event] || 'file.uploaded',
+          'is_active': options[:is_active] || true
+        }.to_json
+        post(uri: '/webhooks/', content: body)
+      end
+
+      # Returns array (not paginated list) of webhooks
+      # @see https://uploadcare.com/docs/api_reference/rest/webhooks/#get-list
+      def list
+        get(uri: '/webhooks/')
+      end
+
+      # Permanently deletes subscription
+      # @see https://uploadcare.com/docs/api_reference/rest/webhooks/#unsubscribe
+      def delete(target_url)
+        body = { 'target_url': target_url }.to_json
+        post(uri: '/webhooks/unsubscribe/', content: body)
+      end
+
+      # Updates webhook
+      # @see https://uploadcare.com/docs/api_reference/rest/webhooks/#subscribe-update
+      def update(id, options = {})
+        body = options.to_json
+        post(uri: "/webhooks/#{id}/", content: body)
+      end
+
+      alias create_webhook create
+      alias list_webhooks list
+      alias delete_webhook delete
+      alias update_webhook update
+    end
+  end
+end

data/lib/uploadcare/concern/error_handler.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Uploadcare
+  module Concerns
+    # Wrapper for responses
+    # raises errors instead of returning monads
+    module ErrorHandler
+      include Exception
+
+      # Extension of ApiStruct's failure method
+      #
+      # Raises errors instead of returning falsey objects
+      # @see https://github.com/rubygarage/api_struct/blob/master/lib/api_struct/client.rb#L55
+      def failure(response)
+        catch_upload_errors(response)
+        parsed_response = JSON.parse(response.body.to_s)
+        raise RequestError, parsed_response['detail'] || parsed_response.map { |k, v| "#{k}: #{v}" }.join('; ')
+      rescue JSON::ParserError
+        raise RequestError, response.body.to_s
+      end
+
+      # Extension of ApiStruct's wrap method
+      #
+      # Catches throttling errors and Upload API errors
+      #
+      # @see https://github.com/rubygarage/api_struct/blob/master/lib/api_struct/client.rb#L45
+      def wrap(response)
+        raise_throttling_error(response) if response.status == 429
+        return failure(response) if response.status >= 300
+
+        catch_upload_errors(response)
+        success(response)
+      end
+
+      private
+
+      # Raise ThrottleError. Also, tells in error when server will be ready for next request
+      def raise_throttling_error(response)
+        retry_after = response.headers['Retry-After'].to_i + 1 || 11
+        raise ThrottleError.new(retry_after), "Response throttled, retry #{retry_after} seconds later"
+      end
+
+      # Upload API returns its errors with code 200, and stores its actual code and details within response message
+      # This methods detects that and raises apropriate error
+      def catch_upload_errors(response)
+        return unless response.code == 200
+
+        parsed_response = JSON.parse(response.body.to_s)
+        error = parsed_response['error'] if parsed_response.is_a?(Hash)
+        raise RequestError, error if error
+      end
+    end
+  end
+end

data/lib/uploadcare/concern/throttle_handler.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Uploadcare
+  module Concerns
+    # This module lets clients send request multiple times if request is throttled
+    module ThrottleHandler
+      # call given block. If ThrottleError is returned, it will wait and attempt again 4 more times
+      # @yield executable block (HTTP request that may be throttled)
+      def handle_throttling
+        (Uploadcare.config.max_throttle_attempts - 1).times do
+          # rubocop:disable Style/RedundantBegin
+          begin
+            return yield
+          rescue(Exception::ThrottleError) => e
+            wait_time = e.timeout
+            sleep(wait_time)
+            next
+          end
+          # rubocop:enable Style/RedundantBegin
+        end
+        yield
+      end
+    end
+  end
+end