rooq 1.0.0

data/exe/rooq

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/rooq"
+require_relative "../lib/rooq/cli"
+
+exit Rooq::CLI.new(ARGV).run

data/lib/rooq/adapters/postgresql.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Rooq
+  module Adapters
+    module PostgreSQL
+      # A simple connection pool for PostgreSQL connections.
+      # For production use, consider using a more robust pool like connection_pool gem.
+      #
+      # @example Basic usage
+      #   pool = Rooq::Adapters::PostgreSQL::ConnectionPool.new(size: 5) do
+      #     PG.connect(dbname: 'myapp', host: 'localhost')
+      #   end
+      #
+      #   ctx = Rooq::Context.using_pool(pool)
+      #   # ... execute queries ...
+      #   pool.shutdown
+      #
+      # @example With timeout
+      #   pool = Rooq::Adapters::PostgreSQL::ConnectionPool.new(size: 10, timeout: 5) do
+      #     PG.connect(connection_string)
+      #   end
+      class ConnectionPool < Rooq::ConnectionPool
+        class TimeoutError < Rooq::Error; end
+
+        attr_reader :size
+
+        # Create a new connection pool.
+        # @param size [Integer] the maximum number of connections
+        # @param timeout [Numeric] seconds to wait for a connection (nil = wait forever)
+        # @yield the block that creates a new connection
+        def initialize(size: 5, timeout: nil, &block)
+          super()
+          @size = size
+          @timeout = timeout
+          @create_connection = block
+          @mutex = Mutex.new
+          @condition = ConditionVariable.new
+          @available = []
+          @in_use = []
+          @shutdown = false
+
+          # Pre-create all connections
+          @size.times { @available << @create_connection.call }
+        end
+
+        # Check out a connection from the pool.
+        # @return [PG::Connection] a database connection
+        # @raise [TimeoutError] if timeout expires while waiting
+        def checkout
+          @mutex.synchronize do
+            raise Error, "Pool has been shut down" if @shutdown
+
+            deadline = @timeout ? Time.now + @timeout : nil
+
+            while @available.empty?
+              if deadline
+                remaining = deadline - Time.now
+                raise TimeoutError, "Timed out waiting for connection" if remaining <= 0
+
+                @condition.wait(@mutex, remaining)
+              else
+                @condition.wait(@mutex)
+              end
+
+              raise Error, "Pool has been shut down" if @shutdown
+            end
+
+            connection = @available.pop
+            @in_use << connection
+            connection
+          end
+        end
+
+        # Check in a connection back to the pool.
+        # @param connection [PG::Connection] the connection to return
+        def checkin(connection)
+          @mutex.synchronize do
+            @in_use.delete(connection)
+            @available << connection unless @shutdown
+            @condition.signal
+          end
+        end
+
+        # @return [Integer] number of available connections
+        def available
+          @mutex.synchronize { @available.length }
+        end
+
+        # Shutdown the pool and close all connections.
+        def shutdown
+          @mutex.synchronize do
+            @shutdown = true
+            @available.each { |conn| conn.close if conn.respond_to?(:close) }
+            @in_use.each { |conn| conn.close if conn.respond_to?(:close) }
+            @available.clear
+            @in_use.clear
+            @condition.broadcast
+          end
+        end
+      end
+
+      # Create a Context configured for PostgreSQL.
+      # @param connection [PG::Connection] a single connection
+      # @return [Rooq::Context]
+      def self.context(connection)
+        Rooq::Context.using(connection, dialect: Rooq::Dialect::PostgreSQL.new)
+      end
+
+      # Create a Context with a connection pool.
+      # @param pool [ConnectionPool] a connection pool
+      # @return [Rooq::Context]
+      def self.pooled_context(pool)
+        Rooq::Context.using_pool(pool, dialect: Rooq::Dialect::PostgreSQL.new)
+      end
+    end
+  end
+end

data/lib/rooq/adapters.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "adapters/postgresql"

