imgwire 0.1.0

data/generated/lib/imgwire-generated/models/validation_error.rb

@@ -0,0 +1,291 @@
+=begin
+#imgwire.dev Backend API development
+
+#No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+The version of the OpenAPI document: 0.1.0
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.14.0
+
+=end
+
+require 'date'
+require 'time'
+
+module ImgwireGenerated
+  class ValidationError
+    attr_accessor :loc
+
+    attr_accessor :msg
+
+    attr_accessor :type
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'loc' => :'loc',
+        :'msg' => :'msg',
+        :'type' => :'type'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'loc' => :'Array<LocationInner>',
+        :'msg' => :'String',
+        :'type' => :'String'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `ImgwireGenerated::ValidationError` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `ImgwireGenerated::ValidationError`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'loc')
+        if (value = attributes[:'loc']).is_a?(Array)
+          self.loc = value
+        end
+      else
+        self.loc = nil
+      end
+
+      if attributes.key?(:'msg')
+        self.msg = attributes[:'msg']
+      else
+        self.msg = nil
+      end
+
+      if attributes.key?(:'type')
+        self.type = attributes[:'type']
+      else
+        self.type = nil
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      if @loc.nil?
+        invalid_properties.push('invalid value for "loc", loc cannot be nil.')
+      end
+
+      if @msg.nil?
+        invalid_properties.push('invalid value for "msg", msg cannot be nil.')
+      end
+
+      if @type.nil?
+        invalid_properties.push('invalid value for "type", type cannot be nil.')
+      end
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      return false if @loc.nil?
+      return false if @msg.nil?
+      return false if @type.nil?
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] loc Value to be assigned
+    def loc=(loc)
+      if loc.nil?
+        fail ArgumentError, 'loc cannot be nil'
+      end
+
+      @loc = loc
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] msg Value to be assigned
+    def msg=(msg)
+      if msg.nil?
+        fail ArgumentError, 'msg cannot be nil'
+      end
+
+      @msg = msg
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] type Value to be assigned
+    def type=(type)
+      if type.nil?
+        fail ArgumentError, 'type cannot be nil'
+      end
+
+      @type = type
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          loc == o.loc &&
+          msg == o.msg &&
+          type == o.type
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [loc, msg, type].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def self._deserialize(type, value)
+      case type.to_sym
+      when :Time
+        Time.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :Boolean
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        # models (e.g. Pet) or oneOf
+        klass = ImgwireGenerated.const_get(type)
+        klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+  end
+
+end

data/generated/lib/imgwire-generated/version.rb

@@ -0,0 +1,15 @@
+=begin
+#imgwire.dev Backend API development
+
+#No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+The version of the OpenAPI document: 0.1.0
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.14.0
+
+=end
+
+module ImgwireGenerated
+  VERSION = '0.1.0'
+end

data/generated/lib/imgwire-generated.rb

@@ -0,0 +1,74 @@
+=begin
+#imgwire.dev Backend API development
+
+#No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+The version of the OpenAPI document: 0.1.0
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.14.0
+
+=end
+
+# Common files
+require 'imgwire-generated/api_client'
+require 'imgwire-generated/api_error'
+require 'imgwire-generated/version'
+require 'imgwire-generated/configuration'
+
+# Models
+require 'imgwire-generated/models/bulk_delete_images_schema'
+require 'imgwire-generated/models/cache_hit_ratio_dataset_point_schema'
+require 'imgwire-generated/models/cors_origin_create_schema'
+require 'imgwire-generated/models/cors_origin_schema'
+require 'imgwire-generated/models/cors_origin_update_schema'
+require 'imgwire-generated/models/custom_domain_certificate_status'
+require 'imgwire-generated/models/custom_domain_create_schema'
+require 'imgwire-generated/models/custom_domain_schema'
+require 'imgwire-generated/models/custom_domain_status'
+require 'imgwire-generated/models/custom_metadata_value'
+require 'imgwire-generated/models/http_validation_error'
+require 'imgwire-generated/models/image_download_job_create_schema'
+require 'imgwire-generated/models/image_download_job_schema'
+require 'imgwire-generated/models/image_download_status'
+require 'imgwire-generated/models/image_schema'
+require 'imgwire-generated/models/image_status'
+require 'imgwire-generated/models/location_inner'
+require 'imgwire-generated/models/metrics_dataset_interval'
+require 'imgwire-generated/models/metrics_datasets_schema'
+require 'imgwire-generated/models/metrics_stat_value_schema'
+require 'imgwire-generated/models/metrics_stats_schema'
+require 'imgwire-generated/models/requests_dataset_point_schema'
+require 'imgwire-generated/models/standard_upload_create_schema'
+require 'imgwire-generated/models/standard_upload_response_schema'
+require 'imgwire-generated/models/storage_bytes_dataset_point_schema'
+require 'imgwire-generated/models/supported_mime_type'
+require 'imgwire-generated/models/transfer_bytes_dataset_point_schema'
+require 'imgwire-generated/models/transformations_dataset_point_schema'
+require 'imgwire-generated/models/upload_token_create_response_schema'
+require 'imgwire-generated/models/uploads_dataset_point_schema'
+require 'imgwire-generated/models/validation_error'
+
+# APIs
+require 'imgwire-generated/api/cors_origins_api'
+require 'imgwire-generated/api/custom_domain_api'
+require 'imgwire-generated/api/images_api'
+require 'imgwire-generated/api/metrics_api'
+
+module ImgwireGenerated
+  class << self
+    # Customize default settings for the SDK using block.
+    #   ImgwireGenerated.configure do |config|
+    #     config.username = "xxx"
+    #     config.password = "xxx"
+    #   end
+    # If no block given, return the default Configuration object.
+    def configure
+      if block_given?
+        yield(Configuration.default)
+      else
+        Configuration.default
+      end
+    end
+  end
+end

