feat: support runtime configuration via supervisor start options

Add support for passing configuration options when starting the
Phoenix.SessionProcess supervisor, allowing runtime config to override
application environment settings.

Features:
- Pass config options when starting supervisor
- Runtime config stored in ETS for fast, concurrent access
- Config module checks ETS first, then app env, then defaults
- Supports all config keys: session_process, max_sessions, session_ttl, rate_limit
- Runtime config takes precedence over application environment

Implementation:
- Modified Supervisor.init/1 to create ETS table with runtime config
- Updated Config module to check ETS before falling back to app env
- Added private helpers get_config/2 and lookup_runtime_config/1
- Updated documentation with examples

Example usage:
  # Application supervision tree
  {Phoenix.SessionProcess, [
    session_process: MyApp.SessionProcess,
    max_sessions: 20_000,
    session_ttl: :timer.hours(2),
    rate_limit: 150
  ]}

All tests pass (148/148), credo passes.

Author: GSMLG-BOT

lib/phoenix/session_process/config.ex

@@ -42,9 +42,32 @@ defmodule Phoenix.SessionProcess.Config do
 
   ## Runtime Configuration
 
-  Configuration values are read at runtime, allowing for dynamic updates:
+  Configuration can be provided in two ways:
 
-      Application.put_env(:phoenix_session_process, :max_sessions, 20_000)
+  ### 1. Application Environment (config files)
+
+      # config/config.exs
+      config :phoenix_session_process,
+        session_process: MyApp.SessionProcess,
+        max_sessions: 10_000
+
+  ### 2. Supervisor Start Options (runtime)
+
+      # lib/my_app/application.ex
+      def start(_type, _args) do
+        children = [
+          {Phoenix.SessionProcess, [
+            session_process: MyApp.SessionProcess,
+            max_sessions: 20_000,
+            session_ttl: :timer.hours(2),
+            rate_limit: 150
+          ]}
+        ]
+
+        Supervisor.start_link(children, strategy: :one_for_one)
+      end
+
+  **Priority**: Runtime options (passed to supervisor) take precedence over application environment.
 
   ## Environment-specific Configuration
 
@@ -89,7 +112,7 @@ defmodule Phoenix.SessionProcess.Config do
   """
   @spec session_process :: module()
   def session_process do
-    Application.get_env(:phoenix_session_process, :session_process, @default_session_process)
+    get_config(:session_process, @default_session_process)
   end
 
   @doc """
@@ -116,7 +139,7 @@ defmodule Phoenix.SessionProcess.Config do
   """
   @spec max_sessions :: integer()
   def max_sessions do
-    Application.get_env(:phoenix_session_process, :max_sessions, @default_max_sessions)
+    get_config(:max_sessions, @default_max_sessions)
   end
 
   @doc """
@@ -147,7 +170,7 @@ defmodule Phoenix.SessionProcess.Config do
   """
   @spec session_ttl :: integer()
   def session_ttl do
-    Application.get_env(:phoenix_session_process, :session_ttl, @default_session_ttl)
+    get_config(:session_ttl, @default_session_ttl)
   end
 
   @doc """
@@ -178,7 +201,7 @@ defmodule Phoenix.SessionProcess.Config do
   """
   @spec rate_limit :: integer()
   def rate_limit do
-    Application.get_env(:phoenix_session_process, :rate_limit, @default_rate_limit)
+    get_config(:rate_limit, @default_rate_limit)
   end
 
   @doc """
@@ -220,4 +243,32 @@ defmodule Phoenix.SessionProcess.Config do
       byte_size(session_id) <= 64 and
       String.match?(session_id, ~r/^[A-Za-z0-9_-]+$/)
   end
+
+  # Private helper to get config value with proper precedence:
+  # 1. Runtime config (ETS table from supervisor start options)
+  # 2. Application environment (config files)
+  # 3. Default value
+  defp get_config(key, default) do
+    case lookup_runtime_config(key) do
+      {:ok, value} ->
+        value
+
+      :not_found ->
+        Application.get_env(:phoenix_session_process, key, default)
+    end
+  end
+
+  # Lookup value from runtime config ETS table
+  defp lookup_runtime_config(key) do
+    table = :phoenix_session_process_runtime_config
+
+    if :ets.whereis(table) != :undefined do
+      case :ets.lookup(table, key) do
+        [{^key, value}] -> {:ok, value}
+        [] -> :not_found
+      end
+    else
+      :not_found
+    end
+  end
 end

lib/phoenix/session_process/superviser.ex

@@ -32,12 +32,30 @@ defmodule Phoenix.SessionProcess.Supervisor do
       def start(_type, _args) do
         children = [
           # ... other children ...
-          {Phoenix.SessionProcess.Supervisor, []}
+          {Phoenix.SessionProcess, []}
+          # Or with runtime configuration:
+          {Phoenix.SessionProcess, [
+            session_process: MyApp.CustomProcess,
+            max_sessions: 20_000,
+            session_ttl: :timer.hours(2),
+            rate_limit: 150
+          ]}
         ]
 
         Supervisor.start_link(children, strategy: :one_for_one)
       end
 
+  ## Runtime Configuration
+
+  Configuration can be provided at supervisor startup, overriding application environment settings:
+
+  - `:session_process` - Default session module to use
+  - `:max_sessions` - Maximum concurrent sessions allowed
+  - `:session_ttl` - Session time-to-live in milliseconds
+  - `:rate_limit` - Maximum session creations per minute
+
+  Runtime configuration takes precedence over application environment configuration.
+
   ## Process Lifecycle
 
   1. **Application Start**: Top-level supervisor starts all children
@@ -74,7 +92,26 @@ defmodule Phoenix.SessionProcess.Supervisor do
   end
 
   @impl true
-  def init(_init_arg) do
+  def init(init_arg) do
+    # Store runtime configuration in ETS for fast access
+    # This allows configuration to be passed at startup instead of only via application env
+    runtime_config = normalize_config(init_arg)
+
+    if runtime_config != [] do
+      # Create ETS table for runtime config (public, readable by all processes)
+      :ets.new(:phoenix_session_process_runtime_config, [
+        :set,
+        :public,
+        :named_table,
+        read_concurrency: true
+      ])
+
+      # Store each config option in ETS
+      Enum.each(runtime_config, fn {key, value} ->
+        :ets.insert(:phoenix_session_process_runtime_config, {key, value})
+      end)
+    end
+
     children = [
       {Registry, keys: :unique, name: Phoenix.SessionProcess.Registry},
       {Phoenix.SessionProcess.ProcessSupervisor, []},
@@ -84,4 +121,16 @@ defmodule Phoenix.SessionProcess.Supervisor do
 
     Supervisor.init(children, strategy: :one_for_one)
   end
+
+  # Normalize and validate configuration options
+  defp normalize_config(opts) when is_list(opts) do
+    valid_keys = [:session_process, :max_sessions, :session_ttl, :rate_limit]
+
+    opts
+    |> Enum.filter(fn {key, _value} -> key in valid_keys end)
+    |> Enum.into(%{})
+    |> Map.to_list()
+  end
+
+  defp normalize_config(_), do: []
 end