data/lib/rooq/cli.rb

@@ -0,0 +1,230 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "fileutils"
+require "optparse"
+require "sorbet-runtime"
+
+module Rooq
+  class CLI
+    extend T::Sig
+
+    sig { params(args: T::Array[String]).void }
+    def initialize(args)
+      @args = args
+      @options = T.let({
+        schema: "public",
+        output: nil,
+        stdout: false,
+        typed: true,
+        namespace: "Schema",
+        database: nil,
+        host: "localhost",
+        port: 5432,
+        username: nil,
+        password: nil
+      }, T::Hash[Symbol, T.untyped])
+    end
+
+    sig { returns(Integer) }
+    def run
+      parse_options!
+
+      case @args.first
+      when "generate", "gen", "g"
+        generate_command
+      when "version", "-v", "--version"
+        version_command
+      when "help", "-h", "--help", nil
+        help_command
+      else
+        $stderr.puts "Unknown command: #{@args.first}"
+        $stderr.puts "Run 'rooq help' for usage information."
+        1
+      end
+    rescue StandardError => e
+      $stderr.puts "Error: #{e.message}"
+      $stderr.puts e.backtrace.first(5).join("\n") if ENV["DEBUG"]
+      1
+    end
+
+    private
+
+    sig { void }
+    def parse_options!
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: rooq <command> [options]"
+
+        opts.on("-d", "--database DATABASE", "Database name (required)") do |v|
+          @options[:database] = v
+        end
+
+        opts.on("-h", "--host HOST", "Database host (default: localhost)") do |v|
+          @options[:host] = v
+        end
+
+        opts.on("-p", "--port PORT", Integer, "Database port (default: 5432)") do |v|
+          @options[:port] = v
+        end
+
+        opts.on("-U", "--username USERNAME", "Database username") do |v|
+          @options[:username] = v
+        end
+
+        opts.on("-W", "--password PASSWORD", "Database password") do |v|
+          @options[:password] = v
+        end
+
+        opts.on("-s", "--schema SCHEMA", "Schema name (default: public)") do |v|
+          @options[:schema] = v
+        end
+
+        opts.on("-o", "--output FILE", "Output file (default: lib/schema.rb)") do |v|
+          @options[:output] = v
+        end
+
+        opts.on("-n", "--namespace NAMESPACE", "Module namespace (default: Schema)") do |v|
+          @options[:namespace] = v
+        end
+
+        opts.on("--stdout", "Print to stdout instead of file") do
+          @options[:stdout] = true
+        end
+
+        opts.on("--[no-]typed", "Generate Sorbet types (default: true)") do |v|
+          @options[:typed] = v
+        end
+
+        opts.on("--help", "Show this help message") do
+          puts opts
+          exit 0
+        end
+      end
+
+      parser.parse!(@args)
+    end
+
+    sig { returns(Integer) }
+    def generate_command
+      @args.shift # Remove the "generate" command
+
+      unless @options[:database]
+        $stderr.puts "Error: Database name is required (-d DATABASE)"
+        $stderr.puts "Run 'rooq help' for usage information."
+        return 1
+      end
+
+      require "pg"
+
+      connection = connect_to_database
+      introspector = Generator::Introspector.new(connection)
+      schema_info = introspector.introspect_schema(schema: @options[:schema])
+
+      generator = Generator::CodeGenerator.new(
+        schema_info,
+        typed: @options[:typed],
+        namespace: @options[:namespace]
+      )
+      code = generator.generate
+
+      if @options[:stdout]
+        puts code
+      else
+        output_file = @options[:output] || default_output_file
+        FileUtils.mkdir_p(File.dirname(output_file))
+        File.write(output_file, code)
+        puts "Generated #{output_file}"
+      end
+
+      connection.close
+      0
+    end
+
+    sig { returns(String) }
+    def default_output_file
+      # Convert namespace to filename: MyApp::Schema -> my_app/schema.rb
+      namespace = @options[:namespace].to_s
+      filename = namespace.gsub("::", "/").gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+      "lib/#{filename}.rb"
+    end
+
+    sig { returns(T.untyped) }
+    def connect_to_database
+      connection_params = {
+        dbname: @options[:database],
+        host: @options[:host],
+        port: @options[:port]
+      }
+
+      connection_params[:user] = @options[:username] if @options[:username]
+      connection_params[:password] = @options[:password] if @options[:password]
+
+      # Also check environment variables
+      connection_params[:user] ||= ENV["PGUSER"]
+      connection_params[:password] ||= ENV["PGPASSWORD"]
+      connection_params[:host] = ENV["PGHOST"] if ENV["PGHOST"]
+      connection_params[:port] = ENV["PGPORT"].to_i if ENV["PGPORT"]
+
+      PG.connect(connection_params)
+    end
+
+    sig { returns(Integer) }
+    def version_command
+      puts "rooq #{Rooq::VERSION}"
+      0
+    end
+
+    sig { returns(Integer) }
+    def help_command
+      puts <<~HELP
+        rOOQ - A jOOQ-inspired query builder for Ruby
+
+        Usage: rooq <command> [options]
+
+        Commands:
+          generate, gen, g    Generate Ruby table definitions from database schema
+          version             Show version
+          help                Show this help message
+
+        Options for 'generate':
+          -d, --database DATABASE     Database name (required)
+          -h, --host HOST             Database host (default: localhost)
+          -p, --port PORT             Database port (default: 5432)
+          -U, --username USERNAME     Database username
+          -W, --password PASSWORD     Database password
+          -s, --schema SCHEMA         Database schema (default: public)
+          -o, --output FILE           Output file (default: lib/schema.rb)
+          -n, --namespace NAMESPACE   Module namespace (default: Schema)
+          --stdout                    Print to stdout instead of file
+          --[no-]typed                Generate Sorbet types (default: true)
+
+        Environment Variables:
+          PGHOST      Default database host
+          PGPORT      Default database port
+          PGUSER      Default database username
+          PGPASSWORD  Default database password
+
+        Examples:
+          # Generate schema to lib/schema.rb
+          rooq generate -d myapp_development
+
+          # Generate with custom namespace (writes to lib/my_app/db.rb)
+          rooq generate -d myapp_development -n MyApp::DB
+
+          # Generate to custom file
+          rooq generate -d myapp_development -o db/schema.rb
+
+          # Generate without Sorbet types
+          rooq generate -d myapp_development --no-typed
+
+          # Print to stdout instead of file
+          rooq generate -d myapp_development --stdout
+
+          # Connect to remote database
+          rooq generate -d myapp -h db.example.com -U postgres -W secret
+
+      HELP
+      0
+    end
+  end
+end

