pg_trunk 0.1.0

data/lib/pg_trunk/operations/views/rename_view.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: false
+
+# @!method ActiveRecord::Migration#rename_view(name, **options)
+# Change the name and/or schema of a view
+#
+# @param [#to_s] :name (nil) The qualified name of the view
+# @option [#to_s] :to (nil) The new qualified name for the view
+# @option [Boolean] :if_exists (false) Suppress the error when the view is absent
+#
+# A view can be renamed by changing both the name
+# and the schema (namespace) it belongs to.
+#
+#   rename_view "views.admin_users", to: "admins"
+#
+# With the `if_exists: true` option, the operation won't fail
+# even when the view wasn't existed.
+#
+#   rename_view "views.admin_users", to: "admins", if_exists: true
+#
+# At the same time, the option makes a view irreversible
+# due to uncertainty of the previous state of the database.
+
+module PGTrunk::Operations::Views
+  # @private
+  class RenameView < Base
+    validates :new_name, presence: true
+    validates :replace_existing, :sql_definition, :check, :force, :version,
+              absence: true
+
+    def to_sql(_version)
+      [*change_schema, *change_name].join("; ")
+    end
+
+    def invert
+      irreversible!("if_exists: true") if if_exists
+      self.class.new(**to_h, name: new_name, to: name)
+    end
+
+    private
+
+    def change_schema
+      return if name.schema == new_name.schema
+
+      sql = "ALTER VIEW"
+      sql << " IF EXISTS" if if_exists
+      sql << " #{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)
+      sql = "ALTER VIEW"
+      sql << " IF EXISTS" if if_exists
+      sql << " #{moved.to_sql} RENAME TO #{new_name.name.inspect};"
+    end
+  end
+end

data/lib/pg_trunk/operations/views.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# nodoc
+module PGTrunk::Operations
+  # @private
+  # Namespace for operations with views
+  module Views
+    require_relative "views/base"
+    require_relative "views/change_view"
+    require_relative "views/create_view"
+    require_relative "views/drop_view"
+    require_relative "views/rename_view"
+  end
+end

data/lib/pg_trunk/operations.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# @private
+module PGTrunk
+  # Namespace for creator definitions and their fetchers
+  module Operations
+    # The order of requirements is essential:
+    # in this order independent objects will be dumped to the schema.
+    require_relative "operations/enums"
+    require_relative "operations/composite_types"
+    require_relative "operations/domains"
+    require_relative "operations/tables"
+    require_relative "operations/views"
+    require_relative "operations/materialized_views"
+    require_relative "operations/functions"
+    require_relative "operations/indexes"
+    require_relative "operations/check_constraints"
+    require_relative "operations/foreign_keys"
+    require_relative "operations/procedures"
+    require_relative "operations/triggers"
+    require_relative "operations/statistics"
+  end
+end

data/lib/pg_trunk/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module PGTrunk
+  # @private
+  VERSION = "0.1.0"
+end

data/lib/pg_trunk.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "active_record/connection_adapters/postgresql_adapter"
+require "active_record/migration"
+require "pg"
+require "rails/railtie"
+
+# @private
+# PGTrunk adds methods to `ActiveRecord::Migration`
+# to create and manage PostgreSQL objects
+# in Rails applications.
+module PGTrunk
+  require_relative "pg_trunk/version"
+  require_relative "pg_trunk/core"
+  require_relative "pg_trunk/operations"
+
+  # @private
+  def self.database
+    @database ||= Adapters::Postgres.new
+  end
+
+  # @private
+  def self.dumper
+    @dumper ||= database.dumper
+  end
+end

