pg_trunk 0.1.0

data/lib/pg_trunk/operations/composite_types.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# nodoc
+module PGTrunk::Operations
+  # @private
+  # Definitions for composite types
+  module CompositeTypes
+    require_relative "composite_types/column"
+    require_relative "composite_types/base"
+    require_relative "composite_types/change_composite_type"
+    require_relative "composite_types/create_composite_type"
+    require_relative "composite_types/drop_composite_type"
+    require_relative "composite_types/rename_composite_type"
+  end
+end

data/lib/pg_trunk/operations/domains/base.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: false
+
+module PGTrunk::Operations::Domains
+  # @abstract
+  # @private
+  # Base class for operations with domain types
+  class Base < PGTrunk::Operation
+    # All attributes that can be used by domain-related commands
+    attribute :collation, :pg_trunk_qualified_name
+    attribute :constraints, :pg_trunk_array_of_hashes, default: []
+    attribute :default_sql, :pg_trunk_multiline_text
+    attribute :null, :boolean
+    attribute :type, :pg_trunk_qualified_name, aliases: :as
+
+    # Populate constraints from a block
+    def constraint(check, name: nil)
+      constraints << Constraint.new(check: check, name: name)
+    end
+
+    # Wrap constraint definitions to value objects
+    after_initialize { constraints.map! { |c| Constraint.build(c) } }
+
+    validates :if_not_exists, absence: true
+    validates :name, presence: true
+    validates :constraints, "PGTrunk/all_items_valid": true, allow_nil: true
+
+    # Use comparison by name from pg_trunk operations base class (default)
+    # Support name as the only positional argument (default)
+
+    ruby_snippet do |s|
+      s.ruby_param(name.lean) if name.present?
+      s.ruby_param(as: type.lean) if type.present?
+      s.ruby_param(to: new_name) if new_name.present?
+      s.ruby_param(if_exists: true) if if_exists
+      s.ruby_param(force: :cascade) if force == :cascade
+
+      s.ruby_line(:collation, collation.lean) if collation.present?
+      s.ruby_line(:default_sql, default_sql, from: from_default_sql) if default_sql
+      s.ruby_line(:null, false) if null == false
+      constraints.sort_by(&:name).each do |c|
+        s.ruby_line(:constraint, c.check, **c.opts)
+      end
+      s.ruby_line(:comment, comment, from: from_comment) if comment
+    end
+  end
+end

