dynamic_migrations 2.2.0 → 3.1.0

data/lib/dynamic_migrations/postgres/server/database/schema/table/trigger.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Schema
+          class Table
+            # This class represents a postgres table trigger
+            class Trigger < Source
+              class ExpectedTableError < StandardError
+              end
+
+              class UnexpectedEventManipulationError < StandardError
+              end
+
+              class UnexpectedActionOrderError < StandardError
+              end
+
+              class UnexpectedActionStatementError < StandardError
+              end
+
+              class UnexpectedActionOrientationError < StandardError
+              end
+
+              class UnexpectedActionTimingError < StandardError
+              end
+
+              class ExpectedOldRecordsTableError < StandardError
+              end
+
+              class ExpectedNewRecordsTableError < StandardError
+              end
+
+              class ExpectedFunctionError < StandardError
+              end
+
+              attr_reader :table
+              attr_reader :name
+              attr_reader :event_manipulation
+              attr_reader :action_timing
+              attr_reader :action_order
+              attr_reader :action_condition
+              attr_reader :action_statement
+              attr_reader :action_orientation
+              attr_reader :function
+              attr_reader :action_reference_old_table
+              attr_reader :action_reference_new_table
+              attr_reader :description
+
+              # initialize a new object to represent a validation in a postgres table
+              def initialize source, table, name, action_timing:, event_manipulation:, action_order:, action_statement:, action_orientation:, function:, action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, description: nil
+                super source
+
+                unless table.is_a? Table
+                  raise ExpectedTableError, table
+                end
+                @table = table
+
+                unless name.is_a? Symbol
+                  raise ExpectedSymbolError, name
+                end
+                @name = name
+
+                unless [:before, :after].include? action_timing
+                  raise UnexpectedActionTimingError, action_timing
+                end
+                @action_timing = action_timing
+
+                unless [:insert, :delete, :update].include? event_manipulation
+                  raise UnexpectedEventManipulationError, event_manipulation
+                end
+                @event_manipulation = event_manipulation
+
+                unless action_order.is_a?(Integer) && action_order >= 1
+                  raise UnexpectedActionOrderError, action_order
+                end
+                @action_order = action_order
+
+                unless action_condition.nil? || action_condition.is_a?(String)
+                  raise ExpectedStringError, action_condition
+                end
+                @action_condition = action_condition
+
+                unless action_statement.is_a?(String) && action_statement[/\AEXECUTE FUNCTION [a-z]+(_[a-z]+)*\.[a-z]+(_[a-z]+)*\(\)\z/]
+                  raise UnexpectedActionStatementError, "unexpected action statement `#{action_statement}`, currently only `EXECUTE FUNCTION function_name()` statements are supported"
+                end
+                @action_statement = action_statement
+
+                unless [:row, :statement].include? action_orientation
+                  raise UnexpectedActionOrientationError, action_orientation
+                end
+                @action_orientation = action_orientation
+
+                unless function.is_a? Function
+                  raise ExpectedFunctionError, function
+                end
+                # this should never happen, but adding it just in case
+                unless function.source == source
+                  raise "Internal error - function source `#{function.source}` does not match trigger source `#{source}`"
+                end
+                @function = function
+                # associate this trigger with the function (so they are aware of each other)
+                @function.add_trigger self
+
+                unless action_reference_old_table.nil? || action_reference_old_table == :old_records
+                  raise ExpectedOldRecordsTableError, "expected :old_records or nil, but got #{action_reference_old_table}"
+                end
+                @action_reference_old_table = action_reference_old_table
+
+                unless action_reference_new_table.nil? || action_reference_new_table == :new_records
+                  raise ExpectedNewRecordsTableError, "expected :new_records or nil, but got #{action_reference_new_table}"
+                end
+                @action_reference_new_table = action_reference_new_table
+
+                unless description.nil?
+                  raise ExpectedStringError, description unless description.is_a? String
+                  @description = description
+                end
+              end
+
+              # return true if this has a description, otherwise false
+              def has_description?
+                !@description.nil?
+              end
+
+              def differences_descriptions other_trigger
+                descriptions = method_differences_descriptions other_trigger, [
+                  :event_manipulation,
+                  :action_timing,
+                  :action_order,
+                  :action_condition,
+                  :action_statement,
+                  :action_orientation,
+                  :action_reference_old_table,
+                  :action_reference_new_table
+                ]
+                # add the function differences descriptions
+                function.differences_descriptions(other_trigger.function).each do |description|
+                  descriptions << "function_#{description}"
+                end
+                # return the combined differences
+                descriptions
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/postgres/server/database/schema/table/triggers.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Schema
+          class Table < Source
+            # This module has all the tables methods for working with triggers
+            module Triggers
+              class TriggerDoesNotExistError < StandardError
+              end
+
+              class TriggerAlreadyExistsError < StandardError
+              end
+
+              # returns the trigger object for the provided trigger name, and raises an
+              # error if the trigger does not exist
+              def trigger name
+                raise ExpectedSymbolError, name unless name.is_a? Symbol
+                raise TriggerDoesNotExistError unless has_trigger? name
+                @triggers[name]
+              end
+
+              # returns true if this table has a trigger with the provided name, otherwise false
+              def has_trigger? name
+                raise ExpectedSymbolError, name unless name.is_a? Symbol
+                @triggers.key? name
+              end
+
+              # returns an array of this tables triggers
+              def triggers
+                @triggers.values
+              end
+
+              def triggers_hash
+                @triggers
+              end
+
+              # adds a new trigger to this table, and returns it
+              def add_trigger name, action_timing:, event_manipulation:, action_order:, action_statement:, action_orientation:, function:, action_condition: nil, action_reference_old_table: nil, action_reference_new_table: nil, description: nil
+                if has_trigger? name
+                  raise(TriggerAlreadyExistsError, "Trigger #{name} already exists")
+                end
+                included_target = self
+                if included_target.is_a? Table
+                  new_trigger = @triggers[name] = Trigger.new source, included_target, name, action_timing: action_timing, event_manipulation: event_manipulation, action_order: action_order, action_statement: action_statement, action_orientation: action_orientation, function: function, action_condition: action_condition, action_reference_old_table: action_reference_old_table, action_reference_new_table: action_reference_new_table, description: description
+                else
+                  raise ModuleIncludedIntoUnexpectedTargetError, included_target
+                end
+                # sort the hash so that the triggers are in alphabetical order by name
+                sorted_triggers = {}
+                @triggers.keys.sort.each do |name|
+                  sorted_triggers[name] = @triggers[name]
+                end
+                @triggers = sorted_triggers
+                # return the new trigger
+                new_trigger
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/postgres/server/database/schema/table/unique_constraint.rb

