better_auth-sinatra 0.8.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c7447781067976bc4c48c8a826db7f10ea2a1b730da8d0ffe1a084e22c97357
-  data.tar.gz: 6471dbc15a2cd08755db616741081cc8aee613040153512796e86e1ce0df300f
+  metadata.gz: c1354b443fe041ddaa63d80da87d5386dd88128ff7b0fdce339b4ec123751e4e
+  data.tar.gz: 38c93a00515742217abe673835752acc65465e6c207904d1219c605f94409ad4
 SHA512:
-  metadata.gz: '09a9f4b4d5b0ef1491e1a20c653cf3a3aaa3a317f65a478b3f4c78d764be46d92faddf6c2c3a9690923fb84aced0b6d6e049496fb40f33309baed358200779d6'
-  data.tar.gz: 67e80a63f8e8db1564265a4f74581cb96c45a5af0bcf9283c27f769685f29a648dc62b8e51ade56bcd3dce3d84fc24dfadba748a5a05abfb6a0ccc81b5791cc4
+  metadata.gz: 674b03f0268f4ed4b07f4d66c0ac348645d3506a7787e0593cd1e33ffdc8a20c5b045e701c998621c7d15ce006c520ec07cc538c4cbfe03fd03263b41b63eaae
+  data.tar.gz: 4c13b0fdec4ec941beef0786b353abaee4b9ec56d5a952af91414e0a65e108f4adb7ea6b8c1801024ad66da789cb5e978b319eb7bc99a445ff0f962b8db980e2

data/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Unreleased
 
+## 0.10.0 - 2026-05-21
+
+- Removed obsolete helper wiring and expanded mounted app, migration, and routing coverage.
+- Updated Sinatra docs for current mounting and integration behavior.
+
 ## 0.7.0 - 2026-05-05
 
 - Fixed auth dispatch when Rack splits mounted paths across `SCRIPT_NAME` and `PATH_INFO`.

data/README.md

@@ -44,6 +44,10 @@ cannot be `/`, because that would capture every Sinatra route before the app can
 handle it. The core app still owns routes such as `/ok`, `/sign-up/email`,
 `/sign-in/email`, and plugin endpoints.
 
+Call `better_auth` once per Sinatra app class. Registering it more than once is
+treated as a configuration error because each Rack mount must delegate to one
+core Better Auth instance.
+
 `better_auth at:` sets the path prefix that Better Auth uses as its core
 `base_path`. The adapter supports two common Rack mount patterns:
 
@@ -58,7 +62,10 @@ When using reverse proxies, `Rack::URLMap`, or another parent app, make sure the
 `PATH_INFO` visible to Sinatra still aligns with the configured auth prefix.
 `SCRIPT_NAME` handling depends on the Rack server and mount stack, so verify
 redirect URLs and cookie paths in integration tests when mounting below a
-sub-path.
+sub-path. If the public auth URL includes a parent mount prefix, set
+`config.base_url` to that public URL, for example `https://app.example/api/auth`;
+core URL inference uses the configured Better Auth base path and cannot infer
+every parent Rack mount layout from Sinatra alone.
 
 ## Helpers
 