data/lib/pg_trunk/operations/domains/change_domain.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: false
+
+# @!method ActiveRecord::Migration#change_domain(name, &block)
+# Modify a domain type
+#
+# @param [#to_s] name (nil) The qualified name of the type
+# @yield [Proc] the block with the type's definition
+# @yieldparam The receiver of methods specifying the type
+#
+# The operation can be used to add or remove constraints,
+# modify the default_sql value, or the description of the domain type.
+# Neither the underlying type nor the collation can be changed.
+#
+#   change_domain "dict.us_postal_code" do |d|
+#     d.null true # from: false
+#     # check is added for inversion
+#     d.drop_constraint "postal_code_length", check: <<~SQL
+#       length(VALUE) > 3 AND length(VALUE) < 6
+#     SQL
+#     d.add_constraint <<~SQL, name: "postal_code_valid"
+#       VALUE ~ '^\d{5}$' OR VALUE ~ '^\d{5}-\d{4}$'
+#     SQL
+#     d.default_sql "'00000'::text", from: "'0000'::text"
+#     d.comment <<~COMMENT, from: <<~COMMENT
+#       Supported currencies
+#     COMMENT
+#       Currencies
+#     COMMENT
+#   end
+#
+# Use blank string (not a `nil` value) to reset either a default_sql,
+# or the comment. `nil`-s here will be ignored.
+#
+# When dropping a constraint you can use a `check` expression.
+# In the same manner, use `from` option with `comment` or `default_sql`
+# to make the operation invertible.
+#
+# It is irreversible in case any `drop_constraint` clause
+# has `if_exists: true` or `force: :cascade` option -- due to
+# uncertainty of the previous state of the database:
+#
+#   # Irreversible change
+#   change_domain "dict.us_postal_code", force: :cascade do |d|
+#     d.drop_constraint "postal_code_valid" # missed `:check` option
+#     d.drop_constraint "postal_code_length"
+#     d.drop_constraint "postal_code_format", if_exists: true
+#     d.default_sql "'0000'::text" # missed `:from` option
+#     d.comment "New comment" # missed `:from` option
+#   end
+
+module PGTrunk::Operations::Domains
+  # @private
+  class ChangeDomain < Base
+    # Methods to populate `constraints` from the block
+
+    def add_constraint(check, name: nil, valid: true)
+      constraints << Constraint.new(name: name, check: check, valid: valid)
+    end
+
+    def rename_constraint(name, to:)
+      constraints << Constraint.new(name: name, new_name: to)
+    end
+
+    def validate_constraint(name)
+      constraints << Constraint.new(name: name, valid: true)
+    end
+
+    def drop_constraint(name, check: nil, if_exists: nil)
+      constraints << Constraint.new(
+        check: check,
+        drop: true,
+        force: force,
+        if_exists: if_exists,
+        name: name,
+      )
+    end
+
+    validates :if_exists, :new_name, :type, :collation, absence: true
+    validate { errors.add :base, "There are no changes" if change.blank? }
+
+    def to_sql(_version)
+      [*change_default, *change_null, *change_constraints, *change_comment]
+        .join(" ")
+    end
+
+    def invert
+      keys = inversion.select { |_, v| v.nil? }.keys.join(", ").presence
+      errors = constraints.map(&:inversion_error).compact
+      errors << "Can't invert #{keys}" if keys.present?
+      raise IrreversibleMigration.new(self, nil, *errors) if errors.any?
+
+      self.class.new(**to_h, **inversion)
+    end
+
+    private
+
+    def change_default
+      <<~SQL.squish if default_sql
+        ALTER DOMAIN #{name.to_sql}
+        #{default_sql.present? ? "SET DEFAULT #{default_sql}" : 'DROP DEFAULT'};
+      SQL
+    end
+
+    def change_null
+      <<~SQL.squish unless null.nil?
+        ALTER DOMAIN #{name.to_sql} #{null ? 'DROP' : 'SET'} NOT NULL;
+      SQL
+    end
+
+    def change_constraints
+      constraints.map do |c|
+        "ALTER DOMAIN #{name.to_sql} #{c.to_sql};"
+      end
+    end
+
+    def change_comment
+      <<~SQL.squish if comment
+        COMMENT ON DOMAIN #{name.to_sql} IS $comment$#{comment}$comment$;
+      SQL
+    end
+
+    def change
+      @change ||= {
+        comment: comment,
+        constraints: constraints.map(&:to_h).presence,
+        default_sql: default_sql,
+        null: null,
+      }.compact
+    end
+
+    def inversion
+      @inversion ||= {
+        comment: from_comment,
+        constraints: constraints&.map(&:invert),
+        default_sql: from_default_sql,
+        null: !null,
+      }.slice(*change.keys)
+    end
+  end
+end

