super-smart-kit 0.0.1

data/doorkeeper-5.9.3/lib/doorkeeper/models/concerns/expiration_time_sql_math.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module Models
+    module ExpirationTimeSqlMath
+      extend ::ActiveSupport::Concern
+
+      WARNING_MESSAGE = <<~WARNING.squish
+        [DOORKEEPER] Doorkeeper doesn't support expiration time math for your database adapter.
+        Records with an individual expires_in value longer than the global TTL may be incorrectly processed.
+        Please add a class method `custom_expiration_time_sql` to your AccessToken/AccessGrant models/mixins to provide a custom
+        SQL expression to calculate access token expiration time. See lib/doorkeeper/orm/active_record/mixins/access_token.rb
+        for more details.
+      WARNING
+
+      class ExpirationTimeSqlGenerator
+        attr_reader :model
+
+        delegate :table_name, to: :@model
+
+        def initialize(model)
+          @model = model
+        end
+
+        def generate_sql
+          raise "`generate_sql` should be overridden for a #{self.class.name}!"
+        end
+      end
+
+      class MySqlExpirationTimeSqlGenerator < ExpirationTimeSqlGenerator
+        def generate_sql
+          Arel.sql("DATE_ADD(#{table_name}.created_at, INTERVAL #{table_name}.expires_in SECOND)")
+        end
+      end
+
+      class SqlLiteExpirationTimeSqlGenerator < ExpirationTimeSqlGenerator
+        def generate_sql
+          Arel.sql("DATETIME(#{table_name}.created_at, '+' || #{table_name}.expires_in || ' SECONDS')")
+        end
+      end
+
+      class SqlServerExpirationTimeSqlGenerator < ExpirationTimeSqlGenerator
+        def generate_sql
+          Arel.sql("DATEADD(second, #{table_name}.expires_in, #{table_name}.created_at) AT TIME ZONE 'UTC'")
+        end
+      end
+
+      class OracleExpirationTimeSqlGenerator < ExpirationTimeSqlGenerator
+        def generate_sql
+          Arel.sql("#{table_name}.created_at + INTERVAL to_char(#{table_name}.expires_in) second")
+        end
+      end
+
+      class PostgresExpirationTimeSqlGenerator < ExpirationTimeSqlGenerator
+        def generate_sql
+          Arel.sql("#{table_name}.created_at + #{table_name}.expires_in * INTERVAL '1 SECOND'")
+        end
+      end
+
+      ADAPTERS_MAPPING = {
+        "sqlite" => SqlLiteExpirationTimeSqlGenerator,
+        "sqlite3" => SqlLiteExpirationTimeSqlGenerator,
+        "postgis" => PostgresExpirationTimeSqlGenerator,
+        "postgresql" => PostgresExpirationTimeSqlGenerator,
+        "mysql" => MySqlExpirationTimeSqlGenerator,
+        "mysql2" => MySqlExpirationTimeSqlGenerator,
+        "trilogy" => MySqlExpirationTimeSqlGenerator,
+        "sqlserver" => SqlServerExpirationTimeSqlGenerator,
+        "oracleenhanced" => OracleExpirationTimeSqlGenerator,
+      }.freeze
+
+      module ClassMethods
+        def supports_expiration_time_math?
+          ADAPTERS_MAPPING.key?(adapter_name.downcase) ||
+            respond_to?(:custom_expiration_time_sql)
+        end
+
+        def expiration_time_sql
+          if respond_to?(:custom_expiration_time_sql)
+            custom_expiration_time_sql
+          else
+            expiration_time_sql_expression
+          end
+        end
+
+        def expiration_time_sql_expression
+          ADAPTERS_MAPPING.fetch(adapter_name.downcase).new(self).generate_sql
+        end
+
+        def adapter_name
+          ActiveRecord::Base.connection.adapter_name
+        end
+      end
+    end
+  end
+end

data/doorkeeper-5.9.3/lib/doorkeeper/models/concerns/orderable.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module Models
+    module Orderable
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def ordered_by(attribute, direction = :asc)
+          order(attribute => direction)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module Models
+    module Ownership
+      extend ActiveSupport::Concern
+
+      included do
+        belongs_to :owner, polymorphic: true, optional: true
+        validates :owner, presence: true, if: :validate_owner?
+      end
+
+      def validate_owner?
+        Doorkeeper.config.confirm_application_owner?
+      end
+    end
+  end
+end

