duodealer_api 1.0.0

data/lib/active_resource/json_errors.rb

@@ -0,0 +1,31 @@
+require 'active_resource/base'
+
+module ActiveResource
+  class Errors < ActiveModel::Errors
+    def from_json(json, save_cache = false)
+      data = ActiveSupport::JSON.decode(json)['errors'] || {} rescue {}
+      case data
+      when String
+        from_string(data, save_cache)
+      else
+        from_hash(data, save_cache)
+      end
+    end
+
+    def from_hash(messages, save_cache = false)
+      clear unless save_cache
+
+      messages.each do |key,errors|
+        errors.each do |error|
+          add(key, error)
+        end
+      end
+    end
+
+    def from_string(error, save_cache = false)
+      clear unless save_cache
+
+      add(:base, error)
+    end
+  end
+end

data/lib/duodealer_api.rb

@@ -0,0 +1,33 @@
+$:.unshift File.dirname(__FILE__)
+require 'active_resource'
+require 'active_support/core_ext/class/attribute_accessors'
+require 'digest/md5'
+require 'base64'
+require 'active_resource/detailed_log_subscriber'
+require 'duodealer_api/limits'
+require 'duodealer_api/api_version'
+require 'duodealer_api/meta'
+require 'active_resource/json_errors'
+require 'duodealer_api/paginated_collection'
+require 'duodealer_api/disable_prefix_check'
+
+module DuodealerAPI
+  include Limits
+end
+
+require 'duodealer_api/events'
+require 'duodealer_api/metafields'
+require 'duodealer_api/countable'
+require 'duodealer_api/resources'
+require 'duodealer_api/session'
+require 'duodealer_api/message_enricher'
+require 'duodealer_api/connection'
+require 'duodealer_api/pagination_link_headers'
+require 'duodealer_api/graphql'
+require 'duodealer_api/graphql/railtie' if defined?(Rails)
+
+if DuodealerAPI::Base.respond_to?(:connection_class)
+  DuodealerAPI::Base.connection_class = DuodealerAPI::Connection
+else
+  require 'active_resource/connection_ext'
+end

