kweerie 0.1.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b47a2f9363e6fb03e19af88b8d34ab9d727e45e2ed7f05e95d41d23835f93693
-  data.tar.gz: cb868fa5858008ce6e2ec14188e81c41fb0ad554e85e491b71ebe625d357257e
+  metadata.gz: 8ee037d0d27c788d915bb3a17c5cdc9fb4dc00dd172ae8f32023df00fd70515d
+  data.tar.gz: '0950c053e7d14f261923f74c5987fa177fa6ffb1f9b2e8213e132f411722d877'
 SHA512:
-  metadata.gz: 3f9927adf42ec5fed6e65ea6c5a83a3166ea10ccadbe9d802a2d2bb6cc02647365df44865052566a6b255fa8dbb91be74f406a0fc61993982589222b2724724a
-  data.tar.gz: '08acf2f917e887a25e0c22aebd493aa861c1bc0fa827e80983ee577f352d1048efabb2285b152cb1d141ccf8846e34071828f4b77960d0b1b51909fb279fcd85'
+  metadata.gz: 75e8dee13094014cefe169804ee050424fe0a946b8055d7f92423a819d578c375817bc580ae1b57b658d513786efc3fa731d3dad3fde3b022ec95cafa2701264
+  data.tar.gz: 8c7066bd2b2d1b2812889c116518d87be3b4868e57443fd54bc67b6980772999c4db8b853e98453331d364caf289ec8005c5ebf3d619ab2330d2b8dab781f7a0

data/.rubocop.yml

@@ -41,3 +41,6 @@ Gemspec/RequiredRubyVersion:
 
 Metrics/BlockLength: 
   Enabled: false
+
+Naming/AccessorMethodName:
+  Enabled: false

data/CHANGELOG.md

@@ -1,4 +1,14 @@
-## [Unreleased]
+## [0.3.0] - 2024-11-21
+
+- changed sql_paths to default_path.
+- fixed generate to handle defined path
+
+## [0.2.0] - 2024-11-12
+
+- changed BaseObjects to BaseObject.
+- remove automatic type inference.
+- added cast_select.
+- added tiny amound of custom types.
 
 ## [0.1.0] - 2024-11-06
 

data/README.md