data/doorkeeper-5.9.3/lib/doorkeeper/models/concerns/polymorphic_resource_owner.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module Models
+    module PolymorphicResourceOwner
+      module ForAccessGrant
+        extend ActiveSupport::Concern
+
+        included do
+          if Doorkeeper.config.polymorphic_resource_owner?
+            belongs_to :resource_owner, polymorphic: true, optional: false
+          else
+            validates :resource_owner_id, presence: true
+          end
+        end
+      end
+
+      module ForAccessToken
+        extend ActiveSupport::Concern
+
+        included do
+          if Doorkeeper.config.polymorphic_resource_owner?
+            belongs_to :resource_owner, polymorphic: true, optional: true
+          end
+        end
+      end
+    end
+  end
+end

data/doorkeeper-5.9.3/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/doorkeeper-5.9.3/lib/doorkeeper/models/concerns/reusable.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module Models
+    module Reusable
+      # Indicates whether the object is reusable (i.e. It is not expired and
+      # has not crossed reuse_limit).
+      #
+      # @return [Boolean] true if can be reused and false in other case
+      def reusable?
+        return false if expired?
+        return true unless expires_in
+
+        threshold_limit = 100 - Doorkeeper.config.token_reuse_limit
+        expires_in_seconds >= threshold_limit * expires_in / 100
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module Models
+    module Revocable
+      # Revokes the object (updates `:revoked_at` attribute setting its value
+      # to the specific time).
+      #
+      # @param clock [Time] time object
+      #
+      def revoke(clock = Time)
+        return if revoked?
+
+        # Wrap in with_primary_role if the model class supports it
+        if self.class.respond_to?(:with_primary_role)
+          self.class.with_primary_role { update_attribute(:revoked_at, clock.now.utc) }
+        else
+          update_attribute(:revoked_at, clock.now.utc)
+        end
+      end
+
+      # Indicates whether the object has been revoked.
+      #
+      # @return [Boolean] true if revoked, false in other case
+      #
+      def revoked?
+        !!(revoked_at && revoked_at <= Time.now.utc)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module Models
+    module Scopes
+      def scopes
+        OAuth::Scopes.from_string(scopes_string)
+      end
+
+      def scopes=(value)
+        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
+        self[:scopes]
+      end
+
+      def includes_scope?(*required_scopes)
+        required_scopes.blank? || required_scopes.any? { |scope| scopes.exists?(scope.to_s) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module Models
+    ##
+    # Storable finder to provide lookups for input plaintext values which are
+    # mapped to their stored versions (e.g., hashing, encryption) before lookup.
+    module SecretStorable
+      extend ActiveSupport::Concern
+
+      delegate :secret_strategy,
+               :fallback_secret_strategy,
+               to: :class
+
+      # :nodoc
+      module ClassMethods
+        # Compare the given plaintext with the secret
+        #
+        # @param input [String]
+        #   The plain input to compare.
+        #
+        # @param secret [String]
+        #   The secret value to compare with.
+        #
+        # @return [Boolean]
+        #   Whether input matches secret as per the secret strategy
+        #
+        delegate :secret_matches?, to: :secret_strategy
+
+        # Returns an instance of the Doorkeeper::AccessToken with
+        # specific token value.
+        #
+        # @param attr [Symbol]
+        #   The token attribute we're looking with.
+        #
+        # @param token [#to_s]
+        #   token value (any object that responds to `#to_s`)
+        #
+        # @return [Doorkeeper::AccessToken, nil] AccessToken object or nil
+        #   if there is no record with such token
+        #
+        def find_by_plaintext_token(attr, token)
+          token = token.to_s
+
+          find_by(attr => secret_strategy.transform_secret(token)) ||
+            find_by_fallback_token(attr, token)
+        end
+
+        # Allow looking up previously plain tokens as a fallback
+        # IFF a fallback strategy has been defined
+        #
+        # @param attr [Symbol]
+        #   The token attribute we're looking with.
+        #
+        # @param plain_secret [#to_s]
+        #   plain secret value (any object that responds to `#to_s`)
+        #
+        # @return [Doorkeeper::AccessToken, nil] AccessToken object or nil
+        #   if there is no record with such token
+        #
+        def find_by_fallback_token(attr, plain_secret)
+          return nil unless fallback_secret_strategy
+
+          # Use the previous strategy to look up
+          stored_token = fallback_secret_strategy.transform_secret(plain_secret)
+          find_by(attr => stored_token).tap do |resource|
+            return nil unless resource
+
+            upgrade_fallback_value resource, attr, plain_secret
+          end
+        end
+
+        # Allow implementations in ORMs to replace a plain
+        # value falling back to to avoid it remaining as plain text.
+        #
+        # @param instance
+        #   An instance of this model with a plain value token.
+        #
+        # @param attr
+        #   The secret attribute name to upgrade.
+        #
+        # @param plain_secret
+        #   The plain secret to upgrade.
+        #
+        def upgrade_fallback_value(instance, attr, plain_secret)
+          upgraded = secret_strategy.store_secret(instance, attr, plain_secret)
+          instance.update(attr => upgraded)
+        end
+
+        ##
+        # Determines the secret storing transformer
+        # Unless configured otherwise, uses the plain secret strategy
+        def secret_strategy
+          ::Doorkeeper::SecretStoring::Plain
+        end
+
+        ##
+        # Determine the fallback storing strategy
+        # Unless configured, there will be no fallback
+        def fallback_secret_strategy
+          nil
+        end
+      end
+    end
+  end
+end

data/doorkeeper-5.9.3/lib/doorkeeper/models/concerns/write_to_primary.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module Models
+    module Concerns
+      # Provides support for Rails read replicas by ensuring write operations
+      # use the primary database when automatic role switching is enabled.
+      #
+      # When Rails uses automatic role switching with read replicas, GET requests
+      # are routed to read-only databases. However, Doorkeeper may need to write
+      # to the database during GET requests (e.g., creating access tokens during
+      # implicit grant flow). This concern wraps write operations with
+      # `connected_to(role: :writing)` to ensure they use the primary database.
+      #
+      # This concern is only active when:
+      # 1. ActiveRecord supports `connected_to` (Rails 6.1+)
+      # 2. The configuration option is enabled
+      #
+      module WriteToPrimary
+        extend ActiveSupport::Concern
+
+        class_methods do
+          # Executes the given block with a connection to the primary database
+          # for writing, if read replica support is enabled and available.
+          #
+          # @yield Block to execute with write connection
+          # @return The result of the block
+          #
+          def with_primary_role(&block)
+            if should_use_primary_role?
+              ::ActiveRecord::Base.connected_to(role: :writing, &block)
+            else
+              yield
+            end
+          end
+
+          private
+
+          # Determines if we should explicitly use the primary role for writes
+          #
+          # @return [Boolean]
+          #
+          def should_use_primary_role?
+            # Guard clause: return false if ActiveRecord is not available
+            return false unless defined?(::ActiveRecord::Base)
+
+            # Only use primary role if:
+            # 1. The enable_multiple_database_roles option is enabled in config
+            # 2. ActiveRecord supports connected_to (Rails 6.1+)
+            Doorkeeper.config.enable_multiple_database_roles &&
+              ::ActiveRecord::Base.respond_to?(:connected_to)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module OAuth
+    module Authorization
+      class Code
+        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!
+          return @token if defined?(@token)
+
+          @token = Doorkeeper.config.access_grant_model.with_primary_role do
+            Doorkeeper.config.access_grant_model.create!(access_grant_attributes)
+          end
+        end
+
+        def oob_redirect
+          { action: :show, code: token.plaintext_token }
+        end
+
+        def access_grant?
+          true
+        end
+
+        private
+
+        def authorization_code_expires_in
+          Doorkeeper.config.authorization_code_expires_in
+        end
+
+        def access_grant_attributes
+          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).merge(custom_attributes)
+        end
+
+        def custom_attributes
+          # Custom access token attributes are saved into the access grant,
+          # and then included in subsequently generated access tokens.
+          @pre_auth.custom_access_token_attributes.to_h.with_indifferent_access
+        end
+
+        def pkce_attributes
+          return {} unless pkce_supported?
+
+          {
+            code_challenge: pre_auth.code_challenge,
+            code_challenge_method: pre_auth.code_challenge_method,
+          }
+        end
+
+        # Ensures firstly, if migration with additional PKCE columns was
+        # generated and migrated
+        def pkce_supported?
+          Doorkeeper.config.access_grant_model.pkce_supported?
+        end
+      end
+    end
+  end
+end

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

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

