better_auth-grape 0.10.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cebdcf11ac8f2e83526cb61c135d129fd04c67118dd1c95d2d36b1ad47cf887a
+  data.tar.gz: 8a110152aa341e4a70e1621057e98cffd6902634a7d0b852b6471cbffe530f27
+SHA512:
+  metadata.gz: 1423fd9801e4bad997878b453687d154e54aa81da8fa6628b9dcb1988b8d262c1f636fa03cedadf46f95ce7976600d290da2615c9e194b07e4da4eb3e2e9fbaf
+  data.tar.gz: dde1aba6f7e74a99a5d28cee11f6298923ba66d8b9536fc4559d1579e4feb25b932dc452f342fb22a1bd20088b7a66211bce7022bfd18ef2a32b7535f2b1f21a

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## 0.10.0
+
+- Improved cookie handling for mounted Grape apps.
+- Added migration planning support and broader integration coverage.
+
+## 0.8.0
+
+- Initial Grape integration package.

data/README.md

@@ -0,0 +1,76 @@
+# better_auth-grape
+
+Grape integration for Better Auth Ruby.
+
+## Installation
+
+```ruby
+gem "better_auth-grape"
+```
+
+## Usage
+
+```ruby
+require "grape"
+require "better_auth/grape"
+
+class API < Grape::API
+  include BetterAuth::Grape
+
+  format :json
+
+  better_auth at: "/api/auth" do |config|
+    config.secret = ENV.fetch("BETTER_AUTH_SECRET")
+    config.base_url = ENV.fetch("BETTER_AUTH_URL", "http://localhost:9292")
+    config.database = ->(options) {
+      BetterAuth::Adapters::Postgres.new(options, url: ENV.fetch("DATABASE_URL"))
+    }
+    config.email_and_password = {
+      enabled: true
+    }
+    config.plugins = []
+  end
+
+  get "/dashboard" do
+    require_authentication
+    {email: current_user.fetch("email")}
+  end
+end
+```
+
+When the API uses Grape path prefixes or path-based versioning, pass a relative
+auth path and the adapter mounts below the effective Grape path:
+
+```ruby
+class API < Grape::API
+  include BetterAuth::Grape
+
+  prefix :api
+  version "v1", using: :path
+
+  better_auth at: "/auth" do |config|
+    config.secret = ENV.fetch("BETTER_AUTH_SECRET")
+    config.base_url = ENV.fetch("BETTER_AUTH_URL")
+    config.database = :memory
+  end
+end
+```
+
+This exposes Better Auth at `/api/v1/auth`.
+
+Load Rake tasks from your application Rakefile:
+
+```ruby
+require "better_auth/grape/tasks"
+```
+
+```bash
+rake better_auth:install
+BETTER_AUTH_DIALECT=postgres rake better_auth:generate:migration
+rake better_auth:migrate
+rake better_auth:migrate:status
+rake better_auth:doctor
+```
+
+When a SQL adapter is configured, migration generation introspects the current
+database and emits only missing Better Auth tables, columns, and indexes.

