rage-rb 1.2.2 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75beeb9e9f98cc51b8b7979be7bbd65253a319092855dfb6bfed0a23fca3bc13
-  data.tar.gz: dc3d0676ca07217e325ec7af031848de7943d1655a3d27f8845500c5a92657b4
+  metadata.gz: 43393d351828980659e1a5e574887b818727744bf679bca2c1e0e0a164848496
+  data.tar.gz: d732652d4966c9cdcdd1825ec692b6c88286e467c229a2e4acdb7658e2b0a455
 SHA512:
-  metadata.gz: 874cec69c0eb95b78f015105ad75695ad147a190b50488e8bb2bddf2bab5eb9811140d70b6566e3002729892a92ce78f568e48842d3c207ae2db7a3e76b7af80
-  data.tar.gz: 848ad81e200d92fcbbeef7cf43f80cdac118bf41b559186e0976e59a79304fac20e183289a0d67316bc88b7d02dfaf98c4f832a1c6a034be63a2eb9582f637a4
+  metadata.gz: e23ca7a0309a24e665850c6c7798a3a4d7cb5dd5d8f239346907bc2be0ae3c6446530e5299e2f5a6b08f773281a8e3c570dc19b9ebe1f6cbe1b0712b643ed688
+  data.tar.gz: 9578c4f912c7ce713639acd0c043de9f4b757ff816e60dd5ae9637434699190d8c84af29a0a42fd7c0f0f32ae6724b710429cde6fab20011c23fd79bade36d13

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 ## [Unreleased]
 
