dorm 0.1.0

data/lib/dorm/connection_pool.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require 'monitor'
+require 'timeout'
+
+module Dorm
+  class ConnectionPool
+    include MonitorMixin
+
+    class PoolExhaustedError < StandardError; end
+    class ConnectionTimeoutError < StandardError; end
+
+    Connection = Data.define(:raw_connection, :created_at, :last_used_at) do
+      def expired?(max_age)
+        Time.now - created_at > max_age
+      end
+
+      def stale?(max_idle)
+        Time.now - last_used_at > max_idle
+      end
+
+      def touch!
+        with(last_used_at: Time.now)
+      end
+    end
+
+    def initialize(
+      size: 5,
+      timeout: 5,
+      max_age: 3600,    # 1 hour
+      max_idle: 300,    # 5 minutes
+      reap_frequency: 60 # 1 minute
+    )
+      super()
+
+      @size = size
+      @timeout = timeout
+      @max_age = max_age
+      @max_idle = max_idle
+      @reap_frequency = reap_frequency
+
+      @available = []
+      @connections = {}
+      @connection_factory = nil
+      @last_reap = Time.now
+
+      start_reaper_thread if @reap_frequency > 0
+    end
+
+    def configure_factory(&block)
+      @connection_factory = block
+    end
+
+    def with_connection(&block)
+      connection = checkout_connection
+      begin
+        result = block.call(connection.raw_connection)
+        result
+      rescue StandardError => e
+        # If connection is bad, don't return it to pool
+        remove_connection(connection)
+        raise
+      ensure
+        # Always try to check the connection back in (if it wasn't removed)
+        if connection && @connections.key?(connection.object_id)
+          updated_connection = connection.touch!
+          synchronize do
+            # Replace the connection in the hash with the updated version
+            @connections[updated_connection.object_id] = updated_connection
+            @connections.delete(connection.object_id) unless connection.equal?(updated_connection)
+          end
+          checkin_connection(updated_connection)
+        end
+      end
+    end
+
+    def size
+      synchronize { @connections.size }
+    end
+
+    def available_count
+      synchronize { @available.size }
+    end
+
+    def checked_out_count
+      synchronize { @connections.size - @available.size }
+    end
+
+    def disconnect!
+      synchronize do
+        @connections.each_value do |conn|
+          close_connection(conn)
+        end
+        @connections.clear
+        @available.clear
+      end
+    end
+
+    # Manual cleanup of expired/stale connections
+    def reap_connections!
+      synchronize do
+        stale_connections = @available.select do |conn|
+          conn.expired?(@max_age) || conn.stale?(@max_idle)
+        end
+
+        stale_connections.each do |conn|
+          @available.delete(conn)
+          @connections.delete(conn.object_id)
+          close_connection(conn)
+        end
+
+        @last_reap = Time.now
+      end
+    end
+
+    private
+
+    def checkout_connection
+      synchronize do
+        # Reap periodically
+        reap_connections! if should_reap?
+
+        # Try to get an available connection first
+        conn = @available.pop
+
+        # If no available connection, try to create a new one
+        conn ||= create_connection
+
+        # If still no connection, we need to wait for one to become available
+        conn = wait_for_connection if conn.nil?
+
+        raise PoolExhaustedError, 'Could not obtain connection' if conn.nil?
+
+        # Mark connection as checked out
+        @connections[conn.object_id] = conn
+        conn
+      end
+    end
+
+    def checkin_connection(connection)
+      synchronize do
+        # Only add back to available if it's still in our connections hash
+        @available.push(connection) if @connections.key?(connection.object_id) && !@available.include?(connection)
+      end
+    end
+
+    def remove_connection(connection)
+      synchronize do
+        @connections.delete(connection.object_id)
+        @available.delete(connection)
+        close_connection(connection)
+      end
+    end
+
+    def create_connection
+      return nil unless @connection_factory
+      return nil if @connections.size >= @size
+
+      raw_conn = @connection_factory.call
+      now = Time.now
+      Connection.new(
+        raw_connection: raw_conn,
+        created_at: now,
+        last_used_at: now
+      )
+    rescue StandardError => e
+      raise Dorm::ConfigurationError, "Failed to create database connection: #{e.message}"
+    end
+
+    def wait_for_connection
+      deadline = Time.now + @timeout
+
+      loop do
+        # Check if we've exceeded the timeout first
+        raise ConnectionTimeoutError, 'Timeout waiting for database connection' if Time.now >= deadline
+
+        synchronize do
+          # Check if a connection became available
+          conn = @available.pop
+          return conn if conn
+        end
+
+        # Small sleep to avoid busy waiting
+        sleep(0.001) # 1ms
+      end
+    end
+
+    def close_connection(connection)
+      case connection.raw_connection
+      when ->(conn) { conn.respond_to?(:close) }
+        connection.raw_connection.close
+      when ->(conn) { conn.respond_to?(:finish) } # PG connection
+        connection.raw_connection.finish
+      end
+    rescue StandardError => e
+      # Log error but don't raise - we're cleaning up
+      puts "Warning: Error closing connection: #{e.message}"
+    end
+
+    def should_reap?
+      Time.now - @last_reap > @reap_frequency
+    end
+
+    def start_reaper_thread
+      @reaper_thread = Thread.new do
+        loop do
+          sleep(@reap_frequency)
+          begin
+            reap_connections!
+          rescue StandardError => e
+            puts "Warning: Error in connection reaper: #{e.message}"
+          end
+        end
+      end
+      @reaper_thread.name = 'Dorm Connection Pool Reaper'
+    end
+  end
+end

