uploadcare-api_struct 1.1.0

data/lib/api_struct/client.rb

@@ -0,0 +1,88 @@
+module ApiStruct
+  class Client
+    DEFAULT_HEADERS = {
+      'Accept': 'application/json',
+      'Content-Type': 'application/json'
+    }
+    URL_OPTION_REGEXP = %r{/:([a-z_]+)}.freeze
+
+    attr_reader :client
+
+    # rubocop:disable Style/MissingRespondToMissing
+    def self.method_missing(method_name, *args, &block)
+      endpoints = Settings.config.endpoints
+      return super unless endpoints.keys.include?(method_name)
+
+      define_method(:api_root) { endpoints[method_name][:root] }
+      define_method(:default_params) { endpoints[method_name][:params] || {} }
+      define_method(:default_path) { first_arg(args) }
+
+      define_method(:headers) do
+        endpoints[method_name][:headers]
+      end
+    end
+    # rubocop:enable Style/MissingRespondToMissing
+
+    HTTP_METHODS = %i[get post patch put delete].freeze
+
+    HTTP_METHODS.each do |http_method|
+      define_method http_method do |*args, **options|
+        options[:params] = default_params.merge(options[:params] || {})
+        wrap client.send(http_method, build_url(args, options), options)
+      rescue HTTP::ConnectionError => e
+        failure(body: e.message, status: :not_connected)
+      end
+    end
+
+    def initialize
+      api_settings_exist
+      client_headers = headers || DEFAULT_HEADERS
+      @client = HTTP::Client.new(headers: client_headers)
+    end
+
+    private
+
+    def wrap(response)
+      response.status < 300 ? success(response) : failure(response)
+    end
+
+    def success(response)
+      body = response.body.to_s
+      result = !body.empty? ? JSON.parse(body, symbolize_names: true) : nil
+      Dry::Monads::Result::Success.call(result)
+    end
+
+    def failure(response)
+      result = ApiStruct::Errors::Client.new(response)
+      Dry::Monads::Result::Failure.call(result)
+    end
+
+    def first_arg(args)
+      args.first.to_s
+    end
+
+    def build_url(args, options)
+      suffix = to_path(args)
+      prefix = to_path(options.delete(:prefix))
+      path = to_path(options.delete(:path) || default_path)
+
+      replace_optional_params(to_path(api_root, prefix, path, suffix), options)
+    end
+
+    def to_path(*args)
+      Array(args).reject { |o| o.respond_to?(:empty?) ? o.empty? : !o }.join('/')
+    end
+
+    def replace_optional_params(url, options)
+      url.gsub(URL_OPTION_REGEXP) do
+        value = options.delete(::Regexp.last_match(1).to_sym)
+        value ? "/#{value}" : ''
+      end
+    end
+
+    def api_settings_exist
+      return if respond_to?(:api_root)
+      raise "\nSet api configuration for #{self.class}."
+    end
+  end
+end

data/lib/api_struct/collection.rb

@@ -0,0 +1,19 @@
+module ApiStruct
+  class Collection < SimpleDelegator
+    attr_reader :collection
+
+    def initialize(collection, entity_klass)
+      raise EntityError, 'Collection must be a Array' unless collection.is_a? Array
+      @collection = collection.map { |item| entity_klass.convert_to_entity(item) }
+      __setobj__(@collection)
+    end
+
+    def success?
+      true
+    end
+
+    def failure?
+      false
+    end
+  end
+end

data/lib/api_struct/concerns/underscore.rb

@@ -0,0 +1,7 @@
+module Concerns
+  module Underscore
+    def underscore(camel_cased_word)
+      Dry::Inflector.new.underscore(camel_cased_word)
+    end
+  end
+end

data/lib/api_struct/entity.rb