@@ -91,11 +98,27 @@ Available tasks:
 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
 ```
 
 `better_auth:install` creates `config/better_auth.rb`. SQL migrations are
-generated under `db/better_auth/migrate`.
+generated under `db/better_auth/migrate`. When a SQL adapter is configured,
+generation introspects the current database and emits only missing Better Auth
+tables, columns, and indexes.
+
+Migration and route tasks load Better Auth configuration from
+`config/better_auth.rb` by default. Set `BETTER_AUTH_CONFIG` (or the
+OpenAuth-compatible `OPEN_AUTH_CONFIG`) to a shared config file if your app keeps
+Better Auth setup elsewhere:
+
+```bash
+BETTER_AUTH_CONFIG=config/auth/better_auth.rb rake better_auth:generate:migration
+```
+
+The migration tasks fail when no config file is found, so generated SQL cannot
+silently omit app plugins or custom schema options.
 
 ## Database Notes
 
@@ -103,10 +126,14 @@ Sinatra does not include a Rails-style database layer or migration command.
 This adapter uses Better Auth core SQL adapters for migrations. Set
 `BETTER_AUTH_DIALECT=postgres`, `mysql`, or `sqlite` when generating SQL.
 
-Generated SQL should keep one statement per line ending with `;`. The migration
-runner handles simple single-line multi-statement files, but hand-edited SQL
-with semicolons inside string literals can confuse the splitter. DDL rollback
-behavior depends on the database, so back up production data before migrating.
+The migration runner delegates SQL rendering and execution behavior to the core
+Better Auth SQL migration layer. It handles multiple statements, quoted strings,
+and PostgreSQL dollar-quoted blocks; DDL rollback behavior still depends on the
+database, so back up production data before migrating.
+
+Exhaustive adapter behavior for PostgreSQL, MySQL, SQLite, and other database
+families is covered in the core `better_auth` package. This Sinatra package only
+smoke-tests that its configuration and Rake tasks delegate to those core paths.
 
 ActiveRecord-backed Sinatra migrations are not supported yet. Apps that already
 use `sinatra-activerecord` can still configure Better Auth manually, but the v1

data/lib/better_auth/sinatra/extension.rb

@@ -16,7 +16,7 @@ module BetterAuth
               "better_auth mount path cannot be '/' (it would capture every request). " \
               "Use a prefix such as #{BetterAuth::Configuration::DEFAULT_BASE_PATH.inspect}."
           end
-          warn "[better_auth-sinatra] better_auth is already configured for this app; the new configuration will be appended." if respond_to?(:better_auth_auth)
+          raise ArgumentError, "better_auth is already configured for this app" if respond_to?(:better_auth_auth)
 
           config = BetterAuth::Sinatra.configuration.copy
           yield config if block_given?

data/lib/better_auth/sinatra/helpers.rb

@@ -54,26 +54,34 @@ module BetterAuth
       def resolve_better_auth_session
         auth = better_auth_auth
         result = auth.api.get_session(
-          headers: better_auth_request_headers,
-          return_headers: true
+          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 better_auth_request_headers
-        request.env.each_with_object({}) do |(key, value), headers|
-          case key
-          when "CONTENT_TYPE"
-            headers["content-type"] = value if value
-          when "CONTENT_LENGTH"
-            headers["content-length"] = value if value
-          else
-            next unless key.start_with?("HTTP_")
-
-            headers[key.delete_prefix("HTTP_").downcase.tr("_", "-")] = value
-          end
-        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)

data/lib/better_auth/sinatra/migration.rb

@@ -1,250 +1,44 @@
 # frozen_string_literal: true
 
-require "fileutils"
+require "better_auth/sql_migration"
 
 module BetterAuth
   module Sinatra
     module Migration
-      DEFAULT_MIGRATIONS_PATH = "db/better_auth/migrate"
-      MISSING_MIGRATIONS_TABLE_MESSAGES = [
-        /no such table/i,
-        /relation .* does not exist/i,
-        /table .* doesn't exist/i,
-        /undefined table/i,
-        /invalid object name/i
-      ].freeze
-
-      class UnsupportedAdapterError < StandardError; end
+      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-sinatra"
 
       module_function
 
       def render(options, dialect:)
-        dialect = normalize_dialect(dialect)
-        config = configuration_for(options)
-        statements = BetterAuth::Schema::SQL.create_statements(config, dialect: dialect)
-        [
-          "-- Generated by better_auth-sinatra",
-          "-- Dialect: #{dialect}",
-          "",
-          statements.join("\n\n"),
-          ""
-        ].join("\n")
+        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"))
-        dialect = normalize_dialect(dialect)
-        FileUtils.mkdir_p(migrations_path)
-        path = File.join(migrations_path, "#{timestamp}_create_better_auth_tables.sql")
-        return path if File.exist?(path)
-
-        File.write(path, render(options, dialect: dialect))
-        path
+      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)
-        auth = auth_for(auth_or_options)
-        adapter = auth.context.adapter
-        unless adapter.respond_to?(:dialect) && adapter.respond_to?(:connection)
-          raise UnsupportedAdapterError, "better_auth-sinatra migrations require core SQL adapters with connection and dialect support"
-        end
-
-        connection = adapter.connection
-        dialect = normalize_dialect(adapter.dialect)
-        files = Dir[File.join(migrations_path, "*.sql")].sort
-        ensure_schema_migrations!(connection, dialect)
-        applied = applied_migrations(connection, dialect)
-
-        files.reject { |file| applied.include?(File.basename(file)) }.each do |file|
-          execute_sql(connection, File.read(file))
-          record_migration(connection, dialect, File.basename(file))
-        end
-      end
-
-      def configuration_for(options)
-        return options.options if options.is_a?(BetterAuth::Auth)
-        return options if options.is_a?(BetterAuth::Configuration)
-
-        BetterAuth::Configuration.new(options)
-      end
-
-      def auth_for(value)
-        return value if value.is_a?(BetterAuth::Auth)
-
-        BetterAuth.auth(value)
-      end
-
-      def ensure_schema_migrations!(connection, dialect)
-        sql = case dialect
-        when :postgres, :sqlite
-          %(CREATE TABLE IF NOT EXISTS #{quote("better_auth_schema_migrations", dialect)} (#{quote("version", dialect)} text PRIMARY KEY);)
-        when :mysql
-          %(CREATE TABLE IF NOT EXISTS #{quote("better_auth_schema_migrations", dialect)} (#{quote("version", dialect)} varchar(191) PRIMARY KEY) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;)
-        when :mssql
-          %(IF OBJECT_ID(N'#{quote("better_auth_schema_migrations", dialect)}', N'U') IS NULL CREATE TABLE #{quote("better_auth_schema_migrations", dialect)} (#{quote("version", dialect)} varchar(255) PRIMARY KEY);)
-        else
-          raise UnsupportedAdapterError, "Unsupported SQL dialect for better_auth-sinatra migrations: #{dialect}"
-        end
-        execute_sql(connection, sql)
+        BetterAuth::SQLMigration.migrate(auth_or_options, migrations_path: migrations_path)
       end
 
-      def applied_migrations(connection, dialect)
-        rows = execute_sql(connection, "SELECT #{quote("version", dialect)} FROM #{quote("better_auth_schema_migrations", dialect)};")
-        Array(rows).map { |row| row["version"] || row[:version] }
-      rescue UnsupportedAdapterError
-        raise
-      rescue => error
-        raise error unless missing_schema_migrations_table?(error)
-
-        []
-      end
-
-      def record_migration(connection, dialect, version)
-        sql = "INSERT INTO #{quote("better_auth_schema_migrations", dialect)} (#{quote("version", dialect)}) VALUES (#{literal(version)});"
-        execute_sql(connection, sql)
-      end
-
-      def execute_sql(connection, sql)
-        statements(sql).each_with_object([]) do |statement, results|
-          result =
-            if connection.respond_to?(:exec)
-              connection.exec(statement)
-            elsif connection.respond_to?(:execute)
-              connection.execute(statement)
-            elsif connection.respond_to?(:query)
-              connection.query(statement)
-            else
-              raise UnsupportedAdapterError, "SQL connection does not support exec, execute, or query"
-            end
-          results.concat(result.to_a) if result.respond_to?(:to_a)
-        end
-      end
-
-      def statements(sql)
-        normalized = sql.to_s.gsub("\r\n", "\n").strip
-        return [] if normalized.empty?
-
-        split_sql_statements(normalized)
-      end
-
-      def split_sql_statements(sql)
-        output = []
-        buffer = +""
-        index = 0
-        quote = nil
-        line_comment = false
-        block_comment = false
-        dollar_tag = nil
-
-        while index < sql.length
-          state = {
-            quote: quote,
-            line_comment: line_comment,
-            block_comment: block_comment,
-            dollar_tag: dollar_tag
-          }
-          index, quote, line_comment, block_comment, dollar_tag = scan_sql_character(sql, buffer, index, state, output)
-        end
-
-        tail = buffer.strip
-        output << tail unless tail.empty?
-        output
-      end
-
-      def scan_sql_character(sql, buffer, index, state, output)
-        char = sql[index]
-        next_char = sql[index + 1]
-        quote = state[:quote]
-        line_comment = state[:line_comment]
-        block_comment = state[:block_comment]
-        dollar_tag = state[:dollar_tag]
-
-        return scan_line_comment(buffer, index, char) + [quote, false, block_comment, dollar_tag] if line_comment && char == "\n"
-        return scan_line_comment(buffer, index, char) + [quote, true, block_comment, dollar_tag] if line_comment
-        return scan_block_comment(buffer, index, char, next_char, quote, line_comment, dollar_tag) if block_comment
-        return scan_dollar_quote(sql, buffer, index, char, quote, line_comment, block_comment, dollar_tag) if dollar_tag
-        return scan_quoted_string(sql, buffer, index, char, quote, line_comment, block_comment, dollar_tag) if quote
-        return [index + 2, quote, true, block_comment, dollar_tag].tap { buffer << char << next_char } if char == "-" && next_char == "-"
-        return [index + 2, quote, line_comment, true, dollar_tag].tap { buffer << char << next_char } if char == "/" && next_char == "*"
-
-        tag = dollar_quote_tag_at(sql, index)
-        return [index + tag.length, quote, line_comment, block_comment, tag].tap { buffer << tag } if tag
-        return [index + 1, char, line_comment, block_comment, dollar_tag].tap { buffer << char } if char == "'" || char == "\""
-
-        if char == ";"
-          statement = buffer.strip
-          output << statement unless statement.empty?
-          buffer.clear
-          return [index + 1, quote, line_comment, block_comment, dollar_tag]
-        end
-
-        buffer << char
-        [index + 1, quote, line_comment, block_comment, dollar_tag]
-      end
-
-      def scan_line_comment(buffer, index, char)
-        buffer << char
-        [index + 1]
-      end
-
-      def scan_block_comment(buffer, index, char, next_char, quote, line_comment, dollar_tag)
-        buffer << char
-        if char == "*" && next_char == "/"
-          buffer << next_char
-          [index + 2, quote, line_comment, false, dollar_tag]
-        else
-          [index + 1, quote, line_comment, true, dollar_tag]
-        end
-      end
-
-      def scan_dollar_quote(sql, buffer, index, char, quote, line_comment, block_comment, dollar_tag)
-        if sql[index, dollar_tag.length] == dollar_tag
-          buffer << dollar_tag
-          [index + dollar_tag.length, quote, line_comment, block_comment, nil]
-        else
-          buffer << char
-          [index + 1, quote, line_comment, block_comment, dollar_tag]
-        end
-      end
-
-      def scan_quoted_string(sql, buffer, index, char, quote, line_comment, block_comment, dollar_tag)
-        buffer << char
-        if char == quote && sql[index + 1] == quote
-          buffer << sql[index + 1]
-          [index + 2, quote, line_comment, block_comment, dollar_tag]
-        elsif char == quote
-          [index + 1, nil, line_comment, block_comment, dollar_tag]
-        else
-          [index + 1, quote, line_comment, block_comment, dollar_tag]
-        end
-      end
-
-      def dollar_quote_tag_at(sql, index)
-        match = sql[index..]&.match(/\A\$[A-Za-z_][A-Za-z0-9_]*\$|\A\$\$/)
-        match&.[](0)
-      end
-
-      def missing_schema_migrations_table?(error)
-        message = error.message.to_s
-        MISSING_MIGRATIONS_TABLE_MESSAGES.any? { |pattern| message.match?(pattern) }
-      end
-
-      def quote(identifier, dialect)
-        BetterAuth::Schema::SQL.quote(identifier, dialect)
-      end
+      def method_missing(name, *args, **kwargs, &block)
+        return BetterAuth::SQLMigration.public_send(name, *args, **kwargs, &block) if BetterAuth::SQLMigration.respond_to?(name)
 
-      def literal(value)
-        "'#{value.to_s.gsub("'", "''")}'"
+        super
       end
 
-      def normalize_dialect(value)
-        case value.to_s.downcase
-        when "postgresql"
-          :postgres
-        when "sqlite3"
-          :sqlite
-        else
-          value.to_sym
-        end
+      def respond_to_missing?(name, include_private = false)
+        BetterAuth::SQLMigration.respond_to?(name, include_private) || super
       end
     end
   end

data/lib/better_auth/sinatra/mounted_app.rb

@@ -29,7 +29,7 @@ module BetterAuth
       def mount_matches?(env)
         return false if @mount_path == "/"
 
-        path_info = normalize_path(env["PATH_INFO"])
+        path_info = normalize_path(env["PATH_INFO"], trim: true)
         return true if path_info == @mount_path || path_info.start_with?("#{@mount_path}/")
 
         full = full_request_path(env)
@@ -39,33 +39,34 @@ module BetterAuth
       def full_request_path(env)
         script = env.fetch("SCRIPT_NAME", "").to_s
         path = env.fetch("PATH_INFO", "").to_s
-        normalize_path("#{script}#{path}")
+        normalize_path("#{script}#{path}", trim: true)
       end
 
       def mounted_path_info(env)
-        path_info = normalize_path(env["PATH_INFO"])
-        return path_info if path_info == @mount_path || path_info.start_with?("#{@mount_path}/")
+        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"])
+        script_name = normalize_path(env["SCRIPT_NAME"], trim: true)
         prefix = (script_name == "/") ? @mount_path : script_name
-        return path_info if path_info == prefix || path_info.start_with?("#{prefix}/")
+        return path_info if comparable_path == prefix || comparable_path.start_with?("#{prefix}/")
 
-        normalize_path("#{prefix}/#{path_info.delete_prefix("/")}")
+        normalize_path("#{prefix}/#{path_info.delete_prefix("/")}", trim: false)
       end
 
       def shared_mount_rewrite?(env, rewritten_path)
-        script_name = normalize_path(env["SCRIPT_NAME"])
-        original_path = normalize_path(env["PATH_INFO"])
+        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)
+      def normalize_path(path, trim: true)
         normalized = path.to_s
         normalized = "/#{normalized}" unless normalized.start_with?("/")
         normalized = normalized.squeeze("/")
-        normalized = normalized.delete_suffix("/") unless normalized == "/"
+        normalized = normalized.delete_suffix("/") if trim && normalized != "/"
         normalized.empty? ? "/" : normalized
       end
     end

data/lib/better_auth/sinatra/tasks.rb

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

data/lib/better_auth/sinatra/version.rb

@@ -2,6 +2,6 @@
 
 module BetterAuth
   module Sinatra
-    VERSION = "0.8.0"
+    VERSION = "0.10.0"
   end
 end

data/lib/better_auth/sinatra.rb

@@ -45,8 +45,25 @@ module BetterAuth
         BetterAuth::Configuration.new(options)
       end
 
-      def load_app_config(path = "config/better_auth.rb")
-        load path if File.exist?(path)
+      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 Sinatra 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: better_auth-sinatra
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Sebastian Sala
@@ -134,14 +134,14 @@ files:
 - lib/better_auth/sinatra/tasks.rb
 - lib/better_auth/sinatra/version.rb
 - lib/better_auth_sinatra.rb
-homepage: https://github.com/sebasxsala/better-auth
+homepage: https://github.com/sebasxsala/better-auth-rb
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/sebasxsala/better-auth
-  source_code_uri: https://github.com/sebasxsala/better-auth
-  changelog_uri: https://github.com/sebasxsala/better-auth/blob/main/packages/better_auth-sinatra/CHANGELOG.md
-  bug_tracker_uri: https://github.com/sebasxsala/better-auth/issues
+  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-sinatra/CHANGELOG.md
+  bug_tracker_uri: https://github.com/sebasxsala/better-auth-rb/issues
 rdoc_options: []
 require_paths:
 - lib