data/lib/duodealer_api/api_version.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+module DuodealerAPI
+  class ApiVersion
+    class UnknownVersion < StandardError; end
+    class ApiVersionNotSetError < StandardError; end
+    include Comparable
+
+    UNSTABLE_HANDLE = 'unstable'
+    HANDLE_FORMAT = /((\d{4}-\d{2})|#{UNSTABLE_HANDLE})/.freeze
+    UNSTABLE_AS_DATE = Time.utc(3000, 1, 1)
+    API_PREFIX = '/admin/api/'
+    LOOKUP_MODES = [:raise_on_unknown, :define_on_unknown].freeze
+
+    class << self
+      attr_reader :versions
+
+      def version_lookup_mode
+        @version_lookup_mode ||= :define_on_unknown
+      end
+
+      def version_lookup_mode=(mode)
+        raise ArgumentError, "Mode must be one of #{LOOKUP_MODES}" unless LOOKUP_MODES.include?(mode)
+        sanitize_known_versions if mode == :raise_on_unknown
+        @version_lookup_mode = mode
+      end
+
+      def find_version(version_or_handle)
+        raise ArgumentError, "NullVersion is not a valid version or version handle." if version_or_handle == NullVersion
+        return version_or_handle if version_or_handle.is_a?(ApiVersion)
+        handle = version_or_handle.to_s
+        @versions ||= {}
+        @versions.fetch(handle) do
+          if @version_lookup_mode == :raise_on_unknown
+            raise UnknownVersion, unknown_version_error_message(handle)
+          else
+            add_to_known_versions(ApiVersion.new(handle: handle))
+          end
+        end
+      end
+
+      def coerce_to_version(version_or_handle)
+        warn(
+          '[DEPRECATED] DuodealerAPI::ApiVersion.coerce_to_version be removed in a future version. ' \
+            'Use `find_version` instead.'
+        )
+        find_version(version_or_handle)
+      end
+
+      def fetch_known_versions
+        @versions = Meta.admin_versions.map do |version|
+          [version.handle, ApiVersion.new(version.attributes.merge(verified: version.persisted?))]
+        end.to_h
+      end
+
+      def define_known_versions
+        warn(
+          '[DEPRECATED] DuodealerAPI::ApiVersion.define_known_versions is deprecated and will be removed in a future version. ' \
+            'Use `fetch_known_versions` instead.'
+        )
+        fetch_known_versions
+      end
+
+      def add_to_known_versions(version)
+        @versions[version.handle] = version
+      end
+
+      def clear_known_versions
+        @versions = {}
+      end
+
+      def clear_defined_versions
+        warn(
+          '[DEPRECATED] DuodealerAPI::ApiVersion.clear_defined_versions is deprecated and will be removed in a future version. ' \
+            'Use `clear_known_versions` instead.'
+        )
+        clear_known_versions
+      end
+
+      def latest_stable_version
+        warn(
+          '[DEPRECATED] DuodealerAPI::ApiVersion.latest_stable_version is deprecated and will be removed in a future version.'
+        )
+        versions.values.find(&:latest_supported?)
+      end
+
+      private
+
+      def sanitize_known_versions
+        return if @versions.nil?
+        @versions = @versions.keys.map do |handle|
+          next unless @versions[handle].verified?
+          [handle, @versions[handle]]
+        end.compact.to_h
+      end
+
+      def unknown_version_error_message(handle)
+        msg = "ApiVersion.version_lookup_mode is set to `:raise_on_unknown`. \n"
+        return msg + "No versions defined. You must call `ApiVersion.fetch_known_versions` first." if @versions.empty?
+        msg + "`#{handle}` is not in the defined version set. Available versions: #{@versions.keys}"
+      end
+    end
+
+    attr_reader :handle, :display_name, :supported, :latest_supported, :verified
+
+    def initialize(attributes)
+      attributes = ActiveSupport::HashWithIndifferentAccess.new(attributes)
+      @handle = attributes[:handle].to_s
+      @display_name = attributes.fetch(:display_name, attributes[:handle].to_s)
+      @supported = attributes.fetch(:supported, false)
+      @latest_supported = attributes.fetch(:latest_supported, false)
+      @verified = attributes.fetch(:verified, false)
+    end
+
+    def to_s
+      handle
+    end
+
+    def latest_supported?
+      latest_supported
+    end
+
+    def supported?
+      supported
+    end
+
+    def verified?
+      verified
+    end
+
+    def <=>(other)
+      handle_as_date <=> other.handle_as_date
+    end
+
+    def ==(other)
+      other.class == self.class && handle == other.handle
+    end
+
+    def hash
+      handle.hash
+    end
+
+    def construct_api_path(path)
+      "#{API_PREFIX}#{handle}/#{path}"
+    end
+
+    def construct_graphql_path
+      construct_api_path('graphql.json')
+    end
+
+    def name
+      warn(
+        '[DEPRECATED] DuodealerAPI::ApiVersion#name is deprecated and will be removed in a future version. ' \
+          'Use `handle` instead.'
+      )
+      handle
+    end
+
+    def stable?
+      warn(
+        '[DEPRECATED] DuodealerAPI::ApiVersion#stable? is deprecated and will be removed in a future version. ' \
+          'Use `supported?` instead.'
+      )
+      supported?
+    end
+
+    def unstable?
+      handle == UNSTABLE_HANDLE
+    end
+
+    def handle_as_date
+      return UNSTABLE_AS_DATE if unstable?
+      year, month, day = handle.split('-')
+      Time.utc(year, month, day)
+    end
+
+    class NullVersion
+      class << self
+        def new(*_args)
+          raise NoMethodError, "NullVersion is an abstract class and cannot be instantiated."
+        end
+
+        def matches?(version)
+          version.nil? || version == self
+        end
+
+        def raise_not_set_error(*_args)
+          raise ApiVersionNotSetError, "You must set DuodealerAPI::Base.api_version before making a request."
+        end
+        alias_method :stable?, :raise_not_set_error
+        alias_method :construct_api_path, :raise_not_set_error
+        alias_method :construct_graphql_path, :raise_not_set_error
+        alias_method :latest_supported?, :raise_not_set_error
+        alias_method :supported?, :raise_not_set_error
+        alias_method :verified?, :raise_not_set_error
+        alias_method :unstable?, :raise_not_set_error
+        alias_method :handle, :raise_not_set_error
+        alias_method :display_name, :raise_not_set_error
+        alias_method :supported, :raise_not_set_error
+        alias_method :verified, :raise_not_set_error
+        alias_method :latest_supported, :raise_not_set_error
+        alias_method :name, :raise_not_set_error
+      end
+    end
+  end
+end

data/lib/duodealer_api/connection.rb

@@ -0,0 +1,35 @@
+module DuodealerAPI
+  class Connection < ActiveResource::Connection
+    attr_reader :response
+
+    module ResponseCapture
+      def handle_response(response)
+        @response = super(DuodealerAPI::MessageEnricher.new(response))
+      end
+    end
+
+    include ResponseCapture
+
+    module RequestNotification
+      def request(method, path, *arguments)
+        super.tap do |response|
+          notify_about_request(method, path, response, arguments)
+        end
+      rescue => e
+        notify_about_request(method, path, e.response, arguments) if e.respond_to?(:response)
+        raise
+      end
+
+      def notify_about_request(method, path, response, arguments)
+        ActiveSupport::Notifications.instrument("request.active_resource_detailed") do |payload|
+          payload[:method]   = method
+          payload[:path]     = path
+          payload[:response] = response
+          payload[:data]     = arguments
+        end
+      end
+    end
+
+    include RequestNotification
+  end
+end

data/lib/duodealer_api/countable.rb

@@ -0,0 +1,14 @@
+module DuodealerAPI
+  module Countable
+    def count(options = {})
+      data = get(:count, options)
+
+      count = case data
+        when Hash then data["count"]
+        else data
+      end
+
+      Integer(count)
+    end
+  end
+end

data/lib/duodealer_api/disable_prefix_check.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module DuodealerAPI
+  module DisablePrefixCheck
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def check_prefix_options(options)
+      end
+
+      # `flexible = true` is hack to allow multiple things through the same AR class
+      def conditional_prefix(resource, flexible = false)
+        resource_id = "#{resource}_id".to_sym
+        resource_type = flexible ? ":#{resource}" : resource.to_s.pluralize
+
+        init_prefix_explicit(resource_type, resource_id)
+
+        define_singleton_method :resource_prefix do |options = {}|
+          resource_type = options[resource] if flexible
+
+          options[resource_id].nil? ? '' : "#{resource_type}/#{options[resource_id]}/"
+        end
+
+        define_singleton_method :instantiate_record do |record, prefix_options = {}|
+          new(record, true).tap do |resource_instance|
+            resource_instance.prefix_options = prefix_options unless prefix_options.blank?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/duodealer_api/events.rb

@@ -0,0 +1,7 @@
+module DuodealerAPI
+  module Events
+    def events
+      Event.find(:all, :params => {:resource => self.class.collection_name, :resource_id => id})
+    end
+  end
+end

data/lib/duodealer_api/graphql.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+require 'graphql/client'
+require 'duodealer_api/graphql/http_client'
+
+module DuodealerAPI
+  module GraphQL
+    DEFAULT_SCHEMA_LOCATION_PATH = Pathname('duodealer_graphql_schemas')
+
+    InvalidSchema = Class.new(StandardError)
+    InvalidClient = Class.new(StandardError)
+
+    class << self
+      delegate :parse, :query, to: :client
+
+      def client(api_version = DuodealerAPI::Base.api_version.handle)
+        initialize_client_cache
+        cached_client = @_client_cache[api_version]
+
+        if cached_client
+          cached_client
+        else
+          schema_file = schema_location.join("#{api_version}.json")
+
+          if !schema_file.exist?
+            raise InvalidClient, <<~MSG
+              Client for API version #{api_version} does not exist because no schema file exists at `#{schema_file}`.
+
+              To dump the schema file, use the `rake duodealer_api:graphql:dump` task.
+            MSG
+          else
+            puts '[WARNING] Client was not pre-initialized. Ensure `DuodealerAPI::GraphQL.initialize_clients` is called during app initialization.'
+            initialize_clients
+            @_client_cache[api_version]
+          end
+        end
+      end
+
+      def clear_clients
+        @_client_cache = {}
+      end
+
+      def initialize_clients
+        initialize_client_cache
+
+        Dir.glob(schema_location.join("*.json")).each do |schema_file|
+          schema_file = Pathname(schema_file)
+          matches = schema_file.basename.to_s.match(/^#{DuodealerAPI::ApiVersion::HANDLE_FORMAT}\.json$/)
+
+          if matches
+            api_version = DuodealerAPI::ApiVersion.new(handle: matches[1])
+          else
+            raise InvalidSchema, "Invalid schema file name `#{schema_file}`. Does not match format of: `<version>.json`."
+          end
+
+          schema = ::GraphQL::Client.load_schema(schema_file.to_s)
+          client = ::GraphQL::Client.new(schema: schema, execute: HTTPClient.new(api_version)).tap do |c|
+            c.allow_dynamic_queries = true
+          end
+
+          @_client_cache[api_version.handle] = client
+        end
+      end
+
+      def schema_location
+        @schema_location || DEFAULT_SCHEMA_LOCATION_PATH
+      end
+
+      def schema_location=(path)
+        @schema_location = Pathname(path)
+      end
+
+      private
+
+      def initialize_client_cache
+        @_client_cache ||= {}
+      end
+    end
+  end
+end

data/lib/duodealer_api/graphql/http_client.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+require 'graphql/client/http'
+
+module DuodealerAPI
+  module GraphQL
+    class HTTPClient < ::GraphQL::Client::HTTP
+      def initialize(api_version)
+        @api_version = api_version
+      end
+
+      def headers(_context)
+        DuodealerAPI::Base.headers
+      end
+
+      def uri
+        DuodealerAPI::Base.site.dup.tap do |uri|
+          uri.path = @api_version.construct_graphql_path
+        end
+      end
+    end
+  end
+end