better_auth-hanami 0.1.0

data/lib/better_auth/hanami/migration.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module BetterAuth
+  module Hanami
+    module Migration
+      module_function
+
+      def render(options)
+        tables = BetterAuth::Schema.auth_tables(options)
+        lines = [
+          "# frozen_string_literal: true",
+          "",
+          "require \"date\"",
+          "require \"rom-sql\"",
+          "",
+          "ROM::SQL.migration do",
+          "  change do"
+        ]
+        tables.each_value { |table| lines.concat(create_table_lines(table, options)) }
+        lines.concat(["  end", "end", ""])
+        lines.join("\n")
+      end
+
+      def create_table_lines(table, options)
+        table_name = table.fetch(:model_name)
+        lines = ["", "    create_table :#{table_name} do"]
+        table.fetch(:fields).each do |logical_field, attributes|
+          lines << column_line(logical_field, attributes, options)
+        end
+        lines << "      primary_key [:id]" if table.fetch(:fields).key?("id")
+        table.fetch(:fields).each do |logical_field, attributes|
+          index = index_line(logical_field, attributes)
+          lines << index if index
+        end
+        lines << "    end"
+        lines
+      end
+
+      def column_line(logical_field, attributes, options)
+        column = attributes[:field_name] || physical_name(logical_field)
+        reference = attributes[:references]
+        if reference
+          target = foreign_key_target(reference.fetch(:model), options)
+          parts = ["foreign_key :#{column}, :#{target}", "type: #{hanami_type(attributes)}"]
+          parts << "null: false" if attributes[:required]
+          parts << "on_delete: :#{reference[:on_delete]}" if reference[:on_delete]
+          return "      #{parts.join(", ")}"
+        end
+
+        parts = ["column :#{column}", hanami_type(attributes)]
+        parts << "null: false" if attributes[:required]
+        default = default_value(attributes)
+        parts << "default: #{default}" unless default.nil?
+        "      #{parts.join(", ")}"
+      end
+
+      def index_line(logical_field, attributes)
+        return unless attributes[:unique] || attributes[:index]
+
+        column = attributes[:field_name] || physical_name(logical_field)
+        unique = attributes[:unique] ? ", unique: true" : ""
+        "      index :#{column}#{unique}"
+      end
+
+      def hanami_type(attributes)
+        case attributes[:type]
+        when "boolean" then "TrueClass"
+        when "date" then "DateTime"
+        when "number" then "Integer"
+        else "String"
+        end
+      end
+
+      def default_value(attributes)
+        default = attributes[:default_value]
+        return if default.respond_to?(:call)
+
+        case default
+        when true then "true"
+        when false then "false"
+        when Numeric then default.to_s
+        when String then default.inspect
+        end
+      end
+
+      def foreign_key_target(model, options)
+        tables = BetterAuth::Schema.auth_tables(options)
+        tables.fetch(model.to_s, nil)&.fetch(:model_name) || model
+      end
+
+      def physical_name(value)
+        value.to_s
+          .gsub(/([a-z\d])([A-Z])/, "\\1_\\2")
+          .tr("-", "_")
+          .downcase
+      end
+    end
+  end
+end

data/lib/better_auth/hanami/mounted_app.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module BetterAuth
+  module Hanami
+    class MountedApp
+      def initialize(auth, mount_path:)
+        @auth = auth
+        @mount_path = normalize_path(mount_path)
+      end
+
+      def call(env)
+        @auth.call(env.merge("PATH_INFO" => mounted_path_info(env)))
+      end
+
+      private
+
+      def mounted_path_info(env)
+        path_info = normalize_path(env["PATH_INFO"])
+        script_name = normalize_path(env["SCRIPT_NAME"])
+        prefix = (script_name == "/") ? @mount_path : script_name
+
+        return path_info if path_info == prefix || path_info.start_with?("#{prefix}/")
+
+        normalize_path("#{prefix}/#{path_info.delete_prefix("/")}")
+      end
+
+      def normalize_path(path)
+        normalized = path.to_s
+        normalized = "/#{normalized}" unless normalized.start_with?("/")
+        normalized = normalized.squeeze("/")
+        normalized = normalized.delete_suffix("/") unless normalized == "/"
+        normalized.empty? ? "/" : normalized
+      end
+    end
+  end
+end

