doorkeeper 5.1.0 → 5.5.0

data/lib/doorkeeper/models/access_token_mixin.rb

@@ -12,6 +12,7 @@ module Doorkeeper
     include Models::Orderable
     include Models::SecretStorable
     include Models::Scopes
+    include Models::ResourceOwnerable
 
     module ClassMethods
       # Returns an instance of the Doorkeeper::AccessToken with
@@ -40,18 +41,35 @@ module Doorkeeper
         find_by_plaintext_token(:refresh_token, refresh_token)
       end
 
+      # Returns an instance of the Doorkeeper::AccessToken
+      # found by previous refresh token. Keep in mind that value
+      # of the previous_refresh_token isn't encrypted using
+      # secrets strategy.
+      #
+      # @param previous_refresh_token [#to_s]
+      #   previous refresh token value (any object that responds to `#to_s`)
+      #
+      # @return [Doorkeeper::AccessToken, nil] AccessToken object or nil
+      #   if there is no record with such refresh token
+      #
+      def by_previous_refresh_token(previous_refresh_token)
+        find_by(refresh_token: previous_refresh_token)
+      end
+
       # Revokes AccessToken records that have not been revoked and associated
       # with the specific Application and Resource Owner.
       #
       # @param application_id [Integer]
       #   ID of the Application
-      # @param resource_owner [ActiveRecord::Base]
-      #   instance of the Resource Owner model
+      # @param resource_owner [ActiveRecord::Base, Integer]
+      #   instance of the Resource Owner model or it's ID
       #
       def revoke_all_for(application_id, resource_owner, clock = Time)
-        where(application_id: application_id,
-              resource_owner_id: resource_owner.id,
-              revoked_at: nil)
+        by_resource_owner(resource_owner)
+          .where(
+            application_id: application_id,
+            revoked_at: nil,
+          )
           .update_all(revoked_at: clock.now.utc)
       end
 
@@ -60,7 +78,7 @@ module Doorkeeper
       #
       # @param application [Doorkeeper::Application]
       #   Application instance
-      # @param resource_owner_or_id [ActiveRecord::Base, Integer]
+      # @param resource_owner [ActiveRecord::Base, Integer]
       #   Resource Owner model instance or it's ID
       # @param scopes [String, Doorkeeper::OAuth::Scopes]
       #   set of scopes
@@ -68,17 +86,53 @@ module Doorkeeper
       # @return [Doorkeeper::AccessToken, nil] Access Token instance or
       #   nil if matching record was not found
       #
-      def matching_token_for(application, resource_owner_or_id, scopes)
-        resource_owner_id = if resource_owner_or_id.respond_to?(:to_key)
-                              resource_owner_or_id.id
-                            else
-                              resource_owner_or_id
-                            end
+      def matching_token_for(application, resource_owner, scopes)
+        tokens = authorized_tokens_for(application&.id, resource_owner)
+        find_matching_token(tokens, application, scopes)
+      end
 
-        tokens = authorized_tokens_for(application.try(:id), resource_owner_id)
-        tokens.detect do |token|
-          scopes_match?(token.scopes, scopes, application.try(:scopes))
+      # Interface to enumerate access token records in batches in order not
+      # to bloat the memory. Could be overloaded in any ORM extension.
+      #
+      def find_access_token_in_batches(relation, **args, &block)
+        relation.find_in_batches(**args, &block)
+      end
+
+      # Enumerates AccessToken records in batches to find a matching token.
+      # Batching is required in order not to pollute the memory if Application
+      # has huge amount of associated records.
+      #
+      # ActiveRecord 5.x - 6.x ignores custom ordering so we can't perform a
+      # database sort by created_at, so we need to load all the matching records,
+      # sort them and find latest one. Probably it would be better to rewrite this
+      # query using Time math if possible, but we n eed to consider ORM and
+      # different databases support.
+      #
+      # @param relation [ActiveRecord::Relation]
+      #   Access tokens relation
+      # @param application [Doorkeeper::Application]
+      #   Application instance
+      # @param scopes [String, Doorkeeper::OAuth::Scopes]
+      #   set of scopes
+      #
+      # @return [Doorkeeper::AccessToken, nil] Access Token instance or
+      #   nil if matching record was not found
+      #
+      def find_matching_token(relation, application, scopes)
+        return nil unless relation
+
+        matching_tokens = []
+        batch_size = Doorkeeper.configuration.token_lookup_batch_size
+
+        find_access_token_in_batches(relation, batch_size: batch_size) do |batch|
+          tokens = batch.select do |token|
+            scopes_match?(token.scopes, scopes, application&.scopes)
+          end
+
+          matching_tokens.concat(tokens)
         end