@@ -8,17 +8,12 @@ module DynamicMigrations
           class Table
             # This class represents a postgres table unique_constraint
             class UniqueConstraint < Source
-              INDEX_TYPES = [:btree, :hash, :gist, :gin, :bring, :spgist]
-
               class ExpectedTableError < StandardError
               end
 
               class ExpectedArrayOfColumnsError < StandardError
               end
 
-              class UnexpectedIndexTypeError < StandardError
-              end
-
               class UnexpectedOrderError < StandardError
               end
 
@@ -30,12 +25,12 @@ module DynamicMigrations
 
               attr_reader :table
               attr_reader :name
-              attr_reader :index_type
               attr_reader :deferrable
               attr_reader :initially_deferred
+              attr_reader :description
 
               # initialize a new object to represent a unique_constraint in a postgres table
-              def initialize source, table, columns, name, index_type: :btree, deferrable: false, initially_deferred: false
+              def initialize source, table, columns, name, description: nil, deferrable: false, initially_deferred: false
                 super source
                 raise ExpectedTableError, table unless table.is_a? Table
                 @table = table
@@ -53,8 +48,10 @@ module DynamicMigrations
                 raise ExpectedSymbolError, name unless name.is_a? Symbol
                 @name = name
 
-                raise UnexpectedIndexTypeError, index_type unless INDEX_TYPES.include?(index_type)
-                @index_type = index_type
+                unless description.nil?
+                  raise ExpectedStringError, description unless description.is_a? String
+                  @description = description
+                end
 
                 raise ExpectedBooleanError, deferrable unless [true, false].include?(deferrable)
                 @deferrable = deferrable
@@ -63,6 +60,11 @@ module DynamicMigrations
                 @initially_deferred = initially_deferred
               end
 
+              # return true if this has a description, otherwise false
+              def has_description?
+                !@description.nil?
+              end
+
               # return an array of this unique_constraints columns
               def columns
                 @columns.values
@@ -72,6 +74,14 @@ module DynamicMigrations
                 @columns.keys
               end
 
+              def differences_descriptions other_unique_constraint
+                method_differences_descriptions other_unique_constraint, [
+                  :column_names,
+                  :deferrable,
+                  :initially_deferred
+                ]
+              end
+
               private
 
               # used internally to set the columns from this objects initialize method

data/lib/dynamic_migrations/postgres/server/database/schema/table/validation.rb