@@ -55,10 +55,10 @@ results = UserSearch.with(
 
 ### Object Mapping
 
-While `Kweerie::Base` returns plain hashes, you can use `Kweerie::BaseObjects` to get typed Ruby objects with proper attribute methods:
+While `Kweerie::Base` returns plain hashes, you can use `Kweerie::BaseObject` to get typed Ruby objects with proper attribute methods:
 
 ```ruby
-class UserSearch < Kweerie::BaseObjects
+class UserSearch < Kweerie::BaseObject
   bind :name, as: '$1'
   bind :created_at, as: '$2'
 end
@@ -148,7 +148,7 @@ UsersByStatus.all                    # ✗ Raises ArgumentError
 UsersByStatus.with(status: 'active') # ✓ Correct usage
 ```
 
-Both methods work with `Kweerie::Base` and `Kweerie::BaseObjects`, returning arrays of hashes or objects respectively:
+Both methods work with `Kweerie::Base` and `Kweerie::BaseObject`, returning arrays of hashes or objects respectively:
 
 ```ruby
 # Returns array of hashes
@@ -158,65 +158,15 @@ users = AllUsers.all
 # => [{"id" => 1, "name" => "Eclipsoid"}, ...]
 
 # Returns array of objects
-class AllUsers < Kweerie::BaseObjects
+class AllUsers < Kweerie::BaseObject
 end
 users = AllUsers.all
 # => [#<AllUsers id=1 name="Eclipsoid">, ...]
 ```
 
-### Automatic Type Casting
-
-BaseObjects automatically casts common PostgreSQL types to their Ruby equivalents:
-
-```ruby
-# In your SQL file
-SELECT 
-  name,
-  created_at,                    -- timestamp
-  age::integer,                  -- integer
-  score::float,                  -- float
-  active::boolean,               -- boolean
-  metadata::jsonb,               -- jsonb
-  tags::jsonb                    -- jsonb array
-FROM users;
-
-# In your Ruby code
-user = UserSearch.with(name: 'Eclipsoid').first
-
-user.created_at   # => Time object
-user.age          # => Integer
-user.score        # => Float
-user.active       # => true/false
-user.metadata     # => Hash with string keys
-user.tags         # => Array
-
-# Nested JSONB data is properly accessible
-user.metadata["role"]                    # => "admin"
-user.metadata["preferences"]["theme"]    # => "dark"
-```
-
-### Pattern Matching Support
-
-BaseObjects support Ruby's pattern matching syntax:
-
-```ruby
-case user
-in { name:, metadata: { role: "admin" } }
-  puts "Admin user: #{name}"
-in { name:, metadata: { role: "user" } }
-  puts "Regular user: #{name}"
-end
-
-# Nested pattern matching
-case user
-in { metadata: { preferences: { theme: "dark" } } }
-  puts "Dark theme user"
-end
-```
-
 ### Object Interface
 
-BaseObjects provide several useful methods:
+BaseObject provide several useful methods:
 
 ```ruby
 # Hash-like access
@@ -230,31 +180,6 @@ user.to_json                   # => JSON string
 # Comparison
 user1 == user2                 # Compare all attributes
 users.sort_by(&:created_at)    # Sortable
-
-# Change tracking
-user.changed?                  # => Check if any attributes changed
-user.changes                   # => Hash of changes with [old, new] values
-user.original_attributes       # => Original attributes from DB
-```
-
-### PostgreSQL Array Support
-
-BaseObjects handles PostgreSQL arrays by converting them to Ruby arrays with proper type casting:
-
-```ruby
-# In your PostgreSQL schema
-create_table :users do |t|
-  t.integer :preferred_ordering, array: true, default: []
-  t.string :tags, array: true
-  t.float :scores, array: true
-end
-
-# In your query
-user = UserSearch.with(name: 'Eclipsoid').first
-
-user.preferred_ordering  # => [1, 3, 2]
-user.tags                 # => ["ruby", "rails"]
-user.scores              # => [98.5, 87.2, 92.0]
 ```
 
 ### SQL File Location
@@ -282,9 +207,90 @@ class UserSearch < Kweerie::Base
 end
 ```
 
+## Type Casting
+
+`cast_select` provides flexible, explicit type casting for your query result fields. Instead of relying on automatic type inference, you can specify exactly how each field should be cast. By default it will return as the string from the database.
+
+### Basic Usage
+
+```ruby
+class UserQuery < Kweerie::BaseObjects
+  cast_select :age, as: ->(val) { val.to_i }
+  cast_select :active, as: Types::Boolean
+  cast_select :metadata, as: Types::PgJsonb
+end
+```
+
+### Casting Options
+
+#### Built-in Type Classes
+The gem includes a few built-in type classes for specific scenarios, you'll find a comprehensive amount of them in rails:
+
+```ruby
+# Boolean casting (handles various boolean representations)
+cast_select :active, as: Types::Boolean
+
+# JSONB casting (handles both objects and arrays)
+cast_select :metadata, as: Types::PgJsonb
+
+# Postgres Array casting
+cast_select :tags, as: Types::PgArray
+```
+
+#### Lambda/Proc Casting
+For simple transformations, you can use a lambda or proc:
+
+```ruby
+class ProductQuery < Kweerie::BaseObjects
+  cast_select :price, as: ->(val) { val.to_f }
+  cast_select :quantity, as: ->(val) { val.to_i }
+  cast_select :sku, as: ->(val) { val.upcase }
+end
+```
+
+#### Method Reference Casting
+You can reference an instance method for complex casting logic:
+
+```ruby
+class OrderQuery < Kweerie::BaseObjects
+  cast_select :total, as: :calculate_total
+  
+  def calculate_total(val)
+    return if val.nil?
+
+    Money.new(val)
+  end
+end
+```
+
+### Custom Type Classes
+
+For reusable, complex casting logic, you can create custom type classes, or use the ones provided by rails:
+
+```ruby
+class Types::Money
+  def cast(value)
+    return nil if value.nil?
+
+    (value.to_f * 100).to_i # Store as cents
+  end
+end
+
+class Types::PGIntArray < Types::PgArray
+  def cast(value)
+    super.map(&:to_i)  # Convert array elements to integers
+  end
+end
+
+class InvoiceQuery < Kweerie::BaseObjects
+  cast_select :amount, as: Types::Money
+  cast_select :line_items, as: Types::PGIntArray
+end
+```
+
 ### Performance Considerations
 
-BaseObjects creates a unique class for each query result set, with the following optimizations:
+BaseObject creates a unique class for each query result set, with the following optimizations:
 
 - Classes are cached and reused for subsequent queries
 - Attribute readers are defined upfront
@@ -318,16 +324,16 @@ Kweerie.configure do |config|
   # Use a custom connection provider
   config.connection_provider = -> { MyCustomConnectionPool.connection }
   
-  # Configure where to look for SQL files
-  config.sql_paths = -> { ['db/queries', 'app/sql'] }
+  # Configure where to look for SQL files. Generator also uses this path
+  config.default_path = 'app/sql'
 end
 ```
 
 ## Requirements
 
-- Ruby 2.7 or higher
+- Ruby 3 or higher
 - PostgreSQL (this gem is PostgreSQL-specific and uses the `pg` gem)
-- Rails 6+ (optional, needed for the generator and default ActiveRecord integration)
+- Rails 7+ (optional, needed for the generator and default ActiveRecord integration)
 
 ## Features
 

data/lib/generators/kweerie/kweerie_generator.rb

@@ -25,10 +25,10 @@ class KweerieGenerator < Rails::Generators::NamedBase
     FileUtils.mkdir_p("app/queries")
 
     # Create the Ruby file
-    create_file "app/queries/#{file_name}.rb", template_content
+    create_file "#{default_path}/#{file_name}.rb", template_content
 
     # Create the SQL file
-    create_file "app/queries/#{file_name}.sql", <<~SQL
+    create_file "#{default_path}/#{file_name}.sql", <<~SQL
       -- Write your SQL query here
       -- Available parameters: #{parameters.map { |p| "$#{parameters.index(p) + 1} (#{p})" }.join(", ")}
 
@@ -50,4 +50,8 @@ class KweerieGenerator < Rails::Generators::NamedBase
   def class_name
     name.classify
   end
+
+  def default_path
+    Kweerie.configuration.default_path
+  end
 end

data/lib/kweerie/base.rb

@@ -100,40 +100,7 @@ module Kweerie
       end
 
       def sql_path
-        @sql_path ||=
-          if @sql_file_location&.key?(:root)
-            raise ConfigurationError, "Root path requires Rails to be defined" unless defined?(Rails)
-
-            path = Rails.root.join(@sql_file_location[:root]).to_s
-            raise SQLFileNotFound, "Could not find SQL file at #{path}" unless File.exist?(path)
-
-            path
-
-          elsif @sql_file_location&.key?(:relative)
-            configured_paths = Kweerie.configuration.sql_paths.call
-            sql_file = configured_paths.map do |path|
-              full_path = File.join(path, @sql_file_location[:relative])
-              full_path if File.exist?(full_path)
-            end.compact.first
-            unless sql_file
-              raise SQLFileNotFound,
-                    "Could not find SQL file #{@sql_file_location[:relative]}"
-            end
-
-            sql_file
-          else # default behavior
-            sql_filename = "#{name.underscore}.sql"
-            configured_paths = Kweerie.configuration.sql_paths.call
-
-            sql_file = configured_paths.map do |path|
-              full_path = File.join(path, sql_filename)
-              full_path if File.exist?(full_path)
-            end.compact.first
-
-            raise SQLFileNotFound, "SQL file not found for #{name}" unless sql_file
-
-            sql_file
-          end
+        @sql_path ||= SQLPathResolver.new(@sql_file_location, name).resolve
       end
 
       def sql_content
@@ -151,7 +118,7 @@ module Kweerie
       #
       # === Returns
       #
-      # Array of hashes representing the query results. When using Kweerie::BaseObjects,
+      # Array of hashes representing the query results. When using Kweerie::BaseObject,
       # returns array of typed objects instead.
       #
       # === Examples
@@ -163,7 +130,7 @@ module Kweerie
       #   )
       #   # => [{"id"=>1, "name"=>"Eclipsoid", "email"=>"eclipsoid@example.com"}]
       #
-      #   # With type casting (BaseObjects)
+      #   # With type casting (BaseObject)
       #   UserSearch.with(created_after: '2024-01-01')
       #   # => [#<UserSearch id=1 created_at=2024-01-01 00:00:00 +0000>]
       #
@@ -205,15 +172,6 @@ module Kweerie
         ordered_params = bindings.transform_values { |position| params[bindings.key(position)] }
         ordered_params.values
       end
-
-      def root_path
-        defined?(Rails) ? Rails.root : Dir.pwd
-      end
-
-      def using_activerecord?
-        defined?(ActiveRecord::Base) &&
-          Kweerie.configuration.connection_provider == Kweerie::Configuration.new.connection_provider
-      end
     end
   end
 end

data/lib/kweerie/base_object.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "object_methods/accessors"
+require_relative "object_methods/comparison"
+require_relative "object_methods/key_transformation"
+require_relative "object_methods/serialization"
+require_relative "object_methods/type_casting"
+
+module Kweerie
+  class BaseObject < Base
+    class << self
+      def with(params = {})
+        results = super
+        return [] if results.empty?
+
+        # Create a unique result class for this query
+        result_class = generate(results.first.keys)
+        # Map results to objects
+        results.map { |row| result_class.new(row) }
+      end
+
+      def cast_select(field, as: nil)
+        cast_definitions[field] = as if as
+      end
+
+      def cast_definitions
+        @cast_definitions ||= {}
+      end
+
+      def generate(attribute_names)
+        cast_definitions = self.cast_definitions
+        Class.new(self) do
+          include Comparable
+          include ObjectMethods::Accessors
+          include ObjectMethods::Comparison
+          include ObjectMethods::KeyTransformation
+          include ObjectMethods::Serialization
+          include ObjectMethods::TypeCasting
+
+          # Define attr_readers for all columns
+          attribute_names.each { |name| attr_reader name }
+
+          define_method :initialize do |attrs|
+            # Store both raw and casted versions
+            @_raw_original_attributes = attrs.dup
+            @_original_attributes = attrs.each_with_object({}) do |(key, value), hash|
+              type_definition = cast_definitions[key.to_sym]
+              casted_value = type_cast_value(value, type_definition)
+              hash[key.to_s] = casted_value
+              instance_variable_set("@#{key}", casted_value)
+            end
+
+            super() if defined?(super)
+          end
+
+          # Nice inspect output
+          define_method :inspect do
+            attrs = attribute_names.map do |name|
+              "#{name}=#{instance_variable_get("@#{name}").inspect}"
+            end.join(" ")
+            "#<#{self.class.superclass.name} #{attrs}>"
+          end
+
+          # Make attribute_names available to instance methods
+          define_method(:attribute_names) { attribute_names }
+        end
+      end
+    end
+  end
+end

data/lib/kweerie/configuration.rb

@@ -2,7 +2,7 @@
 
 module Kweerie
   class Configuration
-    attr_accessor :connection_provider, :sql_paths
+    attr_accessor :connection_provider, :sql_paths, :default_path
 
     def initialize
       # Default to using ActiveRecord's connection if available
@@ -20,6 +20,8 @@ module Kweerie
         paths.unshift("lib/queries") unless defined?(Rails)
         paths
       }
