torque-postgresql 4.1.0 → 4.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 386d035c1a009d6c67f130c50baa9e0db1c417aa79b6190834780855ca92d2ee
-  data.tar.gz: 468a10d17d4ac97b4e83914be5a539e1b2ca78cbb54ae35e9c80fbee41fda18f
+  metadata.gz: c79e4ae9bb15bd5111bdd7f99e93b2be6aeb8dbe8446005f1692b3d419a6a096
+  data.tar.gz: fc41a9e09f887d8d6d9dd3920e2bc3b2d51e3b17af48b76e875c37d7a37a992a
 SHA512:
-  metadata.gz: 503443151d99b82e2e76f1d6ed34b6a314e0b8cdd9cd576933879a7a807d33cecd926c48d3809a01fd785d8777d5ae0135c46fb0d9b4c4c347b4457e807cb6ba
-  data.tar.gz: a7bce5728938390a5bb285185c592dfcaf44f5322fb30b46fbc08ba5edeaf7a30d932177f91a685afa35153ff2ed8c5200edeb88058d571f2402f8c9a204b32e
+  metadata.gz: 7b98f253f6b1b47a1ed18a07e1850793b127847b144a0a75b61f3a96a439b6473117ab769f5a17db17820bd498a81d7adf06f73222c48020fff0b6505fa210e2
+  data.tar.gz: eeb9cbb8dfff58d3d3836e5e7f8199fbf77a7048b387dbde41de77a98ff1254784cf02f0c702d6513c4623b7724da8f70e1829e9d16be26fd0d6f55a9e8cd046

data/Rakefile

@@ -56,3 +56,31 @@ end
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 task default: :spec
+
+RBS_TEST_ENV = {
+  'RBS_TEST' => '1',
+  'RBS_TEST_TARGET' => 'Torque::PostgreSQL::*,Torque::Generators::*',
+  'RBS_TEST_SKIP' => '::Torque::PostgreSQL::Attributes::Lazy,::Torque::PostgreSQL::Adapter::OID::Range::Comparison',
+  'RBS_TEST_OPT' => '-I sig',
+  'RBS_TEST_LOGLEVEL' => ENV.fetch('RBS_TEST_LOGLEVEL', 'warn'),
+}.freeze
+
+namespace :rbs do
+  desc 'Install the third-party signatures listed in rbs_collection.yaml'
+  task :collection do
+    sh 'bundle', 'exec', 'rbs', 'collection', 'install'
+  end
+
+  desc 'Validate sig/ against the collection and the local stubs'
+  task validate: :collection do
+    sh 'bundle', 'exec', 'rbs', '-I', 'sig', 'validate', '--exit-error-on-syntax-error'
+  end
+
+  desc 'Run the spec suite with runtime type checking of every signature'
+  task test: :collection do
+    sh RBS_TEST_ENV, 'bundle', 'exec', 'rspec'
+  end
+end
+
+desc 'Validate the signatures and run the typed spec suite'
+task rbs: %w[rbs:validate rbs:test]

data/lib/generators/torque/skill_generator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'rails/generators/base'
+
+module Torque
+  module Generators
+    class SkillGenerator < Rails::Generators::Base
+      source_root File.expand_path('../../../skills', __dir__)
+
+      desc 'Copies the torque-postgresql agent skill into .claude/skills'
+
+      def copy_skill
+        directory 'torque-postgresql', '.claude/skills/torque-postgresql'
+      end
+    end
+  end
+end

data/lib/generators/torque/templates/trigger.sql.erb

@@ -0,0 +1,3 @@
+CREATE OR REPLACE TRIGGER <%= name %>
+  BEFORE INSERT ON table_name
+  FOR EACH ROW EXECUTE FUNCTION function_name();

data/lib/generators/torque/trigger_generator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'torque/postgresql/versioned_commands/generator'
+
+module Torque
+  module Generators
+    class TriggerGenerator < Rails::Generators::Base
+      include Torque::PostgreSQL::VersionedCommands::Generator
+
+      alias create_trigger_file create_migration_file
+    end
+  end
+end

data/lib/torque/postgresql/adapter/database_statements.rb