@@ -0,0 +1,93 @@
+module ApiStruct
+  class Entity < SimpleDelegator
+    extend Extensions::DryMonads
+    extend Extensions::ApiClient
+
+    class << self
+      def entity_attributes
+        @entity_attributes ||= []
+      end
+
+      def attr_entity(*attrs, &block)
+        entity_attributes.concat attrs
+
+        attrs.each do |attr|
+          define_entity_attribute_getter(attr, &block)
+          define_entity_attribute_setter(attr)
+        end
+      end
+
+      def entities?(attr, options)
+        entity_attributes << attr.to_sym
+        define_method attr.to_s do
+          self.class.collection(entity[attr], options[:as])
+        end
+      end
+      alias has_entities entities?
+
+      def entity?(attr, options)
+        entity_attributes << attr.to_sym
+        define_method attr.to_s do
+          return unless entity[attr]
+          self.class.convert_to_entity(entity[attr], options[:as])
+        end
+      end
+      alias has_entity entity?
+
+      def collection(entities, entity_type = self)
+        Collection.new(entities, entity_type)
+      end
+
+      def convert_to_entity(item, entity_type = self)
+        raise EntityError, "#{entity_type} must be inherited from base_entity" unless entity_type < ApiStruct::Entity
+        entity_type.new(item)
+      end
+
+      private
+
+      def define_entity_attribute_getter(attr)
+        define_method attr.to_s do
+          block_given? ? yield(entity[attr]) : entity[attr]
+        end
+      end
+
+      def define_entity_attribute_setter(attr)
+        define_method "#{attr}=" do |value|
+          entity[attr] = value
+        end
+      end
+    end
+
+    attr_reader :entity, :entity_status
+
+    # rubocop:disable Style/OptionalBooleanParameter
+    def initialize(entity, entity_status = true)
+      raise EntityError, "#{entity} must be Hash" unless entity.is_a?(Hash)
+      @entity = Hashie::Mash.new(extract_attributes(entity))
+      @entity_status = entity_status
+      __setobj__(@entity)
+    end
+    # rubocop:enable Style/OptionalBooleanParameter
+
+    def success?
+      entity_status == true
+    end
+
+    def failure?
+      entity_status == false
+    end
+
+    private
+
+    def extract_attributes(attributes)
+      formatted_attributes = attributes.map { |name, value| [format_name(name), value] }.to_h
+      formatted_attributes.select { |key, _value| self.class.entity_attributes.include?(key.to_sym) }
+    end
+
+    def format_name(name)
+      Dry::Inflector.new.underscore(name).to_sym
+    end
+  end
+
+  class EntityError < StandardError; end
+end

data/lib/api_struct/errors/client.rb

@@ -0,0 +1,43 @@
+module ApiStruct
+  module Errors
+    class Client
+      attr_reader :status, :body, :error
+
+      def initialize(response)
+        if response.is_a?(Hash)
+          @status = response[:status]
+          @body = response[:body]
+        else
+          @status = response.status
+          @body = parse_body(response.body.to_s)
+        end
+      end
+
+      def to_s
+        error
+      end
+
+      private
+
+      def error
+        return @status unless @body
+
+        if @body['errors']
+          @body['errors'].map do |k, v|
+            v.map { |e| "#{k} #{e}".strip }.join("\n")
+          end.join("\n")
+        elsif @body['error']
+          @body['error']
+        else
+          @status
+        end
+      end
+
+      def parse_body(b)
+        !b.empty? ? JSON.parse(b, symbolize_names: true) : nil
+      rescue JSON::ParserError
+        b
+      end
+    end
+  end
+end

data/lib/api_struct/errors/entity.rb

@@ -0,0 +1,7 @@
+module ApiStruct
+  module Errors
+    class Entity < ApiStruct::Entity
+      attr_entity :body, :status, :error
+    end
+  end
+end

data/lib/api_struct/extensions/api_client.rb

@@ -0,0 +1,43 @@
+module ApiStruct
+  module Extensions
+    module ApiClient
+      include Concerns::Underscore
+
+      REJECTED_METHODS = %i[api_root default_path headers]
+
+      attr_reader :clients
+
+      def client_service(*services, **options)
+        @clients ||= {}
+        services.each { |service| register_service(service, options) }
+      end
+
+      private
+
+      def register_service(service, options)
+        options[:prefix] = prefix_from_class(service) if options[:prefix] == true
+        options[:client_key] = options[:prefix] || :base
+
+        @clients[options[:client_key]] = service
+        allowed_methods(service, options).each { |method| define_client_method(method, options) }
+      end
+
+      def define_client_method(method, options)
+        method_name = options[:prefix] ? [options[:prefix], method].join('_') : method
+        define_singleton_method method_name do |*args|
+          from_monad(clients[options[:client_key]].new.send(method, *args))
+        end
+      end
+
+      def prefix_from_class(klass)
+        underscore(klass.name.split('::').last).to_sym
+      end
+
+      def allowed_methods(service, options)
+        return Array(options[:only]) if options[:only]
+        rejected = REJECTED_METHODS.concat(Array(options[:except]))
+        service.instance_methods(false).reject { |method| rejected.include?(method) }
+      end
+    end
+  end
+end

data/lib/api_struct/extensions/dry_monads.rb

@@ -0,0 +1,22 @@
+module ApiStruct
+  module Extensions
+    module DryMonads
+      def from_monad(monad)
+        monad
+          .fmap { |v| from_success(v) }.or_fmap { |e| from_failure(e) }.value!
+      end
+
+      def from_success(value)
+        return Dry::Monads::Result::Success.call(nil) if value.nil?
+
+        value.is_a?(Array) ? collection(value) : new(value)
+      end
+
+      def from_failure(error)
+        ApiStruct::Errors::Entity.new(
+          { status: error.status, body: error.body, error: true }, false
+        )
+      end
+    end
+  end
+end

data/lib/api_struct/settings.rb

@@ -0,0 +1,7 @@
+module ApiStruct
+  class Settings
+    extend ::Dry::Configurable
+
+    setting :endpoints, default: {}
+  end
+end

data/lib/api_struct/version.rb

@@ -0,0 +1,3 @@
+module ApiStruct
+  VERSION = '1.1.0'
+end

data/lib/api_struct.rb

@@ -0,0 +1,20 @@
+require 'http'
+require 'dry-monads'
+require 'dry-configurable'
+require 'dry/inflector'
+require 'json'
+require 'hashie'
+
+require_relative 'api_struct/version'
+require_relative 'api_struct/settings'
+require_relative 'api_struct/concerns/underscore'
+require_relative 'api_struct/extensions/api_client'
+require_relative 'api_struct/extensions/dry_monads'
+require_relative 'api_struct/errors/client'
+require_relative 'api_struct/client'
+require_relative 'api_struct/collection'
+require_relative 'api_struct/entity'
+require_relative 'api_struct/errors/entity'
+
+module ApiStruct
+end

data/spec/api_struct/client_spec.rb

