better_auth-roda 0.10.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 77eb658098b1736ed8bfe2217147b77081c8d0503b546047d09d31c968ca2122
+  data.tar.gz: b852714e6e2a39c99b4ab79c61b85de9a98506edc759c16a029d517f3f338ed9
+SHA512:
+  metadata.gz: 7a87f3f1b578f3f1a1feb6504408612f9b29ba6b5a5197152589e90fd1a8eb1bb13e813b5f387c0ba726a56eae888ba4988415a4c3871dd9f24986a5660d4bde
+  data.tar.gz: fc456faca0a278968ce208d3a2feb78e01a923be18c9eb2cbf281f5c14ac58ec93235bfadb26e9964e1970a4233f85be7c5e12afb16fa30484a3fd90e0731bf8

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## Unreleased
+
+## 0.10.0 - 2026-05-21
+
+- Initial Roda integration package.
+- Fixed nested auth mount handling and expanded plugin, configuration, and migration coverage.

data/README.md

@@ -0,0 +1,62 @@
+# Better Auth Roda
+
+Roda adapter for Better Auth Ruby. This package is a thin integration around
+the core Rack auth object, with a Roda plugin, request helpers, and SQL
+migration tasks.
+
+## Installation
+
+```ruby
+gem "better_auth-roda"
+```
+
+## Usage
+
+```ruby
+require "roda"
+require "better_auth/roda"
+
+class App < Roda
+  plugin :better_auth
+
+  better_auth at: "/api/auth" do |config|
+    config.secret = ENV.fetch("BETTER_AUTH_SECRET")
+    config.base_url = ENV["BETTER_AUTH_URL"]
+    config.database = :memory
+    config.email_and_password = {enabled: true}
+  end
+
+  route do |r|
+    r.better_auth
+
+    r.get "dashboard" do
+      current_user.to_json
+    end
+  end
+end
+```
+
+## Rake Tasks
+
+```ruby
+require "better_auth/roda/tasks"
+```
+
+```bash
+rake better_auth:install
+rake better_auth:generate:migration
+rake better_auth:migrate
+rake better_auth:migrate:status
+rake better_auth:doctor
+rake better_auth:routes
+```
+
+When a SQL adapter is configured, migration generation introspects the current
+database and emits only missing Better Auth tables, columns, and indexes.
+
+## Development
+
+```bash
+cd packages/better_auth-roda
+bundle exec rake ci
+```