+## [1.4.0] - 2024-05-01
+
+### Added
+
+- Support cookies and sessions (#69).
+
+### Fixed
+
+- Improve compatibility with ActiveRecord 7.1 (#80).
+
+## [1.3.0] - 2024-04-17
+
+### Added
+
+- Introduce the `ActiveRecord::ConnectionPool` patch (#78).
+
 ## [1.2.2] - 2024-04-03
 
 ### Fixed

data/Gemfile

@@ -14,3 +14,6 @@ gem "yard"
 gem "pg"
 gem "mysql2"
 gem "connection_pool", "~> 2.0"
+
+gem "rbnacl"
+gem "domain_name"

data/lib/rage/configuration.rb

@@ -15,6 +15,14 @@
 #
 # > Defines the verbosity of the Rage logger. This option defaults to `:debug` for all environments except production, where it defaults to `:info`. The available log levels are: `:debug`, `:info`, `:warn`, `:error`, `:fatal`, and `:unknown`.
 #
+# • _config.secret_key_base_
+#
+# > The `secret_key_base` is used as the input secret to the application's key generator, which is used to encrypt cookies. Rage will fall back to the `SECRET_KEY_BASE` environment variable if this is not set.
+#
+# • _config.fallback_secret_key_base_
+#
+# > Defines one or several old secrets that need to be rotated. Can accept a single key or an array of keys. Rage will fall back to the `FALLBACK_SECRET_KEY_BASE` environment variable if this is not set.
+#
 # # Middleware Configuration
 #
 # • _config.middleware.use_
@@ -85,9 +93,22 @@
 #
 # > Specifies connection timeout.
 #
+# # Transient Settings
+#
+# The settings described in this section should be configured using **environment variables** and are either temporary or will become the default in the future.
+#
+# • _RAGE_DISABLE_IO_WRITE_
+#
+# > Disables the `io_write` hook to fix the ["zero-length iov"](https://bugs.ruby-lang.org/issues/19640) error on Ruby < 3.3.
+#
+# • _RAGE_PATCH_AR_POOL_
+#
+# > Enables the `ActiveRecord::ConnectionPool` patch to optimize database connection management. Use it to increase throughput under high load.
+#
 class Rage::Configuration
   attr_accessor :logger
   attr_reader :log_formatter, :log_level
+  attr_writer :secret_key_base, :fallback_secret_key_base
 
   # used in DSL
   def config = self
@@ -101,6 +122,14 @@ class Rage::Configuration
     @log_level = level.is_a?(Symbol) ? Logger.const_get(level.to_s.upcase) : level
   end
 
+  def secret_key_base
+    @secret_key_base || ENV["SECRET_KEY_BASE"]
+  end
+
+  def fallback_secret_key_base
+    Array(@fallback_secret_key_base || ENV["FALLBACK_SECRET_KEY_BASE"])
+  end
+
   def server
     @server ||= Server.new
   end

data/lib/rage/controller/api.rb

@@ -75,7 +75,7 @@ class RageController::API
         ""
       end
 
-      activerecord_loaded = Rage.config.internal.rails_mode && defined?(::ActiveRecord)
+      activerecord_loaded = defined?(::ActiveRecord)
 
       class_eval <<~RUBY,  __FILE__, __LINE__ + 1
         def __run_#{action}
@@ -324,6 +324,18 @@ class RageController::API
     @response ||= Rage::Response.new(@__headers, @__body)
   end
 
+  # Get the cookie object. See {Rage::Cookies}.
+  # @return [Rage::Cookies]
+  def cookies
+    @cookies ||= Rage::Cookies.new(@__env, self)
+  end
+
+  # Get the session object. See {Rage::Session}.
+  # @return [Rage::Session]
+  def session
+    @session ||= Rage::Session.new(self)
+  end
+
   # Send a response to the client.
   #
   # @param json [String, Object] send a json response to the client; objects like arrays will be serialized automatically
@@ -477,4 +489,9 @@ class RageController::API
   #     def append_info_to_payload(payload)
   #       payload[:response] = response.body
   #     end
+
+  # Reset the entire session. See {Rage::Session}.
+  def reset_session
+    session.clear
+  end
 end

data/lib/rage/cookies.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require "base64"
+require "time"
+
+if !defined?(DomainName)
+  fail <<~ERR
+
+    rage-rb depends on domain_name to specify the domain name for cookies. Add the following line to your Gemfile:
+    gem "domain_name"
+
+  ERR
+end
+
+class Rage::Cookies
+  # @private
+  def initialize(env, controller)
+    @env = env
+    @headers = controller.headers
+    @request_cookies = {}
+    @parsed = false
+
+    @jar = SimpleJar
+  end
+
+  # Read a cookie.
+  #
+  # @param key [Symbol]
+  # @return [String]
+  def [](key)
+    value = request_cookies[key]
+    @jar.load(value) if value
+  end
+
+  # Get the number of cookies.
+  #
+  # @return [Integer]
+  def size
+    request_cookies.count { |_, v| !v.nil? }
+  end
+
+  # Delete a cookie.
+  #
+  # @param key [Symbol]
+  # @param path [String]
+  # @param domain [String]
+  def delete(key, path: "/", domain: nil)
+    @headers.compare_by_identity
+
+    @request_cookies[key] = nil
+    @headers[set_cookie_key(key)] = Rack::Utils.add_cookie_to_header(nil, key, {
+      value: "", expires: Time.at(0), path: path, domain: domain
+    })
+  end
+
+  # Returns a jar that'll automatically encrypt cookie values before sending them to the client and will decrypt them
+  # for read. If the cookie was tampered with by the user (or a 3rd party), `nil` will be returned.
+  #
+  # This jar requires that you set a suitable secret for the verification on your app's `secret_key_base`.
+  #
+  # @example
+  #   cookies.encrypted[:user_id] = current_user.id
+  def encrypted
+    dup.tap { |c| c.jar = EncryptedJar }
+  end
+
+  # Returns a jar that'll automatically set the assigned cookies to have an expiration date 20 years from now.
+  #
+  # @example
+  #   cookies.permanent[:user_id] = current_user.id
+  def permanent
+    dup.tap { |c| c.expires = Time.now + 20 * 365 * 24 * 60 * 60 }
+  end
+
+  # Set a cookie.
+  #
+  # @param key [Symbol]
+  # @param value [String, Hash]
+  # @option value [String] :path
+  # @option value [Boolean] :secure
+  # @option value [Boolean] :httponly
+  # @option value [nil, :none, :lax, :strict] :same_site
+  # @option value [Time] :expires
+  # @option value [String, Array<String>, :all] :domain
+  # @option value [String] :value
+  # @example
+  #   cookie[:user_id] = current_user.id
+  # @example
+  #   cookie[:user_id] = { value: current_user.id, httponly: true, secure: true }
+  def []=(key, value)
+    @headers.compare_by_identity
+
+    unless value.is_a?(Hash)
+      serialized_value = @jar.dump(value)
+      @request_cookies[key] = serialized_value
+      @headers[set_cookie_key(key)] = Rack::Utils.add_cookie_to_header(nil, key, { value: serialized_value, expires: @expires })
+      return
+    end
+
+    if domain = value[:domain]
+      host = @env["HTTP_HOST"]
+
+      _domain = if domain.is_a?(String)
+        domain
+      elsif domain == :all
+        DomainName(host).domain
+      elsif domain.is_a?(Array)
+        host if domain.include?(host)
+      end
+    end
+
+    serialized_value = @jar.dump(value[:value])
+    cookie = Rack::Utils.add_cookie_to_header(nil, key, {
+      path: value[:path],
+      secure: value[:secure],
+      expires: value[:expires] || @expires,
+      httponly: value[:httponly],
+      same_site: value[:same_site],
+      value: serialized_value,
+      domain: _domain
+    })
+
+    @request_cookies[key] = serialized_value
+    @headers[set_cookie_key(key)] = cookie
+  end
+
+  def inspect
+    cookies = request_cookies.transform_values do |v|
+      decoded = Base64.urlsafe_decode64(v) rescue nil
+      is_encrypted = decoded&.start_with?(EncryptedJar::PADDING)
+
+      is_encrypted ? "<encrypted>" : v
+    end
+
+    "#<#{self.class.name} @request_cookies=#{cookies.inspect}"
+  end
+
+  private
+
+  def request_cookies
+    return @request_cookies if @parsed
+
+    @parsed = true
+    if cookie_header = @env["HTTP_COOKIE"]
+      cookie_header.split(/; */n).each do |cookie|
+        next if cookie.empty?
+        key, value = cookie.split("=", 2).yield_self { |k, _| [k.to_sym, _] }
+        unless @request_cookies.has_key?(key)
+          @request_cookies[key] = (Rack::Utils.unescape(value, Encoding::UTF_8) rescue value)
+        end
+      end
+    end
+
+    @request_cookies
+  end
+
+  def set_cookie_key(key)
+    @set_cookie_keys ||= Hash.new { |hash, key| hash[key] = "Set-Cookie".dup }
+    @set_cookie_keys[key]
+  end
+
+  protected
+
+  attr_writer :jar, :expires
+
+  ####################
+  #
+  # Cookie Jars
+  #
+  ####################
+
+  class SimpleJar
+    def self.load(_)
+      _
+    end
+
+    def self.dump(value)
+      value.to_s
+    end
+  end
+
+  class EncryptedJar
+    SALT = "encrypted cookie"
+    PADDING = "00"
+
+    class << self
+      def load(value)
+        box = primary_box
+
+        begin
+          box.decrypt(Base64.urlsafe_decode64(value).byteslice(2..))
+        rescue ArgumentError
+          nil
+        rescue RbNaCl::CryptoError
+          i ||= 0
+          if box = fallback_boxes[i]
+            i += 1
+            retry
+          end
+        end
+      end
+
+      def dump(value)
+        # add two bytes to hold meta information, e.g. in case we
+        # need to change the encryption algorithm in the future
+        Base64.urlsafe_encode64(PADDING + primary_box.encrypt(value.to_s))
+      end
+
+      private
+
+      def primary_box
+        @primary_box ||= begin
+          if !defined?(RbNaCl) || !(Gem::Version.create(RbNaCl::VERSION) >= Gem::Version.create("3.3.0") && Gem::Version.create(RbNaCl::VERSION) < Gem::Version.create("8.0.0"))
+            fail <<~ERR
+
+              rage-rb depends on rbnacl [>= 3.3, < 8.0] to encrypt cookies. Add the following line to your Gemfile:
+              gem "rbnacl"
+
+            ERR
+          end
+
+          unless Rage.config.secret_key_base
+            raise "Rage.config.secret_key_base should be set to use encrypted cookies"
+          end
+
+          RbNaCl::SimpleBox.from_secret_key(
+            RbNaCl::Hash.blake2b(Rage.config.secret_key_base, digest_size: 32, salt: SALT)
+          )
+        end
+      end
+
+      def fallback_boxes
+        @fallback_boxes ||= begin
+          Rage.config.fallback_secret_key_base.map do |key|
+            RbNaCl::SimpleBox.from_secret_key(RbNaCl::Hash.blake2b(key, digest_size: 32, salt: SALT))
+          end
+        end
+      end
+    end # class << self
+  end
+end

data/lib/rage/ext/active_record/connection_pool.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+module Rage::Ext::ActiveRecord::ConnectionPool
+  # items can be added but not removed
+  class BlackHoleList
+    def initialize(arr)
+      @arr = arr
+    end
+
+    def <<(el)
+      @arr << el
+    end
+
+    def shift
+      nil
+    end
+
+    def length
+      0
+    end
+
+    def to_a
+      @arr
+    end
+  end
+
+  def self.extended(instance)
+    instance.class.alias_method :__checkout__, :checkout
+    instance.class.alias_method :__remove__, :remove
+
+    ActiveRecord::ConnectionAdapters::AbstractAdapter.attr_accessor(:__idle_since)
+  end
+
+  def __init_rage_extension
+    # a map of fibers that are currently waiting for a
+    # connection in the format of { Fiber => timestamp }
+    @__blocked = {}
+
+    # a map of fibers that are currently hodling connections
+    # in the format of { Fiber => Connection }
+    @__in_use = {}
+
+    # a list of all DB connections that are currently idle
+    @__connections = build_new_connections
+
+    # how long a fiber can wait for a connection to become available
+    @__checkout_timeout = checkout_timeout
+
+    # how long a connection can be idle for before disconnecting
+    @__idle_timeout = reaper.frequency
+
+    # how often should we check for fibers that wait for a connection for too long
+    @__timeout_worker_frequency = 0.5
+
+    # reject fibers that wait for a connection for more than `@__checkout_timeout`
+    Iodine.run_every((@__timeout_worker_frequency * 1_000).to_i) do
+      if @__blocked.length > 0
+        current_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        @__blocked.each do |fiber, blocked_since|
+          if (current_time - blocked_since) > @__checkout_timeout
+            @__blocked.delete(fiber)
+            fiber.raise(ActiveRecord::ConnectionTimeoutError, "could not obtain a connection from the pool within #{@__checkout_timeout} seconds; all pooled connections were in use")
+          end
+        end
+      end
+    end
+
+    # resume blocked fibers once connections become available
+    Iodine.subscribe("ext:ar-connection-released") do
+      if @__blocked.length > 0 && @__connections.length > 0
+        f, _ = @__blocked.shift
+        f.resume
+      end
+    end
+
+    # unsubscribe on shutdown
+    Iodine.on_state(:on_finish) do
+      Iodine.unsubscribe("ext:ar-connection-released")
+    end
+  end
+
+  # Returns true if there is an open connection being used for the current fiber.
+  def active_connection?
+    @__in_use[Fiber.current]
+  end
+
+  # Retrieve the connection associated with the current fiber, or obtain one if necessary.
+  def connection
+    @__in_use[Fiber.current] ||= @__connections.shift || begin
+      fiber, blocked_since = Fiber.current, Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      @__blocked[fiber] = blocked_since
+      Fiber.yield
+
+      @__connections.shift
+    end
+  end
+
+  # Signal that the fiber is finished with the current connection and it can be returned to the pool.
+  def release_connection(owner = Fiber.current)
+    if conn = @__in_use.delete(owner)
+      conn.__idle_since = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      @__connections << conn
+      Iodine.publish("ext:ar-connection-released", "", Iodine::PubSub::PROCESS) if @__blocked.length > 0
+    end
+
+    conn
+  end
+
+  # Recover lost connections for the pool.
+  def reap
+    @__in_use.each do |fiber, conn|
+      unless fiber.alive?
+        if conn.active?
+          conn.reset!
+          release_connection(fiber)
+        else
+          @__in_use.delete(fiber)
+          conn.disconnect!
+          __remove__(conn)
+          @__connections += build_new_connections(1)
+          Iodine.publish("ext:ar-connection-released", "", Iodine::PubSub::PROCESS) if @__blocked.length > 0
+        end
+      end
+    end
+  end
+
+  # Disconnect all connections that have been idle for at least
+  # `minimum_idle` seconds. Connections currently checked out, or that were
+  # checked in less than `minimum_idle` seconds ago, are unaffected.
+  def flush(minimum_idle = @__idle_timeout)
+    return if minimum_idle.nil? || @__connections.length == 0
+
+    current_time, i = Process.clock_gettime(Process::CLOCK_MONOTONIC), 0
+    while i < @__connections.length
+      conn = @__connections[i]
+      if conn.__idle_since && current_time - conn.__idle_since >= minimum_idle
+        conn.__idle_since = nil
+        conn.disconnect!
+      end
+      i += 1
+    end
+  end
+
+  # Disconnect all currently idle connections. Connections currently checked out are unaffected.
+  def flush!
+    reap
+    flush(-1)
+  end
+
+  # Yields a connection from the connection pool to the block.
+  def with_connection
+    yield connection
+  ensure
+    release_connection
+  end
+
+  # Returns an array containing the connections currently in the pool.
+  def connections
+    @__connections.to_a
+  end
+
+  # Returns true if a connection has already been opened.
+  def connected?
+    true
+  end
+
+  # Return connection pool's usage statistic.
+  def stat
+    {
+      size: size,
+      connections: size,
+      busy: @__in_use.count { |fiber, _| fiber.alive? },
+      dead: @__in_use.count { |fiber, _| !fiber.alive? },
+      idle: @__connections.length,
+      waiting: @__blocked.length,
+      checkout_timeout: @__checkout_timeout
+    }
+  end
+
+  # Disconnects all connections in the pool, and clears the pool.
+  # Raises `ActiveRecord::ExclusiveConnectionTimeoutError` if unable to gain ownership of all
+  # connections in the pool within a timeout interval (default duration is `checkout_timeout * 2` seconds).
+  def disconnect(raise_on_acquisition_timeout = true, disconnect_attempts = 0)
+    # allow request fibers to release connections, but block from acquiring new ones
+    if disconnect_attempts == 0
+      @__connections = BlackHoleList.new(@__connections)
+    end
+
+    # if some connections are in use, we will wait for up to `@__checkout_timeout * 2` seconds
+    if @__in_use.length > 0 && disconnect_attempts <= @__checkout_timeout * 4
+      Iodine.run_after(500) { disconnect(raise_on_acquisition_timeout, disconnect_attempts + 1) }
+      return
+    end
+
+    pool_connections = @__connections.to_a
+
+    # check if there are still some connections in use
+    if @__in_use.length > 0
+      raise(ActiveRecord::ExclusiveConnectionTimeoutError, "could not obtain ownership of all database connections") if raise_on_acquisition_timeout
+      pool_connections += @__in_use.values
+      @__in_use.clear
+    end
+
+    # disconnect all connections
+    pool_connections.each do |conn|
+      conn.disconnect!
+      __remove__(conn)
+    end
+
+    # create a new pool
+    @__connections = build_new_connections
+
+    # notify blocked fibers that there are new connections available
+    [@__blocked.length, @__connections.length].min.times do
+      Iodine.publish("ext:ar-connection-released", "", Iodine::PubSub::PROCESS)
+    end
+  end
+
+  # Disconnects all connections in the pool, and clears the pool.
+  # The pool first tries to gain ownership of all connections. If unable to
+  # do so within a timeout interval (default duration is `checkout_timeout * 2` seconds),
+  # then the pool is forcefully disconnected without any regard for other connection owning fibers.
+  def disconnect!
+    disconnect(false)
+  end
+
+  # Check out a database connection from the pool, indicating that you want
+  # to use it. You should call #checkin when you no longer need this.
+  def checkout(_ = nil)
+    connection
+  end
+
+  # Check in a database connection back into the pool, indicating that you no longer need this connection.
+  def checkin(conn)
+    fiber = @__in_use.key(conn)
+    release_connection(fiber)
+  end
+
+  # Remove a connection from the connection pool. The connection will
+  # remain open and active but will no longer be managed by this pool.
+  def remove(conn)
+    __remove__(conn)
+    @__in_use.delete_if { |_, c| c == conn }
+    @__connections.delete(conn)
+  end
+
+  def clear_reloadable_connections(raise_on_acquisition_timeout = true)
+    disconnect(raise_on_acquisition_timeout)
+  end
+
+  def clear_reloadable_connections!
+    disconnect(false)
+  end
+
+  def num_waiting_in_queue
+    @__blocked.length
+  end
+
+  # Discards all connections in the pool (even if they're currently in use!),
+  # along with the pool itself. Any further interaction with the pool is undefined.
+  def discard!
+    @__discarded = true
+    (@__connections + @__in_use.values).each { |conn| conn.discard! }
+  end
+
+  def discarded?
+    !!@__discarded
+  end
+
+  private
+
+  def build_new_connections(num_connections = size)
+    (1..num_connections).map do
+      __checkout__.tap { |conn| conn.__idle_since = Process.clock_gettime(Process::CLOCK_MONOTONIC) }
+    end
+  end
+end

data/lib/rage/ext/setup.rb

@@ -0,0 +1,36 @@
+# set ActiveSupport isolation level
+if defined?(ActiveSupport::IsolatedExecutionState)
+  ActiveSupport::IsolatedExecutionState.isolation_level = :fiber
+end
+
+# release ActiveRecord connections on yield
+if defined?(ActiveRecord) && ActiveRecord.version < Gem::Version.create("7.1.0")
+  class Fiber
+    def self.defer
+      res = Fiber.yield
+
+      if ActiveRecord::Base.connection_pool.active_connection?
+        ActiveRecord::Base.connection_handler.clear_active_connections!
+      end
+
+      res
+    end
+  end
+end
+
+# make `ActiveRecord::ConnectionPool` work correctly with fibers
+if defined?(ActiveRecord::ConnectionAdapters::ConnectionPool)
+  ActiveRecord::ConnectionAdapters::ConnectionPool
+  module ActiveRecord::ConnectionAdapters
+    class ConnectionPool
+      def connection_cache_key(_)
+        Fiber.current
+      end
+    end
+  end
+end
+
+# patch `ActiveRecord::ConnectionPool`
+if defined?(ActiveRecord) && ENV["RAGE_PATCH_AR_POOL"]
+  Rage.patch_active_record_connection_pool
+end

data/lib/rage/fiber.rb

@@ -91,7 +91,7 @@ class Fiber
 
   # @private
   # under normal circumstances, the method is a copy of `yield`, but it can be overriden to perform
-  # additional steps on yielding, e.g. releasing AR connections; see "lib/rage/rails.rb"
+  # additional steps on yielding, e.g. releasing AR connections; see "lib/rage/ext/setup.rb"
   class << self
     alias_method :defer, :yield
   end

data/lib/rage/rails.rb

@@ -11,34 +11,6 @@ Iodine.patch_rack
 # configure the framework
 Rage.config.internal.rails_mode = true
 
-# patch ActiveRecord's connection pool
-if defined?(ActiveRecord)
-  Rails.configuration.after_initialize do
-    module ActiveRecord::ConnectionAdapters
-      class ConnectionPool
-        def connection_cache_key(_)
-          Fiber.current
-        end
-      end
-    end
-  end
-end
-
-# release ActiveRecord connections on yield
-if defined?(ActiveRecord)
-  class Fiber
-    def self.defer
-      res = Fiber.yield
-
-      if ActiveRecord::Base.connection_pool.active_connection?
-        ActiveRecord::Base.connection_handler.clear_active_connections!
-      end
-
-      res
-    end
-  end
-end
-
 # plug into Rails' Zeitwerk instance to reload the code
 Rails.autoloaders.main.on_setup do
   if Iodine.running?
@@ -71,6 +43,10 @@ end
 Rails.configuration.after_initialize do
   if Rails.logger && !Rage.logger
     rails_logdev = Rails.logger.instance_variable_get(:@logdev)
-    Rage.config.logger = Rage::Logger.new(rails_logdev.dev) if rails_logdev.is_a?(Logger::LogDevice)
+    Rage.configure do
+      config.logger = Rage::Logger.new(rails_logdev.dev) if rails_logdev.is_a?(Logger::LogDevice)
+    end
   end
 end
+
+require "rage/ext/setup"

data/lib/rage/session.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "json"
+
+class Rage::Session
+  # @private
+  KEY = Rack::RACK_SESSION.to_sym
+
+  # @private
+  def initialize(controller)
+    @cookies = controller.cookies.encrypted
+  end
+
+  # Writes the value to the session.
+  #
+  # @param key [Symbol]
+  # @param value [String]
+  def []=(key, value)
+    write_session(add: { key => value })
+  end
+
+  # Returns the value of the key stored in the session or `nil` if the given key is not found.
+  #
+  # @param key [Symbol]
+  def [](key)
+    read_session[key]
+  end
+
+  # Returns the value of the given key from the session, or raises `KeyError` if the given key is not found
+  # and no default value is set. Returns the default value if specified.
+  #
+  # @param key [Symbol]
+  def fetch(key, default = nil, &block)
+    if default.nil?
+      read_session.fetch(key, &block)
+    else
+      read_session.fetch(key, default, &block)
+    end
+  end
+
+  # Deletes the given key from the session.
+  #
+  # @param key [Symbol]
+  def delete(key)
+    write_session(remove: key)
+  end
+
+  # Clears the session.
+  def clear
+    write_session(clear: true)
+  end
+
+  # Returns the session as Hash.
+  def to_hash
+    read_session
+  end
+
+  alias_method :to_h, :to_hash
+
+  def empty?
+    read_session.empty?
+  end
+
+  # Returns `true` if the given key is present in the session.
+  def has_key?(key)
+    read_session.has_key?(key)
+  end
+
+  alias_method :key?, :has_key?
+  alias_method :include?, :has_key?
+
+  def each(&block)
+    read_session.each(&block)
+  end
+
+  def dig(*keys)
+    read_session.dig(*keys)
+  end
+
+  def inspect
+    "#<#{self.class.name} @session=#{to_h.inspect}"
+  end
+
+  private
+
+  def write_session(add: nil, remove: nil, clear: nil)
+    if add
+      read_session.merge!(add)
+    elsif remove && read_session.has_key?(remove)
+      read_session.reject! { |k, _| k == remove }
+    elsif clear
+      read_session.clear
+    end
+
+    @cookies[KEY] = { httponly: true, same_site: :lax, value: read_session.to_json }
+  end
+
+  def read_session
+    @session ||= begin
+      JSON.parse(@cookies[KEY] || "{}", symbolize_names: true)
+    rescue JSON::ParserError
+      {}
+    end
+  end
+end

data/lib/rage/setup.rb

@@ -9,3 +9,5 @@ Dir["#{Rage.root}/config/initializers/**/*.rb"].each { |initializer| load(initia
 Rage.code_loader.setup
 
 require_relative "#{Rage.root}/config/routes"
+
+require "rage/ext/setup"

data/lib/rage/templates/Gemfile

@@ -1,6 +1,6 @@
 source "https://rubygems.org"
 
-gem "rage-rb", "<%= Rage::VERSION %>"
+gem "rage-rb", "~> <%= Rage::VERSION[0..2] %>"
 
 # Build JSON APIs with ease
 # gem "alba"

data/lib/rage/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rage
-  VERSION = "1.2.2"
+  VERSION = "1.4.0"
 end

data/lib/rage-rb.rb

@@ -71,10 +71,40 @@ module Rage
     @code_loader ||= Rage::CodeLoader.new
   end
 
+  def self.patch_active_record_connection_pool
+    patch = proc do
+      is_connected = ActiveRecord::Base.connection_pool rescue false
+      if is_connected
+        puts "INFO: Patching ActiveRecord::ConnectionPool"
+        Iodine.on_state(:on_start) do
+          ActiveRecord::Base.connection_pool.extend(Rage::Ext::ActiveRecord::ConnectionPool)
+          ActiveRecord::Base.connection_pool.__init_rage_extension
+        end
+      else
+        puts "WARNING: DB connection is not established - can't patch ActiveRecord::ConnectionPool"
+      end
+    end
+
+    if Rage.config.internal.rails_mode
+      Rails.configuration.after_initialize(&patch)
+    else
+      patch.call
+    end
+  end
+
   module Router
     module Strategies
     end
   end
+
+  module Ext
+    module ActiveRecord
+      autoload :ConnectionPool, "rage/ext/active_record/connection_pool"
+    end
+  end
+
+  autoload :Cookies, "rage/cookies"
+  autoload :Session, "rage/session"
 end
 
 module RageController

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rage-rb
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.4.0
 platform: ruby
 authors:
 - Roman Samoilov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-03 00:00:00.000000000 Z
+date: 2024-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -105,8 +105,11 @@ files:
 - lib/rage/code_loader.rb
 - lib/rage/configuration.rb
 - lib/rage/controller/api.rb
+- lib/rage/cookies.rb
 - lib/rage/env.rb
 - lib/rage/errors.rb
+- lib/rage/ext/active_record/connection_pool.rb
+- lib/rage/ext/setup.rb
 - lib/rage/fiber.rb
 - lib/rage/fiber_scheduler.rb
 - lib/rage/logger/json_formatter.rb
@@ -128,6 +131,7 @@ files:
 - lib/rage/router/strategies/host.rb
 - lib/rage/router/util.rb
 - lib/rage/rspec.rb
+- lib/rage/session.rb
 - lib/rage/setup.rb
 - lib/rage/sidekiq_session.rb
 - lib/rage/templates/Gemfile