better_auth 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2ba3cc27f9b1ebc6cb35de7a95a10351c30f5523de796c82b7c90773d663381
-  data.tar.gz: 81b03e1d625d242adc6255806b7651cebee65f59179110aae7df85b7beab426f
+  metadata.gz: a5e95c51ce68259fcccbbfabe1bd9ffa5383ce4c098161f1c2d54da76137fa0a
+  data.tar.gz: 7c81ade6292ced9b98c1c411c320e4ad6e05734ea891145f75a9205d6e4fdea0
 SHA512:
-  metadata.gz: 61a29dc835cd5758628b358153888cc78eb721795cd286e55210c920766129826d08b5bbdf2fe9a049df56b3d6a9d4bd8f33c82b067bde77c812c87738af94e2
-  data.tar.gz: 18d543129a8577e9974ce0887db187e837ff2b9175cce97efd33a6afba615f1d34272fb193a0008694c63c998b12740ed6c2490ecb765ad9b24f131be389a250
+  metadata.gz: 4b7f5c635ce16aa7be7f3ea42c5fa03304b7c682821c8a82e55c81754ba330a88aba350f0a6ed59b171333766ba6a973c4a2d15cf3d46debeae42ddd59b602c5
+  data.tar.gz: 524ce3bfb3f023bcf057154fde0e88e0555753016d1297d67d40f2db6de6cf5516b0fcb8b513fd260cd284b38722eeffe9a02784d3d08a58cd5811cce23a1d39

data/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.1] - 2026-03-22
+
+### Fixed
+
+- Fixed gemspec files list to use `Dir.glob` instead of `git ls-files` for better CI compatibility
+
 ### Added
 
 - Initial project setup

data/README.md

@@ -60,11 +60,94 @@ gem install better_auth
 ```ruby
 require 'better_auth'
 
-# Configure Better Auth
-BetterAuth.configure do |config|
-  config.secret_key = ENV['BETTER_AUTH_SECRET']
-  config.database_url = ENV['DATABASE_URL']
-end
+auth = BetterAuth.auth(
+  secret: ENV.fetch("BETTER_AUTH_SECRET"),
+  database: :memory
+)
+```
+
+### Password Hashing
+
+Better Auth Ruby uses upstream-compatible `scrypt` password hashes by default through Ruby's `OpenSSL::KDF.scrypt`, so no extra password-hashing gem is required for the default setup.
+
+```ruby
+auth = BetterAuth.auth(
+  secret: ENV.fetch("BETTER_AUTH_SECRET"),
+  password_hasher: :scrypt # default
+)
+```
+
+Applications that prefer Ruby's familiar BCrypt ecosystem can opt in by adding `gem "bcrypt"` and configuring:
+
+```ruby
+auth = BetterAuth.auth(
+  secret: ENV.fetch("BETTER_AUTH_SECRET"),
+  password_hasher: :bcrypt
+)
+```
+
+Custom Better Auth-style password callbacks are still supported through `email_and_password[:password][:hash]` and `[:verify]`.
+
+### Database Adapters
+
+The core gem ships framework-agnostic adapters for memory, PostgreSQL, MySQL, SQLite, MongoDB, and MSSQL. Driver gems are loaded only when their adapter is instantiated.
+
+```ruby
+auth = BetterAuth.auth(
+  secret: ENV.fetch("BETTER_AUTH_SECRET"),
+  database: BetterAuth::Adapters::SQLite.new(path: "storage/auth.sqlite3")
+)
+```
+
+```ruby
+auth = BetterAuth.auth(
+  secret: ENV.fetch("BETTER_AUTH_SECRET"),
+  database: BetterAuth::Adapters::MongoDB.new(
+    database: mongo_client.database,
+    client: mongo_client,
+    transaction: false
+  )
+)
+```
+
+```ruby
+auth = BetterAuth.auth(
+  secret: ENV.fetch("BETTER_AUTH_SECRET"),
+  database: BetterAuth::Adapters::MSSQL.new(url: ENV.fetch("DATABASE_URL"))
+)
+```
+
+### Social Providers
+
+```ruby
+require "better_auth"
+
+auth = BetterAuth.auth(
+  secret: ENV.fetch("BETTER_AUTH_SECRET"),
+  social_providers: {
+    google: BetterAuth::SocialProviders.google(
+      client_id: ENV.fetch("GOOGLE_CLIENT_ID"),
+      client_secret: ENV.fetch("GOOGLE_CLIENT_SECRET")
+    ),
+    github: BetterAuth::SocialProviders.github(
+      client_id: ENV.fetch("GITHUB_CLIENT_ID"),
+      client_secret: ENV.fetch("GITHUB_CLIENT_SECRET")
+    )
+  }
+)
+```
+
+### JavaScript Client
+
+Ruby Better Auth exposes the same HTTP route surface. Frontend apps should use the upstream Better Auth JavaScript client and point it at the Ruby server:
+
+```ts
+import { createAuthClient } from "better-auth/client";
+
+export const authClient = createAuthClient({
+  baseURL: "http://localhost:3000",
+  basePath: "/api/auth",
+});
 ```
 
 ### Rails Integration
