rooq 1.0.0

data/lib/rooq/result.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+require "date"
+
+module Rooq
+  # Result wraps a database result set and provides:
+  # - Symbol keys instead of string keys
+  # - Automatic type coercion for JSON, JSONB, ARRAY, timestamps, dates
+  # - Enumerable interface
+  #
+  # @example
+  #   result = ctx.fetch_all(query)
+  #   result.each do |row|
+  #     puts row[:title]        # Symbol key access
+  #     puts row[:tags].first   # Array is parsed
+  #     puts row[:metadata]     # JSON is parsed to Hash
+  #   end
+  class Result
+    include Enumerable
+
+    attr_reader :raw_result
+
+    # @param raw_result [PG::Result] the raw database result
+    # @param coercer [TypeCoercer] optional custom type coercer
+    def initialize(raw_result, coercer: TypeCoercer.new)
+      @raw_result = raw_result
+      @coercer = coercer
+      @field_info = build_field_info
+      @rows = nil
+    end
+
+    # @yield [Hash] each row with symbol keys
+    def each(&block)
+      rows.each(&block)
+    end
+
+    # @return [Hash, nil] the first row or nil
+    def first
+      rows.first
+    end
+
+    # @return [Array<Hash>] all rows
+    def to_a
+      rows.dup
+    end
+
+    # @return [Boolean] true if no rows
+    def empty?
+      size.zero?
+    end
+
+    # @return [Integer] number of rows
+    def size
+      @raw_result.ntuples
+    end
+    alias length size
+    alias count size
+
+    private
+
+    def rows
+      @rows ||= build_rows
+    end
+
+    def build_rows
+      result = []
+      @raw_result.ntuples.times do |row_index|
+        result << build_row(row_index)
+      end
+      result
+    end
+
+    def build_row(row_index)
+      row = {}
+      @field_info.each_with_index do |(name, oid), col_index|
+        value = @raw_result.getvalue(row_index, col_index)
+        row[name] = @coercer.coerce(value, oid)
+      end
+      row
+    end
+
+    def build_field_info
+      info = []
+      @raw_result.nfields.times do |i|
+        name = @raw_result.fname(i).to_sym
+        oid = @raw_result.ftype(i)
+        info << [name, oid]
+      end
+      info
+    end
+  end
+
+  # TypeCoercer converts PostgreSQL values to Ruby types based on OID.
+  class TypeCoercer
+    # PostgreSQL type OIDs
+    OID_BOOL = 16
+    OID_INT2 = 21
+    OID_INT4 = 23
+    OID_INT8 = 20
+    OID_FLOAT4 = 700
+    OID_FLOAT8 = 701
+    OID_NUMERIC = 1700
+    OID_TEXT = 25
+    OID_VARCHAR = 1043
+    OID_DATE = 1082
+    OID_TIMESTAMP = 1114
+    OID_TIMESTAMPTZ = 1184
+    OID_JSON = 114
+    OID_JSONB = 3802
+    OID_INT4_ARRAY = 1007
+    OID_INT8_ARRAY = 1016
+    OID_TEXT_ARRAY = 1009
+    OID_VARCHAR_ARRAY = 1015
+    OID_FLOAT4_ARRAY = 1021
+    OID_FLOAT8_ARRAY = 1022
+    OID_BOOL_ARRAY = 1000
+    OID_UUID = 2950
+
+    # Coerce a value based on its PostgreSQL OID.
+    # @param value [String, nil] the raw value from the database
+    # @param oid [Integer] the PostgreSQL type OID
+    # @return [Object] the coerced value
+    def coerce(value, oid)
+      return nil if value.nil?
+
+      case oid
+      when OID_JSON, OID_JSONB
+        coerce_json(value)
+      when OID_INT4_ARRAY, OID_INT8_ARRAY
+        coerce_int_array(value)
+      when OID_TEXT_ARRAY, OID_VARCHAR_ARRAY
+        coerce_text_array(value)
+      when OID_FLOAT4_ARRAY, OID_FLOAT8_ARRAY
+        coerce_float_array(value)
+      when OID_BOOL_ARRAY
+        coerce_bool_array(value)
+      when OID_TIMESTAMP, OID_TIMESTAMPTZ
+        coerce_timestamp(value)
+      when OID_DATE
+        coerce_date(value)
+      when OID_BOOL
+        coerce_bool(value)
+      when OID_INT2, OID_INT4, OID_INT8
+        coerce_integer(value)
+      when OID_FLOAT4, OID_FLOAT8, OID_NUMERIC
+        coerce_float(value)
+      else
+        value
+      end
+    end
+
+    private
+
+    def coerce_json(value)
+      JSON.parse(value)
+    rescue JSON::ParserError
+      value
+    end
+
+    def coerce_int_array(value)
+      parse_pg_array(value).map { |v| v&.to_i }
+    end
+
+    def coerce_text_array(value)
+      parse_pg_array(value)
+    end
+
+    def coerce_float_array(value)
+      parse_pg_array(value).map { |v| v&.to_f }
+    end
+
+    def coerce_bool_array(value)
+      parse_pg_array(value).map { |v| coerce_bool(v) }
+    end
+
+    def coerce_timestamp(value)
+      Time.parse(value)
+    rescue ArgumentError
+      value
+    end
+
+    def coerce_date(value)
+      Date.parse(value)
+    rescue ArgumentError
+      value
+    end
+
+    def coerce_bool(value)
+      return nil if value.nil?
+      return value if value == true || value == false
+
+      value == "t" || value == "true" || value == "1"
+    end
+
+    def coerce_integer(value)
+      return value if value.is_a?(Integer)
+
+      value.to_i
+    end
+
+    def coerce_float(value)
+      return value if value.is_a?(Float)
+
+      value.to_f
+    end
+
+    # Parse PostgreSQL array literal format: {val1,val2,val3}
+    def parse_pg_array(value)
+      return [] if value == "{}"
+
+      # Remove outer braces
+      inner = value[1..-2]
+      return [] if inner.nil? || inner.empty?
+
+      elements = []
+      current = ""
+      in_quotes = false
+      escape_next = false
+
+      inner.each_char do |char|
+        if escape_next
+          current += char
+          escape_next = false
+        elsif char == '\\'
+          escape_next = true
+        elsif char == '"'
+          in_quotes = !in_quotes
+        elsif char == ',' && !in_quotes
+          elements << parse_array_element(current)
+          current = ""
+        else
+          current += char
+        end
+      end
+
+      elements << parse_array_element(current) unless current.empty?
+      elements
+    end
+
+    def parse_array_element(str)
+      return nil if str == "NULL"
+
+      str
+    end
+  end
+end