+
+        matching_tokens.max_by(&:created_at)
       end
 
       # Checks whether the token scopes match the scopes from the parameters
@@ -101,8 +155,8 @@ module Doorkeeper
         (token_scopes.sort == param_scopes.sort) &&
           Doorkeeper::OAuth::Helpers::ScopeChecker.valid?(
             scope_str: param_scopes.to_s,
-            server_scopes: Doorkeeper.configuration.scopes,
-            app_scopes: app_scopes
+            server_scopes: Doorkeeper.config.scopes,
+            app_scopes: app_scopes,
           )
       end
 
@@ -112,48 +166,81 @@ module Doorkeeper
       #
       # @param application [Doorkeeper::Application]
       #   Application instance
-      # @param resource_owner_id [ActiveRecord::Base, Integer]
+      # @param resource_owner [ActiveRecord::Base, Integer]
       #   Resource Owner model instance or it's ID
       # @param scopes [#to_s]
       #   set of scopes (any object that responds to `#to_s`)
-      # @param expires_in [Integer]
+      # @param token_attributes [Hash]
+      #   Additional attributes to use when creating a token
+      # @option token_attributes [Integer] :expires_in
       #   token lifetime in seconds
-      # @param use_refresh_token [Boolean]
+      # @option token_attributes [Boolean] :use_refresh_token
       #   whether to use the refresh token
       #
       # @return [Doorkeeper::AccessToken] existing record or a new one
       #
-      def find_or_create_for(application, resource_owner_id, scopes, expires_in, use_refresh_token)
-        if Doorkeeper.configuration.reuse_access_token
-          access_token = matching_token_for(application, resource_owner_id, scopes)
+      def find_or_create_for(application:, resource_owner:, scopes:, **token_attributes)
+        if Doorkeeper.config.reuse_access_token
+          access_token = matching_token_for(application, resource_owner, scopes)
 
           return access_token if access_token&.reusable?
         end
 
-        create!(
-          application_id: application.try(:id),
-          resource_owner_id: resource_owner_id,
-          scopes: scopes.to_s,
-          expires_in: expires_in,
-          use_refresh_token: use_refresh_token
+        create_for(
+          application: application,
+          resource_owner: resource_owner,
+          scopes: scopes,
+          **token_attributes,
         )
       end
 
+      # Creates a not expired AccessToken record with a matching set of
+      # scopes that belongs to specific Application and Resource Owner.
+      #
+      # @param application [Doorkeeper::Application]
+      #   Application instance
+      # @param resource_owner [ActiveRecord::Base, Integer]
+      #   Resource Owner model instance or it's ID
+      # @param scopes [#to_s]
+      #   set of scopes (any object that responds to `#to_s`)
+      # @param token_attributes [Hash]
+      #   Additional attributes to use when creating a token
+      # @option token_attributes [Integer] :expires_in
+      #   token lifetime in seconds
+      # @option token_attributes [Boolean] :use_refresh_token
+      #   whether to use the refresh token
+      #
+      # @return [Doorkeeper::AccessToken] new access token
+      #
+      def create_for(application:, resource_owner:, scopes:, **token_attributes)
+        token_attributes[:application_id] = application&.id
+        token_attributes[:scopes] = scopes.to_s
+
+        if Doorkeeper.config.polymorphic_resource_owner?
+          token_attributes[:resource_owner] = resource_owner
+        else
+          token_attributes[:resource_owner_id] = resource_owner_id_for(resource_owner)
+        end
+
+        create!(token_attributes)
+      end
+
       # Looking for not revoked Access Token records that belongs to specific
       # Application and Resource Owner.
       #
       # @param application_id [Integer]
       #   ID of the Application model instance
-      # @param resource_owner_id [Integer]
-      #   ID of the Resource Owner model instance
+      # @param resource_owner [ActiveRecord::Base, Integer]
+      #   Resource Owner model instance or it's ID
       #
-      # @return [Doorkeeper::AccessToken] array of matching AccessToken objects
+      # @return [ActiveRecord::Relation]
+      #   collection of matching AccessToken objects
       #
-      def authorized_tokens_for(application_id, resource_owner_id)
-        ordered_by(:created_at, :desc)
-          .where(application_id: application_id,
-                 resource_owner_id: resource_owner_id,
-                 revoked_at: nil)
+      def authorized_tokens_for(application_id, resource_owner)
+        by_resource_owner(resource_owner).where(
+          application_id: application_id,
+          revoked_at: nil,
+        )
       end
 
       # Convenience method for backwards-compatibility, return the last
@@ -161,28 +248,33 @@ module Doorkeeper
       #
       # @param application_id [Integer]
       #   ID of the Application model instance
-      # @param resource_owner_id [Integer]
+      # @param resource_owner [ActiveRecord::Base, Integer]
       #   ID of the Resource Owner model instance
       #
       # @return [Doorkeeper::AccessToken, nil] matching AccessToken object or
       #   nil if nothing was found
       #
-      def last_authorized_token_for(application_id, resource_owner_id)
-        authorized_tokens_for(application_id, resource_owner_id).first
+      def last_authorized_token_for(application_id, resource_owner)
+        authorized_tokens_for(application_id, resource_owner)
+          .ordered_by(:created_at, :desc)
+          .first
       end
 
       ##
       # Determines the secret storing transformer
       # Unless configured otherwise, uses the plain secret strategy
+      #
+      # @return [Doorkeeper::SecretStoring::Base]
+      #
       def secret_strategy
-        ::Doorkeeper.configuration.token_secret_strategy
+        ::Doorkeeper.config.token_secret_strategy
       end
 
       ##
       # Determine the fallback storing strategy
       # Unless configured, there will be no fallback
       def fallback_secret_strategy
-        ::Doorkeeper.configuration.token_secret_fallback_strategy
+        ::Doorkeeper.config.token_secret_fallback_strategy
       end
     end
 
@@ -209,7 +301,11 @@ module Doorkeeper
         expires_in: expires_in_seconds,
         application: { uid: application.try(:uid) },
         created_at: created_at.to_i,
-      }
+      }.tap do |json|
+        if Doorkeeper.configuration.polymorphic_resource_owner?
+          json[:resource_owner_type] = resource_owner_type
+        end
+      end
     end
 
     # Indicates whether the token instance have the same credential
@@ -221,7 +317,22 @@ module Doorkeeper
     #
     def same_credential?(access_token)
       application_id == access_token.application_id &&
+        same_resource_owner?(access_token)
+    end
+
+    # Indicates whether the token instance have the same credential
+    # as the other Access Token.
+    #
+    # @param access_token [Doorkeeper::AccessToken] other token
+    #
+    # @return [Boolean] true if credentials are same of false in other cases
+    #
+    def same_resource_owner?(access_token)
+      if Doorkeeper.configuration.polymorphic_resource_owner?
+        resource_owner == access_token.resource_owner
+      else
         resource_owner_id == access_token.resource_owner_id
+      end
     end
 
     # Indicates if token is acceptable for specific scopes.
@@ -259,8 +370,28 @@ module Doorkeeper
       end
     end
 
+    # Revokes token with `:refresh_token` equal to `:previous_refresh_token`
+    # and clears `:previous_refresh_token` attribute.
+    #
+    def revoke_previous_refresh_token!
+      return unless self.class.refresh_token_revoked_on_use?
+
+      old_refresh_token&.revoke
+      update_attribute(:previous_refresh_token, "") if previous_refresh_token.present?
+    end
+
     private
 
+    # Searches for Access Token record with `:refresh_token` equal to
+    # `:previous_refresh_token` value.
+    #
+    # @return [Doorkeeper::AccessToken, nil]
+    #   Access Token record or nil if nothing found
+    #
+    def old_refresh_token
+      @old_refresh_token ||= self.class.by_previous_refresh_token(previous_refresh_token)
+    end
+
     # Generates refresh token with UniqueToken generator.
     #
     # @return [String] refresh token value
@@ -271,7 +402,7 @@ module Doorkeeper
     end
 
     # Generates and sets the token value with the
-    # configured Generator class (see Doorkeeper.configuration).
+    # configured Generator class (see Doorkeeper.config).
     #
     # @return [String] generated token value
     #
@@ -283,20 +414,32 @@ module Doorkeeper
     def generate_token
       self.created_at ||= Time.now.utc
 
-      @raw_token = token_generator.generate(
+      @raw_token = token_generator.generate(attributes_for_token_generator)
+      secret_strategy.store_secret(self, :token, @raw_token)
+      @raw_token
+    end
+
+    # Set of attributes that would be passed to token generator to
+    # generate unique token based on them.
+    #
+    #  @return [Hash] set of attributes
+    #
+    def attributes_for_token_generator
+      {
         resource_owner_id: resource_owner_id,
         scopes: scopes,
         application: application,
         expires_in: expires_in,
-        created_at: created_at
-      )
-
-      secret_strategy.store_secret(self, :token, @raw_token)
-      @raw_token
+        created_at: created_at,
+      }.tap do |attributes|
+        if Doorkeeper.config.polymorphic_resource_owner?
+          attributes[:resource_owner] = resource_owner
+        end
+      end
     end
 
     def token_generator
-      generator_name = Doorkeeper.configuration.access_token_generator
+      generator_name = Doorkeeper.config.access_token_generator
       generator = generator_name.constantize
 
       return generator if generator.respond_to?(:generate)

data/lib/doorkeeper/models/application_mixin.rb

@@ -20,8 +20,8 @@ module Doorkeeper
       # @param uid [#to_s] UID (any object that responds to `#to_s`)
       # @param secret [#to_s] secret (any object that responds to `#to_s`)
       #
-      # @return [Doorkeeper::Application, nil] Application instance or nil
-      #   if there is no record with such credentials
+      # @return [Doorkeeper::Application, nil]
+      #   Application instance or nil if there is no record with such credentials
       #
       def by_uid_and_secret(uid, secret)
         app = by_uid(uid)
@@ -47,22 +47,23 @@ module Doorkeeper
       # Determines the secret storing transformer
       # Unless configured otherwise, uses the plain secret strategy
       def secret_strategy
-        ::Doorkeeper.configuration.application_secret_strategy
+        ::Doorkeeper.config.application_secret_strategy
       end
 
       ##
       # Determine the fallback storing strategy
       # Unless configured, there will be no fallback
       def fallback_secret_strategy
-        ::Doorkeeper.configuration.application_secret_fallback_strategy
+        ::Doorkeeper.config.application_secret_fallback_strategy
       end
     end
 
     # Set an application's valid redirect URIs.
     #
-    # @param uris [String, Array] Newline-separated string or array the URI(s)
+    # @param uris [String, Array<String>] Newline-separated string or array the URI(s)
+    #
+    # @return [String] The redirect URI(s) separated by newlines.
     #
-    # @return [String] The redirect URI(s) seperated by newlines.
     def redirect_uri=(uris)
       super(uris.is_a?(Array) ? uris.join("\n") : uris)
     end
@@ -72,7 +73,7 @@ module Doorkeeper
     # @param input [#to_s] Plain secret provided by user
     #        (any object that responds to `#to_s`)
     #
-    # @return [true] Whether the given secret matches the stored secret
+    # @return [Boolean] Whether the given secret matches the stored secret
     #                of this application.
     #
     def secret_matches?(input)

data/lib/doorkeeper/models/concerns/ownership.rb

@@ -11,7 +11,7 @@ module Doorkeeper
       end
 
       def validate_owner?
-        Doorkeeper.configuration.confirm_application_owner?
+        Doorkeeper.config.confirm_application_owner?
       end
     end
   end

data/lib/doorkeeper/models/concerns/resource_ownerable.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module Models
+    module ResourceOwnerable
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Searches for record by Resource Owner considering Doorkeeper
+        # configuration for resource owner association.
+        #
+        # @param resource_owner [ActiveRecord::Base, Integer]
+        #   resource owner
+        #
+        # @return [Doorkeeper::AccessGrant, Doorkeeper::AccessToken]
+        #   collection of records
+        #
+        def by_resource_owner(resource_owner)
+          if Doorkeeper.configuration.polymorphic_resource_owner?
+            where(resource_owner: resource_owner)
+          else
+            where(resource_owner_id: resource_owner_id_for(resource_owner))
+          end
+        end
+
+        protected
+
+        # Backward compatible way to retrieve resource owner itself (if
+        # polymorphic association enabled) or just it's ID.
+        #
+        # @param resource_owner [ActiveRecord::Base, Integer]
+        #   resource owner
+        #
+        # @return [ActiveRecord::Base, Integer]
+        #   instance of Resource Owner or it's ID
+        #
+        def resource_owner_id_for(resource_owner)
+          if resource_owner.respond_to?(:to_key)
+            resource_owner.id
+          else
+            resource_owner
+          end
+        end
+      end
+    end
+  end
+end

data/lib/doorkeeper/models/concerns/reusable.rb

@@ -11,7 +11,7 @@ module Doorkeeper
         return false if expired?
         return true unless expires_in
 
-        threshold_limit = 100 - Doorkeeper.configuration.token_reuse_limit
+        threshold_limit = 100 - Doorkeeper.config.token_reuse_limit
         expires_in_seconds >= threshold_limit * expires_in / 100
       end
     end

data/lib/doorkeeper/models/concerns/revocable.rb

@@ -9,7 +9,7 @@ module Doorkeeper
       # @param clock [Time] time object
       #
       def revoke(clock = Time)
-        update_attribute :revoked_at, clock.now.utc
+        update_attribute(:revoked_at, clock.now.utc)
       end
 
       # Indicates whether the object has been revoked.
@@ -19,33 +19,6 @@ module Doorkeeper
       def revoked?
         !!(revoked_at && revoked_at <= Time.now.utc)
       end
-
-      # Revokes token with `:refresh_token` equal to `:previous_refresh_token`
-      # and clears `:previous_refresh_token` attribute.
-      #
-      def revoke_previous_refresh_token!
-        return unless refresh_token_revoked_on_use?
-
-        old_refresh_token&.revoke
-        update_attribute :previous_refresh_token, ""
-      end
-
-      private
-
-      # Searches for Access Token record with `:refresh_token` equal to
-      # `:previous_refresh_token` value.
-      #
-      # @return [Doorkeeper::AccessToken, nil]
-      #   Access Token record or nil if nothing found
-      #
-      def old_refresh_token
-        @old_refresh_token ||=
-          AccessToken.by_refresh_token(previous_refresh_token)
-      end
-
-      def refresh_token_revoked_on_use?
-        AccessToken.refresh_token_revoked_on_use?
-      end
     end
   end
 end

data/lib/doorkeeper/models/concerns/scopes.rb

@@ -8,7 +8,11 @@ module Doorkeeper
       end
 
       def scopes=(value)
-        super Array(value).join(" ")
+        if value.is_a?(Array)
+          super(Doorkeeper::OAuth::Scopes.from_array(value).to_s)
+        else
+          super(Doorkeeper::OAuth::Scopes.from_string(value.to_s).to_s)
+        end
       end
 
       def scopes_string

data/lib/doorkeeper/models/concerns/secret_storable.rb

@@ -25,9 +25,7 @@ module Doorkeeper
         # @return [Boolean]
         #   Whether input matches secret as per the secret strategy
         #
-        def secret_matches?(input, secret)
-          secret_strategy.secret_matches?(input, secret)
-        end
+        delegate :secret_matches?, to: :secret_strategy
 
         # Returns an instance of the Doorkeeper::AccessToken with
         # specific token value.

data/lib/doorkeeper/oauth/authorization/code.rb

@@ -4,37 +4,48 @@ module Doorkeeper
   module OAuth
     module Authorization
       class Code
-        attr_accessor :pre_auth, :resource_owner, :token
+        attr_reader :pre_auth, :resource_owner, :token
 
         def initialize(pre_auth, resource_owner)
           @pre_auth = pre_auth
           @resource_owner = resource_owner
         end
 
-        def issue_token
-          @token ||= AccessGrant.create! access_grant_attributes
+        def issue_token!
+          return @token if defined?(@token)
+
+          @token = Doorkeeper.config.access_grant_model.create!(access_grant_attributes)
         end
 
-        def native_redirect
+        def oob_redirect
           { action: :show, code: token.plaintext_token }
         end
 
-        def configuration
-          Doorkeeper.configuration
+        def access_grant?
+          true
         end
 
         private
 
         def authorization_code_expires_in
-          configuration.authorization_code_expires_in
+          Doorkeeper.config.authorization_code_expires_in
         end
 
         def access_grant_attributes
-          pkce_attributes.merge application_id: pre_auth.client.id,
-                                resource_owner_id: resource_owner.id,
-                                expires_in: authorization_code_expires_in,
-                                redirect_uri: pre_auth.redirect_uri,
-                                scopes: pre_auth.scopes.to_s
+          attributes = {
+            application_id: pre_auth.client.id,
+            expires_in: authorization_code_expires_in,
+            redirect_uri: pre_auth.redirect_uri,
+            scopes: pre_auth.scopes.to_s,
+          }
+
+          if Doorkeeper.config.polymorphic_resource_owner?
+            attributes[:resource_owner] = resource_owner
+          else
+            attributes[:resource_owner_id] = resource_owner.id
+          end
+
+          pkce_attributes.merge(attributes)
         end
 
         def pkce_attributes
@@ -46,10 +57,10 @@ module Doorkeeper
           }
         end
 
-        # ensures firstly, if migration with additional pcke columns was
+        # Ensures firstly, if migration with additional PKCE columns was
         # generated and migrated
         def pkce_supported?
-          Doorkeeper::AccessGrant.pkce_supported?
+          Doorkeeper.config.access_grant_model.pkce_supported?
         end
       end
     end

data/lib/doorkeeper/oauth/authorization/context.rb

@@ -4,12 +4,12 @@ module Doorkeeper
   module OAuth
     module Authorization
       class Context
-        attr_reader :client, :grant_type, :scopes
+        attr_reader :client, :grant_type, :resource_owner, :scopes
 
-        def initialize(client, grant_type, scopes)
-          @client     = client
-          @grant_type = grant_type
-          @scopes     = scopes
+        def initialize(**attributes)
+          attributes.each do |name, value|
+            instance_variable_set(:"@#{name}", value) if respond_to?(name)
+          end
         end
       end
     end