torque-postgresql 4.1.0 → 4.1.1

data/spec/tests/struct_spec.rb

@@ -786,6 +786,18 @@ RSpec.describe 'Struct' do
     it 'leaves nil alone' do
       expect(normalized_klass.new.email).to be_nil
     end
+
+    it 'keeps a normalized struct property as a document inside another' do
+      klass = Class.new(Torque::PostgreSQL::Attributes::Struct) do
+        attribute :bio, Torque::PostgreSQL::Adapter::OID::Struct.new(Profile::Bio)
+        normalizes :bio, with: ->(value) { value }
+      end
+
+      type = Torque::PostgreSQL::Adapter::OID::Struct.new(klass)
+      value = klass.new(bio: { headline: 'Hi' })
+
+      expect(type.serialize(value)).to be_eql('{"bio":{"headline":"Hi"}}')
+    end
   end
 
   context 'on store accessor' do
@@ -884,6 +896,11 @@ RSpec.describe 'Struct' do
       expect(Profile.where(settings: { notifications: true }).pluck(:name)).to be_eql(%w[a])
     end
 
+    it 'casts the property without a permanent connection' do
+      expect(ActiveRecord::Base).not_to receive(:connection)
+      expect(Profile.where(settings: { notifications: true }).to_sql).to include('::boolean = TRUE')
+    end
+
     it 'hands each property back to the predicate builder' do
       expect(Profile.where(settings: { theme: %w[light dark] }).to_sql)
         .to include(%{("profiles"."settings" #>> ARRAY['theme']) IN ('light', 'dark')})
@@ -917,6 +934,18 @@ RSpec.describe 'Struct' do
       expect(model.where(settings: { address: { city: 'SP' } }).pluck(:name)).to be_eql(%w[n])
     end
 
+    it 'reaches inside a property that is not a document by path' do
+      expect(Profile.where(settings: { tags: { 0 => 'test' } }).to_sql)
+        .to include(%{("profiles"."settings" #>> ARRAY['tags', '0']) = 'test'})
+
+      expect(Profile.where(settings: { tags: { first: { name: 'x' } } }).to_sql)
+        .to include(%{("profiles"."settings" #>> ARRAY['tags', 'first', 'name']) = 'x'})
+
+      Profile.create!(name: 'n', settings: { tags: %w[test other] })
+      expect(Profile.where(settings: { tags: { 0 => 'test' } }).pluck(:name)).to be_eql(%w[n])
+      expect(Profile.where(settings: { tags: { 1 => 'test' } }).pluck(:name)).to be_empty
+    end
+
     it 'refuses a json column' do
       expect { Profile.where(bio: { headline: 'x' }).to_sql }
         .to raise_error(ArgumentError, /json columns cannot be queried/)
@@ -928,6 +957,139 @@ RSpec.describe 'Struct' do
     end
   end
 
+  context 'on arel properties' do
+    it 'builds the path to a property' do
+      node = Profile.arel_property_of(:settings, :theme)
+
+      expect(node).to be_a(Torque::PostgreSQL::Arel::Nodes::Property)
+      expect(node.path).to be_eql(%w[theme])
+      expect(node.cast).to be_nil
+      expect(Profile.where(node.eq('dark')).to_sql)
+        .to include(%{("profiles"."settings" #>> ARRAY['theme']) = 'dark'})
+    end
+
+    it 'casts the property to what the class declares for it' do
+      node = Profile.arel_property_of(:settings, :notifications)
+
+      expect(node.cast).to be_eql('boolean')
+      expect(Profile.order(node.desc).to_sql)
+        .to include(%{ORDER BY ("profiles"."settings" #>> ARRAY['notifications'])::boolean DESC})
+    end
+
+    it 'goes as deep as the path says' do
+      node = Profile.arel_property_of(:settings, :tags, 0)
+
+      expect(node.path).to be_eql(%w[tags 0])
+      expect(Profile.order(node.asc).to_sql)
+        .to include(%{ORDER BY ("profiles"."settings" #>> ARRAY['tags', '0']) ASC})
+    end
+
+    it 'reaches the properties of a nested document' do
+      inner = stub_const('ArelInner', Class.new(Torque::PostgreSQL::Attributes::Struct))
+      inner.attribute(:zip, :integer)
+      outer = stub_const('ArelOuter', Class.new(Torque::PostgreSQL::Attributes::Struct))
+      outer.attribute(:address, Torque::PostgreSQL::Adapter::OID::Struct.new(inner))
+
+      model = stub_const('ArelProfile', Class.new(ActiveRecord::Base))
+      model.table_name = 'profiles'
+      model.struct_for(:settings, outer)
+
+      node = model.arel_property_of(:settings, :address, :zip)
+      expect(node.cast).to be_eql('integer')
+      expect(model.order(node.asc).to_sql)
+        .to include(%{ORDER BY ("profiles"."settings" #>> ARRAY['address', 'zip'])::integer ASC})
+    end
+
+    it 'works on a column that is not backed by a class' do
+      node = Video.arel_property_of(:metadata, :file, :duration)
+
+      expect(node.cast).to be_nil
+      expect(Video.where(node.eq('10')).to_sql)
+        .to include(%{("videos"."metadata" #>> ARRAY['file', 'duration']) = '10'})
+    end
+
+    it 'refuses a json column' do
+      expect { Profile.arel_property_of(:bio, :headline) }
+        .to raise_error(ArgumentError, /json columns cannot be queried/)
+    end
+
+    it 'refuses an undeclared property of a strict class' do
+      expect { Profile.arel_property_of(:settings, :nope) }
+        .to raise_error(ArgumentError, /not a declared property/)
+    end
+
+    it 'keeps the type of the property when the column is normalized' do
+      klass = Class.new(Profile) do
+        normalizes :settings, with: ->(value) { value }
+      end
+
+      node = klass.arel_property_of(:settings, :notifications)
+      expect(node.to_sql).to be_eql(%{("profiles"."settings" #>> ARRAY['notifications'])::boolean})
+
+      expect { klass.arel_property_of(:settings, :nope) }
+        .to raise_error(ArgumentError, /not a declared property/)
+    end
+  end
+
+  context 'on ordering and grouping' do
+    let!(:dark) { Profile.create!(name: 'a', settings: { theme: 'dark', notifications: true }) }
+    let!(:light) { Profile.create!(name: 'b', settings: { theme: 'light', notifications: false }) }
+
+    it 'orders by a property' do
+      expect(Profile.order(settings: { theme: :asc }).to_sql)
+        .to include(%{ORDER BY ("profiles"."settings" #>> ARRAY['theme']) ASC})
+
+      expect(Profile.order(settings: { theme: :asc }).pluck(:name)).to be_eql(%w[a b])
+      expect(Profile.order(settings: { theme: :desc }).pluck(:name)).to be_eql(%w[b a])
+    end
+
+    it 'casts the property to what the class declares for it' do
+      expect(Profile.order(settings: { notifications: :desc }).to_sql)
+        .to include(%{ORDER BY ("profiles"."settings" #>> ARRAY['notifications'])::boolean DESC})
+
+      expect(Profile.order(settings: { notifications: :desc }).pluck(:name)).to be_eql(%w[a b])
+    end
+
+    it 'orders by the whole document' do
+      expect(Profile.order(:settings).to_sql).to include(%{ORDER BY "profiles"."settings" ASC})
+    end
+
+    it 'groups by a property' do
+      expect(Profile.group(settings: :theme).to_sql)
+        .to include(%{GROUP BY ("profiles"."settings" #>> ARRAY['theme'])})
+
+      expect(Profile.group(settings: :theme).count).to be_eql('dark' => 1, 'light' => 1)
+    end
+
+    it 'filters groups with having' do
+      expect(Profile.group(:settings).having(settings: { theme: 'dark' }).to_sql)
+        .to include(%{HAVING (("profiles"."settings" #>> ARRAY['theme']) = 'dark')})
+
+      expect(Profile.group(:settings).having(settings: { theme: 'dark' }).count.size).to be_eql(1)
+      expect(Profile.group(settings: :theme).having(settings: { theme: 'dark' }).count)
+        .to be_eql('dark' => 1)
+    end
+
+    it 'plucks a property' do
+      expect(Profile.order(:name).pluck(settings: :theme)).to be_eql(%w[dark light])
+      expect(Profile.order(:name).pluck('settings.theme')).to be_eql(%w[dark light])
+    end
+
+    it 'refuses a json column' do
+      expect { Profile.order(bio: { headline: :asc }).to_sql }
+        .to raise_error(ArgumentError, /json columns cannot be queried/)
+    end
+
+    it 'refuses an undeclared property of a strict class' do
+      expect { Profile.order(settings: { nope: :asc }).to_sql }
+        .to raise_error(ArgumentError, /not a declared property/)
+    end
+
+    it 'leaves associations alone' do
+      expect(Post.order(author: { name: :asc }).to_sql).to include(%{ORDER BY "author"."name" ASC})
+    end
+  end
+
   context 'on encryption options' do
     before do
       ActiveRecord::Encryption.configure(
@@ -965,4 +1127,44 @@ RSpec.describe 'Struct' do
       expect(one).not_to be_eql(two)
     end
   end
+
+  context 'on filtered parameters' do
+    before do
+      ActiveRecord::Encryption.configure(
+        primary_key: 'test master key',
+        deterministic_key: 'test deterministic key',
+        key_derivation_salt: 'testing salt',
+      )
+    end
+
+    let(:app) { Struct.new(:config).new(Struct.new(:filter_parameters).new([])) }
+
+    around do |example|
+      listeners = ActiveRecord::Encryption.encrypted_attribute_declaration_listeners
+      ActiveRecord::Encryption.encrypted_attribute_declaration_listeners = nil
+      ActiveRecord::Encryption::AutoFilteredParameters.new(app).enable
+      example.run
+    ensure
+      ActiveRecord::Encryption.encrypted_attribute_declaration_listeners = listeners
+    end
+
+    let(:struct_klass) do
+      Class.new(Torque::PostgreSQL::Attributes::Struct) do
+        attribute :label, :string
+        attribute :token, :string
+
+        encrypts :token
+      end
+    end
+
+    it 'records the encrypted attribute on the filter list' do
+      expect(struct_klass.filter_attributes).to include(:token)
+    end
+
+    it 'hides the encrypted attribute when inspecting' do
+      inspected = struct_klass.new(label: 'a', token: 'secret').inspect
+      expect(inspected).to include('a')
+      expect(inspected).not_to include('secret')
+    end
+  end
 end

data/spec/tests/table_inheritance_spec.rb

@@ -1419,4 +1419,14 @@ RSpec.describe 'TableInheritance' do
       expect(queries).to be_empty
     end
   end
+
+  context 'on connection' do
+    it 'checks the physical inheritance without a permanent connection' do
+      expect(ActiveRecord::Base).not_to receive(:connection)
+
+      ActivityPost.remove_instance_variable(:@physically_inherited) \
+        if ActivityPost.instance_variable_defined?(:@physically_inherited)
+      expect(ActivityPost.physically_inherited?).to be_truthy
+    end
+  end
 end

data/spec/tests/versioned_commands_spec.rb

@@ -8,6 +8,7 @@ RSpec.describe 'VersionedCommands' do
       expect(connection).not_to respond_to(:create_function)
       expect(connection).not_to respond_to(:create_type)
       expect(connection).not_to respond_to(:create_view)
+      expect(connection).not_to respond_to(:create_trigger)
     end
 
     it 'does not have the methods available in a migration' do
@@ -15,6 +16,7 @@ RSpec.describe 'VersionedCommands' do
       expect(instance).not_to respond_to(:create_function)
       expect(instance).not_to respond_to(:create_type)
       expect(instance).not_to respond_to(:create_view)
+      expect(instance).not_to respond_to(:create_trigger)
     end
 
     it 'does have the methods in schema definition' do
@@ -22,6 +24,7 @@ RSpec.describe 'VersionedCommands' do
       expect(instance).to respond_to(:create_function)
       expect(instance).to respond_to(:create_type)
       expect(instance).to respond_to(:create_view)
+      expect(instance).to respond_to(:create_trigger)
     end
 
     context 'on context' do
@@ -39,6 +42,7 @@ RSpec.describe 'VersionedCommands' do
         expect(result[4]).to eq('20250101000005_create_view_all_users_v1.sql')
         expect(result[5]).to eq('20250101000006_create_type_user_id_v1.sql')
         expect(result[6]).to eq('20250101000007_remove_function_count_users_v2.sql')
+        expect(result[7]).to eq('20250101000008_create_trigger_audit_users_v1.sql')
       end
 
       it 'correctly report the status of all migrations' do
@@ -50,6 +54,7 @@ RSpec.describe 'VersionedCommands' do
         expect(result[4]).to eq(['down', '20250101000005', 'Create View all_users (v1)'])
         expect(result[5]).to eq(['down', '20250101000006', 'Create Type user_id (v1)'])
         expect(result[6]).to eq(['down', '20250101000007', 'Remove Function count_users (v2)'])
+        expect(result[7]).to eq(['down', '20250101000008', 'Create Trigger audit_users (v1)'])
       end
 
       it 'reports for invalid names' do
@@ -280,6 +285,89 @@ RSpec.describe 'VersionedCommands' do
           expect { base.validate!(:view, content, 'internal_test') }.not_to raise_error
         end
       end
+
+      context 'on trigger' do
+        it 'requires a proper definition' do
+          content = <<~SQL
+            CREATE OR REPLACE FUNCTION test() RETURNS trigger;
+          SQL
+
+          expect do
+            base.validate!(:trigger, content, 'test')
+          end.to raise_error(ArgumentError, /Missing or invalid trigger/)
+        end
+
+        it 'prevents multiple trigger definitions' do
+          content = <<~SQL
+            CREATE OR REPLACE TRIGGER test BEFORE INSERT ON users FOR EACH ROW EXECUTE FUNCTION fn();
+            CREATE OR REPLACE TRIGGER other_test BEFORE INSERT ON users FOR EACH ROW EXECUTE FUNCTION fn();
+          SQL
+
+          expect do
+            base.validate!(:trigger, content, 'test')
+          end.to raise_error(ArgumentError, /More than one trigger/)
+        end
+
+        it 'requires OR REPLACE clause' do
+          content = <<~SQL
+            CREATE TRIGGER test BEFORE INSERT ON users FOR EACH ROW EXECUTE FUNCTION fn();
+          SQL
+
+          expect do
+            base.validate!(:trigger, content, 'test')
+          end.to raise_error(ArgumentError, /'OR REPLACE' is required/)
+        end
+
+        it 'requires matching name' do
+          content = <<~SQL
+            CREATE OR REPLACE TRIGGER other_test BEFORE INSERT ON users FOR EACH ROW EXECUTE FUNCTION fn();
+          SQL
+
+          expect do
+            base.validate!(:trigger, content, 'test')
+          end.to raise_error(ArgumentError, /must match file name/)
+        end
+
+        it 'works when setup correctly' do
+          content = <<~SQL
+            CREATE OR REPLACE TRIGGER TEST BEFORE INSERT ON users FOR EACH ROW EXECUTE FUNCTION fn();
+          SQL
+
+          expect { base.validate!(:trigger, content, 'test') }.not_to raise_error
+        end
+
+        it 'supports a bundled function' do
+          content = <<~SQL
+            CREATE OR REPLACE FUNCTION fn() RETURNS trigger AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;
+            CREATE OR REPLACE TRIGGER test BEFORE INSERT ON users FOR EACH ROW EXECUTE FUNCTION fn();
+          SQL
+
+          expect { base.validate!(:trigger, content, 'test') }.not_to raise_error
+        end
+
+        it 'prevents multiple bundled functions' do
+          content = <<~SQL
+            CREATE OR REPLACE FUNCTION fn() RETURNS trigger;
+            CREATE OR REPLACE FUNCTION other_fn() RETURNS trigger;
+            CREATE OR REPLACE TRIGGER test BEFORE INSERT ON users FOR EACH ROW EXECUTE FUNCTION fn();
+          SQL
+
+          expect do
+            base.validate!(:trigger, content, 'test')
+          end.to raise_error(ArgumentError, /one function/)
+        end
+
+        it 'requires OR REPLACE on the bundled function' do
+          content = <<~SQL
+            CREATE FUNCTION fn() RETURNS trigger;
+            CREATE OR REPLACE TRIGGER test BEFORE INSERT ON users FOR EACH ROW EXECUTE FUNCTION fn();
+          SQL
+
+          expect do
+            base.validate!(:trigger, content, 'test')
+          end.to raise_error(ArgumentError, /'OR REPLACE' is required/)
+        end
+      end
     end
 
     context 'on running' do
@@ -363,6 +451,34 @@ RSpec.describe 'VersionedCommands' do
         expect(connection).to receive(:execute).with('DROP VIEW test;')
         command.migrate(:down)
       end
+
+      it 'properly drops triggers' do
+        command.type = 'trigger'
+
+        sql.replace(<<~SQL)
+          CREATE OR REPLACE TRIGGER test
+            BEFORE INSERT ON users
+            FOR EACH ROW EXECUTE FUNCTION fn();
+        SQL
+
+        expect(connection).to receive(:execute).with('DROP TRIGGER test ON users;')
+        command.migrate(:down)
+      end
+
+      it 'properly drops triggers with bundled functions' do
+        command.type = 'trigger'
+
+        sql.replace(<<~SQL)
+          CREATE OR REPLACE FUNCTION fn() RETURNS trigger AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;
+          CREATE OR REPLACE TRIGGER test
+            BEFORE INSERT ON internal.users
+            FOR EACH ROW EXECUTE FUNCTION fn();
+        SQL
+
+        expect(connection).to receive(:execute).with('DROP TRIGGER test ON internal.users;')
+        expect(connection).to receive(:execute).with('DROP FUNCTION fn();')
+        command.migrate(:down)
+      end
     end
 
     context 'on migrator' do
@@ -449,6 +565,8 @@ RSpec.describe 'VersionedCommands' do
     end
 
     before do
+      connection.instance_variable_set(:@schemas_whitelist, nil)
+
       allow(commands_table).to receive(:new).and_return(schema_table)
       allow(schema_table).to receive(:versions_of).and_return([])
       allow(schema_table).to receive(:table_name).and_return('versioned_commands_tbl')
@@ -459,6 +577,7 @@ RSpec.describe 'VersionedCommands' do
       expect(dump_result).not_to include('# These are types managed by versioned commands')
       expect(dump_result).not_to include('# These are functions managed by versioned commands')
       expect(dump_result).not_to include('# These are views managed by versioned commands')
+      expect(dump_result).not_to include('# These are triggers managed by versioned commands')
     end
 
     it 'includes all types' do
@@ -509,5 +628,31 @@ RSpec.describe 'VersionedCommands' do
       expect(dump_result).to include('create_view "internal_other", version: 2')
       expect(dump_result).not_to include('create_view "removed", version: 1')
     end
+
+    it 'includes all triggers' do
+      body = 'RETURNS trigger AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql'
+      connection.execute('CREATE TABLE trigger_users (id integer);')
+      connection.execute('CREATE TABLE internal.trigger_users (id integer);')
+      connection.execute("CREATE FUNCTION trigger_fn() #{body};")
+      connection.execute(<<~SQL)
+        CREATE TRIGGER test BEFORE INSERT ON trigger_users
+        FOR EACH ROW EXECUTE FUNCTION trigger_fn();
+      SQL
+      connection.execute(<<~SQL)
+        CREATE TRIGGER other BEFORE INSERT ON internal.trigger_users
+        FOR EACH ROW EXECUTE FUNCTION trigger_fn();
+      SQL
+
+      allow(schema_table).to receive(:versions_of).with('trigger').and_return([
+        ['test', 1],
+        ['internal_other', 2],
+        ['remove', 1],
+      ])
+
+      expect(dump_result).to include('# These are triggers managed by versioned commands')
+      expect(dump_result).to include('create_trigger "test", version: 1')
+      expect(dump_result).to include('create_trigger "internal_other", version: 2')
+      expect(dump_result).not_to include('create_trigger "removed", version: 1')
+    end
   end
 end