imagekitio 3.0.0 → 4.0.0

data/lib/imagekitio/api_service/file.rb

@@ -1,221 +0,0 @@
-# frozen_string_literal: true
-require_relative '../constant'
-require_relative '../utils/option_validator'
-require 'net/http/post/multipart'
-
-module ImageKitIo
-  module ApiService
-    class File
-      include Utils::OptionValidator
-      include Constantable
-
-      # This File class holds file related operations like
-      # upload, list etc
-      def initialize(req_obj)
-        @req_obj = req_obj
-      end
-
-      # uploads files with required arguments, supports bot url and binary
-      # Options types:
-      #  - `extensions` should be array of hash
-      #     eg: option['extension'] = [
-      #           { 'name' => 'remove-bg', 'options' => { 'add_shadow' => 'true' } },
-      #           { 'name' => 'google-auto-tagging', 'minConfidence' => 80 }
-      #         ]
-      #  - `custom_metadata` should be hash
-      #     eg: option['custom_metadata'] = {
-      #            "SKU": "VS882HJ2JD",
-      #            "price": 599.99,
-      #            "brand": "H&M",
-      #            "discount": 30
-      #         }
-      def upload(file: nil, file_name: nil, **options)
-        raise ArgumentError, constants.MISSING_UPLOAD_FILE_PARAMETER unless file
-        raise ArgumentError, constants.MISSING_UPLOAD_FILE_PARAMETER unless file_name
-
-        content_type = options.delete(:content_type) || ''
-        options = format_to_json(options, :extensions, Array)
-        options = format_to_json(options, :custom_metadata, Hash)
-        options = format_to_json(options, :transformation, Hash)
-        options = validate_upload_options(options || {})
-        if options.is_a?(FalseClass)
-          raise ArgumentError, "Invalid Upload option"
-        else
-          headers = @req_obj.create_headers
-          payload =  {
-            multipart: true,
-            file: file.is_a?(String) ? file : ::UploadIO.new(file, content_type, file_name),
-            fileName: file_name
-          }
-          payload.merge!(options)
-          url = "#{constants.BASE_URL}#{constants.UPLOAD}"
-          @req_obj.request("post", url, headers, payload)
-        end
-      end
-
-      def update_details(file_id: nil, **options)
-        unless options.fetch(:tags, []).is_a?(Array)
-          raise ArgumentError, constants.UPDATE_DATA_TAGS_INVALID
-        end
-        unless options.fetch(:custom_coordinates, "").is_a?(String)
-          raise ArgumentError, constants.UPDATE_DATA_COORDS_INVALID
-        end
-        url = "#{constants.BASE_URL}/#{file_id}/details/"
-        headers = @req_obj.create_headers
-        payload = request_formatter(options || {})
-        @req_obj.request("patch", url, headers, payload.to_json)
-      end
-
-      def list(**options)
-        #  returns list of files on ImageKitIo Server
-        #  :options dictionary of options
-        formatted_options = request_formatter(options || {})
-        raise KeyError(constants.LIST_FILES_INPUT_MISSING) unless formatted_options.is_a?(Hash)
-        url = constants.BASE_URL
-        headers = @req_obj.create_headers.update({params: formatted_options})
-        @req_obj.request("get", url, headers, formatted_options)
-      end
-
-      def get_file_versions(file_id: nil)
-        if file_id == '' || file_id.nil?
-          raise ArgumentError, 'file_id is required'
-        end
-        url = "#{constants.BASE_URL}/#{file_id}/versions"
-        headers = @req_obj.create_headers
-        @req_obj.request('get', url, headers)
-      end
-
-      def get_file_version_detail(file_id: nil, version_id: nil)
-        if file_id == "" || file_id.nil?
-          raise ArgumentError, "file_id is required"
-        end
-        if version_id == "" || version_id.nil?
-          raise ArgumentError, "version_id is required"
-        end
-        url = "#{constants.BASE_URL}/#{file_id}/versions/#{version_id}"
-        headers = @req_obj.create_headers
-        @req_obj.request('get', url, headers)
-      end
-
-      def delete_file_version(file_id: nil, version_id: nil)
-        if file_id == "" || file_id.nil?
-          raise ArgumentError, "file_id is required"
-        end
-        if version_id == "" || version_id.nil?
-          raise ArgumentError, "version_id is required"
-        end
-        url = "#{constants.BASE_URL}/#{file_id}/versions/#{version_id}"
-        headers = @req_obj.create_headers
-        @req_obj.request('delete', url, headers)
-      end
-
-      def restore_file_version(file_id: nil, version_id: nil)
-        if file_id == "" || file_id.nil?
-          raise ArgumentError, "file_id is required"
-        end
-        if version_id == "" || version_id.nil?
-          raise ArgumentError, "version_id is required"
-        end
-        url = "#{constants.BASE_URL}/#{file_id}/versions/#{version_id}/restore"
-        headers = @req_obj.create_headers
-        @req_obj.request('put', url, headers)
-      end
-
-      def details(file_identifier: nil)
-        # Get detail of file by file_identifier
-        if file_identifier == "" || file_identifier.nil?
-          raise ArgumentError, "file_identifier is required"
-        end
-        url = "#{constants.BASE_URL}/#{file_identifier}/details/"
-        headers = @req_obj.create_headers
-        @req_obj.request("get", url, headers)
-      end
-
-      def get_metadata(file_id: nil)
-        # Get metadata of a file by file_id
-        if file_id == "" || file_id.nil?
-          raise ArgumentError, "file_id is required"
-        end
-        url = "#{constants.BASE_URL}/#{file_id}/metadata"
-        @req_obj.request("get", url, @req_obj.create_headers)
-      end
-
-      def delete(file_id: nil)
-        # Delete a file_id by file_id
-        if file_id == "" || file_id.nil?
-          raise ArgumentError, "file_id is required"
-        end
-        url = "#{constants.BASE_URL}/#{file_id}"
-        headers = @req_obj.create_headers
-        @req_obj.request("delete", url, headers)
-      end
-
-      def purge_cache(file_url: nil)
-        # purges cache from server by file_url
-        if file_url == "" || file_url.nil?
-          raise ArgumentError, "file_url is required"
-        end
-        url = "#{constants.BASE_URL}/purge"
-        payload = {'url': file_url}
-        @req_obj.request("post", url, @req_obj.create_headers, payload)
-      end
-
-      def purge_cache_status(request_id: nil)
-        # This function is to get cache_status
-        if request_id == "" || request_id.nil?
-          raise ArgumentError, "remote_file_url is required"
-        end
-        url = "#{constants.BASE_URL}/purge/#{request_id}"
-        @req_obj.request("get", url, @req_obj.create_headers)
-      end
-
-      def get_metadata_from_remote_url(remote_file_url: nil)
-        if remote_file_url == "" || remote_file_url.nil?
-          raise ArgumentError, "remote_file_url is required"
-        end
-        url = "#{constants.REMOTE_METADATA_FULL_URL}?url=#{remote_file_url}"
-        @req_obj.request("get", url, @req_obj.create_headers)
-      end
-
-      def stream_file(remote_file_url: nil, &block)
-        if remote_file_url == '' || remote_file_url.nil?
-          raise ArgumentError, 'remote_file_url is required'
-        end
-        @req_obj.request_stream('get', remote_file_url, headers: @req_obj.create_headers, &block)
-      end
-
-      def copy(source_file_path: nil, destination_path: nil, include_file_versions: false)
-        if source_file_path == '' || source_file_path.nil? || destination_path == '' || destination_path.nil?
-          raise ArgumentError, 'parameters required'
-        end
-        url = "#{constants.BASE_URL}/copy"
-        payload = { 'sourceFilePath': source_file_path, 'destinationPath': destination_path, 'includeFileVersions': include_file_versions }.to_json
-        @req_obj.request('post', url, @req_obj.create_headers, payload)
-      end
-
-      def move(source_file_path: nil, destination_path: nil)
-        if source_file_path == '' || source_file_path.nil? || destination_path == '' || destination_path.nil?
-          raise ArgumentError, 'parameters required'
-        end
-        url = "#{constants.BASE_URL}/move"
-        payload = { 'sourceFilePath': source_file_path, 'destinationPath': destination_path }
-        @req_obj.request('post', url, @req_obj.create_headers, payload)
-      end
-
-      def rename(file_path: nil, new_file_name: nil, **options)
-        if file_path == '' || file_path.nil? || new_file_name == '' || new_file_name.nil?
-          raise ArgumentError, 'parameters required'
-        end
-        url = "#{constants.BASE_URL}/rename"
-        payload = { 'filePath': file_path, 'newFileName': new_file_name }.merge(request_formatter(options)).to_json
-        @req_obj.request('put', url, @req_obj.create_headers, payload)
-      end
-
-
-      private
-      def image_format?(type)
-        %(image/jpeg image/bmp image/apng image/avif image/gif image/ief image/svg+xml image/tiff image/x-icon image/rgb image/webp).include?(type)
-      end
-    end
-  end
-end