data/lib/rooq/condition.rb

@@ -0,0 +1,104 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rooq
+  # Type alias for any condition type
+  AnyCondition = T.type_alias { T.any(Condition, CombinedCondition, ExistsCondition) }
+
+  class Condition
+    extend T::Sig
+
+    sig { returns(Expression) }
+    attr_reader :expression
+
+    sig { returns(Symbol) }
+    attr_reader :operator
+
+    sig { returns(T.untyped) }
+    attr_reader :value
+
+    sig { params(expression: Expression, operator: Symbol, value: T.untyped).void }
+    def initialize(expression, operator, value)
+      @expression = expression
+      @operator = operator
+      @value = value
+      freeze
+    end
+
+    # Backwards compatibility
+    sig { returns(Expression) }
+    def field
+      @expression
+    end
+
+    sig { params(other: AnyCondition).returns(CombinedCondition) }
+    def and(other)
+      CombinedCondition.new(:and, [self, other])
+    end
+
+    sig { params(other: AnyCondition).returns(CombinedCondition) }
+    def or(other)
+      CombinedCondition.new(:or, [self, other])
+    end
+  end
+
+  class CombinedCondition
+    extend T::Sig
+
+    sig { returns(Symbol) }
+    attr_reader :operator
+
+    sig { returns(T::Array[AnyCondition]) }
+    attr_reader :conditions
+
+    sig { params(operator: Symbol, conditions: T::Array[AnyCondition]).void }
+    def initialize(operator, conditions)
+      @operator = operator
+      @conditions = T.let(conditions.freeze, T::Array[AnyCondition])
+      freeze
+    end
+
+    sig { params(other: AnyCondition).returns(CombinedCondition) }
+    def and(other)
+      CombinedCondition.new(:and, [*@conditions, other])
+    end
+
+    sig { params(other: AnyCondition).returns(CombinedCondition) }
+    def or(other)
+      CombinedCondition.new(:or, [*@conditions, other])
+    end
+  end
+
+  # EXISTS condition
+  class ExistsCondition
+    extend T::Sig
+
+    sig { returns(DSL::SelectQuery) }
+    attr_reader :subquery
+
+    sig { returns(T::Boolean) }
+    attr_reader :negated
+
+    sig { params(subquery: DSL::SelectQuery, negated: T::Boolean).void }
+    def initialize(subquery, negated: false)
+      @subquery = subquery
+      @negated = negated
+      freeze
+    end
+  end
+
+  extend T::Sig
+
+  # Helper methods for conditions
+  sig { params(subquery: DSL::SelectQuery).returns(ExistsCondition) }
+  def self.exists(subquery)
+    ExistsCondition.new(subquery)
+  end
+
+  sig { params(subquery: DSL::SelectQuery).returns(ExistsCondition) }
+  def self.not_exists(subquery)
+    ExistsCondition.new(subquery, negated: true)
+  end
+end

