api-blocks 0.5.4 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c58caeda8c2e020e4fee58c89a86a023f6a8992f3f9de5d36f8c14924990340f
-  data.tar.gz: d018108fef550f3d0c24041dee5f9f0ec42be72172e462426399a9cb59d84625
+  metadata.gz: 59832c91147b528479b1e2cf190d52a07c4a92d0bb066dcb95168e25b2ed5d98
+  data.tar.gz: 75c3345a6024fe795c4cf923764f0b3ade9df0aebe42141fbe701be82dd7fc6b
 SHA512:
-  metadata.gz: '04967b07d1693ff958d1c5cb3c088ed2b3cbf3861b271ee920c81c6e3692dcd731917fed35d498ba07b4abfca81918e84e2dfe68f2708aed1261460be201b5f8'
-  data.tar.gz: 83b9641a8e24ea72f62bec80f2d758c7b4c7f60b288da2617757696effa619462fc6f537e03763ebf4fb8436e165b45b20286c2d28b8503abf1aba0b9e97f4b3
+  metadata.gz: 776faa783cdb574d61d7d1b24ed9439f978f294aaca9b70ffd7daca0a3930aff66bedddbe02a5ca93a5051884fdb408c1031e28038688f610ac98b8d24fa67e5
+  data.tar.gz: 681d130b909383ea03ccea48e0b392bd57845ff3c0143387e1b631d0b6afd8457af69a3ca1964deab12cf5f541939375a3ad39c5f3b31274fd25d057f5e7a02f

data/lib/api_blocks/blueprinter/association_extractor.rb

@@ -1,82 +1,90 @@
 # frozen_string_literal: true
 
+require_relative 'join_keys'
+
 # Monkey-patch Blueprinter::AssociationExtractor to use `batch-loader` gem in
 # order to avoid n+1 queries when serializing associations.
 #
 # This does not support associations defined using a `proc` as
 # `options[:blueprint]`
 #
-class Blueprinter::AssociationExtractor < Blueprinter::Extractor
-  alias_method :original_extract, :extract
+module Blueprinter
+  class AssociationExtractor < Blueprinter::Extractor
+    alias original_extract extract
 
-  def extract(association_name, object, local_options, options = {})
-    association = object.association(association_name)
+    def extract(association_name, object, local_options, options = {})
+      return original_extract(association_name, object, local_options, options) unless options.fetch(:batch, true)
 
-    if association.is_a?(ActiveRecord::Associations::HasManyThroughAssociation)
-      return original_extract(association_name, object, local_options, options)
-    end
+      association = object.association(association_name)
 
-    if options[:blueprint].is_a?(Proc)
-      raise "Cannot load blueprints with a `proc` blueprint option with batch-loader"
-    end
+      if association.is_a?(ActiveRecord::Associations::HasManyThroughAssociation)
+        return original_extract(association_name, object, local_options, options)
+      end
 
-    join_key = association.reflection.join_keys
-    association_id = object.send(join_key.foreign_key)
-    association_klass = association.reflection.class_name
+      raise 'Cannot load blueprints with a `proc` blueprint option with batch-loader' if options[:blueprint].is_a?(Proc)
 
-    default_value = case association
-                    when ActiveRecord::Associations::HasManyAssociation
-                      []
-                    end
+      join_key = ::ApiBlocks::Blueprinter::JoinKeys.join_keys(
+        association.reflection
+      )
 
-    view = options[:view] || :default
-    scope = if options[:block].present?
-      options[:block].call(object, local_options)
-    else
-      {}
-    end
+      association_id = object.send(join_key.foreign_key)
+      association_klass = association.reflection.class_name
+
+      default_value = case association
+                      when ActiveRecord::Associations::HasManyAssociation
+                        []
+                      end
+
+      view = options[:view] || :default
+      scope = if options[:block].present?
+                options[:block].call(object, local_options)
+              else
+                {}
+              end
 
-    BatchLoader.for(association_id).batch(
-      default_value: default_value,
-      key: [association_name, association_klass, view, options[:blueprint], scope],
-    ) do |ids, loader, args|
-      model = association_klass.safe_constantize
-      scope = args[:key].last
+      BatchLoader.for(association_id).batch(
+        default_value: default_value,
+        key: [association_name, association_klass, view, options[:blueprint], scope]
+      ) do |ids, loader, args|
+        model = association_klass.safe_constantize
+        scope = args[:key].last
 
-      case association
-      when ActiveRecord::Associations::HasManyAssociation
-        model.where(join_key.key => ids).merge(scope).each do |record|
-          loader.call(record.send(join_key.key)) do |memo|
-            memo << render_blueprint(record, local_options, options)
+        case association
+        when ActiveRecord::Associations::HasManyAssociation
+          model.where(join_key.key => ids).merge(scope).each do |record|
+            loader.call(record.send(join_key.key)) do |memo|
+              memo << render_blueprint(record, local_options, options)
+              memo.uniq
+            end
           end
+        when ActiveRecord::Associations::HasOneAssociation
+          model.where(join_key.key => ids).merge(scope).each do |record|
+            loader.call(
+              record.send(join_key.key),
+              render_blueprint(record, local_options, options)
+            )
+          end
+        when ActiveRecord::Associations::BelongsToAssociation
+          model.where(join_key.key => ids).merge(scope).each do |record|
+            loader.call(
+              record.id,
+              render_blueprint(record, local_options, options)
+            )
+          end
+        else
+          raise "unsupported association kind #{association.class.name}"
         end
-      when ActiveRecord::Associations::HasOneAssociation
-        model.where(join_key.key => ids).merge(scope).each do |record|
-          loader.call(
-            record.send(join_key.key),
-            render_blueprint(record, local_options, options)
-          )
-        end
-      when ActiveRecord::Associations::BelongsToAssociation
-        model.where(join_key.key => ids).merge(scope).each do |record|
-          loader.call(
-            record.id,
-            render_blueprint(record, local_options, options)
-          )
-        end
-      else
-        raise "unsupported association kind #{association.class.name}"
       end
     end
-  end
 
-  private
+    private
 
-  def render_blueprint(value, local_options, options = {})
-    return default_value(options) if value.nil?
+    def render_blueprint(value, local_options, options = {})
+      return default_value(options) if value.nil?
 
-    view = options[:view] || :default
-    blueprint = association_blueprint(options[:blueprint], value)
-    blueprint.prepare(value, view_name: view, local_options: local_options)
+      view = options[:view] || :default
+      blueprint = association_blueprint(options[:blueprint], value)
+      blueprint.prepare(value, view_name: view, local_options: local_options)
+    end
   end
 end

data/lib/api_blocks/blueprinter/join_keys.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# lib/join_keys.rb
+
+module ApiBlocks
+  module Blueprinter
+    class JoinKeys
+      # Based on https://github.com/MaxLap/activerecord_where_assoc/blob/100318de80dea5f3c177526c3f824fda307ebc04/lib/active_record_where_assoc/active_record_compat.rb
+      if ActiveRecord.gem_version >= Gem::Version.new('6.1.0.rc1')
+        JoinKeys = Struct.new(:key, :foreign_key)
+        def self.join_keys(reflection)
+          JoinKeys.new(reflection.join_primary_key, reflection.join_foreign_key)
+        end
+
+      elsif ActiveRecord.gem_version >= Gem::Version.new('5.1')
+        def self.join_keys(reflection)
+          reflection.join_keys
+        end
+      end
+    end
+  end
+end

data/lib/api_blocks/controller.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # frozen_string_litreal: true
 
 require 'pundit'
@@ -17,74 +19,75 @@ require 'active_support/core_ext/module'
 #     pundit_scope :api, :v1
 #   end
 #
-module ApiBlocks::Controller
-  extend ActiveSupport::Concern
-
-  included do
-    self.responder = ApiBlocks::Responder
+module ApiBlocks
+  module Controller
+    extend ActiveSupport::Concern
 
-    before_action :verify_request_format!
+    included do
+      self.responder = ApiBlocks::Responder
 
-    include Pundit
-    rescue_from Pundit::NotAuthorizedError, with: :render_forbidden_error
+      before_action :verify_request_format!
 
-    # Enable pundit after_action hooks to ensure policies are consistently
-    # used.
-    after_action :verify_authorized
-    after_action :verify_policy_scoped, except: :create
+      include Pundit
+      rescue_from Pundit::NotAuthorizedError, with: :render_forbidden_error
 
-    # Override policy_scope to lookup pundit policies under the `scope`
-    # namespace
-    def policy_scope(scope)
-      api_scope = self.class.inherited_pundit_api_scope || []
-
-      super(api_scope + [scope])
-    end
+      # Enable pundit after_action hooks to ensure policies are consistently
+      # used.
+      after_action :verify_authorized
+      after_action :verify_policy_scoped, except: :create
 
-    # Override authorize to lookup pundit policies under the `scope`
-    # namespace
-    def authorize(record, query = nil)
-      api_scope = self.class.inherited_pundit_api_scope || []
+      # Override policy_scope to lookup pundit policies under the `scope`
+      # namespace
+      def policy_scope(scope, policy_scope_class: nil)
+        api_scope = self.class.inherited_pundit_api_scope || []
 
