verikloak-bff 0.2.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8fbec3da2912582f3684c1682fb75b45f9d26c3a1ebf3b7a41d4a5392fbe36c1
-  data.tar.gz: d1b5b9f750bd3cdbbf3308f1581c8327c039f87b660cde73a799a83740f818ae
+  metadata.gz: 459eed20d30ee0052dda42e6e1b18c4ac4f58aa897ba24a0090d19931a28690e
+  data.tar.gz: 20d3f106c2439d3f63b683a79f900d9c072893ec730d9d294e610817b560777e
 SHA512:
-  metadata.gz: 33655caab83ec29f7159264b660aadb878a61c3ca52c4f23e4256cdb30519384833d7ea8244de5c8252368227ef3999691eb1aa282d907c42e94db69fb39ecb3
-  data.tar.gz: d1442646ce08bd0a98ca211f781f0ba623d58d51323ed86492c01cee60086a27c5f27c1fd8d65e4b7ab5ea10c52a9bf6b4942e09c0be80cc8e4d250d6bfb4f48
+  metadata.gz: 47838af8ec9b12a4570e967c188ffcaf7a4ce9556aa06409d6fce1906bc4fd0b16568342baacec85a46883f9161fe015459996453e724e37c7c6a6d7e339e1c8
+  data.tar.gz: b12bcca4f52ba05a8aba8fe145c1664743e70127120642f7bf334aa8db1499301badd988d5a92040d359fc2e61f94d1bbf79699f972fc7f05c12867702a10e72

data/CHANGELOG.md

@@ -7,6 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [0.2.4] - 2025-09-27
+
+### Changed
+- Simplify BFF install generator by inlining configuration lookups and removing unnecessary helper methods.
+- Streamline generated initializer to use `Rails.configuration.middleware` and `Rails.logger` directly.
+- Extract JWT decoding logic into shared `JwtUtils` module to eliminate duplication between `HeaderGuard` and `ConsistencyChecks`.
+- Refactor `HeaderGuard#call` into clear pipeline stages with improved documentation.
+- Enhance middleware stack detection to handle wrapped entries, string names, and complex objects.
+- Remove duplicate proxy trust logic in `ProxyTrust` module by unifying `from_trusted_proxy?` and `trusted?` methods.
+
+### Fixed
+- Resolve RuboCop style violations including useless constant scoping and identical conditional branches.
+
+## [0.2.3] - 2025-09-23
+
+### Changed
+- Stop inserting `Verikloak::BFF::HeaderGuard` automatically via the Railtie and provide a `rails g verikloak:bff:install` generator that drops an initializer to opt in when the core middleware is ready.
+
 ## [0.2.2] - 2025-09-23
 
 ### Changed

data/README.md