@@ -0,0 +1,156 @@
+describe ApiStruct::Client do
+  extend Support::Stub
+
+  # rubocop:disable Lint/ConstantDefinitionInBlock
+  API_ROOT = 'https://jsonplaceholder.typicode.com'
+  # rubocop:enable Lint/ConstantDefinitionInBlock
+
+  let(:api_root) { API_ROOT }
+  stub_api(API_ROOT)
+  let(:client) { StubClient.new }
+
+  # rubocop:disable Lint/ConstantDefinitionInBlock
+  class StubClient < ApiStruct::Client
+    stub_api :posts
+
+    def show(id)
+      get(id)
+    end
+
+    def update(id, params)
+      patch(id, json: params)
+    end
+  end
+  # rubocop:enable Lint/ConstantDefinitionInBlock
+
+  context 'build url options' do
+    context 'url options' do
+      it ' should replace /posts/users/:id to /posts/users if URL option didnt provided' do
+        url = client.send(:build_url, 'users/:id', {})
+        expect(url).to eq "#{api_root}/posts/users"
+      end
+
+      it ' should replace users/:id/comments to users/comments if URL option didnt provided' do
+        url = client.send(:build_url, 'users/:id/comments', {})
+        expect(url).to eq "#{api_root}/posts/users/comments"
+      end
+
+      it 'should replace /users/:id in prefix to /users/1' do
+        url = client.send(:build_url, [], prefix: 'users/:id', id: 1)
+        expect(url).to eq "#{api_root}/users/1/posts"
+      end
+
+      it 'should replace /users/:user_id/posts/:id in prefix to /users/1/posts/12' do
+        url = client.send(:build_url, ':id', prefix: 'users/:user_id', user_id: 1, id: 12)
+        expect(url).to eq "#{api_root}/users/1/posts/12"
+      end
+
+      it 'should replace /users/:id to /users/1' do
+        url = client.send(:build_url, 'users/:id', id: 1)
+        expect(url).to eq "#{api_root}/posts/users/1"
+      end
+
+      it 'user_posts without post_id' do
+        user_id = 1
+        post_id = nil
+        url = client.send(:build_url, post_id, prefix: [:users, user_id])
+        expect(url).to eq "#{api_root}/users/1/posts"
+      end
+
+      it 'user_posts with post_id' do
+        user_id = 1
+        post_id = 2
+        url = client.send(:build_url, post_id, prefix: [:users, user_id])
+        expect(url).to eq "#{api_root}/users/1/posts/2"
+      end
+    end
+
+    it 'should build url with prefix' do
+      VCR.use_cassette('users/1/posts') do
+        response = client.get(prefix: 'users/:id', id: 1)
+        expect(response).to be_success
+        expect(response.value!).to be_kind_of Array
+        expect(response.value!).not_to be_empty
+      end
+    end
+
+    it 'should build url with custom path' do
+      VCR.use_cassette('todos') do
+        response = client.get(path: 'todos/1')
+        expect(response).to be_success
+        expect(response.value![:id]).to eq(1)
+        expect(response.value![:title]).not_to be_empty
+        expect(response.value!.keys).to include(:completed)
+      end
+    end
+
+    context 'Default params' do
+      let(:user_id) { 2 }
+
+      before do
+        allow(client).to receive(:default_params).and_return(userId: user_id)
+      end
+
+      it 'should build url with default params' do
+        VCR.use_cassette('user_todos') do
+          response = client.get(path: 'todos')
+
+          expect(response).to be_success
+          response.value!.each do |response|
+            expect(response[:userId]).to eq(user_id)
+          end
+        end
+      end
+    end
+
+    it 'should build url with prefix as array' do
+      VCR.use_cassette('todos') do
+        response = client.get(path: [:todos, 1])
+        expect(response).to be_success
+        expect(response.value![:id]).to eq(1)
+        expect(response.value![:title]).not_to be_empty
+        expect(response.value!.keys).to include(:completed)
+      end
+    end
+  end
+
+  context 'GET' do
+    it 'when successful response' do
+      VCR.use_cassette('posts/show_success') do
+        response = client.show(1)
+        expect(response).to be_success
+        expect(response.value![:id]).to eq(1)
+        expect(response.value![:title]).not_to be_empty
+      end
+    end
+
+    it 'when failed response' do
+      VCR.use_cassette('posts/show_failure') do
+        response = client.show(101)
+        expect(response).to be_failure
+        expect(response.failure.status).to eq(404)
+      end
+    end
+
+    it 'when failed response with html response' do
+      VCR.use_cassette('posts/show_failure_html') do
+        response = client.show(101)
+        body     = response.failure.body
+        expect(response).to be_failure
+        expect(response.failure.status).to eq(404)
+        expect(body).to be_kind_of(String)
+        expect(body).to match(%r{<body>.+</body>})
+      end
+    end
+  end
+
+  context 'PATCH' do
+    it 'when successful response' do
+      VCR.use_cassette('posts/update_success') do
+        response = client.update(1, title: FFaker::Name.name)
+        expect(response).to be_success
+        expect(response.value![:id]).to eq(1)
+      end
+    end
+  end
+end