provider_kit 0.2.0

data/lib/provider_kit/encrypted_settings.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ProviderKit
+  # Serializable object to read/write from account settings fields (encrypted)
+  class EncryptedSettings < Settings
+
+    def to_value
+      encrypt_data_for_storage
+    end
+
+    def self.dump(data)
+      case data
+      when self
+        data.to_value
+      else
+        new(data).to_value
+      end
+    end
+
+    def self.load(data)
+      new(data.presence)
+    end
+
+    private
+
+      def build_data(data)
+        if Hash === data
+          data
+        elsif decrypted = decrypt_data(data)
+          JSON.parse(decrypted)
+        end
+      end
+
+      def decrypt_data(encrypted_data)
+        if encrypted_data.present?
+          ProviderKit::Encryptor.shared.decrypt(encrypted_data)
+        end
+      end
+
+      def encrypt_data_for_storage
+        if data.present?
+          ProviderKit::Encryptor.shared.encrypt(data.to_json)
+        end
+      end
+
+  end
+end

data/lib/provider_kit/encryptor.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ProviderKit
+  # Wrapper around ActiveSupport::MessageEncryptor with a shared credential key
+  class Encryptor
+
+    def decrypt(encrypted_value, purpose: :provider)
+      crypt.decrypt_and_verify(encrypted_value, purpose:)
+    rescue ActiveSupport::MessageVerifier::InvalidSignature
+      nil
+    end
+
+    def encrypt(raw_value, purpose: :provider)
+      crypt.encrypt_and_sign(raw_value, purpose:)
+    end
+
+    def self.shared
+      @shared ||= new
+    end
+
+    private
+
+      def crypt
+        @crypt ||= ActiveSupport::MessageEncryptor.new(key)
+      end
+
+      def key
+        ProviderKit.config.credentials_key.byteslice(0, 32)
+      end
+
+  end
+end

data/lib/provider_kit/engine.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "active_support"
+
+module ProviderKit
+  class Engine < ::Rails::Engine
+
+    isolate_namespace ProviderKit
+
+    engine_name "provider_kit"
+
+    initializer "provider_kit.load_credentials_key" do |app|
+      ProviderKit.configure do |config|
+        credentials_key = ENV["PROVIDERKIT_KEY"].presence || Rails.application.credentials.secret_key_base.presence || Rails.application.credentials.secret_key_base
+        config.credentials_key ||= credentials_key
+      end
+    end
+
+  end
+end

data/lib/provider_kit/exceptions.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ProviderKit
+
+  module Exceptions
+  end
+
+  class InvalidCapability < StandardError; end
+  class InvalidTask < StandardError; end
+  class InvalidProviderContext < StandardError; end
+
+end

data/lib/provider_kit/execution.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "active_support/rescuable"
+
+module ProviderKit
+  # Handles the execution of Tasks
+  #
+  # Includes callbacks for the perform method, so the following callbacks are available:
+  #
+  # * before_perform
+  # * around_perform
+  # * after_perform
+  #
+  # Also included is Rescuable, so an individual task can be rescued like a job:
+  #
+  #    rescue_from InvalidProviderContext do
+  #      logger.warn "Provider context was not found for this task"
+  #    end
+  #
+  module Execution
+
+    extend ActiveSupport::Concern
+    include ActiveSupport::Rescuable
+
+    def perform_now
+      run_callbacks :perform do
+        perform
+      end
+    rescue => exception
+      tag_logger(self.class.name, process_id) do
+        rescue_with_handler(exception) || raise
+      end
+    end
+
+    def perform
+      fail NotImplementedError
+    end
+
+  end
+end

data/lib/provider_kit/json_client.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module ProviderKit
+  # Generic interface for working with JSON-based APIs.
+  #
+  # This class is just a simple wrapper around net/http so we don't need
+  # to use a third-party networking library for basic stuff.
+  class JsonClient
+
+    DEFAULT_HEADERS = {
+      "Accept" => "application/json",
+      "User-Agent" => "ProviderKitBot/1.0 (+https://example.com)"
+    }
+
+    attr_reader :base_url
+    attr_reader :default_headers
+    attr_reader :default_params
+    attr_reader :default_mode
+
+    def initialize(base_url, **options)
+      @base_url         = base_url
+      @default_headers  = options[:headers].presence || DEFAULT_HEADERS
+      @default_params   = options[:params].presence || {}
+      @default_mode     = options[:mode].presence || :json
+    end
+
+    %w( get post patch put delete ).each do |http_method|
+      class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{ http_method }(path, params: {}, headers: {}, mode: nil)
+          req = request(path, method: :#{ http_method }, params: params, headers: headers, mode: mode)
+          req.json
+        end
+      CODE
+    end
+
+    def request(path, method: :get, params: {}, headers: {}, mode: nil)
+      path      = "/#{ path }".gsub(%r{//}, "/")
+      url       = "#{ base_url }#{ path }"
+      headers   = default_headers.merge(headers)
+      params    = default_params.merge(params)
+      mode      = mode.presence || default_mode
+
+      JsonRequest.new(url, method:, params:, headers:, mode:)
+    end
+
+    private
+
+      # Provide a generic log subscriber for basic request details.
+      #
+      # A more detailed log subscriber could be configured to log the request/response data too if needed later
+      class LogSubscriber < ActiveSupport::LogSubscriber
+
+        def perform_start(event)
+          info do
+            request = event.payload[:request]
+
+            "Performing json request (Request ID: #{ request.process_id }) #{ request.method.to_s.upcase } #{ request.url }"
+          end
+        end
+
+        def perform(event)
+          request = event.payload[:request]
+          ex = event.payload[:exception_object]
+
+          if ex
+            error do
+              "Error performing json request (Request ID: #{ request.process_id }) in #{ event.duration.round(2) }ms: #{ ex.class } (#{ ex.message }):\n" + Array(ex.backtrace).join("\n")
+            end
+          else
+            info do
+              "Performed json request (Request ID: #{ request.process_id }) in #{ event.duration.round(2) }ms (#{ request.method.to_s.upcase } #{ request.url })"
+            end
+          end
+        end
+
+      end
+
+  end
+end
+
+ProviderKit::JsonClient::LogSubscriber.attach_to :provider_kit_json_client

data/lib/provider_kit/json_request.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module ProviderKit
+  # Generic interface for working with http request/response and json
+  class JsonRequest
+
+    include ProviderKit::Callbacks
+    include ProviderKit::Execution
+
+    attr_reader :url
+    attr_reader :method
+    attr_reader :params
+    attr_reader :headers
+    attr_reader :mode
+    attr_reader :body
+    attr_reader :process_id
+
+    attr_reader :http_request
+    attr_reader :http_response
+
+    around_perform do |request, block, _|
+      tag_logger(request.process_id) do
+        payload = { request: }
+        ActiveSupport::Notifications.instrument("perform_start.provider_kit_json_client", payload.dup)
+        ActiveSupport::Notifications.instrument("perform.provider_kit_json_client", payload) do
+          block.call
+        end
+      end
+    end
+
+    def initialize(url, method: :get, params: {}, headers: {}, mode: :json)
+      @url        = url
+      @method     = method
+      @params     = params
+      @headers    = headers
+      @mode       = mode
+      @process_id = SecureRandom.uuid
+
+      prepare_request
+      perform_now
+    end
+
+    def json
+      JSON.parse(body)
+    rescue
+      nil
+    end
+
+    def success?
+      (200..299).include?(status)
+    end
+
+    def status
+      http_response.code.to_i
+    end
+
+    def uri
+      @uri ||= URI(url)
+    end
+
+    private
+
+      def http
+        @http ||= begin
+          http = Net::HTTP.new(uri.host, uri.port)
+
+          if uri.port == 443
+            http.use_ssl = true
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          end
+
+          http
+        end
+      end
+
+      def logger
+        Rails.logger
+      end
+
+      def tag_logger(*tags)
+        tags.unshift("JsonRequest")
+
+        logger.tagged(*tags) { yield }
+      end
+
+      # Thanks
+      # https://github.com/rest-client/rest-client/blob/master/lib/restclient/request.rb#L600
+      def parse_body!
+        return unless http_response.present?
+
+        body = http_response.body
+
+        content_encoding = http_response["content-encoding"]
+
+        @body = if (!body) || body.empty?
+          body
+        elsif content_encoding == "gzip"
+          Zlib::GzipReader.new(StringIO.new(body)).read
+        elsif content_encoding == "deflate"
+          begin
+            Zlib::Inflate.new.inflate(body)
+          rescue Zlib::DataError
+            Zlib::Inflate.new(-Zlib::MAX_WBITS).inflate(body)
+          end
+        else
+          body
+        end
+      end
+
+      def perform
+        return @http_response if @http_response
+
+        @http_response = http.request(http_request)
+        parse_body!
+        http_response
+      end
+
+      def prepare_request
+        case method
+        when :get
+          uri.query = URI.encode_www_form(params)
+          @http_request = Net::HTTP::Get.new(uri)
+        when :post
+          @http_request = Net::HTTP::Post.new(uri)
+          set_request_body!
+        when :delete
+          @http_request = Net::HTTP::Delete.new(uri)
+          set_request_body!
+        when :patch
+          @http_request = Net::HTTP::Patch.new(uri)
+          set_request_body!
+        when :put
+          @http_request = Net::HTTP::Put.new(uri)
+          set_request_body!
+        end
+
+        return nil unless http_request
+
+        headers.each do |key, value|
+          http_request[key] = value
+        end
+      end
+
+      def set_request_body!
+        return unless params.present?
+
+        if use_json_body?
+          http_request.body = params.to_json
+          http_request["Content-Type"] = "application/json"
+        else
+          http_request.set_form_data(params.stringify_keys)
+        end
+      end
+
+      def use_json_body?
+        mode == :json
+      end
+
+  end
+end

data/lib/provider_kit/logging.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module ProviderKit
+  # Utility class to log warnings and failures found during data imports
+  module Logging
+
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :logger, default: ActiveSupport::TaggedLogging.new(Rails.logger)
+
+      around_perform do |task, block, _|
+        tag_logger(task.class.name, task.process_id) do
+          payload = {
+            provider: task.provider&.key.presence || "unknown provider",
+            task:
+          }
+
+          ActiveSupport::Notifications.instrument("perform_start.provider_kit_tasks", payload.dup)
+
+          ActiveSupport::Notifications.instrument("perform.provider_kit_tasks", payload) do
+            block.call
+          end
+        end
+      end
+    end
+
+    private
+
+      def logger
+        Rails.logger
+      end
+
+      def tag_logger(*tags)
+        tags.unshift(provider.key)
+        tags.unshift("Provider")
+
+        logger.tagged(*tags) { yield }
+      end
+
+      class LogSubscriber < ActiveSupport::LogSubscriber
+
+        def perform_start(event)
+          info do
+            task      = event.payload[:task]
+            provider  = event.payload[:provider]
+
+            "Performing #{ task.class.name } (Process ID: #{ task.process_id }) for #{ provider }"
+          end
+        end
+
+        def perform(event)
+          task      = event.payload[:task]
+          provider  = event.payload[:provider]
+          ex        = event.payload[:exception_object]
+
+          if ex
+            error do
+              "Error performing #{ task.class.name } (Process ID: #{ task.process_id }) for #{ provider } in #{ event.duration.round(2) }ms: #{ ex.class } (#{ ex.message }):\n" + Array(ex.backtrace).join("\n")
+            end
+          else
+            info do
+              "Performed #{ task.class.name } (Process ID: #{ task.process_id }) for #{ provider } in #{ event.duration.round(2) }ms"
+            end
+          end
+        end
+
+      end
+
+  end
+end
+
+ProviderKit::Logging::LogSubscriber.attach_to :provider_kit_tasks

data/lib/provider_kit/provideable.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ProviderKit
+  # Shortcut for passing an object into a provider
+  module Provideable
+
+    extend ActiveSupport::Concern
+
+    included do
+      validate :validate_provider_presence
+    end
+
+    def provider
+      if provider_key.present?
+        @provider ||= ProviderKit::ProviderAttribute.new(provider_key, record: self)
+      end
+    end
+
+    def provider=(value)
+      @provider = nil
+
+      write_attribute(:provider, value.to_s.presence)
+    end
+
+    def provider_key
+      read_attribute(:provider).to_s.presence
+    end
+
+    private
+
+      def validate_provider_presence
+        if provider.present? && provider_key != "default"
+          return
+        end
+
+        errors.add :provider, :blank
+      end
+
+  end
+end

data/lib/provider_kit/provider.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ProviderKit
+  # Given an object, try and find its registered data provider
+  #
+  # Or directly pass a provider key
+  class Provider
+
+    attr_reader :record
+
+    def initialize(record)
+      @record = record
+    end
+
+    def key
+      record_provider.presence || record_source.presence
+    end
+
+    def present?
+      provider.present?
+    end
+
+    def provider
+      return nil unless registration
+
+      registration.klass
+    end
+
+    def provider_instance
+      return nil unless provider
+
+      instance = provider.new
+
+      if instance.respond_to?(:context=) && record != key
+        instance.context = record
+      end
+
+      instance
+    end
+
+    def registration
+      if key.present?
+        ProviderKit.registrations[key.to_sym]
+      end
+    end
+
+    private
+
+      def record_provider
+        if record.respond_to?(:provider)
+          record.provider
+        end
+      end
+
+      def record_source
+        if Symbol === record
+          record
+        end
+      end
+
+  end
+end

data/lib/provider_kit/provider_attribute.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module ProviderKit
+  # serializer for a provider attribute turned into a Provider instance
+  class ProviderAttribute
+
+    include Buildable
+
+    attr_reader :key
+    attr_reader :record
+    attr_reader :context
+
+    def initialize(key, record: nil, **context)
+      @key      = (key.to_s.presence || "default").to_sym
+      @record   = record
+      @context  = context.reverse_merge(default_context)
+    end
+
+    def ==(other_key)
+      to_s == other_key.to_s
+    end
+
+    def inspect
+      @key.inspect
+    end
+
+    def method_missing(method_name, *args)
+      return nil unless provider.present?
+
+      if provider.respond_to?(method_name)
+        return provider.public_send(method_name, *args)
+      end
+
+      # self.amazon_selling_partner? ==> self.key == :amazon_selling_partner
+      if match = method_name.to_s.match(/^(?<attribute>[a-z0-9_]+)\?$/)
+        return match[:attribute].to_clean_sym == key
+      end
+
+      provider.with_context(**context).public_send(method_name, *args)
+    end
+
+    def label
+      name
+    end
+
+    def name
+      registration&.name.presence || key.to_s.titleize
+    end
+
+    def options
+      registration&.options.presence || {}
+    end
+
+    def present?
+      provider.present?
+    end
+
+    def registration
+      if present?
+        ProviderKit.registrations[key.to_sym]
+      end
+    end
+
+    def to_s
+      key.to_s
+    end
+
+    def with_context(**context)
+      @context = context
+      self
+    end
+
+    def self.dump(instance)
+      case instance
+      when self
+        instance.to_s
+      else
+        new(instance).to_s
+      end
+    end
+
+    def self.load(str)
+      new(str)
+    end
+
+    private
+
+      def default_context
+        _context = {}
+        _context[record.model_name.param_key.to_sym] = record if record.present?
+        _context
+      end
+
+      def provider
+        @provider ||= with(key)
+      end
+
+  end
+end