securial 0.7.0 → 0.8.0

data/lib/securial/middlewares/request_logger_tag.rb

@@ -1,19 +0,0 @@
-module Securial
-  module Middlewares
-    class RequestLoggerTag
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        request_id = env["action_dispatch.request_id"] || env["HTTP_X_REQUEST_ID"]
-        tags = ["Securial"]
-        tags << request_id if request_id
-
-        logger = Securial.logger || Rails.logger || ::Logger.new(IO::NULL)
-        tagged_logger = logger.is_a?(ActiveSupport::TaggedLogging) ? logger : ActiveSupport::TaggedLogging.new(logger)
-        tagged_logger.tagged(*tags) { @app.call(env) }
-      end
-    end
-  end
-end

data/lib/securial/middlewares/transform_request_keys.rb

@@ -1,33 +0,0 @@
-# lib/securial/middlewares/transform_request_keys.rb
-require "json"
-
-module Securial
-  module Middlewares
-    class TransformRequestKeys
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        if env["CONTENT_TYPE"]&.include?("application/json") && Securial.configuration.response_keys_format != :snake_case
-          req = Rack::Request.new(env)
-          if (req.body&.size || 0) > 0
-            raw = req.body.read
-            req.body.rewind
-            begin
-              parsed = JSON.parse(raw)
-              transformed = Securial::KeyTransformer.deep_transform_keys(parsed) do |key|
-                Securial::KeyTransformer.underscore(key)
-              end
-              env["rack.input"] = StringIO.new(JSON.dump(transformed))
-              env["rack.input"].rewind
-            rescue JSON::ParserError
-              # noop
-            end
-          end
-        end
-        @app.call(env)
-      end
-    end
-  end
-end

data/lib/securial/middlewares/transform_response_keys.rb

@@ -1,52 +0,0 @@
-require "json"
-
-module Securial
-  module Middlewares
-    class TransformResponseKeys
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        status, headers, response = @app.call(env)
-
-        if json_response?(headers)
-          body = extract_body(response)
-
-          if body.present?
-            format = Securial.configuration.response_keys_format
-
-            # Only transform if not snake_case
-            if format != :snake_case
-              begin
-                transformed = Securial::KeyTransformer.deep_transform_keys(JSON.parse(body)) do |key|
-                  Securial::KeyTransformer.camelize(key, format)
-                end
-
-                new_body = [JSON.generate(transformed)]
-                headers["Content-Length"] = new_body.first.bytesize.to_s
-                return [status, headers, new_body]
-              rescue JSON::ParserError
-                # If not valid JSON, fall through and return original response
-              end
-            end
-          end
-        end
-
-        [status, headers, response]
-      end
-
-      private
-
-      def json_response?(headers)
-        headers["Content-Type"]&.include?("application/json")
-      end
-
-      def extract_body(response)
-        response_body = ""
-        response.each { |part| response_body << part }
-        response_body
-      end
-    end
-  end
-end

data/lib/securial/middlewares.rb

@@ -1,10 +0,0 @@
-require_relative "middlewares/transform_request_keys"
-require_relative "middlewares/transform_response_keys"
-require_relative "middlewares/request_logger_tag"
-
-module Securial
-  module Middleware
-    # This module serves as a namespace for middlewares.
-    # It requires the necessary middleware files to provide functionality.
-  end
-end

data/lib/securial/security/request_rate_limiter.rb

@@ -1,68 +0,0 @@
-require "rack/attack"
-require "securial/config"
-require "securial/logger"
-
-module Securial
-  module Security
-    module RequestRateLimiter
-      module_function
-
-      def apply! # rubocop:disable Metrics/MethodLength
-        resp_status = Securial.configuration.rate_limit_response_status
-        resp_message = Securial.configuration.rate_limit_response_message
-        # Throttle login attempts by IP
-        Rack::Attack.throttle("securial/logins/ip",
-                              limit: ->(_req) { Securial.configuration.rate_limit_requests_per_minute },
-                              period: 1.minute
-        ) do |req|
-          if req.path.include?("sessions/login") && req.post?
-            req.ip
-          end
-        end
-
-        # Throttle login attempts by username/email
-        Rack::Attack.throttle("securial/logins/email",
-                              limit: ->(_req) { Securial.configuration.rate_limit_requests_per_minute },
-                              period: 1.minute
-        ) do |req|
-          if req.path.include?("sessions/login") && req.post?
-            req.params["email_address"].to_s.downcase.strip
-          end
-        end
-
-        # Throttle password reset requests by IP
-        Rack::Attack.throttle("securial/password_resets/ip",
-                              limit: ->(_req) { Securial.configuration.rate_limit_requests_per_minute },
-                              period: 1.minute
-        ) do |req|
-          if req.path.include?("password/forgot") && req.post?
-            req.ip
-          end
-        end
-
-        # Throttle password reset requests by email
-        Rack::Attack.throttle("securial/password_resets/email",
-                              limit: ->(_req) { Securial.configuration.rate_limit_requests_per_minute },
-                              period: 1.minute
-        ) do |req|
-          if req.path.include?("password/forgot") && req.post?
-            req.params["email_address"].to_s.downcase.strip
-          end
-        end
-
-        # Custom response for throttled requests
-        Rack::Attack.throttled_responder = lambda do |request|
-          retry_after = (request.env["rack.attack.match_data"] || {})[:period]
-          [
-            resp_status,
-            {
-              "Content-Type" => "application/json",
-              "Retry-After" => retry_after.to_s,
-            },
-            [{ error: resp_message }.to_json]
-          ]
-        end
-      end
-    end
-  end
-end

data/lib/securial/security.rb

@@ -1,8 +0,0 @@
-require "securial/security/request_rate_limiter"
-
-module Securial
-  module Security
-    # This module serves as a namespace for security-related functionality.
-    # It can be extended with additional security features in the future.
-  end
-end

data/lib/securial/version_checker.rb

@@ -1,31 +0,0 @@
-require "net/http"
-require "json"
-
-module Securial
-  module VersionChecker
-    module_function
-
-    def check_latest_version
-      begin
-        rubygems_api_url = "https://rubygems.org/api/v1/versions/securial/latest.json"
-        uri = URI(rubygems_api_url)
-        http = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https", open_timeout: 5, read_timeout: 5)
-        response = http.request(Net::HTTP::Get.new(uri))
-        latest = JSON.parse(response.body)["version"]
-
-        current = Securial::VERSION
-        if Gem::Version.new(latest) > Gem::Version.new(current)
-          Securial.logger.info "A newer version (#{latest}) of Securial is available. You are using #{current}."
-          Securial.logger.info "Please consider updating!"
-          Securial.logger.debug "You can update Securial by running the following command in your terminal:"
-          Securial.logger.debug "`bundle update securial`"
-        else
-          Securial.logger.info "You are using the latest version of Securial (#{current})."
-          Securial.logger.debug "No updates available at this time."
-        end
-      rescue => e
-        Securial.logger.debug("Version check failed: #{e.message}")
-      end
-    end
-  end
-end