data/lib/imgwire/client.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Imgwire
+  class Client
+    attr_reader :api_client, :options, :images, :custom_domain, :cors_origins, :metrics
+
+    def initialize(
+      api_key:,
+      base_url: 'https://api.imgwire.dev',
+      environment_id: nil,
+      timeout: 30,
+      max_retries: 2,
+      backoff_factor: 0.5,
+      upload_http_client: nil
+    )
+      @options = ClientOptions.new(
+        api_key: api_key,
+        base_url: base_url.sub(%r{/\z}, ''),
+        environment_id: environment_id,
+        timeout: timeout,
+        max_retries: max_retries,
+        backoff_factor: backoff_factor,
+        upload_http_client: upload_http_client || HTTP::UploadClient.new
+      )
+
+      configuration = ImgwireGenerated::Configuration.new
+      apply_base_url(configuration, @options.base_url)
+      configuration.timeout = @options.timeout
+
+      @api_client = ImgwireGenerated::ApiClient.new(configuration)
+      @api_client.default_headers['Authorization'] = "Bearer #{api_key}"
+      @api_client.default_headers['User-Agent'] = "imgwire-ruby/#{Imgwire::VERSION}"
+      @api_client.default_headers['X-Environment-Id'] = environment_id if environment_id
+
+      @images = Resources::ImagesResource.new(@api_client, @options)
+      @custom_domain = Resources::CustomDomainResource.new(@api_client)
+      @cors_origins = Resources::CorsOriginsResource.new(@api_client)
+      @metrics = Resources::MetricsResource.new(@api_client)
+    end
+
+    private
+
+    def apply_base_url(configuration, base_url)
+      uri = URI.parse(base_url)
+      configuration.scheme = uri.scheme
+      configuration.host = uri.host.to_s
+      configuration.base_path = uri.path
+    end
+  end
+end

data/lib/imgwire/client_options.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Imgwire
+  ClientOptions = Struct.new(
+    :api_key,
+    :base_url,
+    :environment_id,
+    :timeout,
+    :max_retries,
+    :backoff_factor,
+    :upload_http_client,
+    keyword_init: true
+  )
+end

data/lib/imgwire/http/upload_client.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+
+module Imgwire
+  module HTTP
+    class UploadClient
+      RETRYABLE_ERRORS = [
+        Errno::ECONNRESET,
+        Errno::ETIMEDOUT,
+        IOError,
+        Net::OpenTimeout,
+        Net::ReadTimeout
+      ].freeze
+
+      def put(url, upload, timeout:, max_retries:, backoff_factor:)
+        uri = URI.parse(url)
+        attempts = 0
+
+        begin
+          attempts += 1
+          upload.rewind if upload.respond_to?(:rewind)
+
+          request = Net::HTTP::Put.new(uri)
+          request['Content-Length'] = upload.content_length.to_s
+          request['Content-Type'] = upload.mime_type if upload.mime_type
+          request.body_stream = upload.io
+          request.content_length = upload.content_length
+
+          Net::HTTP.start(
+            uri.host,
+            uri.port,
+            use_ssl: uri.scheme == 'https',
+            open_timeout: timeout,
+            read_timeout: timeout,
+            write_timeout: timeout
+          ) do |http|
+            response = http.request(request)
+            return response if response.is_a?(Net::HTTPSuccess)
+
+            raise "Upload failed with status #{response.code}: #{response.body}"
+          end
+        rescue *RETRYABLE_ERRORS => e
+          raise e if attempts > max_retries + 1
+
+          sleep(backoff_factor * (2**(attempts - 1)))
+          retry
+        end
+      end
+    end
+  end
+end

data/lib/imgwire/image.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Imgwire
+  class Image < ImgwireGenerated::ImageSchema
+    PRESETS = %w[thumbnail small medium large].freeze
+    ROTATE_ANGLES = [0, 90, 180, 270, 360].freeze
+    FORMATS = %w[jpg png avif gif webp].freeze
+
+    RULES = {
+      'background' => %w[background bg],
+      'crop' => %w[crop],
+      'enlarge' => %w[enlarge],
+      'format' => %w[format fm],
+      'gravity' => %w[gravity],
+      'height' => %w[height h],
+      'quality' => %w[quality q],
+      'rotate' => %w[rotate rot],
+      'strip_metadata' => %w[strip_metadata strip],
+      'width' => %w[width w]
+    }.freeze
+
+    def self.wrap(value)
+      return value if value.is_a?(self)
+
+      if value.is_a?(ImgwireGenerated::ImageSchema)
+        attributes = ImgwireGenerated::ImageSchema.attribute_map.keys.to_h do |attribute|
+          [attribute, value.public_send(attribute)]
+        end
+        return new(attributes)
+      end
+      return build_from_hash(value.to_hash) if value.respond_to?(:to_hash)
+
+      build_from_hash(value)
+    end
+
+    def url(options = {})
+      options = symbolize_keys(options)
+      path = build_preset_path(options[:preset])
+      query = build_query(options.except(:preset))
+
+      uri = URI.parse(cdn_url)
+      uri.path = path
+      uri.query = query.empty? ? nil : URI.encode_www_form(query.sort_by(&:first))
+      uri.to_s
+    end
+
+    private
+
+    def symbolize_keys(hash)
+      hash.each_with_object({}) do |(key, value), result|
+        result[key.to_sym] = value
+      end
+    end
+
+    def build_preset_path(preset)
+      return URI.parse(cdn_url).path if preset.nil?
+
+      preset = preset.to_s
+      raise ArgumentError, 'Invalid transformation rule value for preset' unless PRESETS.include?(preset)
+
+      uri = URI.parse(cdn_url)
+      slash_index = uri.path.rindex('/')
+      prefix = slash_index ? uri.path[0..slash_index] : ''
+      file_name = slash_index ? uri.path[(slash_index + 1)..] : uri.path
+      dot_index = file_name.rindex('.')
+      raise ArgumentError, 'Cannot apply a preset to a CDN URL without a file extension.' if dot_index.nil?
+
+      "#{prefix}#{file_name}@#{preset}"
+    end
+
+    def build_query(options)
+      present = []
+
+      RULES.each do |canonical, aliases|
+        matches = aliases.filter_map do |name|
+          symbol = name.to_sym
+          [symbol, options[symbol]] if options.key?(symbol)
+        end
+
+        next if matches.empty?
+        raise ArgumentError, "Duplicate transformation rule: #{canonical}" if matches.length > 1
+
+        value = normalize_rule(canonical, matches.first.last)
+        present << [canonical, value] unless value.nil?
+      end
+
+      present
+    end
+
+    def normalize_rule(canonical, value)
+      case canonical
+      when 'background'
+        string = value.to_s.delete_prefix('#')
+        unless string.match?(/\A[\da-fA-F]{6}\z/)
+          raise ArgumentError,
+                "Invalid transformation rule value for #{canonical}"
+        end
+
+        string.downcase
+      when 'crop', 'gravity'
+        value.to_s
+      when 'enlarge', 'strip_metadata'
+        value ? 'true' : nil
+      when 'format'
+        string = value.to_s
+        unless FORMATS.include?(string)
+          raise ArgumentError,
+                "Invalid transformation rule value for #{canonical}"
+        end
+
+        string
+      when 'height', 'quality', 'width'
+        integer = Integer(value)
+        unless integer.positive?
+          raise ArgumentError,
+                "Invalid transformation rule value for #{canonical}"
+        end
+
+        integer.to_s
+      when 'rotate'
+        integer = Integer(value)
+        unless ROTATE_ANGLES.include?(integer)
+          raise ArgumentError,
+                "Invalid transformation rule value for #{canonical}"
+        end
+
+        integer.to_s
+      else
+        raise ArgumentError, "Unsupported transformation rule: #{canonical}"
+      end
+    rescue ArgumentError, TypeError
+      raise ArgumentError, "Invalid transformation rule value for #{canonical}"
+    end
+  end
+end