@@ -22,9 +22,10 @@ module DynamicMigrations
               attr_reader :check_clause
               attr_reader :deferrable
               attr_reader :initially_deferred
+              attr_reader :description
 
               # initialize a new object to represent a validation in a postgres table
-              def initialize source, table, columns, name, check_clause, deferrable: false, initially_deferred: false
+              def initialize source, table, columns, name, check_clause, description: nil, deferrable: false, initially_deferred: false
                 super source
                 raise ExpectedTableError, table unless table.is_a? Table
                 @table = table
@@ -45,6 +46,11 @@ module DynamicMigrations
                 raise ExpectedStringError, check_clause unless check_clause.is_a? String
                 @check_clause = check_clause
 
+                unless description.nil?
+                  raise ExpectedStringError, description unless description.is_a? String
+                  @description = description
+                end
+
                 raise ExpectedBooleanError, deferrable unless [true, false].include?(deferrable)
                 @deferrable = deferrable
 
@@ -52,6 +58,11 @@ module DynamicMigrations
                 @initially_deferred = initially_deferred
               end
 
+              # return true if this has a description, otherwise false
+              def has_description?
+                !@description.nil?
+              end
+
               # return an array of this validations columns
               def columns
                 @columns.values
@@ -61,6 +72,14 @@ module DynamicMigrations
                 @columns.keys
               end
 
+              def differences_descriptions other_validation
+                method_differences_descriptions other_validation, [
+                  :check_clause,
+                  :deferrable,
+                  :initially_deferred
+                ]
+              end
+
               private
 
               # used internally to set the columns from this objects initialize method

data/lib/dynamic_migrations/postgres/server/database/schema/table.rb

@@ -13,10 +13,14 @@ module DynamicMigrations
             class PrimaryKeyDoesNotExistError < StandardError
             end
 
+            class PrimaryKeyAlreadyExistsError < StandardError
+            end
+
             include Columns
             include Validations
             include Indexes
             include ForeignKeyConstraints
+            include Triggers
             include UniqueConstraints
 
             attr_reader :schema
@@ -24,20 +28,25 @@ module DynamicMigrations
             attr_reader :description
 
             # initialize a new object to represent a postgres table
-            def initialize source, schema, name, description = nil
+            def initialize source, schema, name, description: nil
               super source
+
               raise ExpectedSchemaError, schema unless schema.is_a? Schema
+              @schema = schema
+
               raise ExpectedSymbolError, name unless name.is_a? Symbol
+              @name = name
+
               unless description.nil?
                 raise ExpectedStringError, description unless description.is_a? String
                 @description = description
               end
-              @schema = schema
-              @name = name
+
               @columns = {}
               @validations = {}
               @indexes = {}
               @foreign_key_constraints = {}
+              @triggers = {}
               @unique_constraints = {}
             end
 
@@ -60,10 +69,11 @@ module DynamicMigrations
 
             # returns a primary key if one exists, else raises an error
             def primary_key
-              unless @primary_key
+              pk = @primary_key
+              unless pk
                 raise PrimaryKeyDoesNotExistError
               end
-              @primary_key
+              pk
             end
           end
         end

data/lib/dynamic_migrations/postgres/server/database/schema/tables.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Schema < Source
+          module Tables
+            class TableAlreadyExistsError < StandardError
+            end
+
+            class TableDoesNotExistError < StandardError
+            end
+
+            # create and add a new table from a provided table name
+            def add_table table_name, description: nil
+              raise ExpectedSymbolError, table_name unless table_name.is_a? Symbol
+              if has_table? table_name
+                raise(TableAlreadyExistsError, "Table #{table_name} already exists")
+              end
+              included_target = self
+              if included_target.is_a? Schema
+                new_table = @tables[table_name] = Table.new source, included_target, table_name, description: description
+              else
+                raise ModuleIncludedIntoUnexpectedTargetError, included_target
+              end
+              # sort the hash so that the tables are in alphabetical order by name
+              sorted_tables = {}
+              @tables.keys.sort.each do |table_name|
+                sorted_tables[table_name] = @tables[table_name]
+              end
+              @tables = sorted_tables
+              # return the new table
+              new_table
+            end
+
+            # return a table by its name, raises an error if the table does not exist
+            def table table_name
+              raise ExpectedSymbolError, table_name unless table_name.is_a? Symbol
+              raise TableDoesNotExistError unless has_table? table_name
+              @tables[table_name]
+            end
+
+            # returns true/false representing if a table with the provided name exists
+            def has_table? table_name
+              raise ExpectedSymbolError, table_name unless table_name.is_a? Symbol
+              @tables.key? table_name
+            end
+
+            # returns an array of all tables in the schema
+            def tables
+              @tables.values
+            end
+
+            def tables_hash
+              @tables
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/postgres/server/database/schema.rb