data/lib/better_auth/hanami/routing.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module BetterAuth
+  module Hanami
+    module Routing
+      HTTP_METHODS = %i[get post put patch delete options].freeze
+
+      def self.included(base)
+        base.extend(self)
+      end
+
+      def better_auth(auth: nil, at: BetterAuth::Configuration::DEFAULT_BASE_PATH)
+        mount_path = normalize_better_auth_mount_path(at)
+        auth ||= BetterAuth::Hanami.auth(base_path: mount_path)
+        app = BetterAuth::Hanami::MountedApp.new(auth, mount_path: mount_path)
+
+        HTTP_METHODS.each do |method_name|
+          public_send(method_name, mount_path, to: app)
+          public_send(method_name, "#{mount_path}/*path", to: app)
+        end
+      end
+
+      private
+
+      def normalize_better_auth_mount_path(path)
+        normalized = path.to_s
+        normalized = "/#{normalized}" unless normalized.start_with?("/")
+        normalized = normalized.squeeze("/")
+        normalized = normalized.delete_suffix("/") unless normalized == "/"
+        normalized.empty? ? "/" : normalized
+      end
+    end
+  end
+end

data/lib/better_auth/hanami/sequel_adapter.rb

@@ -0,0 +1,288 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "time"
+require "sequel"
+
+module BetterAuth
+  module Hanami
+    class SequelAdapter < BetterAuth::Adapters::Base
+      attr_reader :connection
+
+      def self.from_hanami(options, container: nil)
+        if container.nil? && defined?(::Hanami) && ::Hanami.respond_to?(:app)
+          container = ::Hanami.app
+        end
+        return BetterAuth::Adapters::Memory.new(options) unless container
+
+        from_container(container, options)
+      end
+
+      def self.from_container(container, options)
+        gateway = if container.respond_to?(:key?) && container.key?("db.gateway")
+          container["db.gateway"]
+        elsif container.respond_to?(:[]) && safe_fetch(container, "db.gateway")
+          container["db.gateway"]
+        end
+        return BetterAuth::Adapters::Memory.new(options) unless gateway
+
+        connection = gateway.respond_to?(:connection) ? gateway.connection : gateway
+        new(options, connection: connection)
+      end
+
+      def self.safe_fetch(container, key)
+        container[key]
+      rescue KeyError
+        nil
+      end
+
+      def initialize(options, connection:)
+        super(options)
+        @connection = connection
+      end
+
+      def create(model:, data:, force_allow_id: false)
+        model = model.to_s
+        input = transform_input(model, data, "create", force_allow_id)
+        table_dataset(model).insert(physical_attributes(model, input))
+        find_one(model: model, where: [{field: "id", value: input.fetch("id")}])
+      end
+
+      def find_one(model:, where: [], select: nil, join: nil)
+        find_many(model: model, where: where, select: select, join: join, limit: 1).first
+      end
+
+      def find_many(model:, where: [], sort_by: nil, limit: nil, offset: nil, select: nil, join: nil)
+        model = model.to_s
+        dataset = table_dataset(model)
+        dataset = apply_where(model, dataset, where || [])
+        dataset = apply_select(model, dataset, select) if select
+        dataset = apply_order(model, dataset, sort_by) if sort_by
+        dataset = dataset.limit(Integer(limit)) if limit
+        dataset = dataset.offset(Integer(offset)) if offset
+
+        records = dataset.all.map { |row| normalize_record(model, row) }
+        attach_joins(model, records, join)
+      end
+
+      def update(model:, where:, update:)
+        model = model.to_s
+        existing = find_one(model: model, where: where, select: ["id"])
+        return nil unless existing
+
+        update_many(model: model, where: where, update: update)
+        find_one(model: model, where: [{field: "id", value: existing.fetch("id")}])
+      end
+
+      def update_many(model:, where:, update:, returning: false)
+        model = model.to_s
+        existing = returning ? find_many(model: model, where: where, select: ["id"]) : []
+        attributes = physical_attributes(model, transform_input(model, update, "update", true))
+        apply_where(model, table_dataset(model), where || []).update(attributes)
+        return unless returning
+
+        existing.map { |record| find_one(model: model, where: [{field: "id", value: record.fetch("id")}]) }
+      end
+
+      def delete(model:, where:)
+        delete_many(model: model, where: where)
+        nil
+      end
+
+      def delete_many(model:, where:)
+        model = model.to_s
+        apply_where(model, table_dataset(model), where || []).delete
+      end
+
+      def count(model:, where: nil)
+        model = model.to_s
+        apply_where(model, table_dataset(model), where || []).count
+      end
+
+      def transaction
+        connection.transaction { yield self }
+      end
+
+      private
+
+      def table_dataset(model)
+        connection[table_for(model).to_sym]
+      end
+
+      def apply_where(model, dataset, where)
+        expression = Array(where).each_with_index.reduce(nil) do |combined, (clause, index)|
+          current = where_expression(model, clause)
+          next current if index.zero?
+
+          connector = fetch_key(clause, :connector).to_s.upcase
+          (connector == "OR") ? Sequel.|(combined, current) : Sequel.&(combined, current)
+        end
+        expression ? dataset.where(expression) : dataset
+      end
+
+      def where_expression(model, clause)
+        field = storage_key(fetch_key(clause, :field))
+        column = storage_field(model, field)
+        identifier = Sequel[column.to_sym]
+        operator = (fetch_key(clause, :operator) || "eq").to_s
+        value = fetch_key(clause, :value)
+
+        case operator
+        when "in" then {column.to_sym => Array(value)}
+        when "not_in" then Sequel.~(column.to_sym => Array(value))
+        when "ne" then Sequel.~(column.to_sym => value)
+        when "gt" then identifier > value
+        when "gte" then identifier >= value
+        when "lt" then identifier < value
+        when "lte" then identifier <= value
+        when "contains" then Sequel.like(identifier, "%#{value}%")
+        when "starts_with" then Sequel.like(identifier, "#{value}%")
+        when "ends_with" then Sequel.like(identifier, "%#{value}")
+        else {column.to_sym => value}
+        end
+      end
+
+      def apply_select(model, dataset, select)
+        dataset.select(*Array(select).map { |field| storage_field(model, storage_key(field)).to_sym })
+      end
+
+      def apply_order(model, dataset, sort_by)
+        column = storage_field(model, storage_key(fetch_key(sort_by, :field))).to_sym
+        direction = (fetch_key(sort_by, :direction).to_s.downcase == "desc") ? Sequel.desc(column) : column
+        dataset.order(direction)
+      end
+
+      def attach_joins(model, records, join)
+        return records unless join
+
+        records.each do |record|
+          join.each_key do |join_model|
+            join_model = join_model.to_s
+            case [model.to_s, join_model]
+            when ["session", "user"], ["account", "user"]
+              record[join_model] = find_one(model: join_model, where: [{field: "id", value: record["userId"]}])
+            when ["user", "account"]
+              record[join_model] = find_many(model: "account", where: [{field: "userId", value: record["id"]}])
+            end
+          end
+        end
+        records
+      end
+
+      def transform_input(model, data, action, force_allow_id)
+        fields = schema_for(model).fetch(:fields)
+        input = stringify_keys(data)
+        output = {}
+
+        fields.each do |field, attributes|
+          next if field == "id" && input.key?(field) && !force_allow_id
+
+          value_provided = input.key?(field)
+          value = input[field]
+          if value_provided && attributes[:input] == false && value && !force_allow_id
+            raise APIError.new("BAD_REQUEST", message: "#{field} is not allowed to be set")
+          end
+
+          if !value_provided && action == "create" && attributes.key?(:default_value)
+            value = resolve_default(attributes[:default_value])
+            value_provided = true
+          elsif !value_provided && action == "update" && attributes[:on_update]
+            value = resolve_default(attributes[:on_update])
+            value_provided = true
+          end
+          if !value_provided && action == "create" && attributes[:required]
+            raise APIError.new("BAD_REQUEST", message: "#{field} is required") unless field == "id"
+          end
+          output[field] = coerce_value(value, attributes) if value_provided
+        end
+
+        output["id"] = generated_id if action == "create" && !output.key?("id")
+        output
+      end
+
+      def physical_attributes(model, logical)
+        logical.each_with_object({}) do |(field, value), attributes|
+          attributes[storage_field(model, field).to_sym] = value
+        end
+      end
+
+      def normalize_record(model, row)
+        return nil unless row
+
+        schema_for(model).fetch(:fields).each_with_object({}) do |(field, attributes), output|
+          column = (attributes[:field_name] || physical_name(field)).to_sym
+          output[field] = coerce_output_value(row[column], attributes) if row.key?(column)
+        end
+      end
+
+      def table_for(model)
+        schema_for(model).fetch(:model_name)
+      end
+
+      def schema_for(model)
+        BetterAuth::Schema.auth_tables(options).fetch(model.to_s)
+      end
+
+      def storage_field(model, field)
+        schema_for(model).fetch(:fields).fetch(field.to_s).fetch(:field_name, physical_name(field))
+      end
+
+      def generated_id
+        generator = options.advanced.dig(:database, :generate_id)
+        return generator.call.to_s if generator.respond_to?(:call)
+        return SecureRandom.uuid if generator == "uuid"
+
+        SecureRandom.hex(16)
+      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 coerce_output_value(value, attributes)
+        return value if value.nil?
+        return coerce_boolean(value) if attributes[:type] == "boolean"
+        return Time.parse(value.to_s) if attributes[:type] == "date" && !value.is_a?(Time)
+
+        value
+      end
+
+      def coerce_boolean(value)
+        return value if value == true || value == false
+        return false if value == 0 || value.to_s == "0" || value.to_s.downcase == "f" || value.to_s.downcase == "false"
+        return true if value == 1 || value.to_s == "1" || value.to_s.downcase == "t" || value.to_s.downcase == "true"
+
+        value
+      end
+
+      def stringify_keys(data)
+        data.each_with_object({}) do |(key, value), result|
+          result[storage_key(key)] = value
+        end
+      end
+
+      def fetch_key(hash, key)
+        hash[key] || hash[key.to_s] || hash[storage_key(key)] || hash[storage_key(key).to_sym]
+      end
+
+      def storage_key(value)
+        parts = physical_name(value).split("_")
+        ([parts.first] + parts.drop(1).map(&:capitalize)).join
+      end
+
+      def physical_name(value)
+        value.to_s
+          .gsub(/([a-z\d])([A-Z])/, "\\1_\\2")
+          .tr("-", "_")
+          .downcase
+      end
+    end
+  end
+end