data/lib/dorm/database.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require_relative 'connection_pool'
+
+module Dorm
+  module Database
+    extend self
+
+    attr_reader :adapter, :pool
+
+    def configure(adapter:, pool_size: 5, pool_timeout: 5, **options)
+      @adapter = adapter.to_sym
+      @connection_options = options
+      @pool_size = pool_size
+      @pool_timeout = pool_timeout
+
+      # Disconnect existing pool if any
+      @pool&.disconnect!
+
+      # Create new pool
+      @pool = ConnectionPool.new(
+        size: pool_size,
+        timeout: pool_timeout,
+        max_age: options[:max_connection_age] || 3600,
+        max_idle: options[:max_idle_time] || 300,
+        reap_frequency: options[:reap_frequency] || 60
+      )
+
+      # Configure the connection factory
+      @pool.configure_factory { establish_connection }
+    end
+
+    def query(sql, params = [])
+      ensure_configured!
+
+      @pool.with_connection do |connection|
+        execute_query(connection, sql, params)
+      end
+    rescue StandardError => e
+      raise Error, "Database query failed: #{e.message}"
+    end
+
+    def transaction(&block)
+      ensure_configured!
+
+      @pool.with_connection do |connection|
+        execute_transaction(connection, &block)
+      end
+    rescue StandardError => e
+      raise Error, "Transaction failed: #{e.message}"
+    end
+
+    # Pool statistics for monitoring
+    def pool_stats
+      return {} unless @pool
+
+      {
+        size: @pool.size,
+        available: @pool.available_count,
+        checked_out: @pool.checked_out_count,
+        adapter: @adapter
+      }
+    end
+
+    # Disconnect all connections (useful for testing or shutdown)
+    def disconnect!
+      @pool&.disconnect!
+    end
+
+    private
+
+    def ensure_configured!
+      return if @pool && @adapter
+
+      raise ConfigurationError, 'Database not configured. Call Dorm.configure first.'
+    end
+
+    def establish_connection
+      case @adapter
+      when :postgresql
+        require 'pg'
+        conn = PG.connect(@connection_options)
+        # Set some reasonable defaults for pooled connections
+        conn.exec("SET application_name = 'Dorm'") if conn.respond_to?(:exec)
+        conn
+      when :sqlite3
+        require 'sqlite3'
+        db = SQLite3::Database.new(@connection_options[:database] || ':memory:')
+        # Return results as hashes instead of arrays
+        db.results_as_hash = true
+        # Enable foreign keys and other useful pragmas
+        db.execute('PRAGMA foreign_keys = ON')
+        db.execute('PRAGMA journal_mode = WAL') unless @connection_options[:database] == ':memory:'
+        db
+      else
+        raise ConfigurationError, "Unsupported database adapter: #{@adapter}"
+      end
+    rescue LoadError => e
+      raise ConfigurationError, "Database adapter gem not found: #{e.message}"
+    rescue StandardError => e
+      raise ConfigurationError, "Failed to establish database connection: #{e.message}"
+    end
+
+    def execute_query(connection, sql, params)
+      case @adapter
+      when :postgresql
+        result = connection.exec_params(sql, params)
+        # Convert PG::Result to array of hashes
+        result.map { |row| row }
+      when :sqlite3
+        if params.empty?
+          connection.execute(sql)
+        else
+          connection.execute(sql, params)
+        end
+      else
+        raise ConfigurationError, "Unsupported database adapter: #{@adapter}"
+      end
+    end
+
+    def execute_transaction(connection, &block)
+      case @adapter
+      when :postgresql
+        connection.transaction(&block)
+      when :sqlite3
+        # SQLite3's transaction method might not work as expected in all cases
+        # Let's be more explicit about transaction handling
+        connection.execute('BEGIN TRANSACTION')
+        begin
+          result = block.call(connection)
+          connection.execute('COMMIT')
+          result
+        rescue StandardError => e
+          connection.execute('ROLLBACK')
+          raise
+        end
+      else
+        raise ConfigurationError, "Unsupported database adapter: #{@adapter}"
+      end
+    end
+  end
+end