+
+      @default_path = defined?(Rails) ? "app/queries" : "lib/queries"
     end
   end
 end

data/lib/kweerie/object_methods/accessors.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ObjectMethods
+  module Accessors
+    def [](key)
+      instance_variable_get("@#{key}")
+    end
+
+    def fetch(key, default = nil)
+      instance_variable_defined?("@#{key}") ? instance_variable_get("@#{key}") : default
+    end
+
+    def original_attributes
+      @_original_attributes
+    end
+
+    def raw_original_attributes
+      @_raw_original_attributes
+    end
+  end
+end

data/lib/kweerie/object_methods/comparison.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ObjectMethods
+  module Comparison
+    def <=>(other)
+      return nil unless other.is_a?(self.class)
+
+      to_h <=> other.to_h
+    end
+
+    def ==(other)
+      return false unless other.is_a?(self.class)
+
+      to_h == other.to_h
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      to_h.hash
+    end
+  end
+end

data/lib/kweerie/object_methods/key_transformation.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ObjectMethods
+  module KeyTransformation
+    def deep_stringify_keys(obj)
+      case obj
+      when Hash
+        obj.transform_keys(&:to_s)
+           .transform_values { |v| deep_stringify_keys(v) }
+      when Array
+        obj.map { |item| item.is_a?(Hash) ? deep_stringify_keys(item) : item }
+      else
+        obj
+      end
+    end
+
+    def deep_symbolize_keys(obj)
+      case obj
+      when Hash
+        obj.transform_keys(&:to_sym)
+           .transform_values { |v| deep_symbolize_keys(v) }
+      when Array
+        obj.map { |item| item.is_a?(Hash) ? deep_symbolize_keys(item) : item }
+      else
+        obj
+      end
+    end
+  end
+end