data/lib/rooq/configuration.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Rooq
+  # Configuration holds all settings for a Rooq context.
+  # Configurations are immutable - use #derive to create modified copies.
+  #
+  # Inspired by jOOQ's Configuration class.
+  # @see https://www.jooq.org/javadoc/latest/org.jooq/org/jooq/Configuration.html
+  class Configuration
+    attr_reader :connection_provider, :dialect
+
+    # Create a new configuration.
+    # @param connection_provider [ConnectionProvider] the connection provider
+    # @param dialect [Dialect::Base] the SQL dialect
+    def initialize(connection_provider: nil, dialect: nil)
+      @connection_provider = connection_provider
+      @dialect = dialect || Dialect::PostgreSQL.new
+      freeze
+    end
+
+    # Create a new configuration from a single connection.
+    # The connection lifecycle is managed externally.
+    # @param connection [Object] a database connection
+    # @param dialect [Dialect::Base] the SQL dialect
+    # @return [Configuration]
+    def self.from_connection(connection, dialect: nil)
+      new(
+        connection_provider: DefaultConnectionProvider.new(connection),
+        dialect: dialect
+      )
+    end
+
+    # Create a new configuration from a connection pool.
+    # Connections are acquired and released per query.
+    # @param pool [ConnectionPool] a connection pool
+    # @param dialect [Dialect::Base] the SQL dialect
+    # @return [Configuration]
+    def self.from_pool(pool, dialect: nil)
+      new(
+        connection_provider: PooledConnectionProvider.new(pool),
+        dialect: dialect
+      )
+    end
+
+    # Create a derived configuration with some settings overridden.
+    # @param connection_provider [ConnectionProvider] new connection provider (optional)
+    # @param dialect [Dialect::Base] new dialect (optional)
+    # @return [Configuration] a new configuration
+    def derive(connection_provider: nil, dialect: nil)
+      Configuration.new(
+        connection_provider: connection_provider || @connection_provider,
+        dialect: dialect || @dialect
+      )
+    end
+  end
+end

