wcc-api 0.1.0 → 0.5.0

data/lib/wcc/api/base_query.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 module WCC::API
   class BaseQuery
-    attr_reader :scope, :paging
-    attr_accessor :limit, :offset
+    attr_reader :scope, :paging, :limit, :offset
     attr_accessor :filter
 
     MAX_LIMIT = 50
@@ -15,7 +16,7 @@ module WCC::API
     end
 
     def permitted_keys
-      %i(limit offset filter)
+      %i[limit offset filter]
     end
 
     def default_scope
@@ -27,11 +28,11 @@ module WCC::API
       @paging = paging
       set_defaults
       permitted_keys.each do |key|
-        self.public_send("#{key}=", params[key]) if params.has_key?(key)
+        public_send("#{key}=", params[key]) if params.key?(key)
       end
     end
 
-    def call(scope=self.scope)
+    def call(scope = self.scope)
       scope = scope.dup
       scope = paged(scope)
       scope = ordered(scope)
@@ -39,7 +40,7 @@ module WCC::API
       scope
     end
 
-    def paged(scope=self.scope)
+    def paged(scope = self.scope)
       if paging
         scope
           .limit(limit)
@@ -49,11 +50,11 @@ module WCC::API
       end
     end
 
-    def ordered(scope=self.scope)
+    def ordered(scope = self.scope)
       scope
     end
 
-    def filtered(scope=self.scope)
+    def filtered(scope = self.scope)
       scope
     end
 
@@ -65,7 +66,7 @@ module WCC::API
 
     def limit=(new_limit)
       new_limit = new_limit.to_i
-      @limit = (new_limit > MAX_LIMIT) ? MAX_LIMIT : new_limit
+      @limit = new_limit > MAX_LIMIT ? MAX_LIMIT : new_limit
     end
 
     def offset=(new_offset)
@@ -85,4 +86,3 @@ module WCC::API
     end
   end
 end
-

data/lib/wcc/api/controller_helpers.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module WCC::API
+  module ControllerHelpers
+    private
+
+    def set_cache_headers(scope_or_record, options = {})
+      options = { public: true, must_revalidate: true }.merge!(options)
+
+      if expiry = options.delete(:expiry)
+        expires_in expiry, options.slice(:public, :must_revalidate)
+      end
+
+      fresh_when scope_or_record, options.slice(:etag, :public, :last_modified)
+    end
+  end
+end

data/lib/wcc/api/json.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module WCC::API
   module JSON
   end

data/lib/wcc/api/json/pagination.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module WCC::API::JSON
   class Pagination
     attr_reader :query, :url_for
@@ -19,12 +21,12 @@ module WCC::API::JSON
         json.sort query.sort if query.respond_to?(:sort)
         json.filter query.filter
         json._links do
-          json.self url_for.(base_url_params)
+          json.self url_for.call(base_url_params)
           if has_previous_page?
-            json.previous url_for.(base_url_params.merge(offset: query.offset - query.limit))
+            json.previous url_for.call(base_url_params.merge(offset: query.offset - query.limit))
           end
           if has_next_page?
-            json.next url_for.(base_url_params.merge(offset: query.offset + query.limit))
+            json.next url_for.call(base_url_params.merge(offset: query.offset + query.limit))
           end
         end
       end
@@ -33,23 +35,26 @@ module WCC::API::JSON
     private
 
     def has_previous_page?
-      query.offset - query.limit >= 0
+      query.paging && query.offset - query.limit >= 0
     end
 
     def has_next_page?
-      query.offset + query.limit < query.total
+      query.paging && query.offset + query.limit < query.total
     end
 
     def base_url_params
-      @base_url_params ||= {
-        limit: query.limit,
-        offset: query.offset,
-        filter: query.filter,
-        only_path: false
-      }.tap do |params|
-        params[:order_by] = query.order_by if query.respond_to?(:order_by)
-        params[:sort] = query.sort if query.respond_to?(:sort)
-      end
+      @base_url_params ||=
+        {
+          filter: query.filter,
+          only_path: false
+        }.tap do |params|
+          if query.paging
+            params[:limit] = query.limit
+            params[:offset] = query.offset
+          end
+          params[:order_by] = query.order_by if query.respond_to?(:order_by)
+          params[:sort] = query.sort if query.respond_to?(:sort)
+        end
     end
   end
 end

data/lib/wcc/api/railtie.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require 'wcc/api'
 
 module WCC
   module API
     class Railtie < Rails::Railtie
-      initializer 'wcc.api railtie initializer', group: :all do |app|
+      initializer 'wcc.api railtie initializer', group: :all do |_app|
         ActiveSupport::Inflector.inflections(:en) do |inflect|
           inflect.acronym 'API'
         end