@@ -31,12 +31,16 @@ use Verikloak::BFF::HeaderGuard, trusted_proxies: ['127.0.0.1', '10.0.0.0/8']
 ```
 
 ### Rails Applications
-Simply add to your Gemfile and the middleware will be automatically integrated:
+Add the gem to your Gemfile and run the install generator to drop an initializer that wires the middleware into Rails:
 ```ruby
 gem 'verikloak-bff'
 ```
 
-The gem automatically inserts `Verikloak::BFF::HeaderGuard` into the Rails middleware stack after the core `Verikloak::Middleware`. If the core middleware is not present (e.g., discovery not configured), it gracefully skips insertion with a warning, allowing Rails to boot normally.
+```sh
+bin/rails g verikloak:bff:install
+```
+
+The generated initializer inserts `Verikloak::BFF::HeaderGuard` after the core `Verikloak::Middleware` during boot. If the core middleware is not present (for example, when verikloak-rails has not been fully configured yet), the initializer logs a warning and allows Rails to boot normally.
 
 For detailed configuration, proxy setup examples, and troubleshooting, see [docs/rails.md](docs/rails.md).
 

data/lib/generators/verikloak/bff/install/install_generator.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'rails/generators/base'
+
+module Verikloak
+  module BFF
+    # Namespace for Rails generators related to Verikloak BFF
+    module Generators
+      # Rails generator for installing Verikloak BFF middleware integration.
+      #
+      # This generator creates a Rails initializer that safely inserts the
+      # Verikloak::BFF::HeaderGuard middleware into the Rails middleware stack.
+      # It replaces automatic middleware insertion to avoid boot failures when
+      # core Verikloak middleware is not yet configured.
+      #
+      # @example Basic usage
+      #   rails g verikloak:bff:install
+      #
+      # @example Custom initializer path
+      #   rails g verikloak:bff:install --initializer=config/initializers/custom_bff.rb
+      #
+      # @see Verikloak::BFF::Rails::Middleware
+      class InstallGenerator < ::Rails::Generators::Base
+        source_root File.expand_path('templates', __dir__)
+
+        # Configuration option for specifying the initializer file path.
+        #
+        # @option options [String] :initializer ('config/initializers/verikloak_bff.rb')
+        #   The path where the initializer file will be created
+        class_option :initializer, type: :string,
+                                   default: 'config/initializers/verikloak_bff.rb',
+                                   desc: 'Path for the generated initializer'
+
+        # Creates the Rails initializer file from template.
+        #
+        # Generates a Rails initializer that safely inserts the HeaderGuard
+        # middleware into the middleware stack with proper error handling.
+        # The initializer uses Verikloak::BFF::Rails::Middleware.insert_after_core
+        # to ensure graceful handling when core middleware is missing.
+        #
+        # @return [void]
+        def create_initializer
+          template 'initializer.rb.erb', options.fetch(:initializer)
+        end
+      end
+    end
+  end
+end

data/lib/generators/verikloak/bff/install/templates/initializer.rb.erb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Configure verikloak-bff to insert its HeaderGuard middleware only after the
+# Verikloak core middleware is present. This avoids boot errors when the core
+# gem has not yet been installed.
+Rails.application.config.after_initialize do
+  Verikloak::BFF::Rails::Middleware.insert_after_core(
+    Rails.application.config.middleware,
+    logger: Rails.logger
+  )
+end

data/lib/verikloak/bff/consistency_checks.rb

@@ -6,8 +6,8 @@
 # @see .enforce!
 
 require 'json'
-require 'jwt' # used only to parse segments safely without verify
 require 'verikloak/bff/constants'
+require 'verikloak/bff/jwt_utils'
 
 module Verikloak
   module BFF
@@ -21,12 +21,7 @@ module Verikloak
       # @param token [String, nil]
       # @return [Hash] claims or empty hash on error
       def decode_claims(token)
-        return {} unless token
-        return {} if token.bytesize > Constants::MAX_TOKEN_BYTES
-
-        JWT.decode(token, nil, false).first
-      rescue StandardError
-        {}
+        Verikloak::BFF::JwtUtils.decode_claims(token)
       end
 
       # mapping: { email: :email, user: :sub, groups: :realm_roles }

data/lib/verikloak/bff/header_guard.rb

@@ -13,7 +13,6 @@
 require 'rack'
 require 'rack/utils'
 require 'json'
-require 'jwt'
 require 'digest'
 require 'verikloak/header_sources'
 require 'verikloak/bff/configuration'
@@ -22,6 +21,7 @@ require 'verikloak/bff/proxy_trust'
 require 'verikloak/bff/forwarded_token'
 require 'verikloak/bff/consistency_checks'
 require 'verikloak/bff/constants'
+require 'verikloak/bff/jwt_utils'
 
 module Verikloak
   module BFF
@@ -58,11 +58,7 @@ module Verikloak
       # @param token [String, nil]
       # @return [Array<Hash>] payload and header hashes
       def decode_unverified(token)
-        return [{}, {}] if token.nil? || token.bytesize > Constants::MAX_TOKEN_BYTES
-
-        JWT.decode(token, nil, false)
-      rescue StandardError
-        [{}, {}]
+        Verikloak::BFF::JwtUtils.decode_unverified(token)
       end
 
       # Remove unsafe characters from a structured logging payload.
@@ -104,6 +100,8 @@ module Verikloak
 
     # Rack middleware that enforces BFF boundary and header/claims consistency.
     class HeaderGuard
+      RequestTokens = Struct.new(:auth, :forwarded, :chosen)
+
       # Accept both Rack 2 and Rack 3 builder call styles:
       # - new(app, key: val)
       # - new(app, { key: val })
@@ -125,22 +123,29 @@ module Verikloak
         raise ArgumentError, 'trusted_proxies must be configured'
       end
 
-      # Process a Rack request.
+      # Process a Rack request through the BFF header guard pipeline.
+      #
+      # Pipeline stages:
+      # 1. Proxy trust validation
+      # 2. Token extraction and state building
+      # 3. Policy enforcement (forwarded token requirements, consistency checks)
+      # 4. Request finalization (Authorization header normalization)
       #
       # @param env [Hash]
       # @return [Array(Integer, Hash, Array<#to_s>)] Rack response triple
       def call(env)
+        # Stage 1: Validate request comes from trusted proxy
         ensure_trusted_proxy!(env)
-        auth_token, fwd_token = ForwardedToken.extract(env, @config.forwarded_header_name)
-        ensure_forwarded_if_required!(fwd_token)
-        chosen = choose_token(auth_token, fwd_token)
-        chosen = seed_authorization_if_needed(env, chosen)
 
-        enforce_header_consistency!(env, auth_token, fwd_token)
-        enforce_claims_consistency!(env, chosen)
-        ForwardedToken.strip_suspicious!(env, @config.auth_request_headers) if @config.strip_suspicious_headers
-        normalize_authorization!(env, chosen, auth_token, fwd_token)
-        expose_env_hints(env, chosen)
+        # Stage 2: Extract and validate tokens, build request state
+        tokens = build_token_state(env)
+
+        # Stage 3: Enforce configured policies (forwarded requirements, consistency)
+        enforce_token_policies!(env, tokens)
+
+        # Stage 4: Finalize request with normalized Authorization header
+        finalize_request!(env, tokens)
+
         @app.call(env)
       rescue Verikloak::BFF::Error => e
         respond_with_error(env, e)
@@ -148,6 +153,41 @@ module Verikloak
 
       private
 
+      # Build token state by extracting, validating, and selecting the active token.
+      #
+      # @param env [Hash]
+      # @return [RequestTokens]
+      def build_token_state(env)
+        auth_token, fwd_token = ForwardedToken.extract(env, @config.forwarded_header_name)
+        ensure_forwarded_if_required!(fwd_token)
+
+        chosen = choose_token(auth_token, fwd_token)
+        chosen = seed_authorization_if_needed(env, chosen)
+
+        RequestTokens.new(auth_token, fwd_token, chosen)
+      end
+
+      # Apply header and claim consistency policies for the current request.
+      #
+      # @param env [Hash]
+      # @param tokens [RequestTokens]
+      # @return [void]
+      def enforce_token_policies!(env, tokens)
+        enforce_header_consistency!(env, tokens.auth, tokens.forwarded)
+        enforce_claims_consistency!(env, tokens.chosen)
+      end
+
+      # Mutate the Rack env with normalized headers and logging hints.
+      #
+      # @param env [Hash]
+      # @param tokens [RequestTokens]
+      # @return [void]
+      def finalize_request!(env, tokens)
+        ForwardedToken.strip_suspicious!(env, @config.auth_request_headers) if @config.strip_suspicious_headers
+        normalize_authorization!(env, tokens.chosen, tokens.auth, tokens.forwarded)
+        expose_env_hints(env, tokens.chosen)
+      end
+
       # Apply per-instance configuration overrides.
       #
       # @param opts [Hash]

data/lib/verikloak/bff/jwt_utils.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'jwt'
+require 'verikloak/bff/constants'
+
+module Verikloak
+  module BFF
+    # Lightweight helpers around JWT decoding without verification.
+    module JwtUtils
+      module_function
+
+      # Decode JWT header and payload without verification, guarding against oversized input.
+      #
+      # @param token [String, nil]
+      # @return [Array<Hash>] [payload, header]
+      def decode_unverified(token)
+        return [{}, {}] if token.nil? || token.bytesize > Constants::MAX_TOKEN_BYTES
+
+        JWT.decode(token, nil, false)
+      rescue StandardError
+        [{}, {}]
+      end
+
+      # Return the decoded JWT payload without verification.
+      #
+      # @param token [String, nil]
+      # @return [Hash]
+      def decode_claims(token)
+        decode_unverified(token).first
+      end
+    end
+  end
+end

data/lib/verikloak/bff/proxy_trust.rb

@@ -23,17 +23,8 @@ module Verikloak
       # @example CIDR + Regex allowlist
       #   ProxyTrust.trusted?(env, ["10.0.0.0/8", /^192\.168\./], :rightmost)
       def trusted?(env, trusted, strategy = :rightmost)
-        return false if trusted.nil? || trusted.empty?
-
-        # Rails-aligned: prefer REMOTE_ADDR; fallback to nearest XFF entry
-        remote = (env['REMOTE_ADDR'] || '').to_s.strip
-        remote = extract_peer_ip(env, strategy) if remote.empty?
-        return false unless remote
-
-        remote_ip = ip_or_nil(remote)
-        trusted.any? { |rule| rule_trusts?(rule, remote, remote_ip, env) }
-      rescue StandardError
-        false
+        remote = resolve_peer(env, :remote_then_xff, strategy)
+        trusted_remote?(remote, trusted, env)
       end
 
       # Select the peer IP from X-Forwarded-For according to strategy or fall back to REMOTE_ADDR.
@@ -59,15 +50,7 @@ module Verikloak
       # @param strategy [Symbol] :rightmost or :leftmost
       # @return [String, nil]
       def selected_peer(env, preference, strategy)
-        case preference.to_s.to_sym
-        when :remote_then_xff
-          ip = (env['REMOTE_ADDR'] || '').to_s.strip
-          return ip unless ip.nil? || ip.empty?
-
-          extract_peer_ip(env, :rightmost) # nearest by default
-        else
-          extract_peer_ip(env, strategy)
-        end
+        resolve_peer(env, preference, strategy)
       end
 
       # Parse string to IPAddr or nil on failure.
@@ -112,16 +95,37 @@ module Verikloak
       # @param trusted [Array<String, Regexp, Proc>, nil]
       # @return [Boolean]
       def self.from_trusted_proxy?(env, trusted)
-        return false if trusted.nil? || trusted.empty?
+        trusted?(env, trusted, :rightmost)
+      end
 
-        ip = (env['REMOTE_ADDR'] || '').to_s.strip
-        ip = env['HTTP_X_FORWARDED_FOR'].to_s.split(',').last.to_s.strip if ip.empty? && env['HTTP_X_FORWARDED_FOR']
-        return false if ip.empty?
+      # Resolve the peer value based on preference and strategy.
+      #
+      # @param env [Hash]
+      # @param preference [Symbol]
+      # @param strategy [Symbol]
+      # @return [String, nil]
+      def resolve_peer(env, preference, strategy)
+        case preference.to_s.to_sym
+        when :remote_then_xff
+          remote = (env['REMOTE_ADDR'] || '').to_s.strip
+          return remote unless remote.empty?
+          # Fall back to X-Forwarded-For when REMOTE_ADDR is empty
+        end
+        extract_peer_ip(env, strategy)
+      end
 
-        remote_ip = ip_or_nil(ip)
-        return false unless remote_ip
+      # Determine whether a remote peer appears in the trusted list.
+      #
+      # @param remote [String, nil]
+      # @param trusted [Array<String, Regexp, Proc>, nil]
+      # @param env [Hash]
+      # @return [Boolean]
+      def trusted_remote?(remote, trusted, env)
+        return false if trusted.nil? || trusted.empty?
+        return false unless remote
 
-        trusted.any? { |rule| rule_trusts?(rule, ip, remote_ip, env) }
+        remote_ip = ip_or_nil(remote)
+        trusted.any? { |rule| rule_trusts?(rule, remote, remote_ip, env) }
       rescue StandardError
         false
       end

data/lib/verikloak/bff/rails.rb

@@ -4,14 +4,20 @@ module Verikloak
   module BFF
     # Rails-specific functionality for Verikloak BFF
     module Rails
-      # Middleware management utilities for Rails applications
+      # Middleware management utilities for Rails applications.
       #
-      # This module provides functionality to insert Verikloak BFF middleware
-      # into Rails middleware stack, with proper error handling for cases where
-      # the core Verikloak middleware is not present.
+      # This module focuses on inserting the HeaderGuard middleware right after
+      # the core Verikloak middleware while gracefully handling stacks that do
+      # not contain the core component.
       module Middleware
         module_function
 
+        CORE_NAME = 'Verikloak::Middleware'
+        HEADER_GUARD_NAME = 'Verikloak::BFF::HeaderGuard'
+        SKIP_MESSAGE = <<~MSG.chomp.freeze
+          [verikloak-bff] Skipping Verikloak::BFF::HeaderGuard insertion because Verikloak::Middleware is not present. Configure verikloak-rails discovery settings and restart once core verification is enabled.
+        MSG
+
         # Inserts Verikloak::BFF::HeaderGuard middleware after Verikloak::Middleware
         #
         # Attempts to insert the HeaderGuard middleware into the Rails middleware stack
@@ -31,12 +37,15 @@ module Verikloak
         def insert_after_core(stack, logger: nil)
           return false unless auto_insert_enabled?
 
-          unless core_present?(stack)
+          core = core_middleware
+          header_guard = header_guard_middleware
+
+          unless stack && core && header_guard && core_present?(stack, core)
             log_skip(logger)
             return false
           end
 
-          stack.insert_after(::Verikloak::Middleware, ::Verikloak::BFF::HeaderGuard)
+          stack.insert_after(core, header_guard)
           true
         rescue RuntimeError => e
           raise unless missing_core?(e)
@@ -54,11 +63,9 @@ module Verikloak
         #
         # @return [Boolean]
         def auto_insert_enabled?
-          return true unless defined?(::Verikloak)
-          return true unless ::Verikloak.respond_to?(:config)
-
-          config = ::Verikloak.config
+          config = core_config
           return true unless config
+
           return config.auto_insert_bff_header_guard if config.respond_to?(:auto_insert_bff_header_guard)
 
           true
@@ -66,56 +73,60 @@ module Verikloak
           true
         end
 
+        # Returns the Verikloak configuration object when available.
+        #
+        # @return [Object, nil]
+        def core_config
+          return nil unless defined?(::Verikloak)
+          return nil unless ::Verikloak.respond_to?(:config)
+
+          ::Verikloak.config
+        rescue StandardError
+          nil
+        end
+
         # Detect whether the Verikloak core middleware is already present in the stack.
         #
         # @param stack [#include?, #each, nil]
         # @return [Boolean]
-        def core_present?(stack)
+        def core_present?(stack, core = core_middleware)
           return false unless stack
 
-          if stack.respond_to?(:include?)
-            begin
-              return true if stack.include?(::Verikloak::Middleware)
-            rescue StandardError
-              # Fall back to manual enumeration when include? is unsupported for this stack
-            end
+          begin
+            return true if core && stack.respond_to?(:include?) && stack.include?(core)
+          rescue StandardError
+            # Fall back to manual enumeration when include? is unsupported for this stack.
           end
 
           return false unless stack.respond_to?(:each)
 
-          stack.each do |middleware|
-            return true if middleware_matches_core?(middleware)
+          stack.each do |entry|
+            candidate = unwrap_middleware(entry)
+            return true if core && candidate == core
+            return true if middleware_name(candidate) == CORE_NAME
           end
 
           false
         end
 
-        # Check whether a middleware entry represents the Verikloak core middleware.
+        # Normalize raw stack entries to a comparable object.
         #
-        # @param middleware [Object]
-        # @return [Boolean]
-        def middleware_matches_core?(middleware)
-          candidate = middleware.is_a?(Array) ? middleware.first : middleware
-
-          klass = extract_middleware_class(candidate)
-
-          klass == ::Verikloak::Middleware ||
-            (klass.is_a?(String) && klass == 'Verikloak::Middleware') ||
-            (klass.respond_to?(:name) && klass.name == 'Verikloak::Middleware')
+        # @param entry [Object]
+        # @return [Object]
+        def unwrap_middleware(entry)
+          entry = entry.first if entry.is_a?(Array)
+          entry.respond_to?(:klass) ? entry.klass : entry
         end
 
-        # Extracts the class or class-like identifier from a middleware candidate.
-        #
-        # @param candidate [Object]
-        # @return [Class, String, Object]
-        def extract_middleware_class(candidate)
-          if candidate.respond_to?(:klass)
-            candidate.klass
-          elsif candidate.respond_to?(:name)
-            candidate.name
-          else
-            candidate
-          end
+        # Resolve a human-readable middleware name if possible.
+        #
+        # @param entry [Object]
+        # @return [String, nil]
+        def middleware_name(entry)
+          return entry if entry.is_a?(String)
+          return entry.to_s if entry.is_a?(Symbol)
+
+          entry.respond_to?(:name) ? entry.name : nil
         end
 
         # Checks if the error indicates missing core Verikloak middleware
@@ -134,7 +145,7 @@ module Verikloak
         #   end
         def missing_core?(error)
           error.message.include?('No such middleware') &&
-            error.message.include?('Verikloak::Middleware')
+            error.message.include?(CORE_NAME)
         end
 
         # Logs a warning message about skipping middleware insertion
@@ -151,11 +162,31 @@ module Verikloak
         # @example Logging without logger (uses warn)
         #   log_skip(nil)
         def log_skip(logger)
-          message = <<~MSG.chomp
-            [verikloak-bff] Skipping Verikloak::BFF::HeaderGuard insertion because Verikloak::Middleware is not present. Configure verikloak-rails discovery settings and restart once core verification is enabled.
-          MSG
+          logger ? logger.warn(SKIP_MESSAGE) : warn(SKIP_MESSAGE)
+        end
 
-          logger ? logger.warn(message) : warn(message)
+        # Safely resolves the core middleware constant when available.
+        #
+        # @return [Class, nil]
+        def core_middleware
+          safe_const_get(CORE_NAME)
+        end
+
+        # Safely resolves the HeaderGuard middleware constant when available.
+        #
+        # @return [Class, nil]
+        def header_guard_middleware
+          safe_const_get(HEADER_GUARD_NAME)
+        end
+
+        # Attempts to constantize the provided class name, returning nil when undefined.
+        #
+        # @param name [String]
+        # @return [Module, Class, nil]
+        def safe_const_get(name)
+          Object.const_get(name)
+        rescue NameError
+          nil
         end
       end
     end

data/lib/verikloak/bff/railtie.rb

@@ -5,29 +5,27 @@ require_relative 'rails'
 module Verikloak
   # Module providing Verikloak BFF (Backend for Frontend) functionality
   module BFF
-    # Railtie class for integrating Verikloak BFF middleware into Rails applications
+    # Railtie for integrating Verikloak BFF with Rails applications.
     #
-    # This class automatically inserts Verikloak::BFF::Rails::Middleware into the
-    # Rails initialization process. The middleware is inserted after the
-    # 'verikloak.middleware' initializer and configured with an appropriate logger.
+    # This Railtie provides access to the BFF installation generator instead of
+    # automatically inserting middleware, which could cause boot failures when
+    # core Verikloak middleware is not yet configured.
     #
-    # @example Automatic initialization in Rails applications
-    #   # Simply adding verikloak-bff to Gemfile automatically enables it
-    #   gem 'verikloak-bff'
+    # @example Installing BFF middleware
+    #   rails g verikloak:bff:install
     #
     # @see Verikloak::BFF::Rails::Middleware
     class Railtie < ::Rails::Railtie
-      # Initializer that inserts Verikloak BFF middleware into Rails application
+      # Loads the install generator when Rails generator infrastructure is available.
       #
-      # This initializer runs after 'verikloak.middleware' and inserts
-      # Verikloak::BFF::Rails::Middleware at the appropriate position.
-      # Uses Rails.logger as the logger if available.
+      # Makes the `verikloak:bff:install` generator discoverable through `rails g`
+      # while keeping generators optional for non-Rails environments.
       #
-      # @param app [Rails::Application] Rails application instance
-      initializer 'verikloak.bff.insert_middleware', after: 'verikloak.middleware' do |app|
-        logger = ::Rails.logger if defined?(::Rails.logger)
+      # @return [void]
+      initializer 'verikloak.bff.load_generators' do
+        next unless defined?(Rails::Generators)
 
-        Verikloak::BFF::Rails::Middleware.insert_after_core(app.config.middleware, logger: logger)
+        require_relative '../../generators/verikloak/bff/install/install_generator'
       end
     end
   end

data/lib/verikloak/bff/version.rb

@@ -5,6 +5,6 @@
 # @return [String]
 module Verikloak
   module BFF
-    VERSION = '0.2.2'
+    VERSION = '0.2.4'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: verikloak-bff
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.4
 platform: ruby
 authors:
 - taiyaky
@@ -78,6 +78,8 @@ files:
 - CHANGELOG.md
 - LICENSE
 - README.md
+- lib/generators/verikloak/bff/install/install_generator.rb
+- lib/generators/verikloak/bff/install/templates/initializer.rb.erb
 - lib/verikloak-bff.rb
 - lib/verikloak/bff.rb
 - lib/verikloak/bff/configuration.rb
@@ -86,6 +88,7 @@ files:
 - lib/verikloak/bff/errors.rb
 - lib/verikloak/bff/forwarded_token.rb
 - lib/verikloak/bff/header_guard.rb
+- lib/verikloak/bff/jwt_utils.rb
 - lib/verikloak/bff/proxy_trust.rb
 - lib/verikloak/bff/rails.rb
 - lib/verikloak/bff/railtie.rb
@@ -98,7 +101,7 @@ metadata:
   source_code_uri: https://github.com/taiyaky/verikloak-bff
   changelog_uri: https://github.com/taiyaky/verikloak-bff/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/taiyaky/verikloak-bff/issues
-  documentation_uri: https://rubydoc.info/gems/verikloak-bff/0.2.2
+  documentation_uri: https://rubydoc.info/gems/verikloak-bff/0.2.4
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths: