foobara-postgresql-crud-driver 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6846188257d6cad52ea962972ddd82f82d72162ea0a46df18983a92bb3c2b444
-  data.tar.gz: 349cb1d585f814335f083ed9cb5105a42bb9e9b10a8a8e5f9fa6444b3670dcfd
+  metadata.gz: 9da1f2e3a8d5170f4badb5d1ec0eeb8b6f443da56ce17b4b97911767620ae099
+  data.tar.gz: b12f27eca628e62f38c7f8d2a1af415d1ab3c72006a18d17f983b4fbb03eea91
 SHA512:
-  metadata.gz: 516fede04188fb07fdb5b62be6400cdaf507c3d7b1ffc961ec5045591f9257c1bbeca2967dd21a12a6e96484690b30344422509e7a4ea5dc5724afab426223d0
-  data.tar.gz: 4cab91509e1450dceafe8bcd022f25f48af4d52906a0d9b5c4a86d75cb1520f5347bf96b4b3f76c09bbb9cdb053e9fd03d8009f77d931831db9e1cfb5c291efa
+  metadata.gz: d7d0d2d19bc3cd5d3c1625b7b4958b0f160f9c733bdac7adc3f39ec09010ddad3f7fe8ce02aa9a9d4c9c6a7bc8216a731c13d299209947cf7ebb8a327a35fdb6
+  data.tar.gz: 8f4c6fa9014c60caef166ecdff36a22e7d87543276d36604da42ec8f7e95ff421547256e1d4e58b02f7ac789c5e5070b3f5fe0b3ec500406a1780fec49426fc7

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [0.0.5] - 2025-11-10
+
+- Improve error messages for foobara type/pg column incompatibilities
+- Validate strings used as integers represent valid integers
+
+## [0.0.4] - 2025-11-09
+
+- Support a few more column types
+- Make sure an entity -> entity association is cast properly
+
 ## [0.0.3] - 2025-10-21
 
 - Pass through options to EntityAttributesCrudDriver instead of disallowing them

data/src/postgresql_crud_driver.rb

@@ -4,6 +4,18 @@ module Foobara
     class NoSuchColumnOrTableError < StandardError; end
 
     class UnsupportedPgColumnTypeError < StandardError
+      attr_accessor :pg_type, :attribute_name, :entity_class
+
+      def initialize(pg_type, entity_class)
+        # :nocov:
+        super("Unsupported column type #{pg_type} on #{entity_class.entity_name}")
+        # :nocov:
+      end
+    end
+
+    class UnsupportedPgColumnTypeForAttributeError < StandardError
+      attr_accessor :pg_type, :attribute_name, :entity_class
+
       def initialize(pg_type, attribute_name, entity_class)
         # :nocov:
         super("Unsupported column type #{pg_type} for attribute #{attribute_name} on #{entity_class.entity_name}")
@@ -11,12 +23,29 @@ module Foobara
       end
     end
 
+    class ColumnTypeMismatchError < StandardError
+      attr_accessor :pg_type, :foobara_type, :entity_class, :attribute_name
+
+      def initialize(pg_type:, foobara_type:, entity_class:, attribute_name: nil)
+        # TODO: figure out a way to test this code path
+        # :nocov:
+        self.pg_type = pg_type
+        self.foobara_type = foobara_type
+        self.entity_class = entity_class
+        self.attribute_name = attribute_name
+
+        super("Column type mismatch between foobara #{foobara_type.type_symbol} " \
+              "and postgres #{pg_type} for #{entity_class.entity_name}.#{attribute_name}")
+        # :nocov:
+      end
+    end
+
     class << self
       def get_transaction_number
         @get_transaction_number ||= 0
         @get_transaction_number += 1
         if @get_transaction_number > 65_535
-          # TODO: test this codepath somehow
+          # TODO: test this code path somehow
           # :nocov:
           @get_transaction_number = 1
           # :nocov:
@@ -225,6 +254,7 @@ module Foobara
         SQL
 
         raw_connection.exec(sql)
+
         find(record_id)
       end
 
@@ -267,9 +297,11 @@ module Foobara
           info = column_info[attribute_name.to_s]
 
           value = case info[:type]