data/lib/better_auth/grape/configuration.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module BetterAuth
+  module Grape
+    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/grape/extension.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module BetterAuth
+  module Grape
+    module Extension
+      def self.included(base)
+        base.extend ClassMethods
+        base.helpers Helpers if base.respond_to?(:helpers)
+      end
+
+      module ClassMethods
+        attr_reader :better_auth_auth, :better_auth_mount_path
+
+        def better_auth(at: BetterAuth::Configuration::DEFAULT_BASE_PATH, auth: nil, **overrides)
+          mount_path = effective_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
+          raise ArgumentError, "better_auth is already configured for this API" if @better_auth_auth
+
+          config = BetterAuth::Grape.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)
+          @better_auth_auth = auth_instance
+          @better_auth_mount_path = mount_path
+
+          mounted_app = BetterAuth::Grape::MountedApp.new(auth_instance, mount_path: mount_path)
+          helpers do
+            define_method(:better_auth_auth) { auth_instance }
+          end
+          mount({mounted_app => mount_path})
+          route_setting :better_auth_internal, true
+          route(:any, "/*better_auth_path") do
+            path_info = env.fetch("PATH_INFO", "").to_s
+            normalized_path_info = path_info.start_with?("/") ? path_info.squeeze("/") : "/#{path_info}".squeeze("/")
+            script_name = env.fetch("SCRIPT_NAME", "").to_s
+            normalized_script_name = script_name.start_with?("/") ? script_name.squeeze("/") : "/#{script_name}".squeeze("/")
+            unless normalized_path_info == mount_path ||
+                normalized_path_info.start_with?("#{mount_path}/") ||
+                normalized_script_name == mount_path ||
+                normalized_script_name.end_with?(mount_path)
+              error!({error: "Not Found"}, 404)
+            end
+
+            rack_status, rack_headers, rack_body = mounted_app.call(env)
+            status rack_status
+            rack_headers.each { |key, value| header key, value }
+            env[::Grape::Env::API_FORMAT] = :txt
+            body rack_body.each.to_a.join
+            nil
+          end
+        end
+
+        private
+
+        def effective_better_auth_mount_path(path)
+          mount_path = normalize_better_auth_mount_path(path)
+          api_prefix = better_auth_api_prefix
+          return mount_path if api_prefix == "/"
+          return mount_path if mount_path == api_prefix || mount_path.start_with?("#{api_prefix}/")
+
+          normalize_better_auth_mount_path("#{api_prefix}/#{mount_path.delete_prefix("/")}")
+        end
+
+        def better_auth_api_prefix
+          parts = [better_auth_root_prefix]
+          version_prefix = better_auth_path_version_prefix
+          parts << version_prefix unless version_prefix == "/"
+          normalize_better_auth_mount_path(parts.reject { |part| part == "/" }.join("/"))
+        end
+
+        def better_auth_root_prefix
+          return "/" unless respond_to?(:prefix)
+
+          configured_prefix = prefix
+          return "/" if configured_prefix.nil? || configured_prefix.to_s.empty?
+
+          normalize_better_auth_mount_path(configured_prefix)
+        end
+
+        def better_auth_path_version_prefix
+          settings = inheritable_setting.namespace_inheritable if respond_to?(:inheritable_setting)
+          version_options = settings&.[](:version_options) || {}
+          return "/" unless version_options[:using]&.to_sym == :path
+
+          versions = settings&.[](:version)
+          version = Array(versions).first
+          return "/" if version.nil? || version.to_s.empty?
+
+          normalize_better_auth_mount_path(version)
+        end
+
+        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
+    end
+  end
+end