data/lib/better_auth/roda/configuration.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module BetterAuth
+  module Roda
+    class Configuration
+      AUTH_OPTION_NAMES = %i[
+        app_name
+        base_url
+        base_path
+        secret
+        secrets
+        database
+        plugins
+        trusted_origins
+        rate_limit
+        session
+        account
+        user
+        verification
+        advanced
+        email_and_password
+        password_hasher
+        email_verification
+        social_providers
+        experimental
+        secondary_storage
+        database_hooks
+        hooks
+        on_api_error
+        disabled_paths
+        logger
+      ].freeze
+
+      attr_accessor(*AUTH_OPTION_NAMES)
+
+      def initialize
+        @base_path = BetterAuth::Configuration::DEFAULT_BASE_PATH
+        @plugins = []
+        @trusted_origins = []
+      end
+
+      def to_auth_options
+        AUTH_OPTION_NAMES.each_with_object({}) do |name, options|
+          value = public_send(name)
+          next if value.nil?
+          next if value.respond_to?(:empty?) && value.empty?
+
+          options[name] = value
+        end
+      end
+
+      def copy
+        self.class.new.tap do |copy|
+          AUTH_OPTION_NAMES.each do |name|
+            value = public_send(name)
+            copy.public_send("#{name}=", deep_dup(value))
+          end
+        end
+      end
+
+      private
+
+      def deep_dup(value)
+        case value
+        when Hash
+          value.transform_values { |entry| deep_dup(entry) }
+        when Array
+          value.map { |entry| deep_dup(entry) }
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/better_auth/roda/migration.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "better_auth/sql_migration"
+
+module BetterAuth
+  module Roda
+    module Migration
+      DEFAULT_MIGRATIONS_PATH = BetterAuth::SQLMigration::DEFAULT_MIGRATIONS_PATH
+      MISSING_MIGRATIONS_TABLE_MESSAGES = BetterAuth::SQLMigration::MISSING_MIGRATIONS_TABLE_MESSAGES
+      UnsupportedAdapterError = BetterAuth::SQLMigration::UnsupportedAdapterError
+      GENERATOR = "better_auth-roda"
+
+      module_function
+
+      def render(options, dialect:)
+        BetterAuth::SQLMigration.render(options, dialect: dialect, generator: GENERATOR)
+      end
+
+      def generate(options, dialect:, migrations_path: DEFAULT_MIGRATIONS_PATH, timestamp: Time.now.utc.strftime("%Y%m%d%H%M%S"), connection: nil)
+        BetterAuth::SQLMigration.generate(
+          options,
+          dialect: dialect,
+          generator: GENERATOR,
+          migrations_path: migrations_path,
+          timestamp: timestamp,
+          connection: connection
+        )
+      end
+
+      def migrate(auth_or_options, migrations_path: DEFAULT_MIGRATIONS_PATH)
+        BetterAuth::SQLMigration.migrate(auth_or_options, migrations_path: migrations_path)
+      end
+
+      def method_missing(name, *args, **kwargs, &block)
+        return BetterAuth::SQLMigration.public_send(name, *args, **kwargs, &block) if BetterAuth::SQLMigration.respond_to?(name)
+
+        super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        BetterAuth::SQLMigration.respond_to?(name, include_private) || super
+      end
+    end
+  end
+end

data/lib/better_auth/roda/mounted_app.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "json"
+
+module BetterAuth
+  module Roda
+    class MountedApp
+      def initialize(auth, mount_path:)
+        @auth = auth
+        @mount_path = normalize_path(mount_path)
+      end
+
+      def mount_matches?(env)
+        return false if @mount_path == "/"
+
+        path_info = normalize_path(env["PATH_INFO"], trim: true)
+        return true if path_info == @mount_path || path_info.start_with?("#{@mount_path}/")
+        return true if script_mount_matches?(normalize_path(env["SCRIPT_NAME"], trim: true))
+
+        full = full_request_path(env)
+        full == @mount_path || full.start_with?("#{@mount_path}/")
+      end
+
+      def call(env)
+        @auth.call(next_env(env))
+      rescue BetterAuth::APIError, JSON::ParserError
+        raise
+      rescue => error
+        handle_unexpected_error(error, env)
+      end
+
+      private
+
+      def next_env(env)
+        rewritten_path = mounted_path_info(env)
+        env.merge("PATH_INFO" => rewritten_path).tap do |next_env|
+          next_env["SCRIPT_NAME"] = "" if shared_mount_rewrite?(env, rewritten_path)
+        end
+      end
+
+      def full_request_path(env)
+        script = env.fetch("SCRIPT_NAME", "").to_s
+        path = env.fetch("PATH_INFO", "").to_s
+        normalize_path("#{script}#{path}", trim: true)
+      end
+
+      def mounted_path_info(env)
+        path_info = normalize_path(env["PATH_INFO"], trim: false)
+        comparable_path = normalize_path(env["PATH_INFO"], trim: true)
+        return path_info if comparable_path == @mount_path || comparable_path.start_with?("#{@mount_path}/")
+
+        script_name = normalize_path(env["SCRIPT_NAME"], trim: true)
+        return normalize_path("#{@mount_path}/#{path_info.delete_prefix("/")}", trim: false) if script_mount_matches?(script_name)
+
+        prefix = (script_name == "/") ? @mount_path : script_name
+        return path_info if comparable_path == prefix || comparable_path.start_with?("#{prefix}/")
+
+        normalize_path("#{prefix}/#{path_info.delete_prefix("/")}", trim: false)
+      end
+
+      def script_mount_matches?(script_name)
+        script_name == @mount_path || script_name.end_with?(@mount_path)
+      end
+
+      def shared_mount_rewrite?(env, rewritten_path)
+        script_name = normalize_path(env["SCRIPT_NAME"], trim: true)
+        original_path = normalize_path(env["PATH_INFO"], trim: true)
+        script_name != "/" &&
+          !original_path.start_with?("#{@mount_path}/") &&
+          rewritten_path.start_with?("#{@mount_path}/")
+      end
+
+      def normalize_path(path, trim: true)
+        normalized = path.to_s
+        normalized = "/#{normalized}" unless normalized.start_with?("/")
+        normalized = normalized.squeeze("/")
+        normalized = normalized.delete_suffix("/") if trim && normalized != "/"
+        normalized.empty? ? "/" : normalized
+      end
+
+      def handle_unexpected_error(error, env)
+        options = @auth.options
+        on_api_error = options.on_api_error || {}
+        raise error if on_api_error[:throw] || on_api_error["throw"]
+
+        callback = on_api_error[:on_error] || on_api_error[:onError] || on_api_error["on_error"] || on_api_error["onError"]
+        callback.call(error, error_context(env)) if callback.respond_to?(:call)
+
+        api_error = BetterAuth::APIError.new("INTERNAL_SERVER_ERROR")
+        [
+          api_error.status_code,
+          {"content-type" => "application/json"},
+          [JSON.generate(api_error.to_h)]
+        ]
+      end
+
+      def error_context(env)
+        path = mounted_path_info(env)
+        route_path = if path == @mount_path
+          "/"
+        else
+          path.delete_prefix(@mount_path)
+        end
+        Struct.new(:path, :env).new(normalize_path(route_path), env)
+      end
+    end
+  end
+end