data/lib/kweerie/object_methods/serialization.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ObjectMethods
+  module Serialization
+    def to_h
+      attribute_names.each_with_object({}) do |name, hash|
+        value = instance_variable_get("@#{name}")
+        hash[name.to_s] = serialize_value(value)
+      end
+    end
+
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
+
+    def deconstruct_keys(keys)
+      symbolized = deep_symbolize_keys(to_h)
+      keys ? symbolized.slice(*keys) : symbolized
+    end
+
+    private
+
+    def serialize_value(value)
+      value.is_a?(Hash) ? deep_stringify_keys(value) : value
+    end
+  end
+end

data/lib/kweerie/object_methods/type_casting.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ObjectMethods
+  module TypeCasting
+    def type_cast_value(value, type_definition)
+      return value if type_definition.nil?
+
+      case type_definition
+      when Symbol
+        public_send(type_definition, value)
+      when Proc
+        type_definition.call(value)
+      when Class
+        type_definition.new.cast(value)
+      else
+        raise ArgumentError, "Unsupported type definition: #{type_definition}"
+      end
+    end
+  end
+end

data/lib/kweerie/sql_path_resolver.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+class SQLPathResolver
+  class ConfigurationError < StandardError; end
+  class SQLFileNotFound < StandardError; end
+
+  def initialize(sql_file_location, name = nil)
+    @sql_file_location = sql_file_location
+    @name = name
+  end
+
+  def resolve
+    return resolve_root_path if root_path?
+    return resolve_relative_path if relative_path?
+
+    resolve_default_path
+  end
+
+  private
+
+  attr_reader :sql_file_location, :name
+
+  def root_path?
+    sql_file_location&.key?(:root)
+  end
+
+  def relative_path?
+    sql_file_location&.key?(:relative)
+  end
+
+  def resolve_root_path
+    raise ConfigurationError, "Root path requires Rails to be defined" unless defined?(Rails)
+
+    path = Rails.root.join(sql_file_location[:root]).to_s
+    validate_file_exists!(path)
+    path
+  end
+
+  def resolve_relative_path
+    relative_file = sql_file_location[:relative]
+    find_in_configured_paths(relative_file) or
+      raise SQLFileNotFound, "Could not find SQL file #{relative_file}"
+  end
+
+  def resolve_default_path
+    raise ArgumentError, "Name must be provided for default path resolution" unless name
+
+    sql_filename = "#{name.underscore}.sql"
+    find_in_configured_paths(sql_filename) or
+      raise SQLFileNotFound, "SQL file not found for #{name}"
+  end
+
+  def find_in_configured_paths(filename)
+    full_path = File.join(path, filename)
+
+    full_path if File.exist?(full_path)
+  end
+
+  def path
+    Kweerie.configuration.default_path
+  end
+
+  def validate_file_exists!(path)
+    raise SQLFileNotFound, "Could not find SQL file at #{path}" unless File.exist?(path)
+  end
+end