@@ -11,11 +11,8 @@ module DynamicMigrations
           class ExpectedDatabaseError < StandardError
           end
 
-          class TableAlreadyExistsError < StandardError
-          end
-
-          class TableDoesNotExistError < StandardError
-          end
+          include Tables
+          include Functions
 
           attr_reader :database
           attr_reader :name
@@ -28,50 +25,7 @@ module DynamicMigrations
             @database = database
             @name = name
             @tables = {}
-          end
-
-          # create and add a new table from a provided table name
-          def add_table table_name, description = nil
-            raise ExpectedSymbolError, table_name unless table_name.is_a? Symbol
-            if has_table? table_name
-              raise(TableAlreadyExistsError, "Table #{table_name} already exists")
-            end
-            included_target = self
-            if included_target.is_a? Schema
-              new_table = @tables[table_name] = Table.new source, included_target, table_name, description
-            else
-              raise ModuleIncludedIntoUnexpectedTargetError, included_target
-            end
-            # sort the hash so that the tables are in alphabetical order by name
-            sorted_tables = {}
-            @tables.keys.sort.each do |table_name|
-              sorted_tables[table_name] = @tables[table_name]
-            end
-            @tables = sorted_tables
-            # return the new table
-            new_table
-          end
-
-          # return a table by its name, raises an error if the table does not exist
-          def table table_name
-            raise ExpectedSymbolError, table_name unless table_name.is_a? Symbol
-            raise TableDoesNotExistError unless has_table? table_name
-            @tables[table_name]
-          end
-
-          # returns true/false representing if a table with the provided name exists
-          def has_table? table_name
-            raise ExpectedSymbolError, table_name unless table_name.is_a? Symbol
-            @tables.key? table_name
-          end
-
-          # returns an array of all tables in the schema
-          def tables
-            @tables.values
-          end
-
-          def tables_hash
-            @tables
+            @functions = {}
           end
         end
       end

data/lib/dynamic_migrations/postgres/server/database/source.rb

@@ -30,6 +30,27 @@ module DynamicMigrations
               raise ExpectedSymbolError, "expected Symbol but got #{value}"
             end
           end
+
+          private
+
+          # used to compare two objects and return a description of the differences
+          # it calls the method names provided on each object and compares the results
+          # and returns a human readable description of the differences
+          def method_differences_descriptions other_object, method_names
+            lines = []
+            ([:name] + method_names + [:description]).each do |method_name|
+              original_value = send method_name
+              updated_value = other_object.send method_name
+              if original_value != updated_value
+                lines << "#{method_name} changed from `#{original_value}` to `#{updated_value}`"
+              end
+            end
+
+            # return an array of lines, not a finalized string, this is because this
+            # method is typically called as part of a larger procedure that will compare
+            # other aspects of the object too
+            lines
+          end
         end
       end
     end

data/lib/dynamic_migrations/postgres/server/database/structure_loader.rb

@@ -63,12 +63,12 @@ module DynamicMigrations
           # useful hash representing the structure of your database
           def fetch_structure
             begin
-              rows = connection.exec_params(<<~SQL)
+              rows = connection.exec(<<~SQL)
                 SELECT * FROM public.dynamic_migrations_structure_cache
               SQL
             rescue PG::UndefinedTable
               create_database_structure_cache
-              rows = connection.exec_params(<<~SQL)
+              rows = connection.exec(<<~SQL)
                 SELECT * FROM public.dynamic_migrations_structure_cache
               SQL
             end
@@ -124,7 +124,7 @@ module DynamicMigrations
 
           # returns a list of the schema names in this database
           def fetch_schema_names
-            rows = connection.exec(<<-SQL)
+            rows = connection.exec(<<~SQL)
               SELECT schema_name
                 FROM information_schema.schemata;
             SQL
@@ -137,9 +137,9 @@ module DynamicMigrations
 
           # returns a list of the table names in the provided schema
           def fetch_table_names schema_name
-            rows = connection.exec_params(<<-SQL, [schema_name.to_s])
-                  SELECT table_name FROM information_schema.tables
-                    WHERE table_schema = $1
+            rows = connection.exec_params(<<~SQL, [schema_name.to_s])
+              SELECT table_name FROM information_schema.tables
+                WHERE table_schema = $1
             SQL
             table_names = rows.map { |row| row["table_name"] }
             table_names.reject! { |table_name| table_name.start_with? "pg_" }