data/lib/wcc/api/rest_client.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require 'wcc'
+require_relative 'rest_client/response'
+require_relative 'rest_client/builder'
+require_relative 'active_record_shim'
+
+module WCC::API
+  class RestClient
+    attr_reader :api_url
+
+    class << self
+      attr_reader :resources, :params
+
+      def rest_client(&block)
+        builder = Builder.new(self)
+        builder.instance_exec(&block)
+        builder.apply
+      end
+    end
+
+    def initialize(api_url:, headers: nil, **options)
+      # normalizes a URL to have a slash on the end
+      @api_url = api_url.gsub(/\/+$/, '') + '/'
+
+      @adapter = RestClient.load_adapter(options[:adapter])
+
+      @options = options
+      @query_defaults = {}
+      @headers = {
+        'Accept' => 'application/json'
+      }.merge(headers || {}).freeze
+      @response_class = options[:response_class] || DefaultResponse
+    end
+
+    # performs an HTTP GET request to the specified path within the configured
+    # space and environment.  Query parameters are merged with the defaults and
+    # appended to the request.
+    def get(path, query = {})
+      url = URI.join(@api_url, path)
+
+      @response_class.new(self,
+        { url: url, query: query },
+        get_http(url, query))
+    end
+
+    def post(path, body = {})
+      url = URI.join(@api_url, path)
+
+      @response_class.new(self,
+        { url: url },
+        post_http(url,
+          body.to_json,
+          headers: { 'Content-Type': 'application/json' }))
+    end
+
+    def put(path, body = {})
+      url = URI.join(@api_url, path)
+
+      @response_class.new(self,
+        { url: url },
+        put_http(url,
+          body.to_json,
+          headers: { 'Content-Type': 'application/json' }))
+    end
+
+    def delete(path)
+      url = URI.join(@api_url, path)
+
+      @response_class.new(self,
+        { url: url },
+        delete_http(url))
+    end
+
+    ADAPTERS = {
+      faraday: ['faraday', '~> 0.9'],
+      typhoeus: ['typhoeus', '~> 1.0']
+    }.freeze
+
+    def self.load_adapter(adapter)
+      case adapter
+      when nil
+        ADAPTERS.each do |a, spec|
+          begin
+            gem(*spec)
+            return load_adapter(a)
+          rescue Gem::LoadError
+            next
+          end
+        end
+        raise ArgumentError, 'Unable to load adapter!  Please install one of '\
+          "#{ADAPTERS.values.map(&:join).join(',')}"
+      when :faraday
+        require 'faraday'
+        ::Faraday.new do |faraday|
+          faraday.response :logger, (Rails.logger if defined?(Rails)), { headers: false, bodies: false }
+          faraday.adapter :net_http
+        end
+      when :typhoeus
+        require_relative 'rest_client/typhoeus_adapter'
+        TyphoeusAdapter.new
+      else
+        unless adapter.respond_to?(:get)
+          raise ArgumentError, "Adapter #{adapter} is not invokeable!  Please "\
+            "pass use one of #{ADAPTERS.keys} or create a Faraday-compatible adapter"
+        end
+        adapter
+      end
+    end
+
+    private
+
+    def get_http(url, query, headers = {})
+      headers = @headers.merge(headers || {})
+
+      q = @query_defaults.dup
+      q = q.merge(query) if query
+
+      resp = @adapter.get(url, q, headers)
+
+      resp = get_http(resp.headers['location'], nil, headers) if [301, 302, 307].include?(resp.status) && !@options[:no_follow_redirects]
+      resp
+    end
+
+    def post_http(url, body, headers: {})
+      headers = @headers.merge(headers || {})
+
+      resp = @adapter.post(url, body, headers)
+
+      resp = get_http(resp.headers['location'], nil, headers) if [301, 302, 307].include?(resp.status) && !@options[:no_follow_redirects]
+      resp
+    end
+
+    def put_http(url, body, headers: {})
+      headers = @headers.merge(headers || {})
+
+      resp = @adapter.put(url, body, headers)
+
+      resp = get_http(resp.headers['location'], nil, headers) if [301, 302, 307].include?(resp.status) && !@options[:no_follow_redirects]
+      resp
+    end
+
+    def delete_http(url, headers: {})
+      headers = @headers.merge(headers || {})
+
+      resp = @adapter.delete(url, {}, headers)
+
+      resp = get_http(resp.headers['location'], nil, headers) if [301, 302, 307].include?(resp.status) && !@options[:no_follow_redirects]
+      resp
+    end
+
+    class Resource
+      attr_reader :client, :endpoint, :model, :options
+
+      def initialize(client, endpoint, model, options)
+        @client = client
+        @endpoint = endpoint
+        @model = model
+        @options = options
+      end
+
+      def find(id, query = {})
+        query = (options[:query] || {}).merge(query)
+        resp = client.get("#{endpoint}/#{id}", query)
+        resp.assert_ok!
+        body = options[:key] ? resp.body[options[:key]] : resp.body
+        model.new(body, resp.headers.freeze)
+      end
+
+      def list(**filters)
+        query = extract_params(filters)
+        query = (options[:query] || {}).merge(query)
+        query = query.merge!(apply_filters(filters, options[:filters]))
+        resp = client.get(endpoint, query)
+        resp.assert_ok!
+        resp.items.map { |s| model.new(s) }
+      end
+
+      def create(body)
+        resp = client.post(endpoint, body)
+        resp.assert_ok!
+        maybe_model_from_response(resp)
+      end
+
+      def update(id, body)
+        resp = client.put("#{endpoint}/#{id}", body)
+        resp.assert_ok!
+        maybe_model_from_response(resp)
+      end
+
+      def destroy(id)
+        resp = client.delete("#{endpoint}/#{id}")
+        resp.assert_ok!
+        maybe_model_from_response(resp)
+      end
+
+      protected
+
+      def maybe_model_from_response(resp)
+        return true if resp.status == 204
+        return true unless resp.raw_body.present?
+
+        body = options[:key] ? resp.body[options[:key]] : resp.body
+        return true unless body.present?
+
+        model.new(body, resp.headers.freeze)
+      end
+
+      def extract_params(filters)
+        filters.each_with_object({}) do |(k, _v), h|
+          k_s = k.to_s
+          h[k_s] = filters.delete(k) if client.class.params.include?(k_s)
+        end
+      end
+
+      def filter_key(filter_name)
+        filter_name
+      end
+
+      def apply_filters(filters, expected_filters)
+        defaults = default_filters(expected_filters) || {}
+        filters.each_with_object(defaults) do |(k, v), h|
+          k = k.to_s
+          raise ArgumentError, "Unknown filter '#{k}'" unless expected_filters.include?(k)
+
+          h[filter_key(k)] = v
+        end
+      end
+
+      def default_filters(expected_filters)
+        options[:default_filters]&.each_with_object({}) do |(k, v), h|
+          k = k.to_s
+          h[filter_key(k)] = v if expected_filters.include?(k)
+        end
+      end
+    end
+  end
+end

