dynamic_migrations 1.0.0

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

@@ -0,0 +1,58 @@
+# 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 columns
+            module Columns
+              class ColumnDoesNotExistError < StandardError
+              end
+
+              class DuplicateColumnError < StandardError
+              end
+
+              # returns the column object for the provided column name, and raises an
+              # error if the column does not exist
+              def column column_name
+                raise ExpectedSymbolError, column_name unless column_name.is_a? Symbol
+                raise ColumnDoesNotExistError unless has_column? column_name
+                @columns[column_name]
+              end
+
+              # returns true if this table has a column with the provided name, otherwise false
+              def has_column? column_name
+                raise ExpectedSymbolError, column_name unless column_name.is_a? Symbol
+                @columns.key? column_name
+              end
+
+              # returns an array of this tables columns
+              def columns
+                @columns.values
+              end
+
+              def columns_hash
+                @columns
+              end
+
+              # adds a new column to this table, and returns it
+              def add_column column_name, data_type, **column_options
+                if has_column? column_name
+                  raise(DuplicateColumnError, "Column #{column_name} already exists")
+                end
+                included_target = self
+                if included_target.is_a? Table
+                  @columns[column_name] = Column.new source, included_target, column_name, data_type, **column_options
+                else
+                  raise ModuleIncludedIntoUnexpectedTargetError, included_target
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Schema
+          class Table
+            # This class represents a postgres foreign key constraint
+            class ForeignKeyConstraint < Source
+              class ExpectedTableError < StandardError
+              end
+
+              class ExpectedArrayOfColumnsError < StandardError
+              end
+
+              class ExpectedDifferentTablesError < StandardError
+              end
+
+              class DuplicateColumnError < StandardError
+              end
+
+              attr_reader :table
+              attr_reader :foreign_table
+              attr_reader :foreign_key_constraint_name
+              attr_reader :deferrable
+              attr_reader :initially_deferred
+
+              # initialize a new object to represent a foreign_key_constraint in a postgres table
+              def initialize source, table, columns, foreign_table, foreign_columns, foreign_key_constraint_name, deferrable: false, initially_deferred: false
+                super source
+
+                raise ExpectedTableError, table unless table.is_a? Table
+                raise ExpectedTableError, foreign_table unless foreign_table.is_a? Table
+
+                # assert that the provided columns is an array
+                unless columns.is_a?(Array) && columns.count > 0
+                  raise ExpectedArrayOfColumnsError
+                end
+
+                # assert that the provided foreign columns is an array
+                unless foreign_columns.is_a?(Array) && foreign_columns.count > 0
+                  raise ExpectedArrayOfColumnsError
+                end
+
+                if table.table_name == foreign_table.table_name && table.schema.schema_name == foreign_table.schema.schema_name
+                  raise ExpectedDifferentTablesError
+                end
+
+                # tables must be set before the columns are added
+                @table = table
+                @foreign_table = foreign_table
+
+                @columns = {}
+                columns.each do |column|
+                  add_column column
+                end
+
+                @foreign_columns = {}
+                foreign_columns.each do |column|
+                  add_column column, true
+                end
+
+                raise ExpectedSymbolError, foreign_key_constraint_name unless foreign_key_constraint_name.is_a? Symbol
+                @foreign_key_constraint_name = foreign_key_constraint_name
+
+                raise ExpectedBooleanError, deferrable unless [true, false].include?(deferrable)
+                @deferrable = deferrable
+
+                raise ExpectedBooleanError, initially_deferred unless [true, false].include?(initially_deferred)
+                @initially_deferred = initially_deferred
+              end
+
+              def columns
+                @columns.values
+              end
+
+              def column_names
+                @columns.keys
+              end
+
+              def foreign_columns
+                @foreign_columns.values
+              end
+
+              def foreign_column_names
+                @foreign_columns.keys
+              end
+
+              def foreign_schema_name
+                @foreign_table.schema.schema_name
+              end
+
+              def foreign_table_name
+                @foreign_table.table_name
+              end
+
+              private
+
+              # used internally to set the columns from this objects initialize method
+              def add_column column, foreign = false
+                if foreign
+                  cs = @foreign_columns
+                  t = @foreign_table
+                else
+                  cs = @columns
+                  t = @table
+                end
+
+                # assert that the provided dsl name is an array of Columns
+                unless column.is_a? Column
+                  raise ExpectedArrayOfColumnsError
+                end
+
+                # assert that the provided column exists within this foreign_key_constraints table
+                unless t.has_column? column.column_name
+                  raise ExpectedArrayOfColumnsError, "One or more columns do not exist in this foreign_key_constraints table"
+                end
+
+                if cs.key? column.column_name
+                  raise(DuplicateColumnError, "Column #{column.column_name} already exists")
+                end
+
+                cs[column.column_name] = column
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# 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 foreign keys
+            module ForeignKeyConstraints
+              class ForeignKeyConstraintDoesNotExistError < StandardError
+              end
+
+              class ForeignKeyConstraintAlreadyExistsError < StandardError
+              end
+
+              # returns the foreign_key_constraint object for the provided foreign_key_constraint name, and raises an
+              # error if the foreign_key_constraint does not exist
+              def foreign_key_constraint foreign_key_constraint_name
+                raise ExpectedSymbolError, foreign_key_constraint_name unless foreign_key_constraint_name.is_a? Symbol
+                raise ForeignKeyConstraintDoesNotExistError unless has_foreign_key_constraint? foreign_key_constraint_name
+                @foreign_key_constraints[foreign_key_constraint_name]
+              end
+
+              # returns true if this table has a foreign_key_constraint with the provided name, otherwise false
+              def has_foreign_key_constraint? foreign_key_constraint_name
+                raise ExpectedSymbolError, foreign_key_constraint_name unless foreign_key_constraint_name.is_a? Symbol
+                @foreign_key_constraints.key? foreign_key_constraint_name
+              end
+
+              # returns an array of this tables foreign_key_constraints
+              def foreign_key_constraints
+                @foreign_key_constraints.values
+              end
+
+              def foreign_key_constraints_hash
+                @foreign_key_constraints
+              end
+
+              # adds a new foreign_key_constraint to this table, and returns it
+              def add_foreign_key_constraint foreign_key_constraint_name, column_names, foreign_schema_name, foreign_table_name, foreign_column_names, **foreign_key_constraint_options
+                if has_foreign_key_constraint? foreign_key_constraint_name
+                  raise(ForeignKeyConstraintAlreadyExistsError, "foreign_key_constraint #{foreign_key_constraint_name} already exists")
+                end
+                columns = column_names.map { |column_name| column column_name }
+                foreign_schema = schema.database.schema foreign_schema_name, source
+                foreign_table = foreign_schema.table foreign_table_name
+                foreign_columns = foreign_column_names.map { |column_name| foreign_table.column column_name }
+                included_target = self
+                if included_target.is_a? Table
+                  @foreign_key_constraints[foreign_key_constraint_name] = ForeignKeyConstraint.new source, included_target, columns, foreign_table, foreign_columns, foreign_key_constraint_name, **foreign_key_constraint_options
+                else
+                  raise ModuleIncludedIntoUnexpectedTargetError, included_target
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Schema
+          class Table
+            # This class represents a postgres table index
+            class Index < Source
+              INDEX_TYPES = [:btree, :hash, :gist, :gin, :bring, :spgist]
+              ORDERS = [:asc, :desc]
+              NULL_POSITIONS = [:first, :last]
+
+              class ExpectedTableError < StandardError
+              end
+
+              class ExpectedArrayOfColumnsError < StandardError
+              end
+
+              class UnexpectedIndexTypeError < StandardError
+              end
+
+              class UnexpectedOrderError < StandardError
+              end
+
+              class UnexpectedNullsPositionError < StandardError
+              end
+
+              class DuplicateColumnError < StandardError
+              end
+
+              attr_reader :table
+              attr_reader :index_name
+              attr_reader :unique
+              attr_reader :where
+              attr_reader :type
+              attr_reader :deferrable
+              attr_reader :initially_deferred
+              attr_reader :order
+              attr_reader :nulls_position
+
+              # initialize a new object to represent a index in a postgres table
+              def initialize source, table, columns, index_name, unique: false, where: nil, type: :btree, deferrable: false, initially_deferred: false, include_columns: [], order: :asc, nulls_position: :last
+                super source
+                raise ExpectedTableError, table unless table.is_a? Table
+                @table = table
+                @columns = {}
+                @include_columns = {}
+
+                # assert that the provided columns is an array
+                unless columns.is_a?(Array) && columns.count > 0
+                  raise ExpectedArrayOfColumnsError
+                end
+
+                columns.each do |column|
+                  add_column column
+                end
+
+                raise ExpectedSymbolError, index_name unless index_name.is_a? Symbol
+                @index_name = index_name
+
+                raise ExpectedBooleanError, unique unless [true, false].include?(unique)
+                @unique = unique
+
+                unless where.nil?
+                  raise ExpectedStringError, where unless where.is_a? String
+                  @where = where
+                end
+
+                raise UnexpectedIndexTypeError, type unless INDEX_TYPES.include?(type)
+                @type = type
+
+                raise ExpectedBooleanError, deferrable unless [true, false].include?(deferrable)
+                @deferrable = deferrable
+
+                raise ExpectedBooleanError, initially_deferred unless [true, false].include?(initially_deferred)
+                @initially_deferred = initially_deferred
+
+                # assert that the include_columns is an array (it's optional, so can be an empty array)
+                unless include_columns.is_a?(Array)
+                  raise ExpectedArrayOfColumnsError
+                end
+
+                include_columns.each do |include_column|
+                  add_column include_column, is_include_column: true
+                end
+
+                raise UnexpectedOrderError, order unless ORDERS.include?(order)
+                @order = order
+
+                raise UnexpectedNullsPositionError, nulls_position unless NULL_POSITIONS.include?(nulls_position)
+                @nulls_position = nulls_position
+              end
+
+              # return an array of this indexes columns
+              def columns
+                @columns.values
+              end
+
+              def column_names
+                @columns.keys
+              end
+
+              # return an array of this indexes include_columns
+              def include_columns
+                @include_columns.values
+              end
+
+              def include_column_names
+                @include_columns.keys
+              end
+
+              private
+
+              # used internally to set the columns from this objects initialize method
+              def add_column column, is_include_column: false
+                # assert that the provided dsl name is an array of Columns
+                unless column.is_a? Column
+                  raise ExpectedArrayOfColumnsError
+                end
+
+                # assert that the provided column exists within this indexes table
+                unless @table.has_column? column.column_name
+                  raise ExpectedArrayOfColumnsError, "One or more columns do not exist in this indexes table"
+                end
+
+                if @columns.key?(column.column_name) || @include_columns.key?(column.column_name)
+                  raise(DuplicateColumnError, "Column #{column.column_name} already exists in index, or is already included")
+                end
+
+                if is_include_column
+                  @include_columns[column.column_name] = column
+                else
+                  @columns[column.column_name] = column
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# 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 indexes
+            module Indexes
+              class IndexDoesNotExistError < StandardError
+              end
+
+              class IndexAlreadyExistsError < StandardError
+              end
+
+              # returns the index object for the provided index name, and raises an
+              # error if the index does not exist
+              def index index_name
+                raise ExpectedSymbolError, index_name unless index_name.is_a? Symbol
+                raise IndexDoesNotExistError unless has_index? index_name
+                @indexes[index_name]
+              end
+
+              # returns true if this table has a index with the provided name, otherwise false
+              def has_index? index_name
+                raise ExpectedSymbolError, index_name unless index_name.is_a? Symbol
+                @indexes.key? index_name
+              end
+
+              # returns an array of this tables indexes
+              def indexes
+                @indexes.values
+              end
+
+              def indexes_hash
+                @indexes
+              end
+
+              # adds a new index to this table, and returns it
+              # include_column_names in broken out from index_options, because it is converted from an
+              # array of column names into an array of columns, and then recombined with the other
+              # options which are sent to the index initialize method
+              def add_index index_name, column_names, include_column_names: [], **index_options
+                if has_index? index_name
+                  raise(IndexAlreadyExistsError, "index #{index_name} already exists")
+                end
+                columns = column_names.map { |column_name| column column_name }
+                include_columns = include_column_names.map { |column_name| column column_name }
+                included_target = self
+                if included_target.is_a? Table
+                  @indexes[index_name] = Index.new source, included_target, columns, index_name, include_columns: include_columns, **index_options
+                else
+                  raise ModuleIncludedIntoUnexpectedTargetError, included_target
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Schema
+          class Table
+            # This class represents a postgres table primary_key
+            class PrimaryKey < Source
+              INDEX_TYPES = [:btree, :gin]
+
+              class ExpectedTableError < StandardError
+              end
+
+              class ExpectedArrayOfColumnsError < StandardError
+              end
+
+              class UnexpectedIndexTypeError < StandardError
+              end
+
+              class DuplicateColumnError < StandardError
+              end
+
+              attr_reader :table
+              attr_reader :primary_key_name
+              attr_reader :index_type
+
+              # initialize a new object to represent a primary_key in a postgres table
+              def initialize source, table, columns, primary_key_name, index_type: :btree
+                super source
+                raise ExpectedTableError, table unless table.is_a? Table
+                @table = table
+                @columns = {}
+
+                # assert that the provided columns is an array
+                unless columns.is_a?(Array) && columns.count > 0
+                  raise ExpectedArrayOfColumnsError
+                end
+
+                columns.each do |column|
+                  add_column column
+                end
+
+                raise ExpectedSymbolError, primary_key_name unless primary_key_name.is_a? Symbol
+                @primary_key_name = primary_key_name
+
+                raise UnexpectedIndexTypeError, index_type unless INDEX_TYPES.include?(index_type)
+                @index_type = index_type
+              end
+
+              # return an array of this primary keys columns
+              def columns
+                @columns.values
+              end
+
+              private
+
+              # used internally to set the columns from this objects initialize method
+              def add_column column
+                # assert that the provided dsl name is an array of Columns
+                unless column.is_a? Column
+                  raise ExpectedArrayOfColumnsError
+                end
+
+                # assert that the provided column exists within this primary keys table
+                unless @table.has_column? column.column_name
+                  raise ExpectedArrayOfColumnsError, "One or more columns do not exist in this primary keys table"
+                end
+
+                if @columns.key?(column.column_name)
+                  raise(DuplicateColumnError, "Column #{column.column_name} already exists in primary_key, or is already included")
+                end
+
+                @columns[column.column_name] = column
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module DynamicMigrations
+  module Postgres
+    class Server
+      class Database
+        class Schema
+          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
+
+              class UnexpectedNullsPositionError < StandardError
+              end
+
+              class DuplicateColumnError < StandardError
+              end
+
+              attr_reader :table
+              attr_reader :unique_constraint_name
+              attr_reader :index_type
+              attr_reader :deferrable
+              attr_reader :initially_deferred
+
+              # initialize a new object to represent a unique_constraint in a postgres table
+              def initialize source, table, columns, unique_constraint_name, index_type: :btree, deferrable: false, initially_deferred: false
+                super source
+                raise ExpectedTableError, table unless table.is_a? Table
+                @table = table
+                @columns = {}
+
+                # assert that the provided columns is an array
+                unless columns.is_a?(Array) && columns.count > 0
+                  raise ExpectedArrayOfColumnsError
+                end
+
+                columns.each do |column|
+                  add_column column
+                end
+
+                raise ExpectedSymbolError, unique_constraint_name unless unique_constraint_name.is_a? Symbol
+                @unique_constraint_name = unique_constraint_name
+
+                raise UnexpectedIndexTypeError, index_type unless INDEX_TYPES.include?(index_type)
+                @index_type = index_type
+
+                raise ExpectedBooleanError, deferrable unless [true, false].include?(deferrable)
+                @deferrable = deferrable
+
+                raise ExpectedBooleanError, initially_deferred unless [true, false].include?(initially_deferred)
+                @initially_deferred = initially_deferred
+              end
+
+              # return an array of this unique_constraints columns
+              def columns
+                @columns.values
+              end
+
+              def column_names
+                @columns.keys
+              end
+
+              private
+
+              # used internally to set the columns from this objects initialize method
+              def add_column column
+                # assert that the provided dsl name is an array of Columns
+                unless column.is_a? Column
+                  raise ExpectedArrayOfColumnsError
+                end
+
+                # assert that the provided column exists within this unique_constraints table
+                unless @table.has_column? column.column_name
+                  raise ExpectedArrayOfColumnsError, "One or more columns do not exist in this unique_constraints table"
+                end
+
+                if @columns.key?(column.column_name)
+                  raise(DuplicateColumnError, "Column #{column.column_name} already exists in unique_constraint, or is already included")
+                end
+
+                @columns[column.column_name] = column
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end