data/lib/better_auth/hanami/version.rb

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

data/lib/better_auth/hanami.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "better_auth"
+require_relative "hanami/version"
+require_relative "hanami/configuration"
+require_relative "hanami/mounted_app"
+require_relative "hanami/routing"
+require_relative "hanami/migration"
+require_relative "hanami/sequel_adapter"
+require_relative "hanami/action_helpers"
+require_relative "hanami/generators/install_generator"
+require_relative "hanami/generators/migration_generator"
+require_relative "hanami/generators/relation_generator"
+
+module BetterAuth
+  module Hanami
+    class << self
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield configuration
+        @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
+    end
+  end
+end

data/lib/better_auth_hanami.rb

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

data/lib/tasks/better_auth.rake

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "better_auth/hanami"
+
+namespace :better_auth do
+  desc "Create Better Auth Hanami provider, routes, settings, tasks, and base migration"
+  task :init do
+    BetterAuth::Hanami::Generators::InstallGenerator.new.run
+  end
+
+  namespace :generate do
+    desc "Create the Better Auth Hanami base migration"
+    task :migration do
+      BetterAuth::Hanami::Generators::MigrationGenerator.new.run
+    end
+
+    desc "Create Hanami relations and repos for Better Auth tables"
+    task :relations do
+      BetterAuth::Hanami::Generators::RelationGenerator.new.run
+    end
+  end
+end