data/lib/rooq/schema_validator.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Rooq
+  class SchemaValidator
+    def initialize(connection, schema: "public")
+      @introspector = Generator::Introspector.new(connection)
+      @schema = schema
+    end
+
+    def validate(tables)
+      errors = []
+
+      tables.each do |table|
+        table_errors = validate_table(table)
+        errors.concat(table_errors)
+      end
+
+      raise SchemaValidationError.new(errors) unless errors.empty?
+
+      true
+    end
+
+    private
+
+    def validate_table(table)
+      errors = []
+
+      db_tables = @introspector.introspect_tables(schema: @schema)
+
+      unless db_tables.include?(table.name.to_s)
+        errors << "Table '#{table.name}' does not exist in database"
+        return errors
+      end
+
+      db_columns = @introspector.introspect_columns(table.name.to_s, schema: @schema)
+      db_column_names = db_columns.map(&:name)
+
+      table.fields.each_key do |field_name|
+        unless db_column_names.include?(field_name.to_s)
+          errors << "Column '#{field_name}' on table '#{table.name}' does not exist in database"
+        end
+      end
+
+      errors
+    end
+  end
+
+  class SchemaValidationError < Error
+    attr_reader :validation_errors
+
+    def initialize(errors)
+      @validation_errors = errors
+      super("Schema validation failed:\n  - #{errors.join("\n  - ")}")
+    end
+  end
+end

data/lib/rooq/table.rb

@@ -0,0 +1,69 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rooq
+  class Table
+    extend T::Sig
+
+    sig { returns(Symbol) }
+    attr_reader :name
+
+    sig { returns(T::Hash[Symbol, Field]) }
+    attr_reader :fields
+
+    sig { params(name: Symbol, block: T.nilable(T.proc.params(builder: TableBuilder).void)).void }
+    def initialize(name, &block)
+      @name = name
+      @fields = T.let({}, T::Hash[Symbol, Field])
+      @field_accessors = T.let({}, T::Hash[Symbol, Field])
+
+      if block_given?
+        builder = TableBuilder.new(self)
+        block.call(builder)
+      end
+
+      @fields.freeze
+      freeze
+    end
+
+    sig { returns(T::Array[Field]) }
+    def asterisk
+      @fields.values
+    end
+
+    sig { params(method_name: Symbol, args: T.untyped).returns(Field) }
+    def method_missing(method_name, *args)
+      field_name = method_name.to_s.downcase.to_sym
+
+      if @fields.key?(field_name)
+        T.must(@fields[field_name])
+      else
+        available = @fields.keys.join(", ")
+        raise ValidationError, "Unknown field '#{field_name}' on table '#{@name}'. Available fields: #{available}"
+      end
+    end
+
+    sig { params(method_name: Symbol, include_private: T::Boolean).returns(T::Boolean) }
+    def respond_to_missing?(method_name, include_private = false)
+      field_name = method_name.to_s.downcase.to_sym
+      @fields.key?(field_name) || super
+    end
+
+    class TableBuilder
+      extend T::Sig
+
+      sig { params(table: Table).void }
+      def initialize(table)
+        @table = table
+      end
+
+      sig { params(name: Symbol, type: Symbol).returns(Field) }
+      def field(name, type)
+        field = Field.new(name, @table.name, type)
+        @table.instance_variable_get(:@fields)[name] = field
+      end
+    end
+  end
+end