data/lib/imagekitio/api_service/folder.rb

@@ -1,49 +0,0 @@
-require_relative '../constant'
-
-module ImageKitIo
-  module ApiService
-    class Folder
-      include Constantable
-
-      def initialize(req_obj)
-        @req_obj = req_obj
-      end
-
-      def create(folder_name: nil, parent_folder_path: nil)
-        if folder_name == '' || folder_name.nil?
-          raise ArgumentError, 'folder_name is required'
-        end
-        url = "#{constants.API_BASE_URL}/folder"
-        payload = { 'folderName': folder_name, 'parentFolderPath': parent_folder_path }.to_json
-        @req_obj.request('post', url, @req_obj.create_headers, payload)
-      end
-
-    def delete(folder_path: nil)
-        if folder_path == '' || folder_path.nil?
-          raise ArgumentError, 'folder_path is required'
-        end
-        url = "#{constants.API_BASE_URL}/folder"
-        payload = { 'folderPath': folder_path }
-        @req_obj.request('delete', url, @req_obj.create_headers, payload)
-      end
-
-      def copy(source_folder_path: nil, destination_path: nil, include_file_versions: false)
-        if source_folder_path == '' || source_folder_path.nil? || destination_path == '' || destination_path.nil?
-          raise ArgumentError, 'Parameters required'
-        end
-        url = "#{constants.BULK_BASE_URL}/copyFolder"
-        payload = { 'sourceFolderPath': source_folder_path, 'destinationPath': destination_path, 'includeFileVersions': include_file_versions }.to_json
-        @req_obj.request('post', url, @req_obj.create_headers, payload)
-      end
-
-      def move(source_folder_path: nil, destination_path: nil)
-        if source_folder_path == '' || source_folder_path.nil? || destination_path == '' || destination_path.nil?
-          raise ArgumentError, 'Parameters required'
-        end
-        url = "#{constants.BULK_BASE_URL}/moveFolder"
-        payload = { 'sourceFolderPath': source_folder_path, 'destinationPath': destination_path }
-        @req_obj.request('post', url, @req_obj.create_headers, payload)
-      end
-    end
-  end
-end