data/doorkeeper-5.9.3/lib/doorkeeper/oauth/authorization/token.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Doorkeeper
+  module OAuth
+    module Authorization
+      class Token
+        attr_reader :pre_auth, :resource_owner, :token
+
+        class << self
+          def build_context(pre_auth_or_oauth_client, grant_type, scopes, resource_owner)
+            oauth_client = if pre_auth_or_oauth_client.respond_to?(:application)
+                             pre_auth_or_oauth_client.application
+                           elsif pre_auth_or_oauth_client.respond_to?(:client)
+                             pre_auth_or_oauth_client.client
+                           else
+                             pre_auth_or_oauth_client
+                           end
+
+            Doorkeeper::OAuth::Authorization::Context.new(
+              client: oauth_client,
+              grant_type: grant_type,
+              scopes: scopes,
+              resource_owner: resource_owner,
+            )
+          end
+
+          def access_token_expires_in(configuration, context)
+            if configuration.option_defined?(:custom_access_token_expires_in)
+              expiration = configuration.custom_access_token_expires_in.call(context)
+              return nil if expiration == Float::INFINITY
+
+              expiration || configuration.access_token_expires_in
+            else
+              configuration.access_token_expires_in
+            end
+          end
+
+          def refresh_token_enabled?(server, context)
+            if server.refresh_token_enabled?.respond_to?(:call)
+              server.refresh_token_enabled?.call(context)
+            else
+              !!server.refresh_token_enabled?
+            end
+          end
+        end
+
+        def initialize(pre_auth, resource_owner)
+          @pre_auth       = pre_auth
+          @resource_owner = resource_owner
+        end
+
+        def issue_token!
+          return @token if defined?(@token)
+
+          context = self.class.build_context(
+            pre_auth.client,
+            Doorkeeper::OAuth::IMPLICIT,
+            pre_auth.scopes,
+            resource_owner,
+          )
+
+          @token = Doorkeeper.config.access_token_model.find_or_create_for(
+            application: application,
+            resource_owner: resource_owner,
+            scopes: pre_auth.scopes,
+            expires_in: self.class.access_token_expires_in(Doorkeeper.config, context),
+            use_refresh_token: false,
+          )
+        end
+
+        def application
+          return unless pre_auth.client
+
+          pre_auth.client.is_a?(Doorkeeper.config.application_model) ? pre_auth.client : pre_auth.client.application
+        end
+
+        def oob_redirect
+          {
+            controller: controller,
+            action: :show,
+            access_token: token.plaintext_token,
+          }
+        end
+
+        def access_token?
+          true
+        end
+
+        private
+
+        def controller
+          @controller ||= begin
+            mapping = Doorkeeper::Rails::Routes.mapping[:token_info] || {}
+            mapping[:controllers] || "doorkeeper/token_info"
+          end
+        end
+      end
+    end
+  end
+end

data/doorkeeper-5.9.3/lib/doorkeeper/oauth/authorization/uri_builder.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "rack/utils"
+
+module Doorkeeper
+  module OAuth
+    module Authorization
+      class URIBuilder
+        class << self
+          def uri_with_query(url, parameters = {})
+            uri = URI.parse(url)
+            original_query = Rack::Utils.parse_query(uri.query)
+            uri.query = build_query(original_query.merge(parameters))
+            uri.to_s
+          end
+
+          def uri_with_fragment(url, parameters = {})
+            uri = URI.parse(url)
+            uri.fragment = build_query(parameters)
+            uri.to_s
+          end
+
+          private
+
+          def build_query(parameters = {})
+            parameters.reject! { |_, value| value.blank? }
+            Rack::Utils.build_query(parameters)
+          end
+        end
+      end
+    end
+  end
+end