veri 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0782d4bd585ca9ca0aaa91cb51fe4b240d9e97ccf829c69890bc2079b38dda18'
-  data.tar.gz: 56cd6f6147a7b23ea2a5cc0b12dd9d573fcae55dcbf49462f93a4db59d5ef724
+  metadata.gz: 33fc3ba81b0ff4f44df7e5bf8e6f6e25c5c318d8b1ca02988f200bf0039d19b9
+  data.tar.gz: 1433809afa4da2090dac9c75d8e1d6a14579c3ad77ff8ae6db49a5291e708b68
 SHA512:
-  metadata.gz: 29763c6104a41dd4987ff30d4c75089d8390d5c36afb7d9f9f297fe627380f0b674d46d4c52aedb27865776d6915bd38ca4acacc2adda7894fe66d9e457bfeec
-  data.tar.gz: '038ae16e36b31d87b4b83f7d51f51bb4c9d9318e6c161c9249f6eeff0a6a970343a2b1acbcb256edb4622bd03e01d1b6dda5c90c441274ef3b841f792dbc8ba6'
+  metadata.gz: 86fcd9a468d1f4fcb0c7fbe820c4e67d40a6c5e96a50bb2804141c4ad9960c5f42e0678bdd6bdf8284e9403c7d77e41fb0f756c78cf4acd019d6094aef95212a
+  data.tar.gz: e50a7bd3673bc9d806e2ed8f3e50820b75373df52720407ccf400073de0ff726ec1e8e89694369878f06b83f8cf8516fdad5ece1645dd62f0afd6ff74e36df95

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## v0.2.2
+
+### Bugs
+
+- Fixed class resolution in `current_user` method
+
+## v0.2.1
+
+### Misc
+
+- Enhanced error messages
+- Performance improvements and code optimizations
+
 ## v0.2.0
 
 ### Breaking

data/lib/veri/configuration.rb

@@ -10,31 +10,66 @@ module Veri
     setting :hashing_algorithm,
             default: :argon2,
             reader: true,
-            constructor: -> (value) { Veri::Inputs.process(value, as: :hashing_algorithm, error: Veri::ConfigurationError) }
+            constructor: -> (value) do
+              Veri::Inputs.process(
+                value,
+                as: :hashing_algorithm,
+                error: Veri::ConfigurationError,
+                message: "Invalid hashing algorithm `#{value.inspect}`, supported algorithms are: #{Veri::Configuration::HASHERS.keys.join(", ")}"
+              )
+            end
     setting :inactive_session_lifetime,
             default: nil,
             reader: true,
-            constructor: -> (value) { Veri::Inputs.process(value, as: :duration, optional: true, error: Veri::ConfigurationError) }
+            constructor: -> (value) do
+              Veri::Inputs.process(
+                value,
+                as: :duration,
+                optional: true,
+                error: Veri::ConfigurationError,
+                message: "Invalid inactive session lifetime `#{value.inspect}`, expected an instance of ActiveSupport::Duration or nil"
+              )
+            end
     setting :total_session_lifetime,
             default: 14.days,
             reader: true,
-            constructor: -> (value) { Veri::Inputs.process(value, as: :duration, error: Veri::ConfigurationError) }
+            constructor: -> (value) do
+              Veri::Inputs.process(
+                value,
+                as: :duration,
+                error: Veri::ConfigurationError,
+                message: "Invalid total session lifetime `#{value.inspect}`, expected an instance of ActiveSupport::Duration"
+              )
+            end
     setting :user_model_name,
             default: "User",
             reader: true,
-            constructor: -> (value) { Veri::Inputs.process(value, as: :string, error: Veri::ConfigurationError) }
+            constructor: -> (value) do
+              Veri::Inputs.process(
+                value,
+                as: :non_empty_string,
+                error: Veri::ConfigurationError,
+                message: "Invalid user model name `#{value.inspect}`, expected an ActiveRecord model name as a string"
+              )
+            end
+
+    HASHERS = {
+      argon2: Veri::Password::Argon2,
+      bcrypt: Veri::Password::BCrypt,
+      scrypt: Veri::Password::SCrypt
+    }.freeze
 
     def hasher