@@ -253,6 +253,15 @@ module Torque
                 WHERE 1=1 AND c.relkind IN ('v', 'm')
                   AND #{filter_by_schema.join(' AND ')};
               SQL
+            when :trigger
+              <<-SQL.squish
+                SELECT n.nspname AS schema, t.tgname AS name
+                FROM pg_trigger t
+                INNER JOIN pg_class c ON c.oid = t.tgrelid
+                INNER JOIN pg_namespace n ON n.oid = c.relnamespace
+                WHERE 1=1 AND NOT t.tgisinternal
+                  AND #{filter_by_schema.join(' AND ')};
+              SQL
             end
 
           select_rows(query, 'SCHEMA')

data/lib/torque/postgresql/adapter/oid/array.rb

@@ -11,10 +11,6 @@ module Torque
 
           private
 
-            # A label path is an Array of labels, so the regular recursion would
-            # take each of its labels as another dimension of the column. Paths
-            # are a single value to PostgreSQL, which means that the entries of
-            # the array are never a dimension of their own
             def type_cast_array(value, method)
               return super unless path_subtype?
               return subtype.public_send(method, value) unless value.is_a?(::Array)

data/lib/torque/postgresql/adapter/oid/composite.rb

@@ -13,8 +13,9 @@ module Torque
           attr_reader :name
 
           # The composite type behind the given type, if there is one, wrapped
-          # or not by an array
+          # or not by an array or a delegator
           def self.from(type)
+            type = OID.unwrap(type)
             type = type.subtype if type.is_a?(ARRAY)
             type if type.is_a?(self)
           end

data/lib/torque/postgresql/adapter/oid/enum.rb

@@ -60,7 +60,7 @@ module Torque
               return value if value.is_a?(@klass)
               @klass.new(value)
             rescue Attributes::Enum::EnumError
-              nil
+              value
             end
 
         end

data/lib/torque/postgresql/adapter/oid/enum_set.rb

@@ -42,8 +42,8 @@ module Torque
               return if value.blank?
               return value if value.is_a?(@klass)
               @klass.new(value)
-            rescue Attributes::EnumSet::EnumSetError
-              nil
+            rescue Attributes::Enum::EnumError
+              ::Array.wrap(value)
             end
 
         end

data/lib/torque/postgresql/adapter/oid/interval.rb

@@ -36,7 +36,7 @@ module Torque
               end
               parts_to_duration(parts.compact)
             when ::Array
-              value.compact!
+              value = value.compact
               parts = CAST_PARTS.drop(6 - value.size).zip(value).to_h
               parts_to_duration(parts)
             when ::Hash

data/lib/torque/postgresql/adapter/oid/lquery.rb

@@ -1,50 +1,67 @@
 # frozen_string_literal: true
 
+require_relative 'ltree'
+
 module Torque
   module PostgreSQL
     module Adapter
       module OID
-        class Lquery < ActiveModel::Type::Value
+        # Same as a path, but the items are the pure parts of a pattern: +:any+
+        # for a star, a Range for a quantified star and an Array for a group of
+        # alternatives. Everything else is a label, written as it appears in SQL
+        class Lquery < Ltree
+          STAR = /\A\*\{(?<min>\d+)?(?<comma>,)?(?<max>\d+)?\}\z/
 
           def type
             :lquery
           end
 
-          def cast(value)
-            return if value.blank?
-            return value if value.is_a?(LQuery)
+          private
 
-            LQuery.new(value)
-          end
+            def value_class
+              LQuery
+            end
 
-          def deserialize(value)
-            return if value.nil?
+            def items_of(entry, sanitize)
+              case entry
+              when ::Symbol then entry == :any ? [:any] : super
+              when ::Range then [entry]
+              when ::Array then [entry.flat_map { |item| items_of(item, sanitize) }]
+              else super
+              end
+            end
 
-            LQuery.load(value)
-          end
+            def compile(item)
+              case item
+              when ::Symbol then item == :any ? '*' : item.to_s
+              when ::Range then quantifier(item)
+              when ::Array then item.map { |entry| compile(entry) }.join('|')
+              else item.to_s
+              end
+            end
 
-          def serialize(value)
-            cast(value)&.to_s
-          end
+            def quantifier(range)
+              min = range.begin
+              max = range.end
+              max -= 1 if max && range.exclude_end?
 