data/lib/better_auth/grape/helpers.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "json"
+
+module BetterAuth
+  module Grape
+    module Helpers
+      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?
+
+        error = BetterAuth::APIError.new("UNAUTHORIZED")
+        if prefers_json_response?
+          error!(error.to_h, 401, {"content-type" => "application/json"})
+        else
+          error!("", 401)
+        end
+      end
+
+      private
+
+      def prefers_json_response?
+        accept = env["HTTP_ACCEPT"].to_s
+        return false if accept.empty? || accept == "*/*"
+
+        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 env["better_auth.session"] if env.key?("better_auth.session")
+
+        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(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(response)
+        apply_better_auth_response_headers(response.headers || {})
+        body = response.body.respond_to?(:join) ? response.body.join : response.body.to_s
+        payload = body.empty? ? nil : JSON.parse(body)
+        raise_better_auth_response_error(response, payload) if response.status.to_i >= 400
+
+        payload
+      end
+
+      def raise_better_auth_response_error(response, payload)
+        payload = payload.is_a?(Hash) ? payload : {}
+        status = BetterAuth::APIError::STATUS_CODES.key(response.status.to_i) || "INTERNAL_SERVER_ERROR"
+        raise BetterAuth::APIError.new(
+          status,
+          message: payload["message"],
+          code: payload["code"],
+          headers: 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 = header["Set-Cookie"].to_s
+        header "Set-Cookie", [existing, set_cookie.to_s].reject(&:empty?).join("\n")
+        env["better_auth.set_cookie"] = [env["better_auth.set_cookie"], set_cookie.to_s].compact.join("\n")
+      end
+
+      def better_auth_auth
+        self.class.respond_to?(:better_auth_auth) ? self.class.better_auth_auth : BetterAuth::Grape.auth
+      end
+    end
+  end
+end

data/lib/better_auth/grape/migration.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "better_auth/sql_migration"
+
+module BetterAuth
+  module Grape
+    module Migration
+      DEFAULT_MIGRATIONS_PATH = BetterAuth::SQLMigration::DEFAULT_MIGRATIONS_PATH
+      UnsupportedAdapterError = BetterAuth::SQLMigration::UnsupportedAdapterError
+      GENERATOR = "better_auth-grape"
+
+      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 statements(sql)
+        BetterAuth::SQLMigration.statements(sql)
+      end
+
+      def normalize_dialect(value)
+        BetterAuth::SQLMigration.normalize_dialect(value)
+      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/grape/mounted_app.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "json"
+
+module BetterAuth
+  module Grape
+    class MountedApp
+      def initialize(auth, mount_path:)
+        @auth = auth
+        @mount_path = normalize_path(mount_path)
+      end
+
+      def call(env)
+        rewritten_path = mounted_path_info(env)
+        next_env = env.merge("PATH_INFO" => rewritten_path)
+        next_env["SCRIPT_NAME"] = "" if shared_mount_rewrite?(env, rewritten_path)
+        @auth.call(next_env)
+      rescue BetterAuth::APIError, JSON::ParserError
+        raise
+      rescue => error
+        handle_unexpected_error(error, env)
+      end
+
+      private
+
+      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.to_s)
+      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/grape/tasks.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "rake"
+require "better_auth/grape"
+
+namespace :better_auth do
+  desc "Create the Better Auth Grape 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::Grape.default_config_template)
+      puts "create #{config_path}"
+    end
+
+    FileUtils.mkdir_p(BetterAuth::Grape::Migration::DEFAULT_MIGRATIONS_PATH)
+  end
+
+  namespace :generate do
+    desc "Create the Better Auth SQL migration"
+    task :migration do
+      BetterAuth::Grape.load_app_config!
+      dialect = BetterAuth::Grape::Migration.normalize_dialect(BetterAuth::Env.get("BETTER_AUTH_DIALECT") || BetterAuth::Env.get("BETTER_AUTH_DATABASE_DIALECT") || "postgres")
+      config = BetterAuth::Grape.migration_configuration
+      adapter = begin
+        BetterAuth::Grape.auth.context.adapter
+      rescue
+        nil
+      end
+      connection = if adapter&.respond_to?(:connection) && adapter.respond_to?(:dialect) && BetterAuth::Grape::Migration.normalize_dialect(adapter.dialect) == dialect
+        adapter.connection
+      end
+      path = BetterAuth::Grape::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::Grape.load_app_config!
+    BetterAuth::Grape::Migration.migrate(BetterAuth::Grape.auth)
+  end
+
+  namespace :migrate do
+    desc "Print pending Better Auth SQL migration status"
+    task :status do
+      BetterAuth::Grape.load_app_config!
+      auth = BetterAuth::Grape.auth
+      adapter = auth.context.adapter
+      unless adapter.respond_to?(:connection) && adapter.respond_to?(:dialect)
+        raise BetterAuth::Grape::Migration::UnsupportedAdapterError, "Better Auth SQL migrations require core SQL adapters with connection and dialect support"
+      end
+      plan = BetterAuth::Grape::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::Grape.load_app_config!
+    exit_code = BetterAuth::Doctor.print(BetterAuth::Doctor.check(BetterAuth::Grape.migration_configuration), stdout: $stdout, stderr: $stderr)
+    abort if exit_code != 0
+  end
+
+  desc "Print Better Auth Grape mount information"
+  task :routes do
+    BetterAuth::Grape.load_app_config!
+    mount_path = BetterAuth::Grape.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/grape/version.rb

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

data/lib/better_auth/grape.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "better_auth"
+require "grape"
+
+require_relative "grape/version"
+require_relative "grape/configuration"
+require_relative "grape/mounted_app"
+require_relative "grape/helpers"
+require_relative "grape/extension"
+require_relative "grape/migration"
+
+module BetterAuth
+  module Grape
+    def self.included(base)
+      Extension.included(base)
+    end
+
+    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 Grape 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/grape"
+
+          BetterAuth::Grape.configure do |config|
+            config.secret = BetterAuth::Env.fetch("BETTER_AUTH_SECRET", "change-me-grape-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-grape"
+              end
+            end
+
+            config.email_and_password = {
+              enabled: true
+            }
+
+            config.plugins = []
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/better_auth_grape.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "better_auth/grape"

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: better_auth-grape
+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: grape
+  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: Grape integration for Better Auth Ruby. Better Auth Ruby is an independent
+  modern authentication framework for Ruby inspired by Better Auth. Provides mounting
+  helpers, 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/grape.rb
+- lib/better_auth/grape/configuration.rb
+- lib/better_auth/grape/extension.rb
+- lib/better_auth/grape/helpers.rb
+- lib/better_auth/grape/migration.rb
+- lib/better_auth/grape/mounted_app.rb
+- lib/better_auth/grape/tasks.rb
+- lib/better_auth/grape/version.rb
+- lib/better_auth_grape.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-grape/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: Grape adapter for Better Auth
+test_files: []