-      case hashing_algorithm
-      when :argon2 then Veri::Password::Argon2
-      when :bcrypt then Veri::Password::BCrypt
-      when :scrypt then Veri::Password::SCrypt
-      else raise Veri::Error, "Invalid hashing algorithm: #{hashing_algorithm}"
-      end
+      HASHERS.fetch(hashing_algorithm) { raise Veri::Error, "Invalid hashing algorithm: #{hashing_algorithm}" }
     end
 
     def user_model
-      Veri::Inputs.process(user_model_name, as: :model, error: Veri::ConfigurationError)
+      Veri::Inputs.process(
+        user_model_name,
+        as: :model,
+        error: Veri::ConfigurationError,
+        message: "Invalid user model name `#{user_model_name}`, expected an ActiveRecord model name as a string"
+      )
     end
   end
 end

data/lib/veri/controllers/concerns/authentication.rb

@@ -23,7 +23,9 @@ module Veri
     end
 
     def current_user
-      @current_user ||= current_session&.identity
+      user_model = Veri::Configuration.user_model
+      primary_key = user_model.primary_key
+      @current_user ||= current_session ? user_model.find_by(primary_key => current_session.authenticatable_id) : nil
     end
 
     def current_session
@@ -32,7 +34,12 @@ module Veri
     end
 
     def log_in(authenticatable)
-      token = Veri::Session.establish(Veri::Inputs.process(authenticatable, as: :authenticatable), request)
+      processed_authenticatable = Veri::Inputs.process(
+        authenticatable,
+        as: :authenticatable,
+        message: "Expected an instance of #{Veri::Configuration.user_model_name}, got `#{authenticatable.inspect}`"
+      )
+      token = Veri::Session.establish(processed_authenticatable, request)
       cookies.encrypted.permanent[:veri_token] = { value: token, httponly: true }
     end
 

data/lib/veri/inputs.rb

@@ -6,22 +6,26 @@ module Veri
 
     include Dry.Types()
 
-    def process(value, as:, optional: false, error: Veri::InvalidArgumentError)
-      checker = send(as)
+    TYPES = {
+      hashing_algorithm: -> { self::Strict::Symbol.enum(:argon2, :bcrypt, :scrypt) },
+      duration: -> { self::Instance(ActiveSupport::Duration) },
+      non_empty_string: -> { self::Strict::String.constrained(min_size: 1) },
+      model: -> { self::Strict::Class.constructor { _1.try(:safe_constantize) || _1 }.constrained(lt: ActiveRecord::Base) },
+      authenticatable: -> { self::Instance(Veri::Configuration.user_model) },
+      request: -> { self::Instance(ActionDispatch::Request) }
+    }.freeze
+
+    def process(value, as:, optional: false, error: Veri::InvalidArgumentError, message: nil)
+      checker = type_for(as)
       checker = checker.optional if optional
 
       checker[value]
     rescue Dry::Types::CoercionError => e
-      raise error, e.message
+      raise error, message || e.message
     end
 
     private
 
-    def hashing_algorithm = self::Strict::Symbol.enum(:argon2, :bcrypt, :scrypt)
-    def duration = self::Instance(ActiveSupport::Duration)
-    def string = self::Strict::String
-    def model = self::Strict::Class.constructor { _1.try(:safe_constantize) || _1 }.constrained(lt: ActiveRecord::Base)
-    def authenticatable = self::Instance(Veri::Configuration.user_model)
-    def request = self::Instance(ActionDispatch::Request)
+    def type_for(name) = Veri::Inputs::TYPES.fetch(name).call
   end
 end

data/lib/veri/models/concerns/authenticatable.rb

@@ -12,17 +12,32 @@ module Veri
 
     def update_password(password)
       update!(
-        hashed_password: hasher.create(Veri::Inputs.process(password, as: :string)),
+        hashed_password: hasher.create(
+          Veri::Inputs.process(
+            password,
+            as: :non_empty_string,
+            message: "Expected a non-empty string, got `#{password.inspect}`"
+          )
+        ),
         password_updated_at: Time.current
       )
     end
 
     def verify_password(password)
-      hasher.verify(Veri::Inputs.process(password, as: :string), hashed_password)
+      hasher.verify(
+        Veri::Inputs.process(
+          password,
+          as: :non_empty_string,
+          message: "Expected a non-empty string, got `#{password.inspect}`"
+        ),
+        hashed_password
+      )
     end
 
     private
 
-    def hasher = Veri::Configuration.hasher
+    def hasher
+      @hasher ||= Veri::Configuration.hasher
+    end
   end
 end

data/lib/veri/models/session.rb

@@ -55,7 +55,11 @@ module Veri
       update!(
         shapeshifted_at: Time.current,
         original_authenticatable: authenticatable,
-        authenticatable: Veri::Inputs.process(user, as: :authenticatable)
+        authenticatable: Veri::Inputs.process(
+          user,
+          as: :authenticatable,
+          message: "Expected an instance of #{Veri::Configuration.user_model_name}, got `#{user.inspect}`"
+        )
       )
     end
 
@@ -68,14 +72,14 @@ module Veri
     end
 
     class << self
-      def establish(authenticatable, request)
+      def establish(user, request)
         token = SecureRandom.hex(32)
         expires_at = Time.current + Veri::Configuration.total_session_lifetime
 
         new(
           hashed_token: Digest::SHA256.hexdigest(token),
           expires_at:,
-          authenticatable: Veri::Inputs.process(authenticatable, as: :authenticatable, error: Veri::Error)
+          authenticatable: Veri::Inputs.process(user, as: :authenticatable, error: Veri::Error)
         ).update_info(
           Veri::Inputs.process(request, as: :request, error: Veri::Error)
         )
@@ -83,20 +87,36 @@ module Veri
         token
       end
 
-      def prune(authenticatable = nil)
-        processed_authenticatable = Veri::Inputs.process(authenticatable, as: :authenticatable, optional: true)
-        scope = processed_authenticatable ? where(authenticatable: processed_authenticatable) : all
-        to_be_pruned = scope.where(expires_at: ...Time.current)
+      def prune(user = nil)
+        scope = if user
+                  where(
+                    authenticatable: Veri::Inputs.process(
+                      user,
+                      as: :authenticatable,
+                      optional: true,
+                      message: "Expected an instance of #{Veri::Configuration.user_model_name} or nil, got `#{user.inspect}`"
+                    )
+                  )
+                else
+                  all
+                end
+
+        expired_scope = scope.where(expires_at: ...Time.current)
+
         if Veri::Configuration.inactive_session_lifetime
-          to_be_pruned = to_be_pruned.or(
-            scope.where(last_seen_at: ...(Time.current - Veri::Configuration.inactive_session_lifetime))
-          )
+          inactive_cutoff = Time.current - Veri::Configuration.inactive_session_lifetime
+          expired_scope = expired_scope.or(scope.where(last_seen_at: ...inactive_cutoff))
         end
-        to_be_pruned.delete_all
+
+        expired_scope.delete_all
       end
 
-      def terminate_all(authenticatable)
-        Veri::Inputs.process(authenticatable, as: :authenticatable).veri_sessions.delete_all
+      def terminate_all(user)
+        Veri::Inputs.process(
+          user,
+          as: :authenticatable,
+          message: "Expected an instance of #{Veri::Configuration.user_model_name}, got `#{user.inspect}`"
+        ).veri_sessions.delete_all
       end
     end
   end

data/lib/veri/version.rb

@@ -1,3 +1,3 @@
 module Veri
-  VERSION = "0.2.0"
+  VERSION = "0.2.2".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: veri
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - enjaku4