-      super(api_scope + [record], query)
-    end
+        super(api_scope + [scope], policy_scope_class: policy_scope_class)
+      end
 
-    handle_api_error Pundit::NotAuthorizedError do |error|
-      [{ detail: error.message }, :forbidden]
-    end
-  end
+      # Override authorize to lookup pundit policies under the `scope`
+      # namespace
+      def authorize(record, query = nil, policy_class: nil)
+        api_scope = self.class.inherited_pundit_api_scope || []
 
-  class_methods do
-    # Returns the `pundit_api_scope` value that was defined last looking up into
-    # the inheritance chain of the current class.
-    def inherited_pundit_api_scope
-      ancestors
-        .select { |a| a.respond_to?(:pundit_api_scope) }
-        .find(&:pundit_api_scope)
-        .pundit_api_scope
-    end
+        super(api_scope + [record], query, policy_class: policy_class)
+      end
 
-    # Provide a default scope to pundit's `PolicyFinder`.
-    def pundit_scope(*scope)
-      @pundit_api_scope ||= scope
+      handle_api_error Pundit::NotAuthorizedError do |error|
+        [{ detail: error.message }, :forbidden]
+      end
     end
 
-    def pundit_api_scope
-      @pundit_api_scope
-    end
+    class_methods do
+      # Returns the `pundit_api_scope` value that was defined last looking up into
+      # the inheritance chain of the current class.
+      def inherited_pundit_api_scope
+        ancestors
+          .select { |a| a.respond_to?(:pundit_api_scope) }
+          .find(&:pundit_api_scope)
+          .pundit_api_scope
+      end
 
+      # Provide a default scope to pundit's `PolicyFinder`.
+      def pundit_scope(*scope)
+        @pundit_api_scope ||= scope
+      end
 
-    # Defines a error handler that returns
-    def handle_api_error(error_class)
-      rescue_from error_class do |ex|
-        problem, status =
-          if block_given?
-            yield ex
-          else
-            [{ detail: ex.message }, :ok]
-          end
+      def pundit_api_scope
+        @pundit_api_scope
+      end
 
-        render problem: problem, status: status
+      # Defines a error handler that returns
+      def handle_api_error(error_class)
+        rescue_from error_class do |ex|
+          problem, status =
+            if block_given?
+              yield ex
+            else
+              [{ detail: ex.message }, :ok]
+            end
+
+          render problem: problem, status: status
+        end
       end
     end
   end

data/lib/api_blocks/doorkeeper.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 # ApiBlocks::Doorkeeper implements API extensions for doorkeeper.
-module ApiBlocks::Doorkeeper
-  extend ActiveSupport::Autoload
+module ApiBlocks
+  module Doorkeeper
+    extend ActiveSupport::Autoload
 
-  autoload :Passwords
-  autoload :Invitations
+    autoload :Passwords
+    autoload :Invitations
+  end
 end

data/lib/api_blocks/doorkeeper/invitations.rb

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
 
 # ApiBlocks::Doorkeeper::Invitations implements an API invitation workflow.
-module ApiBlocks::Doorkeeper::Invitations
-  extend ActiveSupport::Autoload
+module ApiBlocks
+  module Doorkeeper
+    module Invitations
+      extend ActiveSupport::Autoload
 
-  autoload :Controller
-  autoload :Application
+      autoload :Controller
+      autoload :Application
+    end
+  end
 end

data/lib/api_blocks/doorkeeper/invitations/application.rb

@@ -8,10 +8,16 @@
 #
 # @private
 #
-module ApiBlocks::Doorkeeper::Invitations::Application
-  extend ActiveSupport::Concern
+module ApiBlocks
+  module Doorkeeper
+    module Invitations
+      module Application
+        extend ActiveSupport::Concern
 
-  included do
-    validates :invitation_uri, "doorkeeper/redirect_uri": true
+        included do
+          validates :invitation_uri, "doorkeeper/redirect_uri": true
+        end
+      end
+    end
   end
 end

data/lib/api_blocks/doorkeeper/invitations/controller.rb

@@ -2,101 +2,106 @@
 
 # ApiBlocks::Doorkeeper::Invitations::Controller implements a devise invitable
 # API controller.