data/lib/better_auth/roda/plugin.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "json"
+
+class ::Roda
+  module RodaPlugins
+    module BetterAuthPlugin
+      def self.configure(app)
+        app.opts[:better_auth_configured] = false unless app.opts.key?(:better_auth_configured)
+      end
+
+      module ClassMethods
+        def better_auth(at: BetterAuth::Configuration::DEFAULT_BASE_PATH, auth: nil, **overrides)
+          mount_path = normalize_better_auth_mount_path(at)
+          if mount_path == "/"
+            raise ArgumentError,
+              "better_auth mount path cannot be '/' (it would capture every request). " \
+              "Use a prefix such as #{BetterAuth::Configuration::DEFAULT_BASE_PATH.inspect}."
+          end
+          if opts[:better_auth_configured] && opts[:better_auth_owner].equal?(self)
+            raise ArgumentError, "better_auth is already configured for this app"
+          end
+
+          config = BetterAuth::Roda.configuration.copy
+          yield config if block_given?
+          config.base_path = mount_path
+          options = config.to_auth_options.merge(overrides).merge(base_path: mount_path)
+          auth_instance = auth || BetterAuth.auth(options)
+
+          opts[:better_auth_auth] = auth_instance
+          opts[:better_auth_mount_path] = mount_path
+          opts[:better_auth_mounted_app] = BetterAuth::Roda::MountedApp.new(auth_instance, mount_path: mount_path)
+          opts[:better_auth_owner] = self
+          opts[:better_auth_configured] = true
+        end
+
+        private
+
+        def normalize_better_auth_mount_path(path)
+          normalized = path.to_s
+          normalized = "/#{normalized}" unless normalized.start_with?("/")
+          normalized = normalized.squeeze("/")
+          (normalized == "/") ? normalized : normalized.delete_suffix("/")
+        end
+      end
+
+      module RequestMethods
+        def better_auth
+          app = scope.opts[:better_auth_mounted_app]
+          return unless app&.mount_matches?(env)
+
+          halt app.call(env)
+        end
+      end
+
+      module InstanceMethods
+        def current_session
+          data = better_auth_session_data
+          data&.fetch(:session, nil) || data&.fetch("session", nil)
+        end
+
+        def current_user
+          data = better_auth_session_data
+          data&.fetch(:user, nil) || data&.fetch("user", nil)
+        end
+
+        def authenticated?
+          !current_user.nil?
+        end
+
+        def require_authentication
+          return true if authenticated?
+
+          if prefers_json_response?
+            error = BetterAuth::APIError.new("UNAUTHORIZED")
+            request.halt [
+              401,
+              {"content-type" => "application/json"},
+              [JSON.generate(error.to_h)]
+            ]
+          end
+
+          request.halt [401, {}, [""]]
+        end
+
+        private
+
+        def prefers_json_response?
+          accept = request.env["HTTP_ACCEPT"].to_s
+          return false if accept.empty? || accept == "*/*"
+
+          preferred = accept.split(",").filter_map do |entry|
+            media_type, *params = entry.split(";").map(&:strip)
+            next unless media_type == "application/json" || media_type.end_with?("+json") || media_type == "text/html"
+
+            q = params.find { |param| param.start_with?("q=") }&.split("=", 2)&.last&.to_f || 1.0
+            [media_type, q]
+          end.max_by { |_media_type, q| q }
+
+          if preferred
+            media_type, q = preferred
+            return q.positive? && (media_type == "application/json" || media_type.end_with?("+json"))
+          end
+
+          accept.split(",").any? do |entry|
+            media_type = entry.split(";", 2).first.to_s.strip
+            media_type == "application/json" || media_type.end_with?("+json")
+          end
+        end
+
+        def better_auth_session_data
+          return request.env["better_auth.session"] if request.env.key?("better_auth.session")
+
+          request.env["better_auth.session"] = resolve_better_auth_session
+        end
+
+        def resolve_better_auth_session
+          auth = better_auth_auth
+          result = auth.api.get_session(
+            request: Rack::Request.new(request.env),
+            method: "GET",
+            as_response: true
+          )
+          return resolve_better_auth_response(result) if result.respond_to?(:headers) && result.respond_to?(:body)
+
+          apply_better_auth_response_headers(result[:headers] || result["headers"] || {})
+          result[:response] || result["response"]
+        end
+
+        def resolve_better_auth_response(auth_response)
+          apply_better_auth_response_headers(auth_response.headers || {})
+          body = auth_response.body.respond_to?(:join) ? auth_response.body.join : auth_response.body.to_s
+          payload = body.empty? ? nil : JSON.parse(body)
+          raise_better_auth_response_error(auth_response, payload) if auth_response.status.to_i >= 400
+
+          payload
+        end
+
+        def raise_better_auth_response_error(auth_response, payload)
+          payload = payload.is_a?(Hash) ? payload : {}
+          status = BetterAuth::APIError::STATUS_CODES.key(auth_response.status.to_i) || "INTERNAL_SERVER_ERROR"
+          raise BetterAuth::APIError.new(
+            status,
+            message: payload["message"],
+            code: payload["code"],
+            headers: auth_response.headers || {}
+          )
+        end
+
+        def apply_better_auth_response_headers(headers)
+          set_cookie = headers["set-cookie"] || headers["Set-Cookie"] || headers[:set_cookie]
+          return if set_cookie.to_s.empty?
+
+          existing = response.headers["set-cookie"].to_s
+          response.headers["set-cookie"] = [existing, set_cookie.to_s].reject(&:empty?).join("\n")
+        end
+
+        def better_auth_auth
+          opts[:better_auth_auth] || BetterAuth::Roda.auth
+        end
+      end
+    end
+
+    register_plugin(:better_auth, BetterAuthPlugin)
+  end
+end