data/lib/dorm/functional_helpers.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Dorm
+  # Functional composition helpers - inspired by Clojure
+  module FunctionalHelpers
+    module_function
+
+    # Pipe value through a series of functions
+    # pipe(value, f1, f2, f3) equivalent to f3(f2(f1(value)))
+    def pipe(value, *functions)
+      functions.reduce(value) { |v, f| f.call(v) }
+    end
+
+    # Compose functions into a single function
+    # comp(f1, f2, f3) returns ->(x) { f1(f2(f3(x))) }
+    def comp(*functions)
+      ->(x) { functions.reverse.reduce(x) { |v, f| f.call(v) } }
+    end
+
+    # Partial application - fix some arguments
+    # partial(method(:add), 5) returns ->(x) { add(5, x) }
+    def partial(func, *args)
+      # ->(x) { func.call(*args, x) }
+      if [method(:filter), method(:map_over), method(:take)].include?(func)
+        ->(x) { func.call(x, *args) }
+      else
+        ->(x) { func.call(*args, x) }
+      end
+    end
+
+    # Filter collection with predicate
+    def filter(collection, predicate)
+      collection.select(&predicate)
+    end
+
+    # Map over collection
+    def map_over(collection, transform)
+      collection.map(&transform)
+    end
+
+    # Reduce collection
+    def reduce_with(collection, initial, reducer)
+      collection.reduce(initial, &reducer)
+    end
+
+    # Find first element matching predicate
+    def find_first(collection, predicate)
+      collection.find(&predicate)
+    end
+
+    # Take first n elements
+    def take(collection, n)
+      collection.take(n)
+    end
+
+    # Drop first n elements
+    def drop(collection, n)
+      collection.drop(n)
+    end
+
+    # Group by a function result
+    def group_by_fn(collection, grouper)
+      collection.group_by(&grouper)
+    end
+
+    # Sort by a function result
+    def sort_by_fn(collection, sorter)
+      collection.sort_by(&sorter)
+    end
+
+    # Apply function if condition is true, otherwise return original value
+    def apply_if(value, condition, func)
+      condition ? func.call(value) : value
+    end
+
+    # Thread-first macro simulation (Clojure's ->)
+    # thread_first(x, f1, f2, f3) equivalent to f3(f2(f1(x)))
+    def thread_first(value, *functions)
+      pipe(value, *functions)
+    end
+
+    # Thread-last macro simulation (Clojure's ->>)
+    # thread_last(x, f1, f2, f3) equivalent to f3(f2(f1(x)))
+    # Useful when you want the value to be the last argument
+    def thread_last(value, *functions)
+      functions.reduce(value) do |v, f|
+        if f.respond_to?(:curry)
+          f.curry.call(v)
+        else
+          f.call(v)
+        end
+      end
+    end
+
+    # Juxt - apply multiple functions to same value, return array of results
+    # juxt(f1, f2, f3) returns ->(x) { [f1(x), f2(x), f3(x)] }
+    def juxt(*functions)
+      ->(x) { functions.map { |f| f.call(x) } }
+    end
+
+    # Maybe monad helpers for dealing with nils
+    def maybe(value)
+      value.nil? ? None.new : Some.new(value)
+    end
+
+    Some = Data.define(:value) do
+      def bind(&block)
+        result = block.call(value)
+        result.is_a?(Some) || result.is_a?(None) ? result : Some.new(result)
+      end
+
+      def map(&block)
+        Some.new(block.call(value))
+      end
+
+      def value_or(_default)
+        value
+      end
+
+      def some? = true
+      def none? = false
+    end
+
+    None = Data.define do
+      def bind(&block)
+        self
+      end
+
+      def map(&block)
+        self
+      end
+
+      def value_or(default)
+        default
+      end
+
+      def some? = false
+      def none? = true
+    end
+  end
+end