-                  when "integer", "text", "timestamp without time zone"
+                  when "integer", "bigint",
+                       "text", "character varying",
+                       "timestamp without time zone"
                     value
-                  when "jsonb"
+                  when "jsonb", "json"
                     if value.nil?
                       unless info[:is_nullable]
                         # :nocov:
@@ -306,79 +338,20 @@ module Foobara
           # :nocov:
         end
 
-        pg_type = info[:type]
         foobara_type = entity_class.model_type.element_types.element_types[attribute_name]
 
-        value = if value.nil?
-                  if info[:is_nullable]
-                    "NULL"
-                  else
-                    # :nocov:
-                    raise "Unexpected nil value for #{attribute_name}"
-                    # :nocov:
-                  end
-                elsif foobara_type.extends?(:number)
-                  case pg_type
-                  when "integer"
-                    value.to_i
-                  else
-                    # :nocov:
-                    raise UnsupportedPgColumnTypeError.new(pg_type, attribute_name, entity_class)
-                    # :nocov:
-                  end
-                elsif foobara_type.extends?(:string) || foobara_type.extends?(:symbol)
-                  case pg_type
-                  when "text"
-                    "'#{PG::Connection.escape(value.to_s)}'"
-                  else
-                    # :nocov:
-                    raise UnsupportedPgColumnTypeError.new(pg_type, attribute_name, entity_class)
-                    # :nocov:
-                  end
-                elsif foobara_type.extends?(:datetime)
-                  case pg_type
-                  when "timestamp without time zone"
-                    "'#{PG::Connection.escape(value.inspect)}'"
-                  else
-                    # :nocov:
-                    raise UnsupportedPgColumnTypeError.new(pg_type, attribute_name, entity_class)
-                    # :nocov:
-                  end
-                elsif foobara_type.extends?(:model) || foobara_type.extends?(:attributes)
-                  case pg_type
-                  when "jsonb"
-                    "'#{PG::Connection.escape(JSON.fast_generate(value))}'"
-                  else
-                    # :nocov:
-                    raise UnsupportedPgColumnTypeError.new(pg_type, attribute_name, entity_class)
-                    # :nocov:
-                  end
-                elsif foobara_type.extends?(:array)
-                  element_type = foobara_type.element_type
-
-                  if element_type.extends?(:detached_entity)
-                    case pg_type
-                    when "ARRAY"
-                      elements_type = ARRAY_ELEMENT_ENCODERS[info[:element_type]]
-                      array_string = PG::TextEncoder::Array.new(elements_type:).encode(value)
-                      escaped = PG::Connection.escape(array_string)
-
-                      "'#{escaped}'"
-                    else
-                      # :nocov:
-                      raise UnsupportedPgColumnTypeError.new(pg_type, attribute_name, entity_class)
-                      # :nocov:
-                    end
-                  else
-                    # :nocov:
-                    raise UnsupportedPgColumnTypeError.new(pg_type, attribute_name, entity_class)
-                    # :nocov:
-                  end
-                else
-                  # :nocov:
-                  raise UnsupportedPgColumnTypeError.new(pg_type, attribute_name, entity_class)
-                  # :nocov:
-                end
+        value = begin
+          check_type_compatibility!(foobara_type, info, attribute_name:)
+          pg_cast_value(value, foobara_type, info)
+        rescue UnsupportedPgColumnTypeError => e
+          # :nocov:
+          raise UnsupportedPgColumnTypeForAttributeError.new(
+            e.pg_type,
+            attribute_name,
+            entity_class
+          )
+          # :nocov:
+        end
 
         [PostgresqlCrudDriver.escape_identifier(attribute_name), value]
       end
@@ -406,6 +379,107 @@ module Foobara
           ]
         end
       end