data/lib/better_auth/roda/tasks.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "rake"
+require "better_auth/roda"
+
+namespace :better_auth do
+  desc "Create the Better Auth Roda config and migration directory"
+  task :install do
+    config_path = "config/better_auth.rb"
+    FileUtils.mkdir_p(File.dirname(config_path))
+    if File.exist?(config_path)
+      puts "skip #{config_path} already exists"
+    else
+      File.write(config_path, BetterAuth::Roda.default_config_template)
+      puts "create #{config_path}"
+    end
+
+    FileUtils.mkdir_p(BetterAuth::Roda::Migration::DEFAULT_MIGRATIONS_PATH)
+  end
+
+  namespace :generate do
+    desc "Create the Better Auth SQL migration"
+    task :migration do
+      BetterAuth::Roda.load_app_config!
+      dialect = BetterAuth::Roda::Migration.normalize_dialect(BetterAuth::Env.get("BETTER_AUTH_DIALECT") || BetterAuth::Env.get("BETTER_AUTH_DATABASE_DIALECT") || "postgres")
+      config = BetterAuth::Roda.migration_configuration
+      adapter = begin
+        BetterAuth::Roda.auth.context.adapter
+      rescue
+        nil
+      end
+      connection = if adapter&.respond_to?(:connection) && adapter.respond_to?(:dialect) && BetterAuth::Roda::Migration.normalize_dialect(adapter.dialect) == dialect
+        adapter.connection
+      end
+      path = BetterAuth::Roda::Migration.generate(config, dialect: dialect, connection: connection)
+      puts(path ? "create #{path}" : "no migrations needed")
+    end
+  end
+
+  desc "Run pending Better Auth SQL migrations"
+  task :migrate do
+    BetterAuth::Roda.load_app_config!
+    BetterAuth::Roda::Migration.migrate(BetterAuth::Roda.auth)
+  end
+
+  namespace :migrate do
+    desc "Print pending Better Auth SQL migration status"
+    task :status do
+      BetterAuth::Roda.load_app_config!
+      auth = BetterAuth::Roda.auth
+      adapter = auth.context.adapter
+      unless adapter.respond_to?(:connection) && adapter.respond_to?(:dialect)
+        raise BetterAuth::Roda::Migration::UnsupportedAdapterError, "Better Auth SQL migrations require core SQL adapters with connection and dialect support"
+      end
+      plan = BetterAuth::Roda::Migration.plan(auth.options, connection: adapter.connection, dialect: adapter.dialect)
+      if plan.empty?
+        puts "No migrations needed."
+      else
+        plan.to_create.each { |change| puts "create table #{change.table_name}" }
+        plan.to_add.each { |change| puts "add #{change.fields.keys.join(", ")} to #{change.table_name}" }
+        plan.to_index.each { |change| puts "create index #{change.name}" }
+        plan.warnings.each { |warning| puts "warning: #{warning}" }
+      end
+    end
+  end
+
+  desc "Check Better Auth configuration and schema health"
+  task :doctor do
+    BetterAuth::Roda.load_app_config!
+    exit_code = BetterAuth::Doctor.print(BetterAuth::Doctor.check(BetterAuth::Roda.migration_configuration), stdout: $stdout, stderr: $stderr)
+    abort if exit_code != 0
+  end
+
+  desc "Print Better Auth Roda mount information"
+  task :routes do
+    BetterAuth::Roda.load_app_config!
+    mount_path = BetterAuth::Roda.configuration.base_path
+    puts "#{mount_path}/* -> BetterAuth.auth"
+    puts "Core routes are handled by Better Auth; use the OpenAPI plugin or HTTP API docs for endpoint details."
+  end
+end