-module ApiBlocks::Doorkeeper::Invitations::Controller
-  extend ActiveSupport::Concern
-
-  included do # rubocop:disable Metrics/BlockLength
-    skip_after_action :verify_authorized
-    skip_after_action :verify_policy_scoped
-
-    # Initialize a new invitation.
-    def create
-      user = user_model.invite!(
-        create_params, current_user, application: oauth_application,
-      )
-
-      return render(status: :no_content) if user.errors.empty?
-
-      respond_with(user)
-    end
-
-    # Renders informations about the invited user.
-    def show
-      user = user_model.find_by_invitation_token(params[:invitation_token], false)
-
-      if user.nil? || !user.persisted?
-        return render(
-          problem: { details: "invalid invitation token" },
-          status: :bad_request
-        )
+module ApiBlocks
+  module Doorkeeper
+    module Invitations
+      module Controller
+        extend ActiveSupport::Concern
+
+        included do # rubocop:disable Metrics/BlockLength
+          skip_after_action :verify_authorized
+          skip_after_action :verify_policy_scoped
+
+          # Initialize a new invitation.
+          def create
+            user = user_model.invite!(
+              create_params, current_user, application: oauth_application
+            )
+
+            return render(status: :no_content) if user.errors.empty?
+
+            respond_with(user)
+          end
+
+          # Renders informations about the invited user.
+          def show
+            user = user_model.find_by_invitation_token(params[:invitation_token], false)
+
+            if user.nil? || !user.persisted?
+              return render(
+                problem: { details: 'invalid invitation token' },
+                status: :bad_request
+              )
+            end
+
+            respond_with(user)
+          end
+
+          # Redirects to the application's redirect uri.
+          def callback
+            query = {
+              invitation_token: params[:invitation_token]
+            }.to_query
+
+            redirect_to("#{oauth_application.invitation_uri}?#{query}")
+          end
+
+          # Finalize the invitation.
+          def update
+            user = user_model.accept_invitation!(update_params)
+
+            return respond_with(user) unless user.errors.empty?
+
+            user.unlock_access! if unlockable?(user)
+
+            respond_with(Doorkeeper::OAuth::TokenResponse.new(
+              access_token(oauth_application, user)
+            ).body)
+          end
+
+          private
+
+          def create_params
+            params.require(:user).permit(:email)
+          end
+
+          def update_params
+            params.require(:user).permit(
+              :invitation_token, :password, :password_confirmation
+            )
+          end
+
+          # Copied over from devise base controller in order to determine wether a ser
+          # is unlockable or not.
+          def unlockable?(resource)
+            resource.respond_to?(:unlock_access!) &&
+              resource.respond_to?(:unlock_strategy_enabled?) &&
+              resource.unlock_strategy_enabled?(:email)
+          end
+
+          # Returns a new access token for this user.
+          def access_token(application, user)
+            Doorkeeper::AccessToken.find_or_create_for(
+              application,
+              user.id,
+              Doorkeeper.configuration.default_scopes,
+              Doorkeeper.configuration.access_token_expires_in,
+              true
+            )
+          end
+
+          def oauth_application
+            @oauth_application ||= Doorkeeper::Application.find_by!(
+              uid: params[:client_id]
+            )
+          end
+
+          # Returns the user model class.
+          def user_model
+            raise 'the method `user_model` must be implemented on your invitations controller'
+          end
+        end
       end
-
-      respond_with(user)
-    end
-
-    # Redirects to the application's redirect uri.
-    def callback
-      query = {
-        invitation_token: params[:invitation_token]
-      }.to_query
-
-      redirect_to("#{oauth_application.invitation_uri}?#{query}")
-    end
-
-    # Finalize the invitation.
-    def update
-      user = user_model.accept_invitation!(update_params)
-
-      return respond_with(user) unless user.errors.empty?
-
-      user.unlock_access! if unlockable?(user)
-
-      respond_with(Doorkeeper::OAuth::TokenResponse.new(
-        access_token(oauth_application, user)
-      ).body)
-    end
-
-    private
-
-    def create_params
-      params.require(:user).permit(:email)
-    end
-
-    def update_params
-      params.require(:user).permit(
-        :invitation_token, :password, :password_confirmation
-      )
-    end
-
-    # Copied over from devise base controller in order to determine wether a ser
-    # is unlockable or not.
-    def unlockable?(resource)
-      resource.respond_to?(:unlock_access!) &&
-        resource.respond_to?(:unlock_strategy_enabled?) &&
-        resource.unlock_strategy_enabled?(:email)
-    end
-
-    # Returns a new access token for this user.
-    def access_token(application, user)
-      Doorkeeper::AccessToken.find_or_create_for(
-        application,
-        user.id,
-        Doorkeeper.configuration.default_scopes,
-        Doorkeeper.configuration.access_token_expires_in,
-        true
-      )
-    end
-
-    def oauth_application
-      @oauth_application ||= Doorkeeper::Application.find_by!(
-        uid: params[:client_id]
-      )
-    end
-
-
-    # Returns the user model class.
-    def user_model
-      raise 'the method `user_model` must be implemented on your invitations controller' # rubocop:disable Metrics/LineLength
     end
   end
 end