data/lib/imagekitio/base.rb

@@ -1,12 +0,0 @@
-require_relative './configurable'
-
-module ImageKitIo
-  include ImageKitIo::Configurable
-
-  class << self
-    def client
-      ik_config = config
-      @client ||= ImageKitIo::Client.new(ik_config.private_key, ik_config.public_key, ik_config.url_endpoint)
-    end
-  end
-end

data/lib/imagekitio/configurable.rb

@@ -1,43 +0,0 @@
-module ImageKitIo
-  module Configurable
-    def self.included(klass)
-      klass.extend ClassMethods
-    end
-
-    module ClassMethods
-      def config
-        @config ||= Configuration.new
-      end
-
-      def configure
-        yield config
-        initialize_service
-      end
-
-      def initialize_service
-        if config.service == :carrierwave
-          require_relative '../carrierwave/carrierwave'
-        elsif config.service == :active_storage
-          require_relative '../active_storage/active_storage'
-        end
-      end
-
-      def constants
-        config.constants
-      end
-    end
-
-    class Configuration
-      AVAILABLE_SERVICE = [:carrierwave, :active_storage]
-      attr_accessor :public_key, :private_key, :url_endpoint, :service
-
-      def service
-        @service&.to_sym || :carrierwave
-      end
-
-      def constants
-        @constants ||= ImageKitIo::Constant
-      end
-    end
-  end
-end