data/lib/pg_trunk/operations/domains/constraint.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: false
+
+module PGTrunk::Operations::Domains
+  # @private
+  # Definition for the domain's constraint
+  class Constraint
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include ActiveModel::Validations
+
+    def self.build(data)
+      data.is_a?(self) ? data : new(**data)
+    end
+
+    attribute :check, :pg_trunk_multiline_text
+    attribute :drop, :boolean
+    attribute :force, :pg_trunk_symbol
+    attribute :if_exists, :boolean
+    attribute :name, :string
+    attribute :new_name, :string
+    attribute :valid, :boolean
+
+    validates :name, presence: true
+    validates :new_name, "PGTrunk/difference": { from: :name }, allow_nil: true
+    validates :force, inclusion: { in: %i[force restrict] }, allow_nil: true
+
+    def to_h
+      @to_h ||= attributes.compact.symbolize_keys
+    end
+
+    def opts
+      to_h.slice(:name)
+    end
+
+    def invert
+      @invert ||= {}.tap do |i|
+        i[:name] = new_name.presence || name
+        i[:new_name] = name if new_name.present?
+        i[:drop] = !drop if new_name.blank?
+        i[:check] = check if drop
+      end
+    end
+
+    def to_sql
+      rename_sql || drop_sql || add_sql || validate_sql
+    end
+
+    def inversion_error
+      return <<~MSG.squish if if_exists
+        with `if_exists: true` option cannot be inverted
+        due to uncertainty of the previous state of the database.
+      MSG
+
+      return <<~MSG.squish if force == :cascade
+        with `force: :cascade` option cannot be inverted
+        due to uncertainty of the previous state of the database.
+      MSG
+
+      return if check.present?
+
+      "the constraint `#{name}` is dropped without `check` option."
+    end
+
+    private
+
+    def rename_sql
+      <<~SQL.squish if new_name.present?
+        RENAME CONSTRAINT #{name.inspect} TO #{new_name.inspect}
+      SQL
+    end
+
+    def drop_sql
+      return unless drop
+
+      sql = "DROP CONSTRAINT"
+      sql << " IF EXISTS" if if_exists
+      sql << " #{name.inspect}"
+      sql << " CASCADE" if force == :cascade
+      sql << ";"
+    end
+
+    def add_sql
+      <<~SQL.squish if check.present?
+        ADD CONSTRAINT #{name.inspect}
+        CHECK (#{check})#{' NOT VALID' unless valid}
+      SQL
+    end
+
+    def validate_sql
+      "VALIDATE CONSTRAINT #{name.inspect}" if valid
+    end
+  end
+end

data/lib/pg_trunk/operations/domains/create_domain.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: false
+
+# @!method ActiveRecord::Migration#create_domain(name, **options, &block)
+# Create a domain type
+#
+# @param [#to_s] name (nil) The qualified name of the type
+# @option [#to_s] :as (nil) The base type for the domain (alias: :type)
+# @option [#to_s] :collation (nil) The collation
+# @option [Boolean] :null (true) If a value of this type can be NULL
+# @option [#to_s] :default_sql (nil) The snippet for the default value of the domain
+# @option [#to_s] :comment (nil) The comment describing the constraint
+# @yield [Proc] the block with the type's definition
+# @yieldparam The receiver of methods specifying the type
+#
+# @example:
+#
+#   create_domain "dict.us_postal_code", as: "text" do |d|
+#     d.collation "en_US"
+#     d.default_sql "'0000'::text"
+#     d.null false
+#     d.constraint <<~SQL, name: "code_valid"
+#       VALUE ~ '^\d{5}$' OR VALUE ~ '^\d{5}-\d{4}$'
+#     SQL
+#     d.comment "US postal code"
+#   end
+#
+# It is always reversible.
+
+module PGTrunk::Operations::Domains
+  # @private
+  class CreateDomain < Base
+    validates :type, presence: true
+    validates :force, :if_exists, :new_name, absence: true
+
+    from_sql do |_version|
+      <<~SQL
+        SELECT
+          t.oid,
+          (t.typnamespace::regnamespace || '.' || t.typname) AS name,
+          (
+            CASE
+            WHEN b.typnamespace != 'pg_catalog'::regnamespace
+              THEN b.typnamespace::regnamespace || '.' || b.typname
+            ELSE b.typname
+            END
+          ) AS "type",
+          (
+            CASE
+            WHEN c.collnamespace != 'pg_catalog'::regnamespace
+              THEN c.collnamespace::regnamespace || '.' || c.collname
+            WHEN c.collname != 'default'
+              THEN c.collname
+            END
+          ) AS collation,
+          (CASE WHEN t.typnotnull THEN false END) AS null,
+          (
+            CASE
+            WHEN t.typdefaultbin IS NOT NULL
+            THEN pg_get_expr(t.typdefaultbin, 0, true)
+            END
+          ) AS default_sql,
+          (
+            SELECT json_agg(
+              json_build_object(
+                'name', c.conname,
+                'check', pg_get_expr(c.conbin, 0, true)
+              )
+            )
+            FROM pg_constraint c
+            WHERE c.contypid = t.oid
+          ) AS constraints,
+          d.description AS comment
+        FROM pg_type t
+          JOIN pg_trunk e ON e.oid = t.oid
+            AND e.classid = 'pg_type'::regclass
+          JOIN pg_type b ON b.oid = t.typbasetype
+          LEFT JOIN pg_collation c ON c.oid = t.typcollation
+          LEFT JOIN pg_description d ON d.objoid = t.oid
+            AND d.classoid = 'pg_type'::regclass
+        WHERE t.typtype = 'd';
+      SQL
+    end
+
+    def to_sql(_version)
+      [create_domain, *create_comment, register_domain].join(" ")
+    end
+
+    def invert
+      DropDomain.new(**to_h)
+    end
+
+    private
+
+    def create_domain
+      sql = "CREATE DOMAIN #{name.to_sql} AS #{type.to_sql}"
+      sql << " COLLATE #{collation.to_sql}" if collation.present?
+      sql << " DEFAULT #{default_sql}" if default_sql.present?
+      sql << " NOT NULL" if null == false
+      constraints&.each do |c|
+        sql << " CONSTRAINT #{c.name.inspect}" if c.name.present?
+        sql << " CHECK (#{c.check})"
+      end
+      sql << ";"
+    end
+
+    def create_comment
+      return if comment.blank?
+
+      "COMMENT ON DOMAIN #{name.to_sql} IS $comment$#{comment}$comment$;"
+    end
+
+    def register_domain
+      <<~SQL.squish
+        INSERT INTO pg_trunk (oid, classid)
+          SELECT oid, 'pg_type'::regclass
+          FROM pg_type
+          WHERE typname = #{name.quoted}
+            AND typnamespace = #{name.namespace}
+            AND typtype = 'd'
+        ON CONFLICT DO NOTHING;
+      SQL
+    end
+  end
+end

data/lib/pg_trunk/operations/domains/drop_domain.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: false
+
+# @!method ActiveRecord::Migration#drop_domain(name, **options, &block)
+# Drop a domain type by qualified name
+#
+# @param [#to_s] name (nil) The qualified name of the type
+# @option [Boolean] :if_exists (false) Suppress the error when the type is absent
+# @option [Symbol] :force (:restrict) How to process dependent objects (`:cascade` or `:restrict`)
+# @option [#to_s] :as (nil) The base type for the domain (alias: :type)
+# @option [#to_s] :collation (nil) The collation
+# @option [#to_s] :default_sql (nil) The snippet for the default value of the domain
+# @option [#to_s] :comment (nil) The comment describing the constraint
+# @yield [Proc] the block with the type's definition
+# @yieldparam The receiver of methods specifying the type
+#
+# @example:
+#
+#   drop_domain "dict.us_postal_code"
+#
+# To make the operation invertible, use the same options
+# as in the `create_domain` operation.
+#
+#   drop_domain "dict.us_postal_code", as: "string" do |d|
+#     d.constraint <<~SQL, name: "code_valid"
+#       VALUE ~ '^\d{5}$' OR VALUE ~ '^\d{5}-\d{4}$'
+#     SQL
+#     d.comment <<~COMMENT
+#       US postal code
+#     COMMENT
+#   end
+#
+# With the `force: :cascade` option the operation would remove
+# all the objects that use the type.
+#
+#   drop_domain "dict.us_postal_code", force: :cascade
+#
+# With the `if_exists: true` option the operation won't fail
+# even when the view was absent in the database.
+#
+#   drop_domain "dict.us_postal_code", if_exists: true
+#
+# Both options make a migration irreversible due to uncertainty
+# of the previous state of the database.
+
+module PGTrunk::Operations::Domains
+  # @private
+  class DropDomain < Base
+    # Forbid these attributes
+    validates :new_name, absence: true
+
+    def to_sql(_version)
+      sql = "DROP DOMAIN"
+      sql << " IF EXISTS" if if_exists
+      sql << " #{name.to_sql}"
+      sql << " CASCADE" if force == :cascade
+      sql << ";"
+    end
+
+    def invert
+      irreversible!("if_exists: true") if if_exists
+      irreversible!("force: :cascade") if force == :cascade
+      CreateDomain.new(**to_h.except(:force))
+    end
+  end
+end

data/lib/pg_trunk/operations/domains/rename_domain.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: false
+
+# @!method ActiveRecord::Migration#rename_domain(name, to:)
+# Change the name and/or schema of a domain type
+#
+# @param [#to_s] :name (nil) The qualified name of the type
+# @option [#to_s] :to (nil) The new qualified name for the type
+#
+# A domain type can be both renamed and moved to another schema.
+#
+#   rename_domain "us_code", to: "dict.us_postal_code"
+#
+# The operation is always reversible.
+
+module PGTrunk::Operations::Domains
+  # @private
+  class RenameDomain < Base
+    validates :new_name, presence: true
+    validates :force, :if_exists, absence: true
+
+    def to_sql(_version)
+      [*change_schema, *change_name].join("; ")
+    end
+
+    def invert
+      self.class.new(**to_h, name: new_name, to: name)
+    end
+
+    private
+
+    def change_schema
+      return if name.schema == new_name.schema
+
+      "ALTER DOMAIN #{name.to_sql} SET SCHEMA #{new_name.schema.inspect};"
+    end
+
+    def change_name
+      return if new_name.name == name.name
+
+      moved = name.merge(schema: new_name.schema)
+      "ALTER DOMAIN #{moved.to_sql} RENAME TO #{new_name.name.inspect};"
+    end
+  end
+end

data/lib/pg_trunk/operations/domains.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# nodoc
+module PGTrunk::Operations
+  # @private
+  # Namespace for operations with functions
+  module Domains
+    require_relative "domains/constraint"
+    require_relative "domains/base"
+    require_relative "domains/change_domain"
+    require_relative "domains/create_domain"
+    require_relative "domains/drop_domain"
+    require_relative "domains/rename_domain"
+  end
+end

data/lib/pg_trunk/operations/enums/base.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: false
+
+module PGTrunk::Operations::Enums
+  # @abstract
+  # @private
+  # Base class for operations with enumerated types
+  class Base < PGTrunk::Operation
+    # All attributes that can be used by enum-related commands
+    attribute :changes, :pg_trunk_array_of_hashes, default: []
+    attribute :values, :pg_trunk_array_of_strings, default: []
+
+    # populate values one-by-one in a block
+    def value(value)
+      values << value.to_s
+    end
+
+    # wrap change definitions into value objects
+    after_initialize { changes.map! { |change| Change.build(change) } }
+
+    validates :if_not_exists, absence: true
+    validates :name, presence: true
+    validates :changes, "PGTrunk/all_items_valid": true, allow_nil: true
+
+    # Use comparison by name from pg_trunk operations base class (default)
+    # Support name as the only positional argument (default)
+
+    ruby_snippet do |s|
+      s.ruby_param(name.lean) if name.present?
+      s.ruby_param(to: new_name) if new_name.present?
+      s.ruby_param(if_exists: true) if if_exists
+      s.ruby_param(force: :cascade) if force == :cascade
+
+      if values.join(", ").length < 60
+        s.ruby_line(:values, *values)
+      else
+        values.each { |value| s.ruby_line(:value, value) }
+      end
+      changes.select(&:add?).each do |change|
+        s.ruby_line(:add_value, change.name, **change.opts)
+      end
+      changes.select(&:rename?).each do |change|
+        s.ruby_line(:rename_value, change.name, to: change.new_name)
+      end
+      s.ruby_line(:comment, comment) if comment.present?
+    end
+  end
+end

data/lib/pg_trunk/operations/enums/change.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: false
+
+module PGTrunk::Operations::Enums
+  # @private
+  # Definition for the value's change
+  class Change
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include ActiveModel::Validations
+
+    def self.build(data)
+      data.is_a?(self) ? data : new(**data)
+    end
+
+    attribute :name, :string
+    attribute :new_name, :string
+    attribute :after, :string
+    attribute :before, :string
+
+    validates :name, presence: true
+    validates :new_name, "PGTrunk/difference": { from: :name }, allow_nil: true
+    validate { errors.add :after,  :present if rename? && after.present? }
+    validate { errors.add :before, :present if rename? && before.present? }
+    validate { errors.add :before, :present if [after, before].all?(&:present?) }
+
+    def rename?
+      new_name.present?
+    end
+
+    def add?
+      new_name.blank?
+    end
+
+    def to_h
+      attributes.compact.symbolize_keys
+    end
+
+    def opts
+      to_h.slice(:before, :after).compact
+    end
+
+    def invert
+      { name: new_name, new_name: name }
+    end
+
+    def to_sql
+      return "RENAME VALUE '#{name}' TO '#{new_name}'" if new_name.present?
+
+      sql = "ADD VALUE IF NOT EXISTS $value$#{name}$value$"
+      sql << " BEFORE $value$#{before}$value$" if before.present?
+      sql << " AFTER $value$#{after}$value$" if after.present?
+      sql
+    end
+  end
+end