data/lib/better_auth/roda/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module BetterAuth
+  module Roda
+    VERSION = "0.10.0"
+  end
+end

data/lib/better_auth/roda.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "better_auth"
+require "roda"
+require_relative "roda/version"
+require_relative "roda/configuration"
+require_relative "roda/mounted_app"
+require_relative "roda/migration"
+require_relative "roda/plugin"
+
+module BetterAuth
+  module Roda
+    class << self
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield configuration
+        @auth = nil
+        self
+      end
+
+      def reset!
+        @configuration = nil
+        @auth = nil
+      end
+
+      def auth(overrides = nil)
+        options = configuration.to_auth_options
+        return @auth ||= BetterAuth.auth(options) if overrides.nil? || overrides.empty?
+
+        BetterAuth.auth(options.merge(overrides))
+      end
+
+      def migration_configuration
+        options = configuration.to_auth_options
+        options[:secret] ||= BetterAuth::Configuration::DEFAULT_SECRET
+        BetterAuth::Configuration.new(options)
+      end
+
+      def app_config_path(path = nil)
+        path || BetterAuth::Env.get("BETTER_AUTH_CONFIG") || "config/better_auth.rb"
+      end
+
+      def load_app_config(path = nil)
+        config_path = app_config_path(path)
+        return false unless File.exist?(config_path)
+
+        load config_path
+        true
+      end
+
+      def load_app_config!(path = nil)
+        config_path = app_config_path(path)
+        return true if load_app_config(config_path)
+
+        raise ArgumentError,
+          "Better Auth Roda config not found at #{config_path.inspect}. " \
+          "Run `rake better_auth:install` or set BETTER_AUTH_CONFIG to a shared config file."
+      end
+
+      def default_config_template
+        <<~RUBY
+          # frozen_string_literal: true
+
+          require "better_auth/roda"
+
+          BetterAuth::Roda.configure do |config|
+            config.secret = BetterAuth::Env.fetch("BETTER_AUTH_SECRET", "change-me-roda-secret-12345678901234567890")
+            config.base_url = BetterAuth::Env.get("BETTER_AUTH_URL")
+            config.base_path = "/api/auth"
+
+            config.database = ->(options) do
+              case BetterAuth::Env.fetch("BETTER_AUTH_DATABASE_DIALECT", "postgres")
+              when "postgres", "postgresql"
+                BetterAuth::Adapters::Postgres.new(options, url: ENV.fetch("DATABASE_URL"))
+              when "mysql"
+                BetterAuth::Adapters::MySQL.new(options, url: ENV.fetch("DATABASE_URL"))
+              when "sqlite", "sqlite3"
+                BetterAuth::Adapters::SQLite.new(options, path: ENV.fetch("DATABASE_URL", "db/better_auth.sqlite3"))
+              else
+                raise "Unsupported BETTER_AUTH_DATABASE_DIALECT for better_auth-roda"
+              end
+            end
+
+            config.email_and_password = {
+              enabled: true
+            }
+
+            config.plugins = []
+          end
+        RUBY
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: better_auth-roda
+version: !ruby/object:Gem::Version
+  version: 0.10.0
+platform: ruby
+authors:
+- Sebastian Sala
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: better_auth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: roda
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: standardrb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Roda integration for Better Auth Ruby. Better Auth Ruby is an independent
+  modern authentication framework for Ruby inspired by Better Auth. Provides a Roda
+  plugin, request helpers, and SQL migration tasks.
+email:
+- sebastian.sala.tech@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- lib/better_auth/roda.rb
+- lib/better_auth/roda/configuration.rb
+- lib/better_auth/roda/migration.rb
+- lib/better_auth/roda/mounted_app.rb
+- lib/better_auth/roda/plugin.rb
+- lib/better_auth/roda/tasks.rb
+- lib/better_auth/roda/version.rb
+homepage: https://github.com/sebasxsala/better-auth-rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/sebasxsala/better-auth-rb
+  source_code_uri: https://github.com/sebasxsala/better-auth-rb
+  changelog_uri: https://github.com/sebasxsala/better-auth-rb/blob/main/packages/better_auth-roda/CHANGELOG.md
+  bug_tracker_uri: https://github.com/sebasxsala/better-auth-rb/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Roda adapter for Better Auth
+test_files: []