data/lib/imagekitio/constant.rb

@@ -1,36 +0,0 @@
-require_relative './constants/default'
-require_relative './constants/error'
-require_relative './constants/file'
-require_relative './constants/supported_transformation'
-require_relative './constants/url'
-require_relative './configurable'
-
-module ImageKitIo
-  module Constantable
-    def self.included(base)
-      def constants
-        ImageKitIo.constants
-      end
-    end
-  end
-  class Constant
-    include Constants::Default
-    include Constants::Error
-    include Constants::File
-    include Constants::SupportedTransformation
-    include Constants::URL
-
-    class << self
-      def method_missing(symbol, *args)
-        method_name = symbol.to_s.gsub('=', '')
-        if self.const_defined? method_name
-          return self.const_get(method_name) if args.empty?
-
-          self.const_set(method_name, args.first)
-        else
-          super
-        end
-      end
-    end
-  end
-end

data/lib/imagekitio/constants/default.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-# Enum for defaults
-module ImageKitIo
-  module Constants
-    module Default
-      TRANSFORMATION_POSITION = "path"
-      QUERY_TRANSFORMATION_POSITION = "query"
-      VALID_TRANSFORMATION_POSITION = [TRANSFORMATION_POSITION,
-                                       QUERY_TRANSFORMATION_POSITION,].freeze
-      DEFAULT_TIMESTAMP = "9999999999"
-      TRANSFORMATION_PARAMETER = "tr"
-      CHAIN_TRANSFORM_DELIMITER = ":"
-      TRANSFORM_DELIMITER = ","
-      TRANSFORM_KEY_VALUE_DELIMITER = "-"
-
-      SIGNATURE_PARAMETER = "ik-s"
-      TIMESTAMP_PARAMETER = "ik-t"
-      TIMESTAMP = "9999999999"
-    end
-  end
-end

data/lib/imagekitio/constants/error.rb

@@ -1,69 +0,0 @@
-module ImageKitIo
-  module Constants
-    module Error
-      MANDATORY_INIT_MISSING = {
-        'message': "Missing public_key or private_key or url_endpoint during ImageKitIo initialization",
-        help: "",
-      }
-      INVALID_TRANSFORMATION_POS = {'message': "Invalid transformationPosition parameter",
-                                    help: "",}
-      INVALID_URL_GENERATION_PARAM = {'message': "Invalid url parameter", help: ""}
-      INVALID_TRANSFORMATION_OPTIONS = {
-        'message': "Invalid transformation parameter options",
-        help: "",
-      }
-      CACHE_PURGE_URL_MISSING = {'message': "Missing URL parameter for this request",
-                                 help: "",}
-      CACHE_PURGE_STATUS_ID_MISSING = {'message': "Missing Request ID parameter for this request",
-                                       help: "",}
-      FILE_ID_MISSING = {'message': "Missing File ID parameter for this request",
-                         help: "",}
-      UPDATE_DATA_MISSING = {'message': "Missing file update data for this request",
-                             help: "",}
-
-      UPDATE_DATA_TAGS_INVALID = {'message': "Invalid tags parameter for this request",
-                                  help: "tags should be passed as null or an array like ['tag1', 'tag2']",}.freeze
-
-      UPDATE_DATA_COORDS_INVALID =
-        {'message': "Invalid custom_coordinates parameter for this request",
-         help: "custom_coordinates should be passed as null or a string like 'x,y,width,height'",}
-
-      LIST_FILES_INPUT_MISSING = {
-        'message': "Missing options for list files",
-        help: "If you do not want to pass any parameter for listing, pass an empty object",
-      }
-      MISSING_FILE_URL = {'message': "Missing file_url for purge_cache", help: ""}
-      MISSING_UPLOAD_DATA = {'message': "Missing data for upload", help: ""}
-      MISSING_UPLOAD_FILE_PARAMETER = {
-        'message': "Missing file parameter for upload",
-        help: "",
-      }
-      MISSING_UPLOAD_FILENAME_PARAM = {
-        'message': "Missing fileName parameter for upload",
-        help: "",
-      }
-
-      INVALID_PHASH_VALUE =
-        {
-          'message': "Invalid pHash value",
-          help: "Both pHash strings must be valid hexadecimal numbers",
-        }
-
-      MISSING_PHASH_VALUE = {
-        'message': "Missing pHash value",
-        help: "Please pass two pHash values",
-      }
-      UNEQUAL_STRING_LENGTH = {
-        '': "Unequal pHash string length",
-        help: "For distance calculation, the two pHash strings must have equal length",
-      }
-
-      MISSING_PRIVATE_KEY = "ImageKitIo private key missing"
-
-      MISSING_PUBLIC_KEY = "ImageKitIo public key missing"
-
-      MISSING_URL_ENDPOINT = "ImageKitIo URL Endpoint missing. Default URL Endpoint: https://ik.imagekit.io/<YOUR_IMAGEKIT_ID>/"
-
-    end
-  end
-end

data/lib/imagekitio/constants/file.rb

@@ -1,11 +0,0 @@
-module ImageKitIo
-  module Constants
-    module File
-      VALID_FILE_OPTIONS = %w[path fileType tags includeFolder name limit skip]
-
-      VALID_FILE_DETAIL_OPTIONS = ["fileID"]
-
-      VALID_UPLOAD_OPTIONS = %w[file file_name use_unique_file_name tags folder is_private_file custom_coordinates response_fields extensions webhook_url overwrite_file overwrite_AI_tags overwrite_custom_metadata custom_metadata mime overwrite_tags content_type transformation ]
-    end
-  end
-end

data/lib/imagekitio/constants/supported_transformation.rb

@@ -1,39 +0,0 @@
-module ImageKitIo
-  module Constants
-    module SupportedTransformation
-      SUPPORTED_TRANS = {
-        'height': "h",
-        'width': "w",
-        'aspect_ratio': "ar",
-        'quality': "q",
-        'crop': "c",
-        'crop_mode': "cm",
-        'x': "x",
-        'y': "y",
-        'focus': "fo",
-        'format': "f",
-        'radius': "r",
-        'background': "bg",
-        'border': "b",
-        'rotation': "rt",
-        'blur': "bl",
-        'named': "n",
-        'progressive': "pr",
-        'lossless': "lo",
-        'trim': "t",
-        'metadata': "md",
-        'color_profile': "cp",
-        'default_image': "di",
-        'dpr': "dpr",
-        'effect_sharpen': "e-sharpen",
-        'effect_usm': "e-usm",
-        'effect_contrast': "e-contrast",
-        'effect_gray': "e-grayscale",
-        'effect_shadow': "e-shadow",
-        'effect_gradient': "e-gradient",
-        'original': "orig",
-        'raw': 'raw',
-      }
-    end
-  end
-end

data/lib/imagekitio/constants/url.rb

@@ -1,14 +0,0 @@
-module ImageKitIo
-  module Constants
-    module URL
-      # Default URL Constants
-      BASE_URL = "https://api.imagekit.io/v1/files"
-      PURGE_CACHE = "/purge"
-      BULK_FILE_DELETE = "/batch/deleteByFileIds"
-      UPLOAD = "/upload"
-      REMOTE_METADATA_FULL_URL = "https://api.imagekit.io/v1/metadata"
-      BULK_BASE_URL = 'https://api.imagekit.io/v1/bulkJobs'
-      API_BASE_URL = 'https://api.imagekit.io/v1'
-    end
-  end
-end

data/lib/imagekitio/railtie.rb

@@ -1,4 +0,0 @@
-module ImageKitIo
-  class Railtie < ::Rails::Railtie
-  end
-end

data/lib/imagekitio/request.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-require "base64"
-require "rest-client"
-require "json"
-require 'net/http/post/multipart'
-require_relative './constant'
-# Request requests and sends data from server
-module ImageKitIo
-  class Request
-    include Constantable
-
-    attr_reader :private_key, :public_key, :url_endpoint, :transformation_position, :options
-
-    def initialize(private_key, public_key, url_endpoint, transformation_position = nil, options = nil)
-      @private_key = private_key
-      @public_key = public_key
-      @url_endpoint = url_endpoint
-      @transformation_position = transformation_position || constants.TRANSFORMATION_POSITION
-      @options = options || {}
-    end
-
-    # creates required headers
-    def create_headers
-      headers = {'Accept-Encoding': "application/json", 'Content-Type': "application/json"}
-      headers.update(auth_headers)
-    end
-
-    def auth_headers
-      encoded_private_key = Base64.strict_encode64(@private_key+":")
-      {Authorization: "Basic #{encoded_private_key}"}
-    end
-
-    # request method communicates with server
-    def request(method, url, headers = create_headers, payload = nil)
-      headers ||= create_headers
-      response = {}
-      begin
-        if(method.downcase.to_sym == :post && payload.is_a?(Hash) && payload[:multipart])
-          uri = URI.parse(url)
-          http = Net::HTTP.new(uri.host, uri.port)
-          http.use_ssl = (uri.scheme == 'https')
-          req = Net::HTTP::Post::Multipart.new uri.path, payload, headers
-          resp = http.request(req)
-          response[:headers] = resp.to_hash
-        else
-          resp = RestClient::Request.new(method: method,
-                                         url: url,
-                                         headers: headers,
-                                         payload: payload).execute
-          response[:headers] = resp.raw_headers
-        end
-        response[:raw_body] = resp.body
-        response[:status_code] = resp.code
-        resp_c = resp.code.to_i
-        if [400, 403].include?(resp_c)
-          raise RestClient::ExceptionWithResponse, OpenStruct.new({ body: resp.body, code: resp_c, headers: response[:headers] })
-        end
-        if (resp.code.to_i >= 200) && (resp.code.to_i < 204)
-          content_type = resp.respond_to?(:headers) ? resp.headers[:content_type] : resp.content_type
-          if (content_type.include? "application/json")
-            response[:response] = JSON.parse(resp.body.to_s)
-          else
-            raise RestClient::ExceptionWithResponse, OpenStruct.new(code: 404, body: resp.body)
-          end
-        elsif resp.code.to_i == 204
-          response[:response] = {'success': true}
-        end
-
-      rescue RestClient::ExceptionWithResponse => err
-        response[:status_code] = err.http_code if response[:status_code].nil?
-        response[:headers] = err.http_headers if response[:headers].nil?
-        response[:error] = if err.http_code.to_i == 404
-                             {'message': err.response.to_s}
-                           else
-                             err.response.is_a?(OpenStruct) ? JSON.parse(err.response.body) : JSON.parse(err.response)
-                           end
-      end
-      response
-    end
-
-    def request_stream(method, url, headers: nil, payload: nil, **options, &block)
-      headers ||= create_headers
-      response = { response: nil, error: nil }
-      begin
-        RestClient::Request.execute(method: method,
-                                    url: url,
-                                    headers: headers,
-                                    payload: payload,
-                                    **options,
-                                    block_response: block
-                                    )
-      rescue RestClient::ExceptionWithResponse => err
-        err.http_code == 404 ? response[:error] = {'message': err.response.to_s} : JSON.parse(err.response)
-      end
-    end
-  end
-end

data/lib/imagekitio/sdk/version.rb

@@ -1,5 +0,0 @@
-module ImageKitIo
-  module Sdk
-    VERSION = '3.0.0'
-  end
-end