@@ -97,6 +180,8 @@ end
 
 ## Development
 
+Full documentation is being adapted in the root [`docs/`](/Users/sebastiansala/projects/better-auth/docs/README.md) app. Start with the Ruby-first installation, basic usage, Rack, Rails, PostgreSQL, and MySQL pages there; pages with a Ruby port warning still contain upstream TypeScript examples for reference.
+
 ### Quick Start
 
 ```bash
@@ -132,7 +217,7 @@ make test-coverage   # Tests with coverage
 make ci              # Full CI (lint + test)
 
 # Databases for testing
-make db-up           # Start PostgreSQL, MySQL, Redis
+make db-up           # Start PostgreSQL, MySQL, MongoDB, MSSQL, Redis
 make db-down         # Stop containers
 ```
 
@@ -183,10 +268,10 @@ git push origin feat/new-feature
 
 **Automatic Release (GitHub Actions):**
 
-Release is triggered on `push` to `main` when `lib/better_auth/version.rb` changes.
+Release is triggered by package-prefixed tags so each gem can ship independently.
 
 ```bash
-# STEP 1: Update version in lib/better_auth/version.rb
+# STEP 1: Update the target package version file
 # Example: VERSION = "0.1.1"
 
 # STEP 2: Commit and push to main
@@ -194,19 +279,24 @@ git add lib/better_auth/version.rb
 git commit -m "chore: bump version to 0.1.1"
 git push origin main
 
-# STEP 3: GitHub Actions automatically:
+# STEP 3: Create the tag for the gem you want to publish
+git tag better_auth-v0.1.1
+git push origin better_auth-v0.1.1
+
+# STEP 4: GitHub Actions automatically:
 # - Runs tests
 # - Builds the gem
 # - Publishes to RubyGems (if version is new)
-# - Creates and pushes git tag (v0.1.1)
 # - Creates GitHub Release
 ```
 
+Use `better_auth-vX.Y.Z` for the core gem, `better_auth-rails-vX.Y.Z` for Rails, `better_auth-sinatra-vX.Y.Z` for Sinatra, and `better_auth-hanami-vX.Y.Z` for Hanami.
+
 **Required GitHub Configuration:**
 
-1. Go to Settings → Secrets and variables → Actions
-2. Add `RUBYGEMS_API_KEY` with your RubyGems API key
-3. The workflow `.github/workflows/release.yml` does the rest
+1. In RubyGems, configure Trusted Publishing for each gem that should publish from CI.
+2. Use this repository and workflow file: `.github/workflows/release.yml`.
+3. The workflow exchanges GitHub's OIDC token for short-lived RubyGems credentials when the matching package tag is pushed.
 
 **Dry-run options:**
 
@@ -231,8 +321,8 @@ gem build better_auth.gemspec
 gem push better_auth-*.gem
 
 # 4. Create and push the tag