-          def type_cast_for_schema(value)
-            cast(value).to_s.inspect
-          end
+              return '*' if min.nil? && max.nil?
+              return "*{#{min}}" if min == max
 
-          def changed_in_place?(raw_old_value, new_value)
-            raw_old_value != serialize(new_value)
-          end
+              "*{#{min},#{max}}"
+            end
 
-          # Types resolved through the type map are deduplicated and frozen, so
-          # they need to be comparable
-          def ==(other)
-            other.is_a?(self.class)
-          end
-          alias eql? ==
+            def parse(text)
+              return :any if text == '*'
+              return text.split('|') if text.include?('|') && !text.match?(/[!{]/)
 
-          def hash
-            self.class.hash
-          end
+              match = text.match(STAR)
+              return text if match.nil?
+
+              min = match[:min]&.to_i
+              max = match[:comma] ? match[:max]&.to_i : min
+              min..max
+            end
 
         end
       end

data/lib/torque/postgresql/adapter/oid/ltree.rb

@@ -4,6 +4,9 @@ module Torque
   module PostgreSQL
     module Adapter
       module OID
+        # Moves a label path between the shapes the gem accepts, its pure list
+        # of items and the text form PostgreSQL stores. Nothing is validated
+        # here, that is left to PostgreSQL
         class Ltree < ActiveModel::Type::Value
 
           def type
@@ -11,34 +14,37 @@ module Torque
           end
 
           def cast(value)
+            return value if value.is_a?(value_class)
             return if value.blank?
-            return value if value.is_a?(LTree)
 
-            LTree.new(value)
+            value_class.new(value)
+          end
+
+          def serialize(value)
+            path = cast(value)
+            path.map { |item| compile(item) }.join('.') unless path.nil?
           end
 
           def deserialize(value)
             return if value.nil?
 
-            LTree.load(value)
+            value_class.new(value, sanitize: false)
           end
 
-          def serialize(value)
-            cast(value)&.to_s
+          def items_for(value, sanitize: true)
+            ::Array.wrap(value).flat_map { |entry| items_of(entry, sanitize) }
           end
 
           def type_cast_for_schema(value)
-            cast(value).to_s.inspect
+            serialize(value).inspect
           end
 
           def changed_in_place?(raw_old_value, new_value)
             raw_old_value != serialize(new_value)
           end
 
-          # Types resolved through the type map are deduplicated and frozen, so
-          # they need to be comparable
           def ==(other)
-            other.is_a?(self.class)
+            other.class == self.class
           end
           alias eql? ==
 
@@ -46,6 +52,58 @@ module Torque
             self.class.hash
           end
 
+          private
+
+            def value_class
+              LTree
+            end
+
+            def items_of(entry, sanitize)
+              return items_for(LTree.compatible(entry), sanitize: sanitize) if LTree.compatible?(entry)
+
+              case entry
+              when LTree, LQuery then entry.items
+              when ::Array then items_for(entry, sanitize: sanitize)
+              when ::ActiveRecord::Base then labels_of(record_label(entry), sanitize)
+              else labels_of(entry.to_s, sanitize)
+              end
+            end
+
+            def labels_of(text, sanitize)
+              text = sanitize(text) if sanitize
+              text.split('.').map { |item| parse(item) }
+            end
+
+            def record_label(record)
+              id = record.id
+              raise ArgumentError, <<~MSG.squish if id.nil?
+                Unable to use #{record.class.name} as a label because its
+                #{record.class.primary_key} is still empty.
+              MSG
+
+              raise ArgumentError, <<~MSG.squish if id.is_a?(::Array)
+                Unable to use #{record.class.name} as a label because it has a
+                composite primary key, which cannot be a single label.
+              MSG
+
+              id.to_s
+            end
+
+            def sanitize(text)
+              replacements = PostgreSQL.config.ltree.sanitize
+              return text if replacements.blank?
+
+              text.gsub(Regexp.union(replacements.keys), replacements)
+            end
+
+            def compile(item)
+              item.to_s
+            end
+
+            def parse(text)
+              text
+            end
+
         end
       end
     end

data/lib/torque/postgresql/adapter/oid/struct.rb

@@ -79,7 +79,7 @@ module Torque
             set = value.instance_variable_get(:@attributes)
             set.keys.to_h do |name|
               attribute = set[name]
-              type = attribute.type
+              type = OID.unwrap(attribute.type)
 
               next [name, type.document_for(attribute.value)] if type.is_a?(Struct)
               [name, attribute.value_for_database]

data/lib/torque/postgresql/adapter/oid.rb

@@ -1,2 +1,15 @@
 require_relative 'oid/array'
 require_relative 'oid/range'
+
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        def self.unwrap(type)
+          type = type.__getobj__ while type.is_a?(Delegator)
+          type
+        end
+      end
+    end
+  end
+end

data/lib/torque/postgresql/adapter/schema_definitions.rb

@@ -115,6 +115,11 @@ module Torque
           execute VersionedCommands.fetch_command(dir, :view, name, version)
         end
 
+        def create_trigger(name, version:, dir: pool.migrations_paths)
+          return super unless VersionedCommands.valid_type?(:trigger)
+          execute VersionedCommands.fetch_command(dir, :trigger, name, version)
+        end
+
       end
 
       ActiveRecord::ConnectionAdapters::PostgreSQL::Table.include ColumnMethods

data/lib/torque/postgresql/adapter/schema_dumper.rb

@@ -72,6 +72,7 @@ module Torque
 
             yield
             versioned_commands(stream, :view, true)
+            versioned_commands(stream, :trigger, true)
 
             functions(stream) if fx_functions_position == :end
             triggers(stream) if defined?(::Fx::SchemaDumper::Trigger)

data/lib/torque/postgresql/arel/nodes.rb

@@ -81,6 +81,57 @@ module Torque
           end
         end
 
+        # A cross join, which PostgreSQL needs spelled out because an inner
+        # join without a condition is a syntax error
+        class CrossJoin < ::Arel::Nodes::Join
+          def initialize(left, right = nil)
+            super
+          end
+        end
+
+        # An aliased FROM item. +definitions+ maps a column name to the SQL
+        # type a function has to be told to return, +columns+ are the plain
+        # names the alias exposes, +ordinality+ names the appended counter,
+        # and +lateral+ is only needed when the source is a subquery
+        class FromItem < ::Arel::Nodes::Binary
+          attr_reader :columns, :definitions, :ordinality, :lateral
+
+          alias name right
+
+          def initialize(source, name, columns: nil, definitions: nil, ordinality: nil, lateral: false)
+            @columns = Array.wrap(columns).presence&.freeze
+            @definitions = definitions.presence&.freeze
+            @ordinality = ordinality&.to_s
+            @lateral = lateral
+
+            super(source, name.to_s)
+          end
+
+          # The definitions can only be moved into the source when the counter
+          # forces the +ROWS FROM+ form, since PostgreSQL refuses a column
+          # definition list next to +WITH ORDINALITY+
+          def rows_from?
+            ordinality.present? && definitions.present?
+          end
+
+          # What the alias exposes, as name => type, where a +nil+ type means
+          # the name stands on its own. Types are only spelled out here when
+          # they have not been moved into the +ROWS FROM+ source.
+          #
+          # The list is all or nothing, because PostgreSQL matches it
+          # positionally: a partial list silently renames the columns it does
+          # reach instead of naming the ones it does not
+          def alias_columns
+            return {} if columns.nil? && definitions.nil?
+
+            plain = rows_from? ? definitions.keys : columns
+            result = plain.nil? ? definitions : plain.to_h { |name| [name.to_s, nil] }
+
+            return result if ordinality.blank?
+            result.merge(ordinality => nil)
+          end
+        end
+
         class Ref < ::Arel::Nodes::Unary
           attr_reader :reference
           alias to_s expr

data/lib/torque/postgresql/arel/visitors.rb

@@ -40,6 +40,33 @@ module Torque
           collector
         end
 
+        # A cross join only ever carries its source
+        def visit_Torque_PostgreSQL_Arel_Nodes_CrossJoin(o, collector)
+          collector << 'CROSS JOIN '
+          visit(o.left, collector)
+        end
+
+        # Every part here is written only when it is actually needed, since
+        # LATERAL is a noise word on functions and ROWS FROM is only forced
+        # by the counter
+        def visit_Torque_PostgreSQL_Arel_Nodes_FromItem(o, collector)
+          collector << 'LATERAL ' if o.lateral
+
+          collector << 'ROWS FROM (' if o.rows_from?
+          visit(o.left, collector)
+          collector = visit_definitions(o.definitions, collector) << ')' if o.rows_from?
+
+          collector << ' WITH ORDINALITY' if o.ordinality.present?
+          collector << ' ' << quote_table_name(o.name)
+
+          columns = o.alias_columns
+          return collector if columns.blank?
+
+          collector << '('
+          visit_alias_columns(columns, collector)
+          collector << ')'
+        end
+
         # Allow casting any node
         def visit_Torque_PostgreSQL_Arel_Nodes_Cast(o, collector)
           visit(o.left, collector) << '::' << o.right
@@ -47,6 +74,25 @@ module Torque
 
         private
 
+          # The column definition list a function has to be told to return
+          def visit_definitions(definitions, collector)
+            collector << ' AS ('
+            visit_alias_columns(definitions, collector)
+            collector << ')'
+          end
+
+          # A name on its own when it has no type, otherwise the name and the
+          # type it is being given
+          def visit_alias_columns(columns, collector)
+            columns.each_with_index do |(name, type), index|
+              collector << ', ' unless index.zero?
+              collector << quote_column_name(name)
+              collector << ' ' << type if type.present?
+            end
+
+            collector
+          end
+
           def quote_array(value, collector)
             value = value.map(&::Arel::Nodes.method(:build_quoted))
 

data/lib/torque/postgresql/attributes/base.rb

@@ -19,11 +19,11 @@ module Torque
 
         include SimpleEnum
         include ActiveRecord::Store
-        # Rails 8.1 moved normalization to Active Model, which is where these
-        # classes belong anyway
         include(AR810 ? ActiveModel::Attributes::Normalization : ActiveRecord::Normalization)
         include ActiveRecord::Encryption::EncryptableRecord
 
+        class_attribute :filter_attributes, instance_accessor: false, default: []
+
         class << self
           # These classes are not backed by a table, so nothing here has the
           # extra information that a column would provide
@@ -43,6 +43,14 @@ module Torque
 
             super
           end
+
+          def inspection_filter
+            ActiveSupport::ParameterFilter.new(filter_attributes)
+          end
+        end
+
+        def inspect
+          self.class.inspection_filter.filter(to_h).inspect
         end
 
         # Plain access to any property, declared or not
@@ -72,11 +80,6 @@ module Torque
           attributes.symbolize_keys
         end
 
-        def inspect
-          entries = attributes.map { |key, value| "#{key}: #{value.inspect}" }
-          "#<#{self.class.name} #{entries.join(', ')}>"
-        end
-
         def type_for_attribute(name, &block)
           self.class.type_for_attribute(name, &block)
         end

data/lib/torque/postgresql/attributes/composite.rb

@@ -48,7 +48,7 @@ module Torque
             @load_columns_monitor.synchronize do
               next if defined?(@columns)
 
-              columns = connection.composite_column_types(type_name)
+              columns = ActiveRecord::Base.with_connection { |c| c.composite_column_types(type_name) }
               columns.each do |attr_name, attr_type|
                 attribute(attr_name, attr_type) unless attribute_names.include?(attr_name)
               end
@@ -89,10 +89,6 @@ module Torque
               klass.type_name = name
               klass
             end
-
-            def connection
-              ActiveRecord::Base.connection
-            end
         end
       end
     end

data/lib/torque/postgresql/attributes/enum.rb

@@ -51,7 +51,7 @@ module Torque
 
             @load_values_monitor.synchronize do
               next if defined?(@values)
-              @values = connection.enum_values(type_name).freeze
+              @values = ::ActiveRecord::Base.with_connection { |c| c.enum_values(type_name) }.freeze
             end
 
             @values
@@ -115,11 +115,6 @@ module Torque
               valid?(method_name) ? new(method_name.to_s) : super
             end
 
-            # Get a connection based on its name
-            def connection
-              ::ActiveRecord::Base.connection
-            end
-
         end
 
         # Override string initializer to check for a valid value