kweerie 0.1.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b47a2f9363e6fb03e19af88b8d34ab9d727e45e2ed7f05e95d41d23835f93693
-  data.tar.gz: cb868fa5858008ce6e2ec14188e81c41fb0ad554e85e491b71ebe625d357257e
+  metadata.gz: a1ca73e0c3e5890aa9805eed0b491c100be177b958fc9bab9592eaf4f2cdb0d0
+  data.tar.gz: b79729e675821e02c2ff02e3dfcdb8e5237230364790cc9e59e1d4a953ea8da6
 SHA512:
-  metadata.gz: 3f9927adf42ec5fed6e65ea6c5a83a3166ea10ccadbe9d802a2d2bb6cc02647365df44865052566a6b255fa8dbb91be74f406a0fc61993982589222b2724724a
-  data.tar.gz: '08acf2f917e887a25e0c22aebd493aa861c1bc0fa827e80983ee577f352d1048efabb2285b152cb1d141ccf8846e34071828f4b77960d0b1b51909fb279fcd85'
+  metadata.gz: 511ea093375cca24abbb8514a98b26cfb662239b836c3da7140aac4ef06ba7a23bf40074e1d9a973ac56a1cd02d1dd5dac486409968bed8f40b39312b6a8ac6d
+  data.tar.gz: abd8e02e09a00f3d4dd683c5e9e179386c053ed0c390d2f09a8c227866e39ff6303400766f2ff173eaf5d379e3bcad84840621a2fdde5b593c76e8643c72741a

data/.rubocop.yml

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

data/CHANGELOG.md

@@ -1,4 +1,10 @@
 ## [Unreleased]
+## [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
@@ -325,9 +331,9 @@ 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/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>]
       #

data/lib/kweerie/base_object.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string"
+require "json"
+
+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_result_class(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
+
+      private
+
+      def generate_result_class(attribute_names)
+        @generate_result_class ||= ResultClassGenerator.generate(self, attribute_names)
+      end
+    end
+  end
+end

data/lib/kweerie/result_class_components/accessors.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ResultClassComponents
+  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/result_class_components/comparison.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ResultClassComponents
+  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/result_class_components/key_transformation.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ResultClassComponents
+  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/result_class_components/serialization.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ResultClassComponents
+  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/result_class_components/type_casting.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ResultClassComponents
+  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/result_class_generator.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "result_class_components/accessors"
+require_relative "result_class_components/comparison"
+require_relative "result_class_components/key_transformation"
+require_relative "result_class_components/serialization"
+require_relative "result_class_components/type_casting"
+
+module Kweerie
+  class ResultClassGenerator
+    def self.generate(parent_class, attribute_names)
+      Class.new(parent_class) do
+        include Comparable
+        include ResultClassComponents::Accessors
+        include ResultClassComponents::Comparison
+        include ResultClassComponents::KeyTransformation
+        include ResultClassComponents::Serialization
+        include ResultClassComponents::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
+          cast_definitions = parent_class.cast_definitions
+
+          @_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

data/lib/kweerie/sql_path_resolver.rb

@@ -0,0 +1,67 @@
+# 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)
+    configured_paths.find do |path|
+      full_path = File.join(path, filename)
+      return full_path if File.exist?(full_path)
+    end
+  end
+
+  def configured_paths
+    Kweerie.configuration.sql_paths.call
+  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.2.0"
 end

data/lib/kweerie.rb

@@ -26,4 +26,9 @@ 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/result_class_generator"
+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.2.0
 platform: ruby
 authors:
 - Toby
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-08 00:00:00.000000000 Z
+date: 2024-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -68,8 +68,18 @@ 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/result_class_components/accessors.rb
+- lib/kweerie/result_class_components/comparison.rb
+- lib/kweerie/result_class_components/key_transformation.rb
+- lib/kweerie/result_class_components/serialization.rb
+- lib/kweerie/result_class_components/type_casting.rb
+- lib/kweerie/result_class_generator.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