data/pg_trunk.gemspec

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "pg_trunk/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "pg_trunk"
+  spec.version = PGTrunk::VERSION
+  spec.authors = ["Andrew Kozin"]
+  spec.email = ["andrew.kozin@gmail.com"]
+
+  spec.summary = "Empower PostgreSQL migrations in Rails app"
+  spec.description = <<-DESCRIPTION
+    Adds methods to ActiveRecord::Migration to create and manage PostgreSQL objects in Rails
+  DESCRIPTION
+  spec.homepage = "https://github.com/nepalez/pg_trunk"
+  spec.license = "MIT"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/CHANGELOG.md"
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  spec.files = `git ls-files -z`.split("\x0")
+  spec.test_files = spec.files.grep(%r{^spec/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", ">= 4.0.0"
+  spec.add_dependency "pg"
+  spec.add_dependency "railties", ">= 4.0.0"
+
+  spec.required_ruby_version = ">= 2.7.0"
+end

data/spec/dummy/.gitignore

@@ -0,0 +1,16 @@
+# See https://help.github.com/articles/ignoring-files for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile '~/.gitignore_global'
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore the default SQLite database.
+/db/*.sqlite3
+/db/*.sqlite3-journal
+
+# Ignore all logfiles and tempfiles.
+/log/*.log
+/tmp

data/spec/dummy/Rakefile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path("config/application", __dir__)
+
+Rails.application.load_tasks
+
+unless Rake::Task.task_defined?("db:environment:set")
+  desc "dummy task for rails versions where this task does not exist"
+  task "db:environment:set" do
+    # no op
+  end
+end

data/spec/dummy/bin/bundle

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+# noinspection RubyResolve
+load Gem.bin_path("bundler", "bundle")

data/spec/dummy/bin/rails

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+APP_PATH = File.expand_path("../config/application", __dir__)
+require_relative "../config/boot"
+require "rails/commands"

data/spec/dummy/bin/rake

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../config/boot"
+require "rake"
+Rake.application.run

data/spec/dummy/config/application.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require File.expand_path("boot", __dir__)
+
+# Pick the frameworks you want:
+require "active_record/railtie"
+
+# noinspection RubyResolve
+Bundler.require(*Rails.groups)
+
+module Dummy
+  # noinspection RubyResolve
+  class Application < Rails::Application
+    config.cache_classes = true
+    config.eager_load = false
+    config.active_support.deprecation = :stderr
+  end
+end

data/spec/dummy/config/boot.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Set up gems listed in the Gemfile.
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../../Gemfile", __dir__)
+
+require "bundler/setup" if File.exist?(ENV["BUNDLE_GEMFILE"])
+$LOAD_PATH.unshift File.expand_path("../../../lib", __dir__)

data/spec/dummy/config/database.yml

@@ -0,0 +1,14 @@
+development: &default
+  adapter: postgresql
+  database: pg_trunk_dummy_dev
+  encoding: unicode
+  pool: 5
+  <% if ENV.fetch("GITHUB_ACTIONS", false) %>
+  host: localhost
+  username: <%= ENV.fetch("POSTGRES_USER") %>
+  password: <%= ENV.fetch("POSTGRES_PASSWORD") %>
+  <% end %>
+
+test:
+  <<: *default
+  database: pg_trunk_dummy_test

data/spec/dummy/config/environment.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Load the Rails application.
+require File.expand_path("application", __dir__)
+
+# Initialize the Rails application.
+Rails.application.initialize!

data/spec/dummy/config.ru

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# This file is used by Rack-based servers to start the application.
+
+require ::File.expand_path("config/environment", __dir__)
+run Rails.application

data/spec/dummy/db/materialized_views/admin_users_v01.sql

@@ -0,0 +1 @@
+SELECT id, name FROM users WHERE admin;

data/spec/dummy/db/schema.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the operations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# This file is the source Rails uses to define your schema when running `bin/rails
+# db:schema:load`. When creating a new database, `bin/rails db:schema:load` tends to
+# be faster and is potentially less error prone than running all of your
+# operations from scratch. Old operations may fail to apply correctly if those
+# operations use external dependencies or application code.
+#
+# It's strongly recommended that you check this file into your version control system.
+
+ActiveRecord::Schema.define(version: 0) do
+  # These are extensions that must be enabled in order to support this database
+  enable_extension "plpgsql"
+end

data/spec/dummy/db/views/admin_users_v01.sql

@@ -0,0 +1 @@
+SELECT id, name FROM users WHERE admin;

data/spec/dummy/db/views/admin_users_v02.sql

@@ -0,0 +1 @@
+SELECT NULL::bigint AS id, name FROM users WHERE admin;

data/spec/operations/check_constraints/add_check_constraint_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#add_check_constraint" do
+  before_all do
+    run_migration <<~RUBY
+      create_table "users" do |t|
+        t.string :name
+      end
+    RUBY
+  end
+
+  let(:valid_query)   { "INSERT INTO users (name) VALUES ('xx');" }
+  # breaks the constraint 'length(name) > 1'
+  let(:invalid_query) { "INSERT INTO users (name) VALUES ('x');" }
+
+  context "when added separately" do
+    let(:migration) do
+      <<~RUBY.squish
+        add_check_constraint "users", "length((name)::text) > 1"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to enable_sql_request(valid_query) }
+    its(:execution) { is_expected.to disable_sql_request(invalid_query) }
+    its(:execution) { is_expected.to insert(migration).into_schema }
+
+    its(:inversion) { is_expected.to enable_sql_request(valid_query) }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "when added inside the table definition" do
+    let(:migration) do
+      <<~RUBY
+        change_table "users" do |t|
+          t.check_constraint "length(name) > 1"
+        end
+      RUBY
+    end
+    let(:snippet) do
+      <<~RUBY.squish
+        add_check_constraint "users", "length((name)::text) > 1"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to disable_sql_request(invalid_query) }
+    its(:execution) { is_expected.to enable_sql_request(valid_query) }
+    its(:execution) { is_expected.to insert(snippet).into_schema }
+
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with a comment" do
+    let(:migration) do
+      <<~RUBY.squish
+        add_check_constraint "users", "length((name)::text) > 1",
+                             comment: "Name is long enough"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(migration).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "with an explicit name" do
+    let(:migration) do
+      <<~RUBY.squish
+        add_check_constraint "users", "length((name)::text) > 1",
+                             name: "name_is_long_enough"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to insert(migration).into_schema }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "without an expression" do
+    let(:migration) do
+      <<~RUBY
+        add_check_constraint "users"
+      RUBY
+    end
+
+    it { is_expected.to fail_validation.because(/expression can't be blank/i) }
+  end
+end

data/spec/operations/check_constraints/drop_check_constraint_spec.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#drop_check_constraint" do
+  before_all do
+    run_migration <<~RUBY
+      create_table "users" do |t|
+        t.string :name
+      end
+    RUBY
+  end
+
+  # satisfy the constraint 'length(name) > 1'
+  let(:valid_query) { "INSERT INTO users (name) VALUES ('xx');" }
+  # breaks the constraint 'length(name) > 1'
+  let(:invalid_query) { "INSERT INTO users (name) VALUES ('x');" }
+
+  context "when the constraint was named explicitly" do
+    before { run_migration(snippet) }
+
+    let(:snippet) do
+      <<~RUBY.squish
+        add_check_constraint "users", "length((name)::text) > 1",
+                             name: "name_is_long_enough"
+      RUBY
+    end
+
+    context "with an expression" do
+      let(:migration) do
+        <<~RUBY.squish
+          drop_check_constraint "users", "length((name)::text) > 1",
+                                name: "name_is_long_enough"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to enable_sql_request(invalid_query) }
+      its(:execution) { is_expected.to remove(snippet).from_schema }
+
+      its(:inversion) { is_expected.to disable_sql_request(invalid_query) }
+      its(:inversion) { is_expected.to enable_sql_request(valid_query) }
+      its(:inversion) { is_expected.not_to change_schema }
+    end
+
+    context "without an expression" do
+      let(:migration) do
+        <<~RUBY
+          drop_check_constraint "users", name: "name_is_long_enough"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to enable_sql_request(invalid_query) }
+      its(:execution) { is_expected.to remove(snippet).from_schema }
+
+      it { is_expected.to be_irreversible.because(/expression can't be blank/i) }
+    end
+
+    context "without table name" do
+      let(:migration) do
+        <<~RUBY
+          drop_check_constraint
+        RUBY
+      end
+
+      it { is_expected.to fail_validation.because(/table can't be blank/i) }
+    end
+  end
+
+  context "when the constraint was anonymous" do
+    before { run_migration(snippet) }
+
+    let(:snippet) do
+      <<~RUBY.squish
+        add_check_constraint "users", "length((name)::text) > 1"
+      RUBY
+    end
+    let(:migration) do
+      <<~RUBY
+        drop_check_constraint "users", "length((name)::text) > 1"
+      RUBY
+    end
+
+    its(:execution) { is_expected.to enable_sql_request(invalid_query) }
+    its(:execution) { is_expected.to remove(snippet).from_schema }
+
+    its(:inversion) { is_expected.to disable_sql_request(invalid_query) }
+    its(:inversion) { is_expected.to enable_sql_request(valid_query) }
+    its(:inversion) { is_expected.not_to change_schema }
+  end
+
+  context "when a constraint not existed" do
+    context "without the `it_exists: true` option" do
+      let(:migration) do
+        <<~RUBY
+          drop_check_constraint :users, name: "id_positive"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to raise_error(StandardError) }
+    end
+
+    context "with the `it_exists: true` option" do
+      let(:migration) do
+        <<~RUBY
+          drop_check_constraint :users, "id_positive", if_exists: true
+        RUBY
+      end
+
+      its(:execution) { is_expected.not_to raise_error }
+      it { is_expected.to be_irreversible.because_of(/if_exists: true/i) }
+    end
+  end
+end

data/spec/operations/check_constraints/rename_check_constraint_spec.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+describe ActiveRecord::Migration, "#rename_check_constraint" do
+  before_all do
+    run_migration <<~RUBY
+      create_table :users do |t|
+        t.string :name
+      end
+    RUBY
+  end
+  before { run_migration(old_snippet) }
+
+  context "when the constraint was anonymous" do
+    let(:old_snippet) do
+      <<~RUBY.squish
+        add_check_constraint "users", "length(name) > 1"
+      RUBY
+    end
+
+    context "with a new name" do
+      let(:migration) do
+        <<~RUBY.squish
+          rename_check_constraint "users", "length(name) > 1", to: "my_new_key"
+        RUBY
+      end
+      let(:new_snippet) do
+        <<~RUBY.squish
+          add_check_constraint "users", "length((name)::text) > 1",
+                               name: "my_new_key"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to insert(new_snippet).into_schema }
+      its(:reversion) { is_expected.not_to change_schema }
+    end
+
+    context "without a new name" do
+      let(:migration) do
+        <<~RUBY.squish
+          rename_check_constraint "users", "length((name)::text) > 1"
+        RUBY
+      end
+
+      it { is_expected.to fail_validation.because(/new name must be different/i) }
+    end
+  end
+
+  context "when the constraint was named explicitly" do
+    let(:old_snippet) do
+      <<~RUBY.squish
+        add_check_constraint "users", "length(name) > 1", name: "my_key"
+      RUBY
+    end
+
+    context "without new name" do
+      let(:migration) do
+        <<~RUBY
+          rename_check_constraint "users", "length((name)::text) > 1",
+                                  name: "my_key"
+        RUBY
+      end
+      let(:new_snippet) do
+        <<~RUBY
+          add_check_constraint "users", "length((name)::text) > 1"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to insert(new_snippet).into_schema }
+      its(:reversion) { is_expected.not_to change_schema }
+    end
+
+    context "with a new name" do
+      let(:migration) do
+        <<~RUBY
+          rename_check_constraint "users", "length((name)::text) > 1",
+                                  name: "my_key",
+                                  to: "new_key"
+        RUBY
+      end
+      let(:snippet) do
+        <<~RUBY.squish
+          add_check_constraint "users", "length((name)::text) > 1", name: "new_key"
+        RUBY
+      end
+
+      its(:execution) { is_expected.to insert(snippet).into_schema }
+      its(:reversion) { is_expected.not_to change_schema }
+    end
+  end
+end