dynamic_migrations 3.3.1 → 3.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3917e377fb83c0bf7d8d836521935e6fecb298d1fea691bef33b212577f78801
-  data.tar.gz: 54c2c5ebc5c685029806cc2ecc99aea2871bf3a480fe245041594fe616362de8
+  metadata.gz: 4175e35ddf2a941304c9efec0400c7ed6d933bf982d3744eb45f2891d6806ec6
+  data.tar.gz: c78c493bf1660d8b2eb36fe355a07869b8ef2fdbc4a05527da51e27b56dcfa2e
 SHA512:
-  metadata.gz: 18028c2423770216cb7b2121e626d361b4c9bd8943b17b28903221e0a05e63cb2b9ade9d59b23b4168a995d8e2d35b3ca9476a6f94f6b13980ef2931c7aa8885
-  data.tar.gz: d2591dc1c9cf267efc8cf038dcef0a80ecd19eb0981dde81ae5fc68c853125ba805d7a2716123794843452fdc1eafe9dc7a9a1c34a09f71739e3aebd1b4579ff
+  metadata.gz: f4e13bc988a286385fa6e39b4cbf5d001674cec8482ee9cb4680d34fe9b3a82fc869dccbef8c31527f3f23a4230796cc07b4559bd90c35373b3865877328878c
+  data.tar.gz: 73a51e5ae774cd41863e67c2f5cf7f541beaeddbf6b027d81637a6926542d267fb0ca34e790b86b206786668cf2fc3466242a6347871ed552f739aa2a7a8baf8

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [3.4.0](https://github.com/craigulliott/dynamic_migrations/compare/v3.3.1...v3.4.0) (2023-08-23)
+
+
+### Features
+
+* adding support for enums and extensions ([6e00d5f](https://github.com/craigulliott/dynamic_migrations/commit/6e00d5fc726e2a1bbeb282477c8bca92b94462cf))
+
 ## [3.3.1](https://github.com/craigulliott/dynamic_migrations/compare/v3.3.0...v3.3.1) (2023-08-18)
 
 

data/lib/dynamic_migrations/active_record/migrators/enum.rb

@@ -0,0 +1,44 @@
+module DynamicMigrations
+  module ActiveRecord
+    module Migrators
+      module Enum
+        # create a postgres enum
+        def create_enum enum_name, values
+          # schema_name was not provided to this method, it comes from the migration class
+          execute <<~SQL
+            CREATE TYPE #{schema_name}.#{enum_name} as ENUM ('#{values.join("','")}');
+          SQL
+        end
+
+        # add vaues to a given enum
+        def add_enum_values enum_name, values
+          sqls = values.map do |value|
+            "ALTER TYPE #{schema_name}.#{enum_name} ADD ATTRIBUTE '#{value}';"
+          end
+          execute sqls.join("\n")
+        end
+
+        # remove a enum from the schema
+        def drop_enum enum_name
+          execute <<~SQL
+            DROP TYPE #{schema_name}.#{enum_name};
+          SQL
+        end
+
+        # add a comment to a enum
+        def set_enum_comment enum_name, comment
+          execute <<~SQL
+            COMMENT ON TYPE #{schema_name}.#{enum_name} IS '#{quote comment}';
+          SQL
+        end
+
+        # remove the comment from a enum
+        def remove_enum_comment enum_name
+          execute <<~SQL
+            COMMENT ON TYPE #{schema_name}.#{enum_name} IS null;
+          SQL
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/active_record/migrators.rb

@@ -30,6 +30,7 @@ module DynamicMigrations
       include Function
       include UniqueConstraint
       include Trigger
+      include Enum
 
       # The schema name should be set before the migrations for
       # each schema's migrations are run. This is done by:

data/lib/dynamic_migrations/postgres/generator/database_migration.rb

@@ -0,0 +1,14 @@
+module DynamicMigrations
+  module Postgres
+    class Generator
+      class DatabaseMigration < Migration
+        # these sections are in order for which they will appear in a migration,
+        # note that removals come before additions, and that the order here optomizes
+        # for dependencies (i.e. columns have to be created before indexes are added and
+        # triggers are removed before functions are dropped)
+        add_structure_template [:create_extension], "Create Extension"
+        add_structure_template [:drop_extension], "Drop Extension"
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/postgres/generator/enum.rb

@@ -0,0 +1,75 @@
+module DynamicMigrations
+  module Postgres
+    class Generator
+      module Enum
+        class UnremovableEnumValuesError < StandardError
+        end
+
+        def create_enum enum, code_comment = nil
+          add_fragment schema: enum.schema,
+            migration_method: :create_enum,
+            object: enum,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              create_enum :#{enum.name}, [
+                :#{enum.values.join(",\n  :")}
+              ]
+            RUBY
+        end
+
+        def update_enum original_enum, updated_enum, code_comment = nil
+          added_values = updated_enum.values - original_enum.values
+          removed_values = original_enum.values - updated_enum.values
+
+          if removed_values.any?
+            raise UnremovableEnumValuesError, "You can not remove enum values from postgres. Tring to remove '#{removed_values.join("', ")}'"
+          end
+
+          add_fragment schema: updated_enum.schema,
+            migration_method: :add_enum_values,
+            object: updated_enum,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              add_enum_values :#{updated_enum.name}, [
+                :#{added_values.join(",\n  :")}
+              ]
+            RUBY
+        end
+
+        def drop_enum enum, code_comment = nil
+          add_fragment schema: enum.schema,
+            migration_method: :drop_enum,
+            object: enum,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              drop_enum :#{enum.name}
+            RUBY
+        end
+
+        # add a comment to a enum
+        def set_enum_comment enum, code_comment = nil
+          add_fragment schema: enum.schema,
+            migration_method: :set_enum_comment,
+            object: enum,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              set_enum_comment :#{enum.name}, <<~COMMENT
+                #{indent enum.description || ""}
+              COMMENT
+            RUBY
+        end
+
+        # remove the comment from a enum
+        def remove_enum_comment enum, code_comment = nil
+          add_fragment schema: enum.schema,
+            migration_method: :remove_enum_comment,
+            object: enum,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              remove_enum_comment :#{enum.name}
+            RUBY
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/postgres/generator/extension.rb

@@ -0,0 +1,27 @@
+module DynamicMigrations
+  module Postgres
+    class Generator
+      module Extension
+        def create_extension extension_name, code_comment = nil
+          # no table or schema name for this fragment (it is executed at the database level)
+          add_fragment migration_method: :create_extension,
+            object: extension_name,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              create_extension :#{extension_name}
+            RUBY
+        end
+
+        def drop_extension extension_name, code_comment = nil
+          # no table or schema name for this fragment (it is executed at the database level)
+          add_fragment migration_method: :drop_extension,
+            object: extension_name,
+            code_comment: code_comment,
+            migration: <<~RUBY
+              drop_extension :#{extension_name}
+            RUBY
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/postgres/generator/migration.rb

@@ -2,9 +2,6 @@ module DynamicMigrations
   module Postgres
     class Generator
       class Migration
-        class UnexpectedSchemaError < StandardError
-        end
-
         class SectionNotFoundError < StandardError
         end
 
@@ -17,6 +14,29 @@ module DynamicMigrations
         class NoFragmentsError < StandardError
         end
 
+        class MissingRequiredTableName < StandardError
+        end
+
+        class MissingRequiredSchemaName < StandardError
+        end
+
+        class UnexpectedTableError < StandardError
+        end
+
+        class UnexpectedSchemaError < StandardError
+        end
+
+        attr_reader :table_name
+        attr_reader :schema_name
+        attr_reader :fragments
+
+        # schema_name and table_name can be nil
+        def initialize schema_name = nil, table_name = nil
+          @schema_name = schema_name
+          @table_name = table_name
+          @fragments = []
+        end
+
         # Defines a new section in the migration file, this is used to group
         # migration fragments of the provided method names together under the
         # provided header
@@ -47,25 +67,27 @@ module DynamicMigrations
           @structure_templates = []
         end
 
-        attr_reader :schema_name
-        attr_reader :fragments
-
-        def initialize schema_name
-          @schema_name = schema_name
-          @fragments = []
-        end
-
         # Add a migration fragment to this migration, if the migration is not
         # configured (via a structure template) to handle the method_name of the
         # fragment, then am error is raised. An error will also be raised if the
         # migration belongs to a different schema than the provided fragment.
         def add_fragment fragment
-          raise UnexpectedSchemaError unless @schema_name == fragment.schema_name
-
           unless supported_migration_method? fragment.migration_method
             raise UnexpectedMigrationMethodNameError, "Expected method to be a valid migrator method, got `#{fragment.migration_method}`"
           end
 
+          # confirm the fragment is for this schema (even if both
+          # these values are nil/there is no schema)
+          unless @schema_name == fragment.schema_name
+            raise UnexpectedSchemaError, "Fragment is for schema `#{fragment.schema_name || "nil"}` but migration is for schema `#{@schema_name || "nil"}`"
+          end
+
+          # confirm this fragment is for this table, this works for database and schame
+          # migrations to, as all values should be nil
+          unless @table_name == fragment.table_name
+            raise UnexpectedTableError, "Fragment is for table `#{fragment.table_name || "nil"}` but migration is for table `#{@table_name || "nil"}`"
+          end
+
           @fragments << fragment
 
           fragment
@@ -122,25 +144,34 @@ module DynamicMigrations
           raise NoFragmentsError if fragments.empty?
 
           if fragments_for_method? :create_schema
-            "create_#{first_fragment_using_migration_method(:create_schema).schema_name}_schema".to_sym
+            :"create_#{first_fragment_using_migration_method(:create_schema).schema_name}_schema"
 
           elsif fragments_for_method? :drop_schema
-            "drop_#{first_fragment_using_migration_method(:drop_schema).schema_name}_schema".to_sym
+            :"drop_#{first_fragment_using_migration_method(:drop_schema).schema_name}_schema"
 
           elsif fragments_for_method? :create_table
-            "create_#{first_fragment_using_migration_method(:create_table).table_name}".to_sym
+            :"create_#{first_fragment_using_migration_method(:create_table).table_name}"
 
           elsif fragments_for_method? :drop_table
-            "drop_#{first_fragment_using_migration_method(:drop_table).table_name}".to_sym
+            :"drop_#{first_fragment_using_migration_method(:drop_table).table_name}"
 
           elsif all_fragments_for_method? [:create_function]
-            "create_function_#{@fragments.find { |s| s.migration_method == :create_function }&.object_name}".to_sym
+            :"create_function_#{@fragments.find { |s| s.migration_method == :create_function }&.object_name}"
 
           elsif all_fragments_for_method? [:create_function, :update_function, :drop_function, :set_function_comment, :remove_function_comment]
             :schema_functions
 
+          elsif all_fragments_for_method? [:create_enum, :add_enum_values, :drop_enum, :set_enum_comment, :remove_enum_comment]
+            :enums
+
+          elsif all_fragments_for_method? [:create_extension]
+            (@fragments.count > 1) ? :":create_extensions" : :"create_#{fragments.first&.object_name}_extension"
+
+          elsif all_fragments_for_method? [:drop_extension]
+            (@fragments.count > 1) ? :":drop_extensions" : :"drop_#{fragments.first&.object_name}_extension"
+
           elsif @fragments.first&.table_name
-            "changes_for_#{@fragments.first&.table_name}".to_sym
+            :"changes_for_#{@fragments.first&.table_name}"
 
           else
             :changes

data/lib/dynamic_migrations/postgres/generator/schema_migration.rb

@@ -7,10 +7,18 @@ module DynamicMigrations
         # for dependencies (i.e. columns have to be created before indexes are added and
         # triggers are removed before functions are dropped)
         add_structure_template [:remove_function_comment, :drop_function], "Remove Functions"
+        add_structure_template [:remove_enum_comment, :drop_enum], "Drop Enums"
         add_structure_template [:drop_schema], "Drop this schema"
+        add_structure_template [:create_enum, :add_enum_values, :set_enum_comment], "Enums"
         add_structure_template [:create_schema], "Create this schema"
         add_structure_template [:create_function], "Functions"
         add_structure_template [:update_function, :set_function_comment], "Update Functions"
+        add_structure_template [:create_extension, :drop_extension], "Extensions"
+
+        def initialize schema_name
+          raise MissingRequiredSchemaName unless schema_name
+          super
+        end
       end
     end
   end

data/lib/dynamic_migrations/postgres/generator/table_migration.rb

@@ -2,12 +2,6 @@ module DynamicMigrations
   module Postgres
     class Generator
       class TableMigration < Migration
-        class UnexpectedTableError < StandardError
-        end
-
-        class MissingRequiredTableName < StandardError
-        end
-
         # these sections are in order for which they will appear in a migration,
         # note that removals come before additions, and that the order here optomizes
         # for dependencies (i.e. columns have to be created before indexes are added and
@@ -31,18 +25,9 @@ module DynamicMigrations
         add_structure_template [:add_trigger, :set_trigger_comment], "Triggers"
         add_structure_template [:update_function, :set_function_comment], "Update Functions"
 
-        attr_accessor :table_name
-
         def initialize schema_name, table_name
+          raise MissingRequiredSchemaName unless schema_name
           raise MissingRequiredTableName unless table_name
-          super schema_name
-          @table_name = table_name
-        end
-
-        def add_fragment fragment
-          unless @table_name == fragment.table_name
-            raise UnexpectedTableError, "Frgment is for table `#{fragment.table_name}` but migration is for table `#{@table_name}`"
-          end
           super
         end
       end

data/lib/dynamic_migrations/postgres/generator.rb

@@ -16,6 +16,9 @@ module DynamicMigrations
       class TableMigrationNotFound < StandardError
       end
 
+      class UnprocessableFragmentError < StandardError
+      end
+
       include Schema
       include Table
       include Column
@@ -26,6 +29,8 @@ module DynamicMigrations
       include Validation
       include Function
       include Trigger
+      include Enum
+      include Extension
 
       def initialize
         @fragments = []
@@ -36,6 +41,9 @@ module DynamicMigrations
         # a hash to hold the generated migrations orgnized by their schema and table
         # this makes it easier and faster to work with them within this method
         database_migrations = {}
+        # the database_specific_migration is for migrations which dont belong
+        # within a specific schema
+        database_specific_migration = DatabaseMigration.new
 
         # Process each fragment, and organize them into migrations. We create a shared
         # Migration for each table, and a single shared migration for any schema migrations
@@ -54,15 +62,22 @@ module DynamicMigrations
           table_name = fragment.table_name
           # If we have a table name, then add the migration fragment to a
           # TableMigration which holds all of the migrations for this table
-          if table_name
+          if table_name && schema_name
             table_migration = schema_migrations[:table_migrations][table_name] ||= TableMigration.new(schema_name, table_name)
             table_migration.add_fragment fragment
 
-          # migration fragments which do not belong to a specific table are added
+          # migration fragments which do have a schema, but do not belong to a specific table are added
           # to a dedicated SchemaMigration object
-          else
+          elsif schema_name && table_name.nil?
             schema_migration = schema_migrations[:schema_migration] ||= SchemaMigration.new(schema_name)
             schema_migration.add_fragment fragment
+
+            # migrations with no schema or table, are added to a database
+            # migration (these re really just creating/dropping extensions)
+          elsif schema_name.nil? && table_name.nil?
+            database_specific_migration.add_fragment fragment
+          else
+            raise UnprocessableFragmentError
           end
         end
 
@@ -158,6 +173,11 @@ module DynamicMigrations
         # the order is determined by their dependencies
         final_migrations = dependency_sorter.tsort
 
+        # if any database only migrations exist, then add them to the from of the array here
+        if database_specific_migration.fragments.any?
+          final_migrations.unshift database_specific_migration
+        end
+
         # return the final migrations in the expected format
         final_migrations.map do |migration|
           {
@@ -200,11 +220,11 @@ module DynamicMigrations
         @dep[node].each(&block)
       end
 
-      def add_fragment schema:, migration_method:, object:, migration:, table: nil, code_comment: nil, dependent_table: nil
+      def add_fragment migration_method:, object:, migration:, schema: nil, table: nil, code_comment: nil, dependent_table: nil
         # Remove any empty lines and whitespace from the beginning or the end of the migration and then
         # strip any empty lines witin the migration (remove the whitespace from them, not delete them).
         final_migration = strip_empty_lines(migration).strip
-        fragment = Fragment.new(schema.name, table&.name, migration_method, object.name, code_comment, final_migration)
+        fragment = Fragment.new(schema&.name, table&.name, migration_method, object.name, code_comment, final_migration)
         if dependent_table
           fragment.set_dependent_table dependent_table.schema.name, dependent_table.name
         end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        module ConfiguredExtensions
+          class ConfiguredExtensionAlreadyExistsError < StandardError
+          end
+
+          # adds a new configured extension for this database
+          def add_configured_extension extension_name
+            raise ExpectedSymbolError, extension_name unless extension_name.is_a? Symbol
+            if has_configured_extension? extension_name
+              raise(ConfiguredExtensionAlreadyExistsError, "Configured extension #{extension_name} already exists")
+            end
+            # sort the hash so that the extensions are in alphabetical order by name
+            @configured_extensions[extension_name] = true
+            sorted_extensions = {}
+            @configured_extensions.keys.sort.each do |extension_name|
+              sorted_extensions[extension_name] = true
+            end
+            @configured_extensions = sorted_extensions
+          end
+
+          # returns true if this table has a configured extension with the provided name, otherwise false
+          def has_configured_extension? extension_name
+            raise ExpectedSymbolError, extension_name unless extension_name.is_a? Symbol
+            @configured_extensions.key? extension_name
+          end
+
+          # returns an array of this tables configured extensions
+          def configured_extensions
+            @configured_extensions.keys
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/extensions.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Differences
+          class ToMigrations
+            module Extensions
+              def process_extension extension_name, configuration_extension, database_extension
+                # if the extension exists in the configuration but not in the database
+                # then we have to create it
+                if configuration_extension[:exists] == true && database_extension[:exists] == false
+                  # a migration to create the extension
+                  @generator.create_extension extension_name
+
+                # if the extension exists in the database but not in the configuration
+                # then we need to delete it
+                elsif configuration_extension[:exists] == false && database_extension[:exists] == true
+                  # a migration to drop the extension
+                  @generator.drop_extension extension_name
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/enums.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Differences
+          class ToMigrations
+            module Schemas
+              module Enums
+                def process_enums schema_name, configuration_enums, database_enums
+                  # process all the enums
+                  enum_names = (configuration_enums.keys + database_enums.keys).uniq
+                  enum_names.each do |enum_name|
+                    process_enum schema_name, enum_name, configuration_enums[enum_name] || {}, database_enums[enum_name] || {}
+                  end
+                end
+
+                def process_enum schema_name, enum_name, configuration_enum, database_enum
+                  # If the enum exists in the configuration but not in the database
+                  # then we have to create it.
+                  if configuration_enum[:exists] == true && database_enum[:exists] == false
+                    # a migration to create the enum
+                    enum = @database.configured_schema(schema_name).enum(enum_name)
+                    @generator.create_enum enum
+                    # optionally add the description
+                    if enum.has_description?
+                      @generator.set_enum_comment enum
+                    end
+
+                  # If the schema exists in the database but not in the configuration
+                  # then we need to delete it.
+                  elsif configuration_enum[:exists] == false && database_enum[:exists] == true
+                    # a migration to create the enum
+                    enum = @database.loaded_schema(schema_name).enum(enum_name)
+                    @generator.drop_enum enum
+
+                  # If the enum exists in both the configuration and database representations
+                  # but the values is different then we need to update the values.
+                  elsif configuration_enum[:values][:matches] == false
+                    original_enum = @database.loaded_schema(schema_name).enum(enum_name)
+                    updated_enum = @database.configured_schema(schema_name).enum(enum_name)
+                    @generator.update_enum original_enum, updated_enum
+                    # does the description also need to be updated
+                    if configuration_enum[:description][:matches] == false
+                      # if the description was removed
+                      if configuration_enum[:description].nil?
+                        @generator.remove_enum_comment updated_enum
+                      else
+                        @generator.set_enum_comment updated_enum
+                      end
+                    end
+
+                  # If the enum exists in both the configuration and database representations
+                  # but the description is different then we need to update the description.
+                  elsif configuration_enum[:description][:matches] == false
+                    enum = @database.configured_schema(schema_name).enum(enum_name)
+                    # if the description was removed
+                    if configuration_enum[:description].nil?
+                      @generator.remove_enum_comment enum
+                    else
+                      @generator.set_enum_comment enum
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas.rb

@@ -18,6 +18,7 @@ module DynamicMigrations
                   # we process the tables and functions after we create the schema
                   # otherwise the schemas objects will not be able to be created
                   process_functions schema_name, configuration_schema[:functions], {}
+                  process_enums schema_name, configuration_schema[:enums], {}
                   process_tables schema_name, configuration_schema[:tables], {}
 
                 # if the schema exists in the database but not in the configuration
@@ -26,6 +27,7 @@ module DynamicMigrations
                   # we process the tables and functions before we drop the schema
                   # as this will drop any dependencies on the schema
                   process_functions schema_name, {}, database_schema[:functions]
+                  process_enums schema_name, {}, database_schema[:enums]
                   process_tables schema_name, {}, database_schema[:tables]
 
                   # a migration to drop the schema
@@ -36,6 +38,7 @@ module DynamicMigrations
                 # then we just need to process the tables and functions
                 else
                   process_functions schema_name, configuration_schema[:functions], database_schema[:functions]
+                  process_enums schema_name, configuration_schema[:enums], database_schema[:enums]
                   process_tables schema_name, configuration_schema[:tables], database_schema[:tables]
                 end
               end

data/lib/dynamic_migrations/postgres/server/database/differences/to_migrations.rb

@@ -12,8 +12,10 @@ module DynamicMigrations
             class UnexpectedDifferencesObjectError < StandardError
             end
 
+            include Extensions
             include Schemas
             include Schemas::Functions
+            include Schemas::Enums
             include Schemas::Tables
             include Schemas::Tables::Columns
             include Schemas::Tables::ForeignKeyConstraints
@@ -35,11 +37,17 @@ module DynamicMigrations
             end
 
             def migrations
+              # process all the extensions
+              extension_names = differences[:configuration][:extensions].keys
+              extension_names.each do |extension_name|
+                process_extension extension_name, differences[:configuration][:extensions][extension_name], differences[:database][:extensions][extension_name]
+              end
+
               # process all the schemas (we can fetch the schema names from either the
               # configuration or the database object)
-              schema_names = differences[:configuration].keys
+              schema_names = differences[:configuration][:schemas].keys
               schema_names.each do |schema_name|
-                process_schema schema_name, differences[:configuration][schema_name], differences[:database][schema_name]
+                process_schema schema_name, differences[:configuration][:schemas][schema_name], differences[:database][:schemas][schema_name]
               end
 
               # return the migrations organized by schema

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

@@ -32,11 +32,38 @@ module DynamicMigrations
           # versions of the current database
           def to_h
             {
-              configuration: self.class.compare_schemas(@database.configured_schemas_hash, @database.loaded_schemas_hash),
-              database: self.class.compare_schemas(@database.loaded_schemas_hash, @database.configured_schemas_hash)
+              configuration: {
+                schemas: self.class.compare_schemas(@database.configured_schemas_hash, @database.loaded_schemas_hash),
+                extensions: self.class.compare_extensions(@database.configured_extensions, @database.loaded_extensions)
+              },
+              database: {
+                schemas: self.class.compare_schemas(@database.loaded_schemas_hash, @database.configured_schemas_hash),
+                extensions: self.class.compare_extensions(@database.loaded_extensions, @database.configured_extensions)
+              }
             }
           end
 
+          def self.compare_extensions extensions, comparison_extensions
+            result = {}
+            # the extensions
+            extensions.each do |extension_name|
+              # compare this extension to the equivilent in the comparison list
+              # note that the comparison may be nil
+              result[extension_name] = {
+                exists: true
+              }
+            end
+            # look for any in the comparison list which were not in the base list
+            comparison_extensions.each do |extension_name|
+              unless result.key? extension_name
+                result[extension_name] = {
+                  exists: false
+                }
+              end
+            end
+            result
+          end
+
           def self.compare_schemas schemas, comparison_schemas
             result = {}
             # the base schemas
@@ -63,10 +90,12 @@ module DynamicMigrations
 
             comparison_tables = comparison_schema.nil? ? {} : comparison_schema.tables_hash
             comparison_functions = comparison_schema.nil? ? {} : comparison_schema.functions_hash
+            comparison_enums = comparison_schema.nil? ? {} : comparison_schema.enums_hash
             {
               exists: true,
               tables: compare_tables(schema.tables_hash, comparison_tables),
-              functions: compare_functions(schema.functions_hash, comparison_functions)
+              functions: compare_functions(schema.functions_hash, comparison_functions),
+              enums: compare_enums(schema.enums_hash, comparison_enums)
             }
           end
 
@@ -158,6 +187,29 @@ module DynamicMigrations
             result
           end
 
+          # compare two hash representations of a set of enums and return
+          # an object which represents the provided `enums` and any differences
+          # between it and the `comparison_enums`
+          def self.compare_enums enums, comparison_enums
+            result = {}
+            # the base enums
+            enums.each do |enum_name, enum|
+              result[enum_name] = compare_record enum, comparison_enums[enum_name], [
+                :values,
+                :description
+              ]
+            end
+            # look for any in the comparison list which were not in the base list
+            comparison_enums.each do |enum_name, enum|
+              unless result.key? enum_name
+                result[enum_name] = {
+                  exists: false
+                }
+              end
+            end
+            result
+          end
+
           # compare two hash representations of a set of columns and return
           # an object which represents the provided `columns` and any differences
           # between it and the `comparison_columns`

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        module EnumsLoader
+          def fetch_enums
+            rows = connection.exec(<<~SQL)
+              SELECT
+                n.nspname AS schema_name,
+                t.typname AS enum_name,
+                e.enumlabel AS enum_value,
+                obj_description(e.enumtypid, 'pg_type') as enum_description
+              FROM pg_type t
+                JOIN pg_enum e ON t.oid = e.enumtypid
+                JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+                ORDER BY enumsortorder
+            SQL
+
+            schemas = {}
+            rows.each do |row|
+              schema_name = row["schema_name"].to_sym
+              enum_name = row["enum_name"].to_sym
+              enum_value = row["enum_value"].to_sym
+
+              schema = schemas[schema_name] ||= {}
+              enum = schema[enum_name] ||= {
+                values: [],
+                description: row["enum_description"]
+              }
+              enum[:values] << enum_value
+            end
+            schemas
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        module ExtensionsLoader
+          # return an array of the extensions active in this database
+          def fetch_extensions
+            rows = connection.exec(<<~SQL)
+              SELECT
+                extname AS name
+              FROM pg_extension;
+            SQL
+
+            extensions = []
+            rows.each do |row|
+              extensions << row["name"].to_sym
+            end
+            extensions
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        module LoadedExtensions
+          class LoadedExtensionAlreadyExistsError < StandardError
+          end
+
+          # adds a new loaded extension for this database
+          def add_loaded_extension extension_name
+            raise ExpectedSymbolError, extension_name unless extension_name.is_a? Symbol
+            if has_loaded_extension? extension_name
+              raise(LoadedExtensionAlreadyExistsError, "Loaded extension #{extension_name} already exists")
+            end
+            # sort the hash so that the extensions are in alphabetical order by name
+            @loaded_extensions[extension_name] = true
+            sorted_extensions = {}
+            @loaded_extensions.keys.sort.each do |extension_name|
+              sorted_extensions[extension_name] = true
+            end
+            @loaded_extensions = sorted_extensions
+          end
+
+          # returns true if this table has a loaded extension with the provided name, otherwise false
+          def has_loaded_extension? extension_name
+            raise ExpectedSymbolError, extension_name unless extension_name.is_a? Symbol
+            @loaded_extensions.key? extension_name
+          end
+
+          # returns an array of this tables loaded extensions
+          def loaded_extensions
+            @loaded_extensions.keys
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,7 +13,7 @@ module DynamicMigrations
 
           # recursively process the database and build all the schemas,
           # tables and columns
-          def recursively_build_schemas_from_database
+          def recursively_load_database_structure
             validations = fetch_validations
             fetch_structure.each do |schema_name, schema_definition|
               schema = add_loaded_schema schema_name
@@ -39,6 +39,18 @@ module DynamicMigrations
               end
             end
 
+            # add any active extensions to the database
+            fetch_extensions.each do |extension_name|
+              add_loaded_extension extension_name
+            end
+
+            # add any enums
+            fetch_enums.each do |schema_name, schema_definition|
+              schema_definition.each do |enum_name, enum_definition|
+                loaded_schema(schema_name).add_enum enum_name, enum_definition[:values], description: enum_definition[:description]
+              end
+            end
+
             # now that the structure has been loaded, we can add keys (foreign
             # keys need to be added last, because they can depend on tables from
             # different schemas)

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Schema
+          # This class represents a postgres enum.
+          class Enum < Source
+            class ExpectedSchemaError < StandardError
+            end
+
+            class ExpectedValuesError < StandardError
+            end
+
+            attr_reader :schema
+            attr_reader :name
+            attr_reader :values
+            attr_reader :description
+
+            # initialize a new object to represent a postgres enum
+            def initialize source, schema, name, values, description: nil
+              super source
+
+              @values = []
+
+              raise ExpectedSchemaError, schema unless schema.is_a? Schema
+              @schema = schema
+
+              raise ExpectedSymbolError, name unless name.is_a? Symbol
+              @name = name
+
+              unless values.is_a?(Array) && values.count > 0
+                raise ExpectedValuesError, "Values are required for enums"
+              end
+              @values = values
+
+              unless description.nil?
+                raise ExpectedStringError, description unless description.is_a? String
+                @description = description.strip
+                @description = nil if description == ""
+              end
+            end
+
+            # returns true if this enum has a description, otehrwise false
+            def has_description?
+              !@description.nil?
+            end
+
+            def differences_descriptions other_enum
+              method_differences_descriptions other_enum, [
+                :values
+              ]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Schema < Source
+          module Enums
+            class EnumAlreadyExistsError < StandardError
+            end
+
+            class EnumDoesNotExistError < StandardError
+            end
+
+            # create and add a new enum
+            def add_enum enum_name, values, description: nil
+              raise ExpectedSymbolError, enum_name unless enum_name.is_a? Symbol
+              if has_enum? enum_name
+                raise(EnumAlreadyExistsError, "Enum #{enum_name} already exists")
+              end
+              included_target = self
+              if included_target.is_a? Schema
+                new_enum = @enums[enum_name] = Enum.new source, included_target, enum_name, values, description: description
+              else
+                raise ModuleIncludedIntoUnexpectedTargetError, included_target
+              end
+              # sort the hash so that the enums are in alphabetical order by name
+              sorted_enums = {}
+              @enums.keys.sort.each do |enum_name|
+                sorted_enums[enum_name] = @enums[enum_name]
+              end
+              @enums = sorted_enums
+              # return the new enum
+              new_enum
+            end
+
+            # return a enum by its name, raises an error if the enum does not exist
+            def enum enum_name
+              raise ExpectedSymbolError, enum_name unless enum_name.is_a? Symbol
+              raise EnumDoesNotExistError unless has_enum? enum_name
+              @enums[enum_name]
+            end
+
+            # returns true/false representing if a enum with the provided name exists
+            def has_enum? enum_name
+              raise ExpectedSymbolError, enum_name unless enum_name.is_a? Symbol
+              @enums.key? enum_name
+            end
+
+            # returns an array of all enums in the schema
+            def enums
+              @enums.values
+            end
+
+            def enums_hash
+              @enums
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -23,7 +23,7 @@ module DynamicMigrations
             def initialize source, schema, name, definition, description: nil
               super source
 
-              @triggers ||= []
+              @triggers = []
 
               raise ExpectedSchemaError, schema unless schema.is_a? Schema
               @schema = schema

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

@@ -13,6 +13,7 @@ module DynamicMigrations
 
           include Tables
           include Functions
+          include Enums
 
           attr_reader :database
           attr_reader :name
@@ -26,6 +27,7 @@ module DynamicMigrations
             @name = name
             @tables = {}
             @functions = {}
+            @enums = {}
           end
         end
       end

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

@@ -104,7 +104,7 @@ module DynamicMigrations
 
           # recursively process the database and build all the schemas,
           # tables and columns
-          def recursively_build_schemas_from_database
+          def recursively_load_database_structure
             fetch_structure.each do |schema_name, schema_definition|
               schema = add_loaded_schema schema_name
 

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

@@ -17,6 +17,10 @@ module DynamicMigrations
         include LoadedSchemas
         include ConfiguredSchemas
         include LoadedSchemasBuilder
+        include ConfiguredExtensions
+        include LoadedExtensions
+        include EnumsLoader
+        include ExtensionsLoader
 
         attr_reader :server
         attr_reader :name
@@ -29,6 +33,8 @@ module DynamicMigrations
           @name = name
           @configured_schemas = {}
           @loaded_schemas = {}
+          @configured_extensions = {}
+          @loaded_extensions = {}
         end
 
         # if `source` is :configuration then returns the configured schema with

data/lib/dynamic_migrations/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DynamicMigrations
-  VERSION = "3.3.1"
+  VERSION = "3.4.0"
 end

data/lib/dynamic_migrations.rb

@@ -15,11 +15,16 @@ require "dynamic_migrations/postgres/server/database/structure_loader"
 require "dynamic_migrations/postgres/server/database/validations_loader"
 require "dynamic_migrations/postgres/server/database/keys_and_unique_constraints_loader"
 require "dynamic_migrations/postgres/server/database/triggers_and_functions_loader"
+require "dynamic_migrations/postgres/server/database/extensions_loader"
+require "dynamic_migrations/postgres/server/database/enums_loader"
 require "dynamic_migrations/postgres/server/database/loaded_schemas_builder"
 require "dynamic_migrations/postgres/server/database/loaded_schemas"
 require "dynamic_migrations/postgres/server/database/configured_schemas"
+require "dynamic_migrations/postgres/server/database/loaded_extensions"
+require "dynamic_migrations/postgres/server/database/configured_extensions"
 
 require "dynamic_migrations/postgres/server/database/differences"
+require "dynamic_migrations/postgres/server/database/differences/to_migrations/extensions"
 require "dynamic_migrations/postgres/server/database/differences/to_migrations/schemas"
 require "dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables"
 require "dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/columns"
@@ -30,6 +35,7 @@ require "dynamic_migrations/postgres/server/database/differences/to_migrations/s
 require "dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/unique_constraints"
 require "dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/validations"
 require "dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/functions"
+require "dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/enums"
 require "dynamic_migrations/postgres/server/database/differences/to_migrations"
 
 require "dynamic_migrations/postgres/server/database"
@@ -37,8 +43,10 @@ require "dynamic_migrations/postgres/server/database/source"
 
 require "dynamic_migrations/postgres/server/database/schema/tables"
 require "dynamic_migrations/postgres/server/database/schema/functions"
+require "dynamic_migrations/postgres/server/database/schema/enums"
 require "dynamic_migrations/postgres/server/database/schema"
 require "dynamic_migrations/postgres/server/database/schema/function"
+require "dynamic_migrations/postgres/server/database/schema/enum"
 require "dynamic_migrations/postgres/server/database/schema/table/validations"
 require "dynamic_migrations/postgres/server/database/schema/table/indexes"
 require "dynamic_migrations/postgres/server/database/schema/table/foreign_key_constraints"
@@ -58,8 +66,10 @@ require "dynamic_migrations/postgres/server"
 require "dynamic_migrations/postgres/connections"
 
 require "dynamic_migrations/postgres/generator/schema"
+require "dynamic_migrations/postgres/generator/extension"
 require "dynamic_migrations/postgres/generator/table"
 require "dynamic_migrations/postgres/generator/column"
+require "dynamic_migrations/postgres/generator/enum"
 require "dynamic_migrations/postgres/generator/foreign_key_constraint"
 require "dynamic_migrations/postgres/generator/function"
 require "dynamic_migrations/postgres/generator/index"
@@ -70,6 +80,7 @@ require "dynamic_migrations/postgres/generator/validation"
 require "dynamic_migrations/postgres/generator"
 require "dynamic_migrations/postgres/generator/fragment"
 require "dynamic_migrations/postgres/generator/migration"
+require "dynamic_migrations/postgres/generator/database_migration"
 require "dynamic_migrations/postgres/generator/schema_migration"
 require "dynamic_migrations/postgres/generator/table_migration"
 require "dynamic_migrations/postgres/generator/migration_dependency_sorter"
@@ -82,6 +93,7 @@ require "dynamic_migrations/active_record/migrators/function"
 require "dynamic_migrations/active_record/migrators/trigger"
 require "dynamic_migrations/active_record/migrators/table"
 require "dynamic_migrations/active_record/migrators/index"
+require "dynamic_migrations/active_record/migrators/enum"
 require "dynamic_migrations/active_record/migrators/column"
 require "dynamic_migrations/active_record/migrators"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dynamic_migrations
 version: !ruby/object:Gem::Version
-  version: 3.3.1
+  version: 3.4.0
 platform: ruby
 authors:
 - Craig Ulliott
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-08-18 00:00:00.000000000 Z
+date: 2023-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -67,6 +67,7 @@ files:
 - lib/dynamic_migrations.rb
 - lib/dynamic_migrations/active_record/migrators.rb
 - lib/dynamic_migrations/active_record/migrators/column.rb
+- lib/dynamic_migrations/active_record/migrators/enum.rb
 - lib/dynamic_migrations/active_record/migrators/foreign_key_constraint.rb
 - lib/dynamic_migrations/active_record/migrators/function.rb
 - lib/dynamic_migrations/active_record/migrators/index.rb
@@ -86,6 +87,9 @@ files:
 - lib/dynamic_migrations/postgres/connections.rb
 - lib/dynamic_migrations/postgres/generator.rb
 - lib/dynamic_migrations/postgres/generator/column.rb
+- lib/dynamic_migrations/postgres/generator/database_migration.rb
+- lib/dynamic_migrations/postgres/generator/enum.rb
+- lib/dynamic_migrations/postgres/generator/extension.rb
 - lib/dynamic_migrations/postgres/generator/foreign_key_constraint.rb
 - lib/dynamic_migrations/postgres/generator/fragment.rb
 - lib/dynamic_migrations/postgres/generator/function.rb
@@ -102,11 +106,14 @@ files:
 - lib/dynamic_migrations/postgres/generator/validation.rb
 - lib/dynamic_migrations/postgres/server.rb
 - lib/dynamic_migrations/postgres/server/database.rb
+- lib/dynamic_migrations/postgres/server/database/configured_extensions.rb
 - lib/dynamic_migrations/postgres/server/database/configured_schemas.rb
 - lib/dynamic_migrations/postgres/server/database/connection.rb
 - lib/dynamic_migrations/postgres/server/database/differences.rb
 - lib/dynamic_migrations/postgres/server/database/differences/to_migrations.rb
+- lib/dynamic_migrations/postgres/server/database/differences/to_migrations/extensions.rb
 - lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas.rb
+- lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/enums.rb
 - lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/functions.rb
 - lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables.rb
 - lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/columns.rb
@@ -116,10 +123,15 @@ files:
 - lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/triggers.rb
 - lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/unique_constraints.rb
 - lib/dynamic_migrations/postgres/server/database/differences/to_migrations/schemas/tables/validations.rb
+- lib/dynamic_migrations/postgres/server/database/enums_loader.rb
+- lib/dynamic_migrations/postgres/server/database/extensions_loader.rb
 - lib/dynamic_migrations/postgres/server/database/keys_and_unique_constraints_loader.rb
+- lib/dynamic_migrations/postgres/server/database/loaded_extensions.rb
 - lib/dynamic_migrations/postgres/server/database/loaded_schemas.rb
 - lib/dynamic_migrations/postgres/server/database/loaded_schemas_builder.rb
 - lib/dynamic_migrations/postgres/server/database/schema.rb
+- lib/dynamic_migrations/postgres/server/database/schema/enum.rb
+- lib/dynamic_migrations/postgres/server/database/schema/enums.rb
 - lib/dynamic_migrations/postgres/server/database/schema/function.rb
 - lib/dynamic_migrations/postgres/server/database/schema/functions.rb
 - lib/dynamic_migrations/postgres/server/database/schema/table.rb