-git tag -a v0.1.1 -m "Release v0.1.1"
-git push origin --tags
+git tag -a better_auth-v0.1.1 -m "Release better_auth v0.1.1"
+git push origin better_auth-v0.1.1
 ```
 
 ### Project Structure
@@ -262,6 +352,6 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Security
 
-If you discover a security vulnerability within Better Auth Ruby, please send an e-mail to [security@better-auth.com](mailto:security@better-auth.com).
+If you discover a security vulnerability within Better Auth Ruby, please send an e-mail to [security@openparcel.dev](mailto:security@openparcel.dev).
 
 All reports will be promptly addressed, and you'll be credited accordingly.

data/lib/better_auth/adapters/base.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module BetterAuth
+  module Adapters
+    class Base
+      attr_reader :options
+
+      def initialize(options)
+        @options = options
+      end
+
+      def create(**)
+        raise NotImplementedError
+      end
+
+      def find_one(**)
+        raise NotImplementedError
+      end
+
+      def find_many(**)
+        raise NotImplementedError
+      end
+
+      def update(**)
+        raise NotImplementedError
+      end
+
+      def update_many(**)
+        raise NotImplementedError
+      end
+
+      def delete(**)
+        raise NotImplementedError
+      end
+
+      def delete_many(**)
+        raise NotImplementedError
+      end
+
+      def count(**)
+        raise NotImplementedError
+      end
+
+      def transaction
+        yield self
+      end
+    end
+  end
+end

data/lib/better_auth/adapters/internal_adapter.rb

@@ -0,0 +1,439 @@
+# frozen_string_literal: true
+
+require "json"
+require "securerandom"
+require "time"
+
+module BetterAuth
+  module Adapters
+    class InternalAdapter
+      attr_reader :adapter, :options, :hooks
+
+      def initialize(adapter, options)
+        @adapter = adapter
+        @options = options
+        @hooks = DatabaseHooks.new(adapter, options)
+      end
+
+      def create_oauth_user(user, account)
+        adapter.transaction do
+          created_user = create_user(user)
+          created_account = create_account(stringify_keys(account).merge("userId" => created_user["id"]))
+          {user: created_user, account: created_account}
+        end
+      end
+
+      def create_user(user)
+        data = timestamps.merge(stringify_keys(user))
+        data["email"] = data["email"].to_s.downcase if data["email"]
+        hooks.create(data, "user")
+      end
+
+      def create_account(account)
+        hooks.create(timestamps.merge(stringify_keys(account)), "account")
+      end
+
+      def link_account(account)
+        create_account(account)
+      end
+
+      def list_sessions(user_id)
+        if secondary_storage
+          active_session_entries(user_id).filter_map do |entry|
+            data = parse_storage(secondary_storage.get(entry.fetch("token")))
+            next unless data && data["session"]
+
+            normalize_session_dates(data["session"])
+          end
+        else
+          adapter.find_many(model: "session", where: [{field: "userId", value: user_id}])
+        end
+      end
+
+      def list_users(limit: nil, offset: nil, sort_by: nil, where: nil)
+        adapter.find_many(model: "user", where: where || [], limit: limit, offset: offset, sort_by: sort_by)
+      end
+
+      def count_total_users(where: nil)
+        adapter.count(model: "user", where: where || [])
+      end
+
+      def delete_user(user_id)
+        delete_sessions(user_id) if !secondary_storage || options.session[:store_session_in_database]
+        hooks.delete_many([{field: "userId", value: user_id}], "account")
+        hooks.delete([{field: "id", value: user_id}], "user")
+      end
+
+      def create_session(user_id, dont_remember_me = false, override = nil, override_all = false, context = nil)
+        override = stringify_keys(override || {})
+        token = override.delete("token") || SecureRandom.hex(16)
+        base = {
+          "ipAddress" => "",
+          "userAgent" => "",
+          "expiresAt" => Time.now + (dont_remember_me ? 86_400 : options.session[:expires_in].to_i),
+          "userId" => user_id,
+          "token" => token
+        }.merge(timestamps)
+        data = override_all ? base.merge(override) : override.merge(base)
+
+        custom = secondary_storage && lambda do |session_data|
+          actual_session = apply_schema_create("session", session_data)
+          store_session(actual_session)
+          actual_session
+        end
+        execute_main = !secondary_storage || options.session[:store_session_in_database]
+        created = hooks.create(data, "session", custom: custom, context: context)
+        adapter.create(model: "session", data: data, force_allow_id: true) if secondary_storage && execute_main
+        created
+      end
+
+      def find_session(token)
+        if secondary_storage
+          data = parse_storage(secondary_storage.get(token))
+          return nil unless data
+
+          return {
+            session: normalize_session_dates(data["session"]),
+            user: normalize_user_dates(data["user"])
+          }
+        end
+
+        found = find_session_with_user(token)
+        return nil unless found && found["user"]
+
+        user = found.delete("user")
+        {session: found, user: user}
+      end
+
+      def find_sessions(tokens)
+        tokens.filter_map { |token| find_session(token) }
+      end
+
+      def update_session(token, session)
+        data = stringify_keys(session)
+        if secondary_storage
+          return hooks.update(data, [{field: "token", value: token}], "session", custom: lambda { |actual_data|
+            update_stored_session(token, actual_data)
+          })
+        end
+
+        hooks.update(data, [{field: "token", value: token}], "session")
+      end
+
+      def delete_session(token)
+        if secondary_storage
+          data = parse_storage(secondary_storage.get(token))
+          if data && data["session"]
+            user_id = data["session"]["userId"]
+            entries = active_session_entries(user_id).reject { |entry| entry["token"] == token }
+            write_active_sessions(user_id, entries)
+          end
+          secondary_storage.delete(token)
+          return if !options.session[:store_session_in_database] || options.session[:preserve_session_in_database]
+        end
+
+        hooks.delete([{field: "token", value: token}], "session")
+      end
+
+      def delete_sessions(user_id_or_tokens)
+        if secondary_storage
+          if user_id_or_tokens.is_a?(Array)
+            user_id_or_tokens.each { |token| secondary_storage.delete(token) }
+          else
+            active_session_entries(user_id_or_tokens).each { |entry| secondary_storage.delete(entry["token"]) }
+            secondary_storage.delete(active_key(user_id_or_tokens))
+          end
+          return if !options.session[:store_session_in_database] || options.session[:preserve_session_in_database]
+        end
+
+        field = user_id_or_tokens.is_a?(Array) ? "token" : "userId"
+        operator = user_id_or_tokens.is_a?(Array) ? "in" : nil
+        hooks.delete_many([{field: field, value: user_id_or_tokens, operator: operator}], "session")
+      end
+
+      def delete_accounts(user_id)
+        hooks.delete_many([{field: "userId", value: user_id}], "account")
+      end
+
+      def delete_account(account_id)
+        hooks.delete([{field: "id", value: account_id}], "account")
+      end
+
+      def find_oauth_user(email, account_id, provider_id)
+        account = find_account_with_user(account_id, provider_id)
+        if account
+          user = account["user"] || adapter.find_one(model: "user", where: [{field: "email", value: email.to_s.downcase}])
+          return nil unless user
+
+          linked = account.dup
+          linked.delete("user")
+          return {user: user, linked_account: linked, accounts: [linked]}
+        end
+
+        found_user = adapter.find_one(model: "user", where: [{field: "email", value: email.to_s.downcase}])
+        return nil unless found_user
+
+        {user: found_user, linked_account: nil, accounts: find_accounts(found_user["id"])}
+      end
+
+      def find_user_by_email(email, include_accounts: false)
+        user = adapter.find_one(model: "user", where: [{field: "email", value: email.to_s.downcase}])
+        return nil unless user
+
+        {user: user, accounts: include_accounts ? find_accounts(user["id"]) : []}
+      end
+
+      def find_user_by_id(user_id)
+        return nil if user_id.to_s.empty?
+
+        adapter.find_one(model: "user", where: [{field: "id", value: user_id}])
+      end
+
+      def update_user(user_id, data)
+        user = hooks.update(stringify_keys(data), [{field: "id", value: user_id}], "user")
+        refresh_user_sessions(user) if user
+        user
+      end
+
+      def update_user_by_email(email, data)
+        user = hooks.update(stringify_keys(data), [{field: "email", value: email.to_s.downcase}], "user")
+        refresh_user_sessions(user) if user
+        user
+      end
+
+      def update_password(user_id, password)
+        hooks.update_many({password: password}, [{field: "userId", value: user_id}, {field: "providerId", value: "credential"}], "account")
+      end
+
+      def find_accounts(user_id)
+        adapter.find_many(model: "account", where: [{field: "userId", value: user_id}])
+      end
+
+      def find_account(account_id)
+        adapter.find_one(model: "account", where: [{field: "accountId", value: account_id}])
+      end
+
+      def find_account_by_provider_id(account_id, provider_id)
+        adapter.find_one(model: "account", where: [{field: "accountId", value: account_id}, {field: "providerId", value: provider_id}])
+      end
+
+      def find_account_by_user_id(user_id)
+        find_accounts(user_id)
+      end
+
+      def update_account(id, data)
+        hooks.update(stringify_keys(data), [{field: "id", value: id}], "account")
+      end
+
+      def create_verification_value(data)
+        hooks.create(timestamps.merge(stringify_keys(data)), "verification")
+      end
+
+      def find_verification_value(identifier)
+        values = adapter.find_many(
+          model: "verification",
+          where: [{field: "identifier", value: identifier}],
+          sort_by: {field: "createdAt", direction: "desc"},
+          limit: 1
+        )
+        hooks.delete_many([{field: "expiresAt", value: Time.now, operator: "lt"}], "verification") unless options.verification[:disable_cleanup]
+        values.first
+      end
+
+      def delete_verification_value(id)
+        hooks.delete([{field: "id", value: id}], "verification")
+      end
+
+      def delete_verification_by_identifier(identifier)
+        hooks.delete([{field: "identifier", value: identifier}], "verification")
+      end
+
+      def update_verification_value(id, data)
+        hooks.update(stringify_keys(data), [{field: "id", value: id}], "verification")
+      end
+
+      private
+
+      def secondary_storage
+        options.secondary_storage
+      end
+
+      def joins_enabled?
+        !!options.experimental[:joins]
+      end
+
+      def find_session_with_user(token)
+        return adapter.find_one(model: "session", where: [{field: "token", value: token}], join: {user: true}) if joins_enabled?
+
+        session = adapter.find_one(model: "session", where: [{field: "token", value: token}])
+        user = session && adapter.find_one(model: "user", where: [{field: "id", value: session["userId"]}])
+        (session && user) ? session.merge("user" => user) : nil
+      end
+
+      def find_account_with_user(account_id, provider_id)
+        if joins_enabled?
+          return adapter.find_one(model: "account", where: [{field: "accountId", value: account_id}, {field: "providerId", value: provider_id}], join: {user: true})
+        end
+
+        account = adapter.find_one(model: "account", where: [{field: "accountId", value: account_id}, {field: "providerId", value: provider_id}])
+        user = account && adapter.find_one(model: "user", where: [{field: "id", value: account["userId"]}])
+        (account && user) ? account.merge("user" => user) : account
+      end
+
+      def timestamps
+        now = Time.now
+        {"createdAt" => now, "updatedAt" => now}
+      end
+
+      def stringify_keys(data)
+        data.each_with_object({}) do |(key, value), result|
+          result[Schema.storage_key(key)] = value
+        end
+      end
+
+      def apply_schema_create(model, data)
+        fields = Schema.auth_tables(options)[model]&.fetch(:fields)
+        fields ||= session_additional_fields if model == "session"
+        output = stringify_keys(data)
+        fields.each do |field, attributes|
+          unless output.key?(field)
+            if attributes.key?(:default_value)
+              output[field] = resolve_default(attributes[:default_value])
+            elsif attributes[:required] && field != "id"
+              raise APIError.new("BAD_REQUEST", message: "#{field} is required")
+            end
+          end
+          output[field] = coerce_value(output[field], attributes) if output.key?(field)
+        end
+        output
+      end
+
+      def session_additional_fields
+        (options.session[:additional_fields] || {}).each_with_object({}) do |(key, value), result|
+          result[Schema.storage_key(key)] = value
+        end
+      end
+
+      def resolve_default(default)
+        default.respond_to?(:call) ? default.call : default
+      end
+
+      def coerce_value(value, attributes)
+        return value if value.nil?
+        return Time.parse(value) if attributes[:type] == "date" && value.is_a?(String)
+
+        value
+      end
+
+      def store_session(session)
+        user = adapter.find_one(model: "user", where: [{field: "id", value: session["userId"]}])
+        now_ms = current_millis
+        expires_ms = millis(session["expiresAt"])
+        entries = active_session_entries(session["userId"])
+          .reject { |entry| entry["expiresAt"].to_i <= now_ms || entry["token"] == session["token"] }
+          .push({"token" => session["token"], "expiresAt" => expires_ms})
+          .sort_by { |entry| entry["expiresAt"] }
+        write_active_sessions(session["userId"], entries)
+        secondary_storage.set(session["token"], JSON.generate({session: session, user: user}), ttl(expires_ms))
+      end
+
+      def update_stored_session(token, data)
+        parsed = parse_storage(secondary_storage.get(token))
+        return nil unless parsed && parsed["session"]
+
+        merged = parsed["session"].merge(data)
+        merged["expiresAt"] = normalize_time(merged["expiresAt"])
+        merged["createdAt"] = normalize_time(merged["createdAt"])
+        merged["updatedAt"] = normalize_time(merged["updatedAt"])
+        secondary_storage.set(token, JSON.generate({session: merged, user: parsed["user"]}), ttl(millis(merged["expiresAt"])))
+        entries = active_session_entries(merged["userId"])
+          .reject { |entry| entry["token"] == token || entry["expiresAt"].to_i <= current_millis }
+          .push({"token" => token, "expiresAt" => millis(merged["expiresAt"])})
+          .sort_by { |entry| entry["expiresAt"] }
+        write_active_sessions(merged["userId"], entries)
+        merged
+      end
+
+      def refresh_user_sessions(user)
+        return unless secondary_storage && user
+
+        active_session_entries(user["id"]).each do |entry|
+          parsed = parse_storage(secondary_storage.get(entry["token"]))
+          next unless parsed && parsed["session"]
+
+          secondary_storage.set(entry["token"], JSON.generate({session: parsed["session"], user: user}), ttl(millis(parsed["session"]["expiresAt"])))
+        end
+      end
+
+      def active_session_entries(user_id)
+        raw = secondary_storage.get(active_key(user_id))
+        Array(parse_storage(raw)).map do |entry|
+          entry.transform_keys(&:to_s)
+        end
+      end
+
+      def write_active_sessions(user_id, entries)
+        future = entries.select { |entry| entry["expiresAt"].to_i > current_millis }.sort_by { |entry| entry["expiresAt"] }
+        if future.empty?
+          secondary_storage.delete(active_key(user_id))
+        else
+          secondary_storage.set(active_key(user_id), JSON.generate(future), ttl(future.last["expiresAt"]))
+        end
+      end
+
+      def active_key(user_id)
+        "active-sessions-#{user_id}"
+      end
+
+      def parse_storage(value)
+        return value.transform_keys(&:to_s) if value.is_a?(Hash)
+        return value.map { |entry| entry.is_a?(Hash) ? entry.transform_keys(&:to_s) : entry } if value.is_a?(Array)
+        return nil unless value
+
+        parsed = JSON.parse(value)
+        parse_storage(parsed)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def normalize_session_dates(session)
+        return nil unless session
+
+        session.transform_keys(&:to_s).merge(
+          "expiresAt" => normalize_time(session["expiresAt"] || session[:expiresAt]),
+          "createdAt" => normalize_time(session["createdAt"] || session[:createdAt]),
+          "updatedAt" => normalize_time(session["updatedAt"] || session[:updatedAt])
+        )
+      end
+
+      def normalize_user_dates(user)
+        return nil unless user
+
+        user.transform_keys(&:to_s).merge(
+          "createdAt" => normalize_time(user["createdAt"] || user[:createdAt]),
+          "updatedAt" => normalize_time(user["updatedAt"] || user[:updatedAt])
+        )
+      end
+
+      def normalize_time(value)
+        return value if value.is_a?(Time)
+        return Time.at(value / 1000.0) if value.is_a?(Integer) && value > 10_000_000_000
+        return Time.at(value) if value.is_a?(Integer)
+
+        Time.parse(value.to_s)
+      end
+
+      def millis(value)
+        (normalize_time(value).to_f * 1000).to_i
+      end
+
+      def ttl(expires_ms)
+        [(expires_ms - current_millis) / 1000, 0].max.floor
+      end
+
+      def current_millis
+        (Time.now.to_f * 1000).to_i
+      end
+    end
+  end
+end