data/lib/rooq/connection.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Rooq
+  # Abstract interface for connection lifecycle management.
+  # Implementations control how connections are acquired and released.
+  #
+  # This is inspired by jOOQ's ConnectionProvider interface.
+  # @see https://www.jooq.org/javadoc/latest/org.jooq/org/jooq/ConnectionProvider.html
+  class ConnectionProvider
+    # Acquire a connection for query execution.
+    # @return [Object] a database connection
+    # @raise [NotImplementedError] if not implemented by subclass
+    def acquire
+      raise NotImplementedError, "#{self.class} must implement #acquire"
+    end
+
+    # Release a previously acquired connection.
+    # @param connection [Object] the connection to release
+    # @raise [NotImplementedError] if not implemented by subclass
+    def release(connection)
+      raise NotImplementedError, "#{self.class} must implement #release"
+    end
+
+    # Execute a block with an acquired connection, ensuring release.
+    # @yield [connection] the acquired connection
+    # @return [Object] the result of the block
+    def with_connection
+      connection = acquire
+      begin
+        yield connection
+      ensure
+        release(connection)
+      end
+    end
+  end
+
+  # A connection provider that wraps a single connection.
+  # The connection lifecycle is managed externally by the caller.
+  # Release is a no-op - the connection stays open until closed externally.
+  #
+  # Use this when you want to control transactions and connection lifecycle yourself.
+  class DefaultConnectionProvider < ConnectionProvider
+    attr_reader :connection
+
+    # @param connection [Object] the connection to wrap
+    def initialize(connection)
+      super()
+      @connection = connection
+    end
+
+    # Always returns the same connection instance.
+    # @return [Object] the wrapped connection
+    def acquire
+      @connection
+    end
+
+    # No-op - the connection lifecycle is managed externally.
+    # @param connection [Object] the connection (ignored)
+    def release(connection)
+      # No-op: connection lifecycle is managed externally
+    end
+  end
+
+  # A connection provider that acquires connections from a pool.
+  # Connections are returned to the pool after each query.
+  #
+  # The pool must respond to #checkout (or #acquire) and optionally #checkin.
+  # If the pool doesn't respond to #checkin, the connection's #close method is called.
+  class PooledConnectionProvider < ConnectionProvider
+    attr_reader :pool
+
+    # @param pool [ConnectionPool] a connection pool
+    def initialize(pool)
+      super()
+      @pool = pool
+    end
+
+    # Acquire a connection from the pool.
+    # @return [Object] a database connection
+    def acquire
+      if @pool.respond_to?(:checkout)
+        @pool.checkout
+      elsif @pool.respond_to?(:acquire)
+        @pool.acquire
+      else
+        raise Error, "Pool must respond to #checkout or #acquire"
+      end
+    end
+
+    # Release a connection back to the pool.
+    # @param connection [Object] the connection to release
+    def release(connection)
+      if @pool.respond_to?(:checkin)
+        @pool.checkin(connection)
+      elsif connection.respond_to?(:close)
+        connection.close
+      end
+    end
+  end
+
+  # Abstract interface for connection pools.
+  # Implementations manage a pool of reusable database connections.
+  class ConnectionPool
+    # Check out a connection from the pool.
+    # @return [Object] a database connection
+    def checkout
+      raise NotImplementedError, "#{self.class} must implement #checkout"
+    end
+
+    # Check in a connection back to the pool.
+    # @param connection [Object] the connection to return
+    def checkin(connection)
+      raise NotImplementedError, "#{self.class} must implement #checkin"
+    end
+
+    # @return [Integer] total pool size
+    def size
+      raise NotImplementedError, "#{self.class} must implement #size"
+    end
+
+    # @return [Integer] number of available connections
+    def available
+      raise NotImplementedError, "#{self.class} must implement #available"
+    end
+
+    # Shutdown the pool and close all connections.
+    def shutdown
+      raise NotImplementedError, "#{self.class} must implement #shutdown"
+    end
+  end
+end