+
+      def pg_cast_value(value, foobara_type, pg_info)
+        pg_type = pg_info[:type]
+
+        if value.nil?
+          if pg_info[:is_nullable]
+            "NULL"
+          else
+            # :nocov:
+            raise "Unexpected nil value for #{attribute_name}"
+            # :nocov:
+          end
+        elsif foobara_type.extends?(:number)
+          validate_intable!(value)
+          value.to_i
+        elsif foobara_type.extends?(:string) || foobara_type.extends?(:symbol)
+          "'#{PG::Connection.escape(value.to_s)}'"
+        elsif foobara_type.extends?(:datetime)
+          "'#{PG::Connection.escape(value.inspect)}'"
+        elsif foobara_type.extends?(:detached_entity)
+          pg_cast_value(value, foobara_type.target_class.primary_key_type, pg_info)
+        elsif foobara_type.extends?(:model) || foobara_type.extends?(:attributes) ||
+              foobara_type == BuiltinTypes[:duck]
+          "'#{PG::Connection.escape(JSON.fast_generate(value))}'"
+        elsif foobara_type.extends?(:array)
+          element_type = foobara_type.element_type
+
+          if element_type.extends?(:detached_entity)
+            if element_type.target_class.primary_key_type.extends?(:integer)
+              value.each { validate_intable!(it) }
+            end
+            elements_type = ARRAY_ELEMENT_ENCODERS[pg_info[:element_type]]
+            array_string = PG::TextEncoder::Array.new(elements_type:).encode(value)
+            escaped = PG::Connection.escape(array_string)
+
+            "'#{escaped}'"
+          else
+            # :nocov:
+            raise UnsupportedPgColumnTypeError.new(pg_type, entity_class)
+            # :nocov:
+          end
+        else
+          # :nocov:
+          raise UnsupportedPgColumnTypeError.new(pg_type, entity_class)
+          # :nocov:
+        end
+      end
+
+      def validate_intable!(value)
+        if value.is_a?(::String) || value.is_a?(::Symbol)
+          unless value =~ /\A[+-]?\d+\z/
+            # :nocov:
+            raise "Expected something that could be cast to an integer but got #{value}"
+            # :nocov:
+          end
+        end
+      end
+
+      def check_type_compatibility!(foobara_type, pg_info, pg_type: pg_info[:type], attribute_name: nil)
+        if foobara_type.extends?(:integer)
+          unless pg_type == "integer" || pg_type == "bigint" || pg_type == "_int4"
+            # :nocov:
+            raise ColumnTypeMismatchError.new(pg_type:, foobara_type:, attribute_name:, entity_class:)
+            # :nocov:
+          end
+        elsif foobara_type.extends?(:string) || foobara_type.extends?(:symbol)
+          unless pg_type == "text" || pg_type == "character varying"
+            # :nocov:
+            raise ColumnTypeMismatchError.new(pg_type:, foobara_type:, attribute_name:, entity_class:)
+            # :nocov:
+          end
+        elsif foobara_type.extends?(:datetime)
+          unless pg_type == "timestamp without time zone"
+            # :nocov:
+            raise ColumnTypeMismatchError.new(pg_type:, foobara_type:, attribute_name:, entity_class:)
+            # :nocov:
+          end
+        elsif foobara_type.extends?(:detached_entity)
+          check_type_compatibility!(foobara_type.target_class.primary_key_type, pg_info, pg_type:, attribute_name:)
+        elsif foobara_type.extends?(:model) || foobara_type.extends?(:attributes) ||
+              foobara_type == BuiltinTypes[:duck]
+          unless pg_type == "jsonb" || pg_type == "json"
+            # :nocov:
+            raise ColumnTypeMismatchError.new(pg_type:, foobara_type:, attribute_name:, entity_class:)
+            # :nocov:
+          end
+        elsif foobara_type.extends?(:array)
+          if pg_type == "ARRAY"
+            element_type = foobara_type.element_type
+            check_type_compatibility!(element_type, pg_info, pg_type: pg_info[:element_type], attribute_name:)
+            # :nocov:
+          elsif pg_type != json && pg_type != jsonb
+            raise ColumnTypeMismatchError.new(pg_type:, foobara_type:, attribute_name:, entity_class:)
+            # :nocov:
+          end
+        else
+          # :nocov:
+          raise UnsupportedPgColumnTypeError.new(pg_type, entity_class)
+          # :nocov:
+        end
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foobara-postgresql-crud-driver
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - Miles Georgi