data/lib/kweerie/types/boolean.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Types
+  class Boolean
+    TRUTHY = [true, 1, "1", "t", "T", "true", "TRUE"].freeze
+    FALSEY = [false, 0, "0", "f", "F", "false", "FALSE"].freeze
+
+    def cast(value)
+      return nil if value.nil?
+      return value if value.is_a?(Boolean)
+
+      if TRUTHY.include?(value)
+        true
+      elsif FALSEY.include?(value)
+        false
+      else
+        raise ArgumentError, "Invalid boolean value: #{value}"
+      end
+    end
+  end
+end

data/lib/kweerie/types/pg_array.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Types
+  class PgArray
+    def cast(value)
+      clean_value = value.gsub(/^{|}$/, "")
+      return [] if clean_value.empty?
+
+      elements = clean_value.split(/,(?=(?:[^"]*"[^"]*")*[^"]*$)/)
+      elements.map { |element| cast_array_element(element) }
+    end
+
+    def cast_array_element(element)
+      case element
+      when /^\d+$/ then element.to_i
+      when /^\d*\.\d+$/          then element.to_f
+      when /^(true|false)$/i     then element.downcase == "true"
+      when /^"(.*)"$/            then ::Regexp.last_match(1)
+      else element
+      end
+    end
+  end
+end

data/lib/kweerie/types/pg_jsonb.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Types
+  class PgJsonb
+    def cast(value)
+      return {} if value.nil?
+      return value if value.is_a?(Hash)
+
+      JSON.parse(value.to_s)
+    rescue JSON::ParserError
+      raise ArgumentError, "Invalid JSON value: #{value}"
+    end
+  end
+end

data/lib/kweerie/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kweerie
-  VERSION = "0.1.5"
+  VERSION = "0.3.0"
 end

data/lib/kweerie.rb

@@ -26,4 +26,8 @@ end
 
 require_relative "kweerie/configuration"
 require_relative "kweerie/base"
-require_relative "kweerie/base_objects"
+require_relative "kweerie/base_object"
+require_relative "kweerie/sql_path_resolver"
+require_relative "kweerie/types/boolean"
+require_relative "kweerie/types/pg_array"
+require_relative "kweerie/types/pg_jsonb"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kweerie
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.3.0
 platform: ruby
 authors:
 - Toby
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-08 00:00:00.000000000 Z
+date: 2024-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -68,8 +68,17 @@ files:
 - lib/generators/kweerie/kweerie_generator.rb
 - lib/kweerie.rb
 - lib/kweerie/base.rb
-- lib/kweerie/base_objects.rb
+- lib/kweerie/base_object.rb
 - lib/kweerie/configuration.rb
+- lib/kweerie/object_methods/accessors.rb
+- lib/kweerie/object_methods/comparison.rb
+- lib/kweerie/object_methods/key_transformation.rb
+- lib/kweerie/object_methods/serialization.rb
+- lib/kweerie/object_methods/type_casting.rb
+- lib/kweerie/sql_path_resolver.rb
+- lib/kweerie/types/boolean.rb
+- lib/kweerie/types/pg_array.rb
+- lib/kweerie/types/pg_jsonb.rb
 - lib/kweerie/version.rb
 - sig/kweerie.rbs
 homepage: https://github.com/tobyond/kweerie

data/lib/kweerie/base_objects.rb

@@ -1,210 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/string"
-require "json"
-
-module Kweerie
-  class BaseObjects < Base
-    class << self
-      def with(params = {})
-        results = super
-        return [] if results.empty?
-
-        # Create a unique result class for this query
-        result_class = generate_result_class(results.first.keys)
-
-        # Map results to objects
-        results.map { |row| result_class.new(row) }
-      end
-
-      private
-
-      def generate_result_class(attribute_names)
-        @generate_result_class ||= Class.new(self) do
-          # Include comparison and serialization modules
-          include Comparable
-
-          # Define attr_readers for all columns
-          attribute_names.each do |name|
-            attr_reader name
-          end
-
-          define_method :initialize do |attrs|
-            # Store both raw and casted versions
-            @_raw_original_attributes = attrs.dup
-            @_original_attributes = attrs.transform_keys(&:to_s).transform_values do |value|
-              type_cast_value(value)
-            end
-
-            attrs.each do |name, value|
-              casted_value = type_cast_value(value)
-              instance_variable_set("@#{name}", casted_value)
-            end
-            super() if defined?(super)
-          end
-
-          define_method :type_cast_value do |value|
-            case value
-            when /^\d{4}-\d{2}-\d{2}( \d{2}:\d{2}:\d{2})?$/ # DateTime check
-              Time.parse(value)
-            when /^\d+$/ # Integer check
-              value.to_i
-            when /^\d*\.\d+$/ # Float check
-              value.to_f
-            when /^(true|false)$/i # Boolean check
-              value.downcase == "true"
-            when /^{.*}$/ # Could be PG array or JSON
-              if value.start_with?("{") && value.end_with?("}") && !value.include?('"=>') && !value.include?(": ")
-                # PostgreSQL array (simple heuristic: no "=>" or ":" suggests it's not JSON)
-                parse_pg_array(value)
-              else
-                # Attempt JSON parse
-                begin
-                  parsed = JSON.parse(value)
-                  deep_stringify_keys(parsed)
-                rescue JSON::ParserError
-                  value
-                end
-              end
-            when /^[\[{]/ # Pure JSON (arrays starting with [ or other JSON objects)
-              begin
-                parsed = JSON.parse(value)
-                deep_stringify_keys(parsed)
-              rescue JSON::ParserError
-                value
-              end
-            else
-              value
-            end
-          end
-
-          define_method :parse_pg_array do |value|
-            # Remove the curly braces
-            clean_value = value.gsub(/^{|}$/, "")
-            return [] if clean_value.empty?
-
-            # Split on comma, but not within quoted strings
-            elements = clean_value.split(/,(?=(?:[^"]*"[^"]*")*[^"]*$)/)
-
-            elements.map do |element|
-              case element
-              when /^\d+$/ # Integer
-                element.to_i
-              when /^\d*\.\d+$/ # Float
-                element.to_f
-              when /^(true|false)$/i # Boolean
-                element.downcase == "true"
-              when /^"(.*)"$/ # Quoted string
-                ::Regexp.last_match(1)
-              else
-                element
-              end
-            end
-          end
-
-          define_method :deep_symbolize_keys do |obj|
-            case obj
-            when Hash
-              obj.transform_keys(&:to_sym).transform_values { |v| deep_symbolize_keys(v) }
-            when Array
-              obj.map { |item| item.is_a?(Hash) ? deep_symbolize_keys(item) : item }
-            else
-              obj
-            end
-          end
-
-          # Nice inspect output
-          define_method :inspect do
-            attrs = attribute_names.map do |name|
-              "#{name}=#{instance_variable_get("@#{name}").inspect}"
-            end.join(" ")
-            "#<#{self.class.superclass.name} #{attrs}>"
-          end
-
-          # Hash-like access
-          define_method :[] do |key|
-            instance_variable_get("@#{key}")
-          end
-
-          define_method :fetch do |key, default = nil|
-            instance_variable_defined?("@#{key}") ? instance_variable_get("@#{key}") : default
-          end
-
-          # Comparison methods
-          define_method :<=> do |other|
-            return nil unless other.is_a?(self.class)
-
-            to_h <=> other.to_h
-          end
-
-          define_method :== do |other|
-            return false unless other.is_a?(self.class)
-
-            to_h == other.to_h
-          end
-
-          define_method :eql? do |other|
-            self == other
-          end
-
-          define_method :hash do
-            to_h.hash
-          end
-
-          # Add helper method for deep string keys
-          define_method :deep_stringify_keys do |obj|
-            case obj
-            when Hash
-              obj.transform_keys(&:to_s).transform_values { |v| deep_stringify_keys(v) }
-            when Array
-              obj.map { |item| item.is_a?(Hash) ? deep_stringify_keys(item) : item }
-            else
-              obj
-            end
-          end
-
-          # Serialization
-          define_method :to_h do
-            attribute_names.each_with_object({}) do |name, hash|
-              value = instance_variable_get("@#{name}")
-              # Ensure string keys in output
-              hash[name.to_s] = value.is_a?(Hash) ? deep_stringify_keys(value) : value
-            end
-          end
-
-          define_method :to_json do |*args|
-            to_h.to_json(*args)
-          end
-
-          # Pattern matching support (Ruby 2.7+)
-          define_method :deconstruct_keys do |keys|
-            symbolized = deep_symbolize_keys(to_h)
-            keys ? symbolized.slice(*keys) : symbolized
-          end
-
-          # Original attributes access
-          define_method :original_attributes do
-            @_original_attributes
-          end
-
-          # Raw attributes access
-          define_method :raw_original_attributes do
-            @_raw_original_attributes
-          end
-
-          # ActiveModel-like changes tracking
-          define_method :changed? do
-            to_h != @_original_attributes
-          end
-
-          define_method :changes do
-            to_h.each_with_object({}) do |(key, value), changes|
-              original = @_original_attributes[key]
-              changes[key] = [original, value] if original != value
-            end
-          end
-        end
-      end
-    end
-  end
-end