data/lib/wcc/api/rest_client/api_error.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module WCC::API
+  class RestClient
+    class ApiError < StandardError
+      attr_reader :response
+
+      def self.[](code)
+        case code
+        when 404
+          NotFoundError
+        else
+          ApiError
+        end
+      end
+
+      def initialize(response)
+        @response = response
+        super(response.error_message)
+      end
+    end
+
+    class NotFoundError < ApiError
+    end
+  end
+end

data/lib/wcc/api/rest_client/builder.rb

@@ -0,0 +1,82 @@
+module WCC::API
+  class RestClient
+    class Builder
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def params(*params)
+        @params = params.map(&:to_s)
+      end
+
+      attr_writer :resource_class
+      def resource_class
+        @resource_class ||=
+          @klass.const_get("Resource") || WCC::API::RestClient::Resource
+      end
+
+      def resource(endpoint, model:, **options, &block)
+        @resources ||= {}
+
+        resource_class = options[:resource_class] || self.resource_class
+        if block_given?
+          resource_class = Class.new(resource_class, &block)
+        end
+        @resources[endpoint] = options.merge({
+          resource_class: resource_class,
+          model: model,
+        })
+      end
+
+      def apply
+        closed_params = (@params || []).freeze
+        resources = @resources
+        klass = @klass
+
+        klass.class_exec do
+          define_singleton_method :params do
+            closed_params
+          end
+
+          define_singleton_method :default do
+            @default ||= new
+          end
+
+          define_singleton_method :default= do |client|
+            @default = client
+          end
+
+          resources.each do |(endpoint, options)|
+            attr_name = options[:attribute] || endpoint.downcase
+            resource_class = options[:resource_class]
+
+            define_method attr_name do
+              instance_variable_get("@#{attr_name}") ||
+                instance_variable_set("@#{attr_name}", 
+                  resource_class.new(self, endpoint, options[:model], @options.merge(options))
+                )
+            end
+          end
+        end
+
+        resources.each do |(endpoint, options)|
+          options[:model].class_exec do
+            define_singleton_method :client do
+              klass.default
+            end
+
+            define_singleton_method :endpoint do
+              endpoint
+            end
+
+            define_singleton_method :key do
+              options[:key]
+            end
+          end
+
+          options[:model].send(:include, WCC::API::ActiveRecordShim)
+        end
+      end
+    end
+  end
+end