data/lib/rooq/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Rooq
+  VERSION = "1.0.0"
+end

data/lib/rooq.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Rooq
+  class Error < StandardError; end
+  class SchemaError < Error; end
+  class ValidationError < Error; end
+end
+
+require_relative "rooq/version"
+require_relative "rooq/connection"
+require_relative "rooq/configuration"
+require_relative "rooq/expression"
+require_relative "rooq/field"
+require_relative "rooq/table"
+require_relative "rooq/condition"
+require_relative "rooq/dsl"
+require_relative "rooq/dialect"
+require_relative "rooq/generator"
+require_relative "rooq/result"
+require_relative "rooq/parameter_converter"
+require_relative "rooq/executor"
+require_relative "rooq/context"
+require_relative "rooq/schema_validator"
+require_relative "rooq/query_validator"
+require_relative "rooq/adapters"

data/rooq.gemspec

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "lib/rooq/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "rooq"
+  spec.version = Rooq::VERSION
+  spec.authors = ["Guillermo G. Almazor"]
+  spec.email = ["guille@galmazor.com"]
+
+  spec.summary = "A jOOQ-inspired query builder for Ruby"
+  spec.description = "Build type-safe SQL queries using a fluent, chainable API. Generate Ruby code from database schemas with optional Sorbet type annotations."
+  spec.homepage = "https://github.com/ggalmazor/rooq"
+  spec.license = "AGPL-3.0-only"
+  spec.required_ruby_version = ">= 3.4"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github .idea docs/])
+    end
+  end
+
+  spec.bindir = "exe"
+  spec.executables = ["rooq"]
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "pg", "~> 1.5"
+  spec.add_dependency "sorbet-runtime", "~> 0.5"
+end

data/sorbet/config

@@ -0,0 +1,4 @@
+--dir
+.
+--ignore=/tmp/
+--ignore=/vendor/bundle

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: rooq
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Guillermo G. Almazor
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: sorbet-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+description: Build type-safe SQL queries using a fluent, chainable API. Generate Ruby
+  code from database schemas with optional Sorbet type annotations.
+email:
+- guille@galmazor.com
+executables:
+- rooq
+extensions: []
+extra_rdoc_files: []
+files:
+- ".tool-versions"
+- ".yardopts"
+- CHANGELOG.md
+- CLAUDE.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- USAGE.md
+- exe/rooq
+- lib/rooq.rb
+- lib/rooq/adapters.rb
+- lib/rooq/adapters/postgresql.rb
+- lib/rooq/cli.rb
+- lib/rooq/condition.rb
+- lib/rooq/configuration.rb
+- lib/rooq/connection.rb
+- lib/rooq/context.rb
+- lib/rooq/dialect.rb
+- lib/rooq/dialect/base.rb
+- lib/rooq/dialect/postgresql.rb
+- lib/rooq/dsl.rb
+- lib/rooq/dsl/delete_query.rb
+- lib/rooq/dsl/insert_query.rb
+- lib/rooq/dsl/select_query.rb
+- lib/rooq/dsl/update_query.rb
+- lib/rooq/executor.rb
+- lib/rooq/expression.rb
+- lib/rooq/field.rb
+- lib/rooq/generator.rb
+- lib/rooq/generator/code_generator.rb
+- lib/rooq/generator/introspector.rb
+- lib/rooq/parameter_converter.rb
+- lib/rooq/query_validator.rb
+- lib/rooq/result.rb
+- lib/rooq/schema_validator.rb
+- lib/rooq/table.rb
+- lib/rooq/version.rb
+- rooq.gemspec
+- sorbet/config
+homepage: https://github.com/ggalmazor/rooq
+licenses:
+- AGPL-3.0-only
+metadata:
+  homepage_uri: https://github.com/ggalmazor/rooq
+  source_code_uri: https://github.com/ggalmazor/rooq
+  changelog_uri: https://github.com/ggalmazor/rooq/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: A jOOQ-inspired query builder for Ruby
+test_files: []