better_auth-passkey 0.8.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1b6ca556a3e04611cfc956e3d8861c05ce0933063f8a1a73c561caa5abcbb99
-  data.tar.gz: 83ea6e86f56b59c7a6bcc0c4ea1504078f9900017ccd807a2a05da1cf73ca383
+  metadata.gz: 0bc0ba7fd7e24d51fa66e69af69a9765451d92dd8cb87d5a3a5c23e6734dc258
+  data.tar.gz: 32d5ac99eb08d923dda471be6cb66b08b5c6c660ff80998e3f3e9cb2132f367c
 SHA512:
-  metadata.gz: 5383e6056c527e1d6ddf00a84b4acc5b00895ff478a823c5830fff053c4cf6281424f5bad3ea932de43f7b741474f54871913d07609f69995c46cb7f141b64b3
-  data.tar.gz: 75d60921c7de4cd1d3a8b414e4339dc692a91a1c6c866b6e879a50b2f2ae1e135bace181bb43e86a3601b86709e041d46afb526430d50a600705d7741306a001
+  metadata.gz: ec4ec014d9a35ed4ee62ed3e65748d8f87e3fdc2f286cf34285ad6a9fd7a5d9ad5ed5ad48f40b95ddff9ca1805a044090d71c75033bdcef7d6692b286898e29d
+  data.tar.gz: 0f90a06468a408976910c81fc490124695be43e6f7c9e2d4e5b81efd6a553a026efef296e059d3ab02365ba74b42fdbc05457ad92774db0e51f9708dd0360c9b

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## [Unreleased]
 
+## [0.10.0] - 2026-05-21
+
+- Improved passkey challenge handling, management routes, rate limits, and adapter coverage.
+
 ## [0.7.0] - 2026-05-05
 
 - Require a fresh session for session-required passkey registration verification.

data/README.md

@@ -127,7 +127,7 @@ The Ruby plugin tracks Better Auth `v1.6.9` upstream behavior. A few wire-shape
 - `rp_id` resolution falls back to `URI.parse(base_url).host` (port stripped). When `base_url` is empty or unparseable, `rp_id` defaults to `"localhost"`.
 - For passkey-first registration, the `after_verification` callback may return `{ user_id: nil }` or `{ user_id: "" }` to leave the resolved user unchanged. Returning any other non-empty-string value (integer, boolean, etc.) raises `RESOLVED_USER_INVALID`.
 - `update_passkey` accepts an empty-string `name` to match upstream `z.string()`. Missing or non-string `name` still raises `VALIDATION_ERROR`.
-- Cross-user `delete_passkey` raises `UNAUTHORIZED` with the `PASSKEY_NOT_FOUND` message, mirroring upstream's `requireResourceOwnership` middleware behavior when only `notFoundError` is configured.
+- Cross-user `delete_passkey` and `update_passkey` raise `NOT_FOUND` with the `PASSKEY_NOT_FOUND` message. This is an intentional Ruby hardening to avoid user/passkey enumeration while preserving the upstream error message.
 - Existing databases should deduplicate historical `credential_id` values before adding the unique constraint during migration.
 
 ## Notes

data/lib/better_auth/passkey/credentials.rb

@@ -47,6 +47,17 @@ module BetterAuth
         record["credentialID"] || record["credentialId"] || record[:credentialID] || record[:credential_id]
       end
 
+      def response_credential_id(response)
+        return nil unless response.is_a?(Hash)
+
+        response["id"] || response[:id]
+      end
+
+      def duplicate_credential_error?(error)
+        message = "#{error.class.name} #{error.message}".downcase
+        message.include?("credential") && (message.include?("unique") || message.include?("duplicate") || message.include?("constraint"))
+      end
+
       def credential_descriptor(record, kind: :allow)
         descriptor = {id: credential_id(record)}
         descriptor[:type] = "public-key" if kind == :allow

data/lib/better_auth/passkey/routes/authentication.rb

@@ -10,7 +10,7 @@ module BetterAuth
         module_function
 
         def generate_passkey_authentication_options_endpoint(config)
-          Endpoint.new(path: "/passkey/generate-authenticate-options", method: "GET") do |ctx|
+          Endpoint.new(path: "/passkey/generate-authenticate-options", method: "GET", metadata: Routes.openapi_for(:generate_authentication_options)) do |ctx|
             session = BetterAuth::Routes.current_session(ctx, allow_nil: true)
             relying_party = Utils.relying_party(config, ctx)
             passkeys = if session
@@ -39,7 +39,7 @@ module BetterAuth
         end
 
         def verify_passkey_authentication_endpoint(config)
-          Endpoint.new(path: "/passkey/verify-authentication", method: "POST") do |ctx|
+          Endpoint.new(path: "/passkey/verify-authentication", method: "POST", metadata: Routes.openapi_for(:verify_authentication)) do |ctx|
             body = Utils.normalize_hash(ctx.body)
             Utils.require_key!(body, :response)
             origin = Utils.origin(config, ctx)
@@ -54,7 +54,12 @@ module BetterAuth
             begin
               response = Credentials.webauthn_response(body[:response])
               credential_id = response.fetch("id")
-              passkey = ctx.context.adapter.find_one(model: "passkey", where: [{field: "credentialID", value: credential_id}])
+              passkey = begin
+                ctx.context.adapter.find_one(model: "passkey", where: [{field: "credentialID", value: credential_id}])
+              rescue => error
+                ctx.context.logger&.error("Failed to find passkey", error)
+                raise APIError.new("BAD_REQUEST", message: ErrorCodes::PASSKEY_ERROR_CODES.fetch("AUTHENTICATION_FAILED"))
+              end
               raise APIError.new("UNAUTHORIZED", message: ErrorCodes::PASSKEY_ERROR_CODES.fetch("PASSKEY_NOT_FOUND")) unless passkey
 
               relying_party = Utils.relying_party(config, ctx, origin: origin)
@@ -70,17 +75,21 @@ module BetterAuth
                 verification: credential,
                 client_data: response
               })
-              ctx.context.adapter.update(
+              updated_passkey = ctx.context.adapter.update(
                 model: "passkey",
                 where: [{field: "id", value: passkey.fetch("id")}],
-                update: {counter: credential.sign_count}
+                update: {counter: credential.sign_count.to_i}
               )
-              session = ctx.context.internal_adapter.create_session(passkey.fetch("userId"))
-              raise APIError.new("INTERNAL_SERVER_ERROR", message: ErrorCodes::PASSKEY_ERROR_CODES.fetch("UNABLE_TO_CREATE_SESSION")) unless session
+              unless updated_passkey
+                raise APIError.new("BAD_REQUEST", message: ErrorCodes::PASSKEY_ERROR_CODES.fetch("AUTHENTICATION_FAILED"))
+              end
 
               user = ctx.context.internal_adapter.find_user_by_id(passkey.fetch("userId"))
               raise APIError.new("INTERNAL_SERVER_ERROR", message: "User not found") unless user
 
+              session = ctx.context.internal_adapter.create_session(passkey.fetch("userId"))
+              raise APIError.new("INTERNAL_SERVER_ERROR", message: ErrorCodes::PASSKEY_ERROR_CODES.fetch("UNABLE_TO_CREATE_SESSION")) unless session
+
               Cookies.set_session_cookie(ctx, {session: session, user: user})
               ctx.context.internal_adapter.delete_verification_by_identifier(verification_token)
               ctx.json({session: session, user: user})

data/lib/better_auth/passkey/routes/management.rb

@@ -7,7 +7,7 @@ module BetterAuth
         module_function
 
         def list_passkeys_endpoint
-          Endpoint.new(path: "/passkey/list-user-passkeys", method: "GET") do |ctx|
+          Endpoint.new(path: "/passkey/list-user-passkeys", method: "GET", metadata: Routes.openapi_for(:list_passkeys)) do |ctx|
             session = BetterAuth::Routes.current_session(ctx)
             passkeys = ctx.context.adapter.find_many(model: "passkey", where: [{field: "userId", value: session.fetch(:user).fetch("id")}])
             ctx.json(passkeys.map { |passkey| Credentials.wire(passkey) })
@@ -15,23 +15,34 @@ module BetterAuth
         end
 
         def delete_passkey_endpoint
-          Endpoint.new(path: "/passkey/delete-passkey", method: "POST") do |ctx|
+          Endpoint.new(path: "/passkey/delete-passkey", method: "POST", metadata: Routes.openapi_for(:delete_passkey)) do |ctx|
             session = BetterAuth::Routes.current_session(ctx)
             body = Utils.normalize_hash(ctx.body)
             Utils.require_string!(body, :id)
-            passkey = ctx.context.adapter.find_one(model: "passkey", where: [{field: "id", value: body[:id]}])
+            passkey = ctx.context.adapter.find_one(
+              model: "passkey",
+              where: [
+                {field: "id", value: body[:id]},
+                {field: "userId", value: session.fetch(:user).fetch("id")}
+              ]
+            )
             raise APIError.new("NOT_FOUND", message: ErrorCodes::PASSKEY_ERROR_CODES.fetch("PASSKEY_NOT_FOUND")) unless passkey
-            unless passkey.fetch("userId") == session.fetch(:user).fetch("id")
-              raise APIError.new("UNAUTHORIZED", message: ErrorCodes::PASSKEY_ERROR_CODES.fetch("PASSKEY_NOT_FOUND"))
-            end
 
-            ctx.context.adapter.delete(model: "passkey", where: [{field: "id", value: passkey.fetch("id")}])
+            deleted = ctx.context.adapter.delete_many(
+              model: "passkey",
+              where: [
+                {field: "id", value: passkey.fetch("id")},
+                {field: "userId", value: session.fetch(:user).fetch("id")}
+              ]
+            )
+            raise APIError.new("NOT_FOUND", message: ErrorCodes::PASSKEY_ERROR_CODES.fetch("PASSKEY_NOT_FOUND")) if deleted.to_i.zero?
+
             ctx.json({status: true})
           end
         end
 
         def update_passkey_endpoint
-          Endpoint.new(path: "/passkey/update-passkey", method: "POST") do |ctx|
+          Endpoint.new(path: "/passkey/update-passkey", method: "POST", metadata: Routes.openapi_for(:update_passkey)) do |ctx|
             session = BetterAuth::Routes.current_session(ctx)
             body = Utils.normalize_hash(ctx.body)
             Utils.require_string!(body, :id)
@@ -39,18 +50,24 @@ module BetterAuth
               raise APIError.new("BAD_REQUEST", message: BASE_ERROR_CODES.fetch("VALIDATION_ERROR"))
             end
 
-            passkey = ctx.context.adapter.find_one(model: "passkey", where: [{field: "id", value: body[:id]}])
+            passkey = ctx.context.adapter.find_one(
+              model: "passkey",
+              where: [
+                {field: "id", value: body[:id]},
+                {field: "userId", value: session.fetch(:user).fetch("id")}
+              ]
+            )
             raise APIError.new("NOT_FOUND", message: ErrorCodes::PASSKEY_ERROR_CODES.fetch("PASSKEY_NOT_FOUND")) unless passkey
-            if passkey.fetch("userId") != session.fetch(:user).fetch("id")
-              raise APIError.new("UNAUTHORIZED", message: ErrorCodes::PASSKEY_ERROR_CODES.fetch("YOU_ARE_NOT_ALLOWED_TO_REGISTER_THIS_PASSKEY"))
-            end
 
             updated = ctx.context.adapter.update(
               model: "passkey",
-              where: [{field: "id", value: body[:id]}],
+              where: [
+                {field: "id", value: body[:id]},
+                {field: "userId", value: session.fetch(:user).fetch("id")}
+              ],
               update: {name: body[:name].to_s}
             )
-            raise APIError.new("INTERNAL_SERVER_ERROR", message: ErrorCodes::PASSKEY_ERROR_CODES.fetch("FAILED_TO_UPDATE_PASSKEY")) unless updated
+            raise APIError.new("NOT_FOUND", message: ErrorCodes::PASSKEY_ERROR_CODES.fetch("PASSKEY_NOT_FOUND")) unless updated
 
             ctx.json({passkey: Credentials.wire(updated)})
           end

data/lib/better_auth/passkey/routes/registration.rb

@@ -10,7 +10,7 @@ module BetterAuth
         module_function
 
         def generate_passkey_registration_options_endpoint(config)
-          Endpoint.new(path: "/passkey/generate-register-options", method: "GET") do |ctx|
+          Endpoint.new(path: "/passkey/generate-register-options", method: "GET", metadata: Routes.openapi_for(:generate_registration_options)) do |ctx|
             query = Utils.normalize_hash(ctx.query)
             Utils.validate_authenticator_attachment!(query[:authenticator_attachment])
             user = Utils.resolve_registration_user(config, ctx, query)
@@ -40,7 +40,7 @@ module BetterAuth
         end
 
         def verify_passkey_registration_endpoint(config)
-          Endpoint.new(path: "/passkey/verify-registration", method: "POST") do |ctx|
+          Endpoint.new(path: "/passkey/verify-registration", method: "POST", metadata: Routes.openapi_for(:verify_registration)) do |ctx|
             body = Utils.normalize_hash(ctx.body)
             Utils.require_key!(body, :response)
             require_session = config.dig(:registration, :require_session) != false
@@ -62,6 +62,11 @@ module BetterAuth
 
             begin
               response = Credentials.webauthn_response(body[:response])
+              credential_id = Credentials.response_credential_id(response)
+              if credential_id && ctx.context.adapter.find_one(model: "passkey", where: [{field: "credentialID", value: credential_id}])
+                ctx.context.internal_adapter.delete_verification_by_identifier(verification_token)
+                raise APIError.new("BAD_REQUEST", message: ErrorCodes::PASSKEY_ERROR_CODES.fetch("PREVIOUSLY_REGISTERED"))
+              end
               relying_party = Utils.relying_party(config, ctx, origin: origin)
               credential = WebAuthn::Credential.from_create(response, relying_party: relying_party)
               credential.verify(challenge.fetch("expectedChallenge"), user_verification: false)
@@ -82,21 +87,30 @@ module BetterAuth
               raise APIError.new("BAD_REQUEST", message: ErrorCodes::PASSKEY_ERROR_CODES.fetch("PREVIOUSLY_REGISTERED"))
             end
 
-            data = ctx.context.adapter.create(
-              model: "passkey",
-              data: {
-                name: body[:name],
-                userId: target_user_id,
-                credentialID: credential.id,
-                publicKey: Base64.strict_encode64(credential.public_key),
-                counter: credential.sign_count,
-                deviceType: authenticator_data&.credential_backup_eligible? ? "multiDevice" : "singleDevice",
-                backedUp: authenticator_data&.credential_backed_up? || false,
-                transports: Array(Credentials.attestation_response(credential)&.transports).join(","),
-                createdAt: Time.now,
-                aaguid: Credentials.attestation_response(credential)&.aaguid
-              }
-            )
+            begin
+              data = ctx.context.adapter.create(
+                model: "passkey",
+                data: {
+                  name: body[:name],
+                  userId: target_user_id,
+                  credentialID: credential.id,
+                  publicKey: Base64.strict_encode64(credential.public_key),
+                  counter: credential.sign_count.to_i,
+                  deviceType: authenticator_data&.credential_backup_eligible? ? "multiDevice" : "singleDevice",
+                  backedUp: authenticator_data&.credential_backed_up? || false,
+                  transports: Array(Credentials.attestation_response(credential)&.transports).join(","),
+                  createdAt: Time.now,
+                  aaguid: Credentials.attestation_response(credential)&.aaguid
+                }
+              )
+            rescue => error
+              ctx.context.internal_adapter.delete_verification_by_identifier(verification_token)
+              if Credentials.duplicate_credential_error?(error)
+                raise APIError.new("BAD_REQUEST", message: ErrorCodes::PASSKEY_ERROR_CODES.fetch("PREVIOUSLY_REGISTERED"))
+              end
+              ctx.context.logger&.error("Failed to create passkey", error)
+              raise APIError.new("INTERNAL_SERVER_ERROR", message: ErrorCodes::PASSKEY_ERROR_CODES.fetch("FAILED_TO_VERIFY_REGISTRATION"))
+            end
             ctx.context.internal_adapter.delete_verification_by_identifier(verification_token)
             ctx.json(Credentials.wire(data))
           rescue APIError

data/lib/better_auth/passkey/routes.rb

@@ -1,5 +1,181 @@
 # frozen_string_literal: true
 
+module BetterAuth
+  module Passkey
+    module Routes
+      module_function
+
+      def openapi_for(route)
+        {
+          generate_registration_options: generate_registration_options_openapi,
+          verify_registration: verify_registration_openapi,
+          generate_authentication_options: generate_authentication_options_openapi,
+          verify_authentication: verify_authentication_openapi,
+          list_passkeys: list_passkeys_openapi,
+          delete_passkey: delete_passkey_openapi,
+          update_passkey: update_passkey_openapi
+        }.fetch(route)
+      end
+
+      def generate_registration_options_openapi
+        {
+          openapi: {
+            operationId: "generatePasskeyRegistrationOptions",
+            description: "Generate registration options for a new passkey",
+            parameters: [
+              BetterAuth::OpenAPI.query_parameter("authenticatorAttachment", schema: {type: "string", enum: ["platform", "cross-platform"]}, description: "Type of authenticator to use for registration"),
+              BetterAuth::OpenAPI.query_parameter("name", description: "Optional custom name for the passkey"),
+              BetterAuth::OpenAPI.query_parameter("context", description: "Optional context for passkey-first registration flows")
+            ],
+            responses: {
+              "200" => BetterAuth::OpenAPI.json_response("Success", passkey_options_schema)
+            }
+          }
+        }
+      end
+
+      def verify_registration_openapi
+        {
+          openapi: {
+            operationId: "passkeyVerifyRegistration",
+            description: "Verify registration of a new passkey",
+            requestBody: BetterAuth::OpenAPI.json_request_body(
+              BetterAuth::OpenAPI.object_schema(
+                {
+                  response: {type: "object", additionalProperties: true, description: "WebAuthn registration response"},
+                  name: {type: "string", description: "Name of the passkey"}
+                },
+                required: ["response"]
+              )
+            ),
+            responses: {
+              "200" => BetterAuth::OpenAPI.json_response("Success", BetterAuth::OpenAPI.ref_schema("Passkey")),
+              "400" => {description: "Bad request"}
+            }
+          }
+        }
+      end
+
+      def generate_authentication_options_openapi
+        {
+          openapi: {
+            operationId: "passkeyGenerateAuthenticateOptions",
+            description: "Generate authentication options for a passkey",
+            responses: {
+              "200" => BetterAuth::OpenAPI.json_response("Success", passkey_options_schema)
+            }
+          }
+        }
+      end
+
+      def verify_authentication_openapi
+        {
+          openapi: {
+            operationId: "passkeyVerifyAuthentication",
+            description: "Verify authentication of a passkey",
+            requestBody: BetterAuth::OpenAPI.json_request_body(
+              BetterAuth::OpenAPI.object_schema(
+                {
+                  response: {type: "object", additionalProperties: true, description: "WebAuthn authentication response"}
+                },
+                required: ["response"]
+              )
+            ),
+            responses: {
+              "200" => BetterAuth::OpenAPI.json_response("Success", BetterAuth::OpenAPI.session_response_schema_pair)
+            }
+          }
+        }
+      end
+
+      def list_passkeys_openapi
+        {
+          openapi: {
+            description: "List all passkeys for the authenticated user",
+            responses: {
+              "200" => BetterAuth::OpenAPI.json_response(
+                "Passkeys retrieved successfully",
+                BetterAuth::OpenAPI.array_schema(BetterAuth::OpenAPI.ref_schema("Passkey"))
+              )
+            }
+          }
+        }
+      end
+
+      def delete_passkey_openapi
+        {
+          openapi: {
+            description: "Delete a specific passkey",
+            requestBody: BetterAuth::OpenAPI.json_request_body(passkey_id_body_schema),
+            responses: {
+              "200" => BetterAuth::OpenAPI.json_response("Passkey deleted successfully", BetterAuth::OpenAPI.status_response_schema)
+            }
+          }
+        }
+      end
+
+      def update_passkey_openapi
+        {
+          openapi: {
+            description: "Update a specific passkey's name",
+            requestBody: BetterAuth::OpenAPI.json_request_body(
+              BetterAuth::OpenAPI.object_schema(
+                {
+                  id: {type: "string", description: "The ID of the passkey which will be updated"},
+                  name: {type: "string", description: "The new passkey name"}
+                },
+                required: ["id", "name"]
+              )
+            ),
+            responses: {
+              "200" => BetterAuth::OpenAPI.json_response(
+                "Passkey updated successfully",
+                BetterAuth::OpenAPI.object_schema(
+                  {
+                    passkey: BetterAuth::OpenAPI.ref_schema("Passkey")
+                  },
+                  required: ["passkey"]
+                )
+              )
+            }
+          }
+        }
+      end
+
+      def passkey_id_body_schema
+        BetterAuth::OpenAPI.object_schema(
+          {
+            id: {type: "string", description: "The ID of the passkey"}
+          },
+          required: ["id"]
+        )
+      end
+
+      def passkey_options_schema
+        BetterAuth::OpenAPI.object_schema(
+          {
+            challenge: {type: "string"},
+            rp: {
+              type: "object",
+              properties: {
+                name: {type: "string"},
+                id: {type: "string"}
+              }
+            },
+            user: {type: "object", additionalProperties: true},
+            timeout: {type: "number"},
+            attestation: {type: "string"},
+            excludeCredentials: {type: "array", items: {type: "object", additionalProperties: true}},
+            allowCredentials: {type: "array", items: {type: "object", additionalProperties: true}},
+            userVerification: {type: "string"},
+            extensions: {type: "object", additionalProperties: true}
+          }
+        )
+      end
+    end
+  end
+end
+
 require_relative "routes/registration"
 require_relative "routes/authentication"
 require_relative "routes/management"

data/lib/better_auth/passkey/utils.rb

@@ -25,17 +25,22 @@ module BetterAuth
       end
 
       def allowed_origins(config, ctx, origin: nil)
-        Array(origin || config[:origin] || ctx.context.options.base_url).compact
+        _request_origin = origin
+        configured = config.key?(:origin) ? config[:origin] : nil
+        origins = configured || context_base_url(ctx)
+        Array(origins).compact.map { |value| origin_for(value) }
       end
 
       def rp_id(config, ctx)
         return config[:rp_id] if config[:rp_id]
 
-        base_url = ctx.context.options.base_url.to_s
+        base_url = context_base_url(ctx).to_s
         return "localhost" if base_url.empty?
 
         URI.parse(base_url).host || "localhost"
       rescue URI::InvalidURIError
+        raise APIError.new("BAD_REQUEST", message: ErrorCodes::PASSKEY_ERROR_CODES.fetch("FAILED_TO_VERIFY_REGISTRATION")) if strict_base_url?(ctx)
+
         "localhost"
       end
 
@@ -169,6 +174,31 @@ module BetterAuth
           callback.call(data)
         end
       end
+
+      def context_base_url(ctx)
+        if ctx.context.respond_to?(:base_url)
+          ctx.context.base_url
+        else
+          ctx.context.options.base_url
+        end
+      end
+
+      def strict_base_url?(ctx)
+        return ctx.context.passkey_strict_base_url? if ctx.context.respond_to?(:passkey_strict_base_url?)
+
+        true
+      end
+
+      def origin_for(value)
+        uri = URI.parse(value.to_s)
+        if uri.scheme && uri.host
+          BetterAuth::Configuration.origin_for(uri) || value.to_s
+        else
+          value.to_s
+        end
+      rescue URI::InvalidURIError
+        value.to_s
+      end
     end
   end
 end

data/lib/better_auth/passkey/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: better_auth-passkey
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Sebastian Sala
@@ -91,6 +91,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.25'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -105,6 +133,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.2'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.83'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.83'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: standardrb
   requirement: !ruby/object:Gem::Requirement
@@ -119,6 +175,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: tiny_tds
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
 description: Adds passkey/WebAuthn registration, authentication, and credential management
   routes for Better Auth Ruby. Better Auth Ruby is an independent modern authentication
   framework for Ruby inspired by Better Auth.
@@ -142,14 +212,14 @@ files:
 - lib/better_auth/passkey/utils.rb
 - lib/better_auth/passkey/version.rb
 - lib/better_auth/plugins/passkey.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-passkey/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-passkey/CHANGELOG.md
+  bug_tracker_uri: https://github.com/sebasxsala/better-auth-rb/issues
 rdoc_options: []
 require_paths:
 - lib