jwt_sessions 2.3.0 → 2.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d331e9e3ca2bfd7123da3eb09e89e581183c3b66
-  data.tar.gz: ff77d8f388aee4ccf119d510021713f496740c63
+  metadata.gz: ea880100e93f25c3fc31e32161f6881a21c184cb
+  data.tar.gz: b549fea16c7d4ea09d8c1f7002a0d5cdd06c36b5
 SHA512:
-  metadata.gz: cd4a1641f899fc84c80a35e45e1f38913bbc755299f22fb2757584cccea1f2c9f7ccbfeee8148256183d3ed26dbf36626c08e83247b75017ae5b51a8e3dcf80e
-  data.tar.gz: bf43e0372e99e2d68df0d600555364afd3e2894d34ac107ab05c7ea0e048abb1e62d7391ae6ac1d9f29e8f38ae783328b41c99a7c4f1ef8b449cab5b4f564abb
+  metadata.gz: 78a5845fb2168f8ae8023d6ce6cc291ed2803fecefe2298afbc4423fc7319a29a7a75efd68fa2a17fc28e498a0b73d0c183ca1f1fb1f6005efc6430898acd92b
+  data.tar.gz: dc9074a35fee61a1749d42ec5bd3de687c683a8aa39c32c683eb58579b5831e735dc9904ff60c61b1add355ed61ddbb2686a74f171ceaa3922fcb737618f3bad

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018 Yulia Oletskaya
+Copyright (c) 2019 Yulia Oletskaya
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -45,7 +45,7 @@ All tokens are encoded and decoded by [ruby-jwt](https://github.com/jwt/ruby-jwt
 Put this line in your Gemfile
 
 ```ruby
-gem 'jwt_sessions'
+gem "jwt_sessions"
 ```
 
 Then run
@@ -70,7 +70,7 @@ class ApplicationController < ActionController::API
   private
 
   def not_authorized
-    render json: { error: 'Not authorized' }, status: :unauthorized
+    render json: { error: "Not authorized" }, status: :unauthorized
   end
 end
 ```
@@ -79,14 +79,14 @@ Specify an encryption key for JSON Web Tokens in `config/initializers/jwt_sessio
 It's adviced to store the key itself within the app secrets.
 
 ```ruby
-JWTSessions.algorithm = 'HS256'
+JWTSessions.algorithm = "HS256"
 JWTSessions.encryption_key = Rails.application.secrets.secret_jwt_encryption_key
 ```
 
 Most of the encryption algorithms require private and public keys to sign a token, yet HMAC only require a single key, so you can use a shortcat `encryption_key` to sign the token. For other algorithms you must specify a private and public keys separately.
 
 ```ruby
-JWTSessions.algorithm   = 'RS256'
+JWTSessions.algorithm   = "RS256"
 JWTSessions.private_key = OpenSSL::PKey::RSA.generate(2048)
 JWTSessions.public_key  = JWTSessions.private_key.public_key
 ```
@@ -124,7 +124,7 @@ class LoginController < ApplicationController
       session = JWTSessions::Session.new(payload: payload)
       render json: session.login
     else
-      render json: 'Invalid user', status: :unauthorized
+      render json: "Invalid user", status: :unauthorized
     end
   end
 end
@@ -188,7 +188,7 @@ The `payload` method is available to fetch encoded data from the token.
 
 ```ruby
 def current_user
-  @current_user ||= User.find(payload['user_id'])
+  @current_user ||= User.find(payload["user_id"])
 end
 ```
 
@@ -234,12 +234,12 @@ Example Sinatra app. \
 NOTE: Since rack updates HTTP headers by using `HTTP_` prefix, upcasing and using underscores for sake of simplicity JWTSessions tokens header names are converted to rack-style in this example.
 
 ```ruby
-require 'sinatra/base'
+require "sinatra/base"
 
-JWTSessions.access_header = 'authorization'
-JWTSessions.refresh_header = 'x_refresh_token'
-JWTSessions.csrf_header = 'x_csrf_token'
-JWTSessions.encryption_key = 'secret key'
+JWTSessions.access_header = "authorization"
+JWTSessions.refresh_header = "x_refresh_token"
+JWTSessions.csrf_header = "x_csrf_token"
+JWTSessions.encryption_key = "secret key"
 
 class SimpleApp < Sinatra::Base
   include JWTSessions::Authorization
@@ -257,28 +257,28 @@ class SimpleApp < Sinatra::Base
   end
 
   before do
-    content_type 'application/json'
+    content_type "application/json"
   end
 
-  post '/login' do
-    access_payload = { key: 'access value' }
-    refresh_payload = { key: 'refresh value' }
+  post "/login" do
+    access_payload = { key: "access value" }
+    refresh_payload = { key: "refresh value" }
     session = JWTSessions::Session.new(payload: access_payload, refresh_payload: refresh_payload)
     session.login.to_json
   end
 
   # POST /refresh
   # x_refresh_token: ...
-  post '/refresh' do
+  post "/refresh" do
     authorize_refresh_request!
-    access_payload = { key: 'reloaded access value' }
+    access_payload = { key: "reloaded access value" }
     session = JWTSessions::Session.new(payload: access_payload, refresh_payload: payload)
     session.refresh(found_token).to_json
   end
 
   # GET /payload
   # authorization: Bearer ...
-  get '/payload' do
+  get "/payload" do
     authorize_access_request!
     payload.to_json
   end
@@ -298,18 +298,18 @@ In order to configure token store you should set up a store adapter in a followi
 Memory store accepts only `prefix` (used for redis db keys). Here is a default configuration for Redis:
 
 ```ruby
-JwtSessions.token_store = :redis, {
-  redis_host: '127.0.0.1',
-  redis_port: '6379',
-  redis_db_name: '0',
-  token_prefix: 'jwt_'
+JWTSessions.token_store = :redis, {
+  redis_host: "127.0.0.1",
+  redis_port: "6379",
+  redis_db_name: "0",
+  token_prefix: "jwt_"
 }
 ```
 
 You can also provide a Redis URL instead:
 
 ```ruby
-JwtSessions.token_store = :redis, { redis_url: 'redis://localhost:6397' }
+JWTSessions.token_store = :redis, { redis_url: "redis://localhost:6397" }
 ```
 
 **NOTE:** if `REDIS_URL` environment variable is set it is used automatically.
@@ -317,20 +317,20 @@ JwtSessions.token_store = :redis, { redis_url: 'redis://localhost:6397' }
 ##### JWT signature
 
 ```ruby
-JWTSessions.algorithm = 'HS256'
+JWTSessions.algorithm = "HS256"
 ```
 
-You need to specify a secret to use for HMAC, this setting doesn't have a default value.
+You need to specify a secret to use for HMAC, this setting doesn"t have a default value.
 
 ```ruby
-JWTSessions.encryption_key = 'secret'
+JWTSessions.encryption_key = "secret"
 ```
 
 If you are using another algorithm like RSA/ECDSA/EDDSA you should specify private and public keys.
 
 ```ruby
-JWTSessions.private_key = 'abcd'
-JWTSessions.public_key  = 'efjh'
+JWTSessions.private_key = "abcd"
+JWTSessions.public_key  = "efjh"
 ```
 
 NOTE: ED25519 and HS512256 require rbnacl installation in order to make it work.
@@ -354,7 +354,7 @@ class UsersController < ApplicationController
 
   def token_claims
     {
-      aud: ['admin', 'staff'],
+      aud: ["admin", "staff"],
       exp_leeway: 15 # will be used instead of default leeway only for exp claim
     }
   end
@@ -368,11 +368,11 @@ Claims are also supported by `JWTSessions::Session`, you can pass `access_claims
 Default request headers/cookies names can be re-configured
 
 ```ruby
-JWTSessions.access_header  = 'Authorization'
-JWTSessions.access_cookie  = 'jwt_access'
-JWTSessions.refresh_header = 'X-Refresh-Token'
-JWTSessions.refresh_cookie = 'jwt_refresh'
-JWTSessions.csrf_header    = 'X-CSRF-Token'
+JWTSessions.access_header  = "Authorization"
+JWTSessions.access_cookie  = "jwt_access"
+JWTSessions.refresh_header = "X-Refresh-Token"
+JWTSessions.refresh_cookie = "jwt_refresh"
+JWTSessions.csrf_header    = "X-CSRF-Token"
 ```
 
 ##### Expiration time
@@ -417,7 +417,7 @@ class LoginController < ApplicationController
 
       render json: { csrf: tokens[:csrf] }
     else
-      render json: 'Invalid email or password', status: :unauthorized
+      render json: "Invalid email or password", status: :unauthorized
     end
   end
 end
@@ -502,20 +502,20 @@ session.flush_by_uid(uid) # => 1
 It's possible to group sessions by custom namespaces
 
 ```ruby
-session = JWTSessions::Session.new(namespace: 'account-1')
+session = JWTSessions::Session.new(namespace: "account-1")
 ```
 
 and selectively flush sessions by namespace
 
 ```ruby
-session = JWTSessions::Session.new(namespace: 'ie-sessions')
+session = JWTSessions::Session.new(namespace: "ie-sessions")
 session.flush_namespaced # will flush all sessions which belong to the same namespace
 ```
 
 it's posible to flush access tokens only
 
 ```ruby
-session = JWTSessions::Session.new(namespace: 'ie-sessions')
+session = JWTSessions::Session.new(namespace: "ie-sessions")
 session.flush_namespaced_access_tokens # will flush all access tokens which belong to the same namespace, but will keep refresh tokens
 ```
 
@@ -556,7 +556,7 @@ class LoginController < ApplicationController
 
       render json: { access: tokens[:access], csrf: tokens[:csrf] }
     else
-      render json: 'Cannot login', status: :unauthorized
+      render json: "Cannot login", status: :unauthorized
     end
   end
 end
@@ -570,7 +570,7 @@ class RefreshController < ApplicationController
   end
 
   def access_payload
-    user = User.find_by!(email: payload['user_id'])
+    user = User.find_by!(email: payload["user_id"])
     { user_id: user.id, role: user.role, permissions: user.permissions }
   end
 end

data/lib/jwt_sessions/access_token.rb

@@ -8,7 +8,7 @@ module JWTSessions
       @csrf       = csrf
       @uid        = uid
       @expiration = expiration
-      @payload    = payload.merge('uid' => uid, 'exp' => expiration.to_i)
+      @payload    = payload.merge("uid" => uid, "exp" => expiration.to_i)
       @store      = store
     end
 
@@ -17,11 +17,11 @@ module JWTSessions
     end
 
     def refresh_uid=(uid)
-      self.payload['ruid'] = uid
+      self.payload["ruid"] = uid
     end
 
     def refresh_uid
-      payload['ruid']
+      payload["ruid"]
     end
 
     def token
@@ -44,7 +44,7 @@ module JWTSessions
       # and to retrieve session's CSRF token
       def find(uid, store)
         token_attrs = store.fetch_access(uid)
-        raise Errors::Unauthorized, 'Access token not found' if token_attrs.empty?
+        raise Errors::Unauthorized, "Access token not found" if token_attrs.empty?
         build_with_token_attrs(store, uid, token_attrs)
       end
 

data/lib/jwt_sessions/authorization.rb

@@ -67,15 +67,15 @@ module JWTSessions
     end
 
     def request_headers
-      raise Errors::Malconfigured, 'request_headers is not implemented'
+      raise Errors::Malconfigured, "request_headers is not implemented"
     end
 
     def request_cookies
-      raise Errors::Malconfigured, 'request_cookies is not implemented'
+      raise Errors::Malconfigured, "request_cookies is not implemented"
     end
 
     def request_method
-      raise Errors::Malconfigured, 'request_method is not implemented'
+      raise Errors::Malconfigured, "request_method is not implemented"
     end
 
     def valid_csrf_token?(csrf_token, token_type)
@@ -98,20 +98,20 @@ module JWTSessions
 
     def retrieve_csrf
       token = request_headers[JWTSessions.csrf_header]
-      raise Errors::Unauthorized, 'CSRF token is not found' unless token
+      raise Errors::Unauthorized, "CSRF token is not found" unless token
       token
     end
 
     def token_from_headers(token_type)
-      raw_token = request_headers[JWTSessions.header_by(token_type)] || ''
-      token = raw_token.split(' ')[-1]
-      raise Errors::Unauthorized, 'Token is not found' unless token
+      raw_token = request_headers[JWTSessions.header_by(token_type)] || ""
+      token = raw_token.split(" ")[-1]
+      raise Errors::Unauthorized, "Token is not found" unless token
       token
     end
 
     def token_from_cookies(token_type)
       token = request_cookies[JWTSessions.cookie_by(token_type)]
-      raise Errors::Unauthorized, 'Token is not found' unless token
+      raise Errors::Unauthorized, "Token is not found" unless token
       token
     end
 

data/lib/jwt_sessions/refresh_token.rb

@@ -16,7 +16,7 @@ module JWTSessions
       @uid               = options.fetch(:uid, SecureRandom.uuid)
       @expiration        = options.fetch(:expiration, JWTSessions.refresh_expiration)
       @namespace         = options.fetch(:namespace, nil)
-      @token             = Token.encode(options.fetch(:payload, {}).merge('uid' => uid, 'exp' => expiration.to_i))
+      @token             = Token.encode(options.fetch(:payload, {}).merge("uid" => uid, "exp" => expiration.to_i))
     end
 
     class << self
@@ -35,7 +35,7 @@ module JWTSessions
 
       def find(uid, store, namespace = nil)
         token_attrs = store.fetch_refresh(uid, namespace)
-        raise Errors::Unauthorized, 'Refresh token not found' if token_attrs.empty?
+        raise Errors::Unauthorized, "Refresh token not found" if token_attrs.empty?
         build_with_token_attrs(store, uid, token_attrs, namespace)
       end
 

data/lib/jwt_sessions/session.rb

@@ -52,7 +52,7 @@ module JWTSessions
 
     def refresh_by_access_payload(&block)
       raise Errors::InvalidPayload if payload.nil?
-      ruid = retrieve_val_from(payload, :access, 'ruid', 'refresh uid')
+      ruid = retrieve_val_from(payload, :access, "ruid", "refresh uid")
       retrieve_refresh_token(ruid)
 
       check_access_uid_within_refresh_token(&block) if block_given?
@@ -62,7 +62,7 @@ module JWTSessions
 
     def flush_by_access_payload
       raise Errors::InvalidPayload if payload.nil?
-      ruid = retrieve_val_from(payload, :access, 'ruid', 'refresh uid')
+      ruid = retrieve_val_from(payload, :access, "ruid", "refresh uid")
       flush_by_uid(ruid)
     end
 
@@ -109,8 +109,8 @@ module JWTSessions
     end
 
     def valid_access_request?(external_csrf_token, external_payload)
-      ruid = retrieve_val_from(external_payload, :access, 'ruid', 'refresh uid')
-      uid  = retrieve_val_from(external_payload, :access, 'uid', 'access uid')
+      ruid = retrieve_val_from(external_payload, :access, "ruid", "refresh uid")
+      uid  = retrieve_val_from(external_payload, :access, "uid", "access uid")
 
       refresh_token = RefreshToken.find(ruid, JWTSessions.token_store)
       return false unless uid == refresh_token.access_uid
@@ -147,7 +147,7 @@ module JWTSessions
     def access_token_data(token)
       uid = token_uid(token, :access, @access_claims)
       data = store.fetch_access(uid)
-      raise Errors::Unauthorized, 'Access token not found' if data.empty?
+      raise Errors::Unauthorized, "Access token not found" if data.empty?
       data
     end
 
@@ -158,7 +158,7 @@ module JWTSessions
 
     def token_uid(token, type, claims)
       token_payload = JWTSessions::Token.decode(token, claims).first
-      uid           = token_payload.fetch('uid', nil)
+      uid           = token_payload.fetch("uid", nil)
       if uid.nil?
         message = "#{type.to_s.capitalize} token payload does not contain token uid"
         raise Errors::InvalidPayload, message
@@ -204,7 +204,7 @@ module JWTSessions
     end
 
     def check_access_uid_within_refresh_token
-      uid = retrieve_val_from(payload, :access, 'uid', 'access uid')
+      uid = retrieve_val_from(payload, :access, "uid", "access uid")
       access_uid = @_refresh.access_uid
       return if access_uid.size.zero?
       yield @_refresh.uid, @_refresh.access_expiration if access_uid != uid

data/lib/jwt_sessions/store_adapters/memory_store_adapter.rb

@@ -13,20 +13,20 @@ module JWTSessions
       end
 
       def fetch_access(uid)
-        access_token = value_if_not_expired(uid, 'access', '')
+        access_token = value_if_not_expired(uid, "access", "")
         access_token.empty? ? {} : { csrf: access_token[:csrf] }
       end
 
       def persist_access(uid, csrf, expiration)
         access_token = { csrf: csrf, expiration: expiration }
-        storage['']['access'].store(uid, access_token)
+        storage[""]["access"].store(uid, access_token)
       end
 
       def fetch_refresh(uid, namespace)
-        value_if_not_expired(uid, 'refresh', namespace.to_s)
+        value_if_not_expired(uid, "refresh", namespace.to_s)
       end
 
-      def persist_refresh(uid:, access_expiration:, access_uid:, csrf:, expiration:, namespace: '')
+      def persist_refresh(uid:, access_expiration:, access_uid:, csrf:, expiration:, namespace: "")
         update_refresh_fields(
           uid,
           namespace.to_s,
@@ -37,7 +37,7 @@ module JWTSessions
         )
       end
 
-      def update_refresh(uid:, access_expiration:, access_uid:, csrf:, namespace: '')
+      def update_refresh(uid:, access_expiration:, access_uid:, csrf:, namespace: "")
         update_refresh_fields(
           uid,
           namespace.to_s,
@@ -51,16 +51,16 @@ module JWTSessions
         namespace_keys = namespace.nil? ? storage.keys : [namespace]
 
         namespace_keys.each_with_object({}) do |namespace_key, acc|
-          select_keys(storage[namespace_key]['refresh'], acc)
+          select_keys(storage[namespace_key]["refresh"], acc)
         end
       end
 
       def destroy_refresh(uid, namespace)
-        storage[namespace.to_s]['refresh'].delete(uid)
+        storage[namespace.to_s]["refresh"].delete(uid)
       end
 
       def destroy_access(uid)
-        storage['']['access'].delete(uid)
+        storage[""]["access"].delete(uid)
       end
 
       private
@@ -71,8 +71,8 @@ module JWTSessions
       end
 
       def update_refresh_fields(key, namespace, fields)
-        updated_refresh = value_if_not_expired(key, 'refresh', namespace).merge(fields)
-        storage[namespace]['refresh'].store(key, updated_refresh)
+        updated_refresh = value_if_not_expired(key, "refresh", namespace).merge(fields)
+        storage[namespace]["refresh"].store(key, updated_refresh)
       end
 
       def select_keys(keys_hash, acc)

data/lib/jwt_sessions/store_adapters/redis_store_adapter.rb

@@ -11,7 +11,7 @@ module JWTSessions
         @prefix = token_prefix
 
         begin
-          require 'redis'
+          require "redis"
           @storage = configure_redis_client(options)
         rescue LoadError => e
           msg = "Could not load the 'redis' gem, please add it to your gemfile or " \
@@ -61,7 +61,7 @@ module JWTSessions
       end
 
       def all_refresh_tokens(namespace)
-        keys_in_namespace = storage.keys(refresh_key('*', namespace))
+        keys_in_namespace = storage.keys(refresh_key("*", namespace))
         (keys_in_namespace || []).each_with_object({}) do |key, acc|
           uid = uid_from_key(key)
           acc[uid] = fetch_refresh(uid, namespace)
@@ -80,7 +80,7 @@ module JWTSessions
 
       def configure_redis_client(redis_url: nil, redis_host: nil, redis_port: nil, redis_db_name: nil)
         if redis_url && (redis_host || redis_port || redis_db_name)
-          raise ArgumentError, 'redis_url cannot be passed along with redis_host, redis_port or redis_db_name options'
+          raise ArgumentError, "redis_url cannot be passed along with redis_host, redis_port or redis_db_name options"
         end
 
         redis_url ||= build_redis_url(
@@ -99,7 +99,7 @@ module JWTSessions
         redis_host ||= JWTSessions.redis_host
         redis_port ||= JWTSessions.redis_port
 
-        redis_base_url = ENV['REDIS_URL'] || "redis://#{redis_host}:#{redis_port}"
+        redis_base_url = ENV["REDIS_URL"] || "redis://#{redis_host}:#{redis_port}"
         URI.join(redis_base_url, redis_db_name).to_s
       end
 
@@ -116,7 +116,7 @@ module JWTSessions
       end
 
       def wildcard_refresh_key(uid)
-        (storage.keys(refresh_key(uid, '*')) || []).first
+        (storage.keys(refresh_key(uid, "*")) || []).first
       end
 
       def access_key(uid)
@@ -124,7 +124,7 @@ module JWTSessions
       end
 
       def uid_from_key(key)
-        key.split('_').last
+        key.split("_").last
       end
     end
   end

data/lib/jwt_sessions/token.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'jwt'
+require "jwt"
 
 module JWTSessions
   class Token
@@ -13,19 +13,19 @@ module JWTSessions
       def decode(token, claims = {})
         decode_options = { algorithm: JWTSessions.algorithm }.merge(JWTSessions.jwt_options.to_h).merge(claims)
         JWT.decode(token, JWTSessions.public_key, JWTSessions.validate?, decode_options)
-      rescue JWT::InvalidIssuerError, JWT::InvalidIatError, JWT::InvalidAudError, JWT::InvalidSubError, JWT::InvalidJtiError => e
+      rescue JWT::InvalidIssuerError, JWT::InvalidIatError, JWT::InvalidAudError, JWT::InvalidSubError, JWT::InvalidJtiError, JWT::ExpiredSignature => e
         raise Errors::ClaimsVerification, e.message
       rescue JWT::DecodeError => e
         raise Errors::Unauthorized, e.message
       rescue StandardError
-        raise Errors::Unauthorized, 'could not decode a token'
+        raise Errors::Unauthorized, "could not decode a token"
       end
 
       def decode!(token)
         decode_options = { algorithm: JWTSessions.algorithm }
         JWT.decode(token, JWTSessions.public_key, false, decode_options)
       rescue StandardError
-        raise Errors::Unauthorized, 'could not decode a token'
+        raise Errors::Unauthorized, "could not decode a token"
       end
 
       def meta

data/lib/jwt_sessions/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JWTSessions
-  VERSION = '2.3.0'
+  VERSION = "2.3.1"
 end

data/lib/jwt_sessions.rb

@@ -1,25 +1,25 @@
 # frozen_string_literal: true
 
-require 'securerandom'
-require 'uri'
-
-require 'jwt_sessions/errors'
-require 'jwt_sessions/token'
-require 'jwt_sessions/refresh_token'
-require 'jwt_sessions/csrf_token'
-require 'jwt_sessions/access_token'
-require 'jwt_sessions/session'
-require 'jwt_sessions/authorization'
-require 'jwt_sessions/rails_authorization' if defined?(::Rails)
-require 'jwt_sessions/version'
-require 'jwt_sessions/store_adapters'
+require "securerandom"
+require "uri"
+
+require "jwt_sessions/errors"
+require "jwt_sessions/token"
+require "jwt_sessions/refresh_token"
+require "jwt_sessions/csrf_token"
+require "jwt_sessions/access_token"
+require "jwt_sessions/session"
+require "jwt_sessions/authorization"
+require "jwt_sessions/rails_authorization" if defined?(::Rails)
+require "jwt_sessions/version"
+require "jwt_sessions/store_adapters"
 
 module JWTSessions
   extend self
 
   attr_accessor :redis_url
 
-  NONE = 'none'
+  NONE = "none"
 
   JWTOptions = Struct.new(*JWT::DefaultOptions::DEFAULT_OPTIONS.keys)
 
@@ -35,18 +35,18 @@ module JWTSessions
                              refresh_header
                              token_prefix].freeze
 
-  DEFAULT_REDIS_HOST       = '127.0.0.1'
-  DEFAULT_REDIS_PORT       = '6379'
-  DEFAULT_REDIS_DB_NAME    = '0'
-  DEFAULT_TOKEN_PREFIX     = 'jwt_'
-  DEFAULT_ALGORITHM        = 'HS256'
+  DEFAULT_REDIS_HOST       = "127.0.0.1"
+  DEFAULT_REDIS_PORT       = "6379"
+  DEFAULT_REDIS_DB_NAME    = "0"
+  DEFAULT_TOKEN_PREFIX     = "jwt_"
+  DEFAULT_ALGORITHM        = "HS256"
   DEFAULT_ACCESS_EXP_TIME  = 3600 # 1 hour in seconds
   DEFAULT_REFRESH_EXP_TIME = 604800 # 1 week in seconds
-  DEFAULT_ACCESS_COOKIE    = 'jwt_access'
-  DEFAULT_ACCESS_HEADER    = 'Authorization'
-  DEFAULT_REFRESH_COOKIE   = 'jwt_refresh'
-  DEFAULT_REFRESH_HEADER   = 'X-Refresh-Token'
-  DEFAULT_CSRF_HEADER      = 'X-CSRF-Token'
+  DEFAULT_ACCESS_COOKIE    = "jwt_access"
+  DEFAULT_ACCESS_HEADER    = "Authorization"
+  DEFAULT_REFRESH_COOKIE   = "jwt_refresh"
+  DEFAULT_REFRESH_HEADER   = "X-Refresh-Token"
+  DEFAULT_CSRF_HEADER      = "X-CSRF-Token"
 
   DEFAULT_SETTINGS_KEYS.each do |setting|
     var_name = :"@#{setting}"
@@ -149,6 +149,6 @@ module JWTSessions
   def supported_algos
     # TODO once ECDSA is fixed in ruby-jwt it can be added to the list of algos just the same way others are added
     algos = JWT::Algos.constants - [:Unsupported, :Ecdsa]
-    algos.map { |algo| JWT::Algos.const_get(algo)::SUPPORTED }.flatten + [NONE, *JWT::Algos::Ecdsa::SUPPORTED.split(' ')]
+    algos.map { |algo| JWT::Algos.const_get(algo)::SUPPORTED }.flatten + [NONE, *JWT::Algos::Ecdsa::SUPPORTED.split(" ")]
   end
 end