ec-pg 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64cd8465d41750ff6dfefa8f4e9d7a5c05ecb90c65f657ac2d0670f700e5d516
-  data.tar.gz: abba235476bd2b3e624f0ba13a9c4bbe63fce55f7c410ae69b0537de0b6a0d08
+  metadata.gz: 615463774272fc429a2f2dfe75db88f133cdd4507b5d5d94147ff84da214a220
+  data.tar.gz: f23f77f305c261f719a37a79d9728aba485a7b214332b08abc87abcab2330421
 SHA512:
-  metadata.gz: 7a2a8e48e04b460014c0a1603fcad4117d319dbecc53680f4c5238c342c57b087332849db7814c7dfff483ef11a2b7ae6e91179b2deec1ecdd8e37bf093d6c87
-  data.tar.gz: d2c51f56fd6b3c69406ff3e363ec5f35c9344c8d96dedfd4eeb55303b70a907b3128a167ef5c0c510cc3bb199b523119547c4c54e779d9cdeea94209f60b6252
+  metadata.gz: 27e2de6ff3980f2ff75160147fcfc87dd1ad2b5f4f3965bde1601883c23bfa637fc0c38ce93d6b7a3b4f2d537eb8835252026781e162a7324e3951f2e216ae22
+  data.tar.gz: f8135d52f5fd32e97a6e992b6930b0a19b14a27d3e926d6ef03ae19df960baf72ca54557c8d8e5dad0184b6f4360b69cae9be961cac084bc452558362fb7e35f

data/README.md

@@ -201,6 +201,97 @@ Ec::Pg.current_schema  # => 'acme'
 
 ---
 
+## Schema lifecycle (create / drop)
+
+`SchemaRegistry` handles PostgreSQL schema DDL — separate from `SchemaManager` which only handles `search_path` switching.
+
+```ruby
+# Create a schema (raises SchemaAlreadyExists if it exists)
+Ec::Pg::SchemaRegistry.create!("tenant_abc")
+
+# Drop a schema
+Ec::Pg::SchemaRegistry.drop!("tenant_abc")
+Ec::Pg::SchemaRegistry.drop!("tenant_abc", cascade: true)  # drop with all objects
+
+# Check existence
+Ec::Pg::SchemaRegistry.exists?("tenant_abc")   # => true / false
+
+# List all non-system schemas
+Ec::Pg::SchemaRegistry.all   # => ["public", "tenant_abc", ...]
+```
+
+### Rake tasks
+
+```bash
+rake 'ec_pg:schema:create[tenant_abc]'
+rake 'ec_pg:schema:drop[tenant_abc]'
+rake 'ec_pg:schema:drop[tenant_abc,cascade]'
+rake  ec_pg:schema:list
+```
+
+---
+
+## Migrations
+
+`Migrator` runs ActiveRecord migrations inside a specific schema or shard context. Schema migrations track `schema_migrations` in the tenant schema (not the public schema), so tenants can be at different versions.
+
+### Schema migrations
+
+```ruby
+# Migrate to latest
+Ec::Pg::Migrator.migrate_schema("tenant_abc")
+
+# Migrate to a specific version
+Ec::Pg::Migrator.migrate_schema("tenant_abc", version: 20240101120000)
+
+# Migrate a list of schemas
+Ec::Pg::Migrator.migrate_each_schema(["tenant_a", "tenant_b"])
+
+# Roll back
+Ec::Pg::Migrator.rollback_schema("tenant_abc")          # 1 step
+Ec::Pg::Migrator.rollback_schema("tenant_abc", steps: 3)
+```
+
+### Shard migrations
+
+```ruby
+# Migrate a single shard
+Ec::Pg::Migrator.migrate_shard(:shard_one)
+
+# Migrate all shards (derives :shard_1..:shard_N from configuration.number_of_shards)
+Ec::Pg::Migrator.migrate_each_shard
+
+# Migrate an explicit list of shards
+Ec::Pg::Migrator.migrate_each_shard([:shard_one, :shard_two])
+
+# Roll back
+Ec::Pg::Migrator.rollback_shard(:shard_one)
+Ec::Pg::Migrator.rollback_shard(:shard_one, steps: 2)
+```
+
+Custom migration paths can be passed to any method via `paths:`:
+
+```ruby
+Ec::Pg::Migrator.migrate_schema("tenant_abc", paths: ["db/tenant_migrate"])
+```
+
+### Rake tasks
+
+```bash
+rake 'ec_pg:migrate:schema[tenant_abc]'
+rake 'ec_pg:migrate:schemas[tenant_a,tenant_b]'
+rake 'ec_pg:migrate:rollback_schema[tenant_abc]'
+rake 'ec_pg:migrate:rollback_schema[tenant_abc,3]'
+
+rake 'ec_pg:migrate:shard[shard_one]'
+rake  ec_pg:migrate:shards
+rake 'ec_pg:migrate:shards[shard_one,shard_two]'
+rake 'ec_pg:migrate:rollback_shard[shard_one]'
+rake 'ec_pg:migrate:rollback_shard[shard_one,2]'
+```
+
+---
+
 ## Rack middleware
 
 Add `ContextSwitcher` to automatically resolve tenant context from each request:

data/Rakefile

@@ -6,3 +6,8 @@ require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new(:spec)
 
 task default: :spec
+
+path = File.expand_path(__dir__)
+Dir.glob("#{path}/lib/tasks/**/*.rake").each do |f| 
+  load f 
+end

data/lib/ec/pg/configuration.rb

@@ -10,6 +10,7 @@ module Ec
       attr_reader :number_of_shards
       attr_reader :get_context_method
       attr_accessor :context_switch_exclude_paths
+      attr_accessor :pg_excluded_names
 
       def initialize
         self.logger = Logger.new($stdout)
@@ -17,6 +18,7 @@ module Ec
         self.number_of_shards = 1
         self.rls_mode = :local
         self.context_switch_exclude_paths = []
+        self.pg_excluded_names = []
       end
 
       def number_of_shards=(value)

data/lib/ec/pg/migrator.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Ec
+  module Pg
+    # Runs ActiveRecord migrations in the context of a specific schema or shard.
+    #
+    # == Schema migrations
+    #
+    # Sets search_path to the target schema before running migrations so that
+    # Rails creates (and tracks via schema_migrations) tables inside that schema.
+    #
+    #   Migrator.migrate_schema("tenant_abc")
+    #   Migrator.migrate_schema("tenant_abc", version: 20240101120000)
+    #   Migrator.rollback_schema("tenant_abc", steps: 2)
+    #
+    #   Migrator.migrate_each_schema(["tenant_a", "tenant_b"])
+    #
+    # == Shard migrations
+    #
+    # Connects to the target shard before running migrations.
+    #
+    #   Migrator.migrate_shard(:shard_one)
+    #   Migrator.rollback_shard(:shard_one, steps: 1)
+    #
+    #   # Migrate all shards derived from configuration.number_of_shards
+    #   Migrator.migrate_each_shard
+    #
+    #   # Or supply an explicit list
+    #   Migrator.migrate_each_shard([:shard_one, :shard_two])
+    #
+    class Migrator
+      class << self
+        # Runs pending migrations with search_path set to +schema_name+.
+        #
+        # @param schema_name [String]
+        # @param paths   [Array<String>] migration paths (defaults to Rails configured paths)
+        # @param version  [Integer, nil] target version; migrates to latest when nil
+        def migrate_schema(connection, schema_name, paths: nil, version: nil)
+          Ec::Pg.dprint("Running migration for: #{schema_name}".red)
+          connection.schema_search_path = schema_name
+          run_migrations(connection, paths: paths, version: version)
+        end
+
+        def migrate_all_schemas 
+          Ec::Pg::SchemaMixin.registered_models.each do |model|
+            model.schemas.each do |shard, schemas|
+              Ec::Pg.switch(shard: shard) do 
+                schemas.each do |schema|
+                  Ec::Pg.dprint("migrating model: #{model}, shard: #{shard}, schema: #{schema}")
+                    migrate_schema(model.connection, schema)
+                end
+              end
+            end
+          end
+        end
+
+        # Calls {migrate_schema} for each name in +schema_names+.
+        #
+        # @param schema_names [Array<String>]
+        def migrate_each_schema(connection, schema_names, paths: nil, version: nil)
+          schema_names.each { |name| migrate_schema(connection, name, paths: paths, version: version) }
+        end
+
+        # Rolls back +steps+ migrations with search_path set to +schema_name+.
+        #
+        # @param schema_name [String]
+        # @param steps  [Integer] number of migrations to roll back (default 1)
+        def rollback_schema(schema_name, steps: 1, paths: nil)
+          SchemaManager.with_schema(schema_name) do
+            build_context(paths).rollback(steps)
+          end
+        end
+
+        # Runs pending migrations connected to +shard_name+.
+        #
+        # @param shard_name [Symbol]
+        # @param paths  [Array<String>]
+        # @param version [Integer, nil]
+        def migrate_shard(shard_name, paths: nil, version: nil)
+          ShardManager.with_shard(shard_name) do
+            run_migrations(paths: paths, version: version)
+          end
+        end
+
+        # Calls {migrate_shard} for each name in +shard_names+.
+        # When +shard_names+ is omitted, derives +:shard_1+ through +:shard_N+
+        # from +configuration.number_of_shards+.
+        #
+        # @param shard_names [Array<Symbol>, nil]
+        def migrate_each_shard(shard_names = nil, paths: nil, version: nil)
+          (shard_names || default_shards).each do |name|
+            migrate_shard(name, paths: paths, version: version)
+          end
+        end
+
+        # Rolls back +steps+ migrations connected to +shard_name+.
+        #
+        # @param shard_name [Symbol]
+        # @param steps  [Integer]
+        def rollback_shard(shard_name, steps: 1, paths: nil)
+          ShardManager.with_shard(shard_name) do
+            build_context(paths).rollback(steps)
+          end
+        end
+
+        private
+
+        def run_migrations(connection, paths: nil, version: nil)
+          Ec::Pg.dprint("migrations_path: #{paths}")
+
+          ActiveRecord::Base.establish_connection(connection.pool.db_config)
+          connection.pool.migration_context.migrate
+        end
+
+        def default_shards
+          n = Ec::Pg.configuration.number_of_shards
+          (1..n).map { |i| :"shard_#{i}" }
+        end
+      end
+    end
+  end
+end

data/lib/ec/pg/mixin.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Ec 
+  module Pg
+    module Mixin
+      extend ActiveSupport::Concern
+
+      include SchemaMixin
+      include ShardMixin
+      include RlsMixin
+      include SchemaRegistryMixin
+    end
+  end
+end

data/lib/ec/pg/railtie.rb

@@ -28,10 +28,15 @@ module Ec
       #
       # rake_tasks do
       #   load 'tasks/ec-pg-ar.rake'
-      #   if DH::PG.configuration.db_migrate_tenants
+      #   if Ec::Pg.configuration.db_migrate_tenants
       #     require_relative '../support/migration_tasks_enhancer'
       #   end
       # end
+
+      rake_tasks do
+        load File.expand_path("../../tasks/ec_pg_migrate.rake", __dir__)
+        load File.expand_path("../../tasks/ec_pg_schema.rake", __dir__)
+      end
     end
   end
 end

data/lib/ec/pg/schema_registry/cloner.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Ec 
+  module Pg 
+    module SchemaRegistry
+      class Cloner < Struct.new(:connection, :schema, keyword_init: true)
+        include Mixin 
+
+        PgDumpBlacklistedStatements = [
+          /SET search_path/i,
+          /SET lock_timeout/i,
+          /SET row_security/i,
+          /SET idle_in_transaction_session_timeout/i,
+          /CREATE SCHEMA #{Ec::Pg.configuration.default_schema}/i,
+          /COMMENT ON SCHEMA #{Ec::Pg.configuration.default_schema}/i
+        ].freeze
+
+        def call
+          connection.execute(
+            patched_search_path(default_schema_dump)
+          )
+        end
+
+        def patched_search_path(sql)
+          search_path = %[SET search_path = "#{schema}", #{Ec::Pg.configuration.default_schema};]
+
+          swap_schema_qualifier(sql)
+            .split("\n")
+            .reject{|line| line =~ /\\(un)?restrict/}
+            .reject{|line| matches_blacklist?(line, PgDumpBlacklistedStatements).present?}
+            .prepend(search_path)
+            .join("\n")
+        end
+
+        def default_schema_dump
+          # TODO: check exit code of pg_dump
+          with_pg_env {
+            shell_command(
+              %(pg_dump -s -x -O -n #{Ec::Pg.configuration.default_schema} #{configurations[:database]})
+            )
+          }
+        end
+
+        def swap_schema_qualifier(sql)
+          sql.gsub(/#{Ec::Pg.configuration.default_schema}\.\w*/) do |match|
+            if Ec::Pg.configuration.pg_excluded_names.any? {|name| match.include? name}
+              match
+            else
+              match.gsub("#{Ec::Pg.configuration.default_schema}.", %("#{schema}".))
+            end
+          end
+        end
+
+        def matches_blacklist?(input, regexps)
+          regexps.select {|c| input.match(c)}
+        end
+      end
+    end
+  end
+end

data/lib/ec/pg/schema_registry/mixin.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Ec 
+  module Pg 
+    module SchemaRegistry
+      module Mixin 
+        extend ActiveSupport::Concern 
+
+        def with_pg_env(&block)
+          pghost = ENV['PGHOST']
+          pgport = ENV['PGPORT']
+          pguser = ENV['PGUSER']
+          pgpassword = ENV['PGPASSWORD']
+
+          ENV['PGUSER'] = configurations[:superusername] if configurations[:superusername]
+          ENV['PGHOST'] = configurations[:host] if configurations[:host]
+          ENV['PGPORT'] = configurations[:port].to_s if configurations[:port]
+          ENV['PGPASSWORD'] = configurations[:password].to_s if configurations[:password]
+
+          block.call
+        ensure
+          ENV['PGHOST'] = pghost
+          ENV['PGPORT'] = pgport
+          ENV['PGUSER'] = pguser
+          ENV['PGPASSWORD'] = pgpassword
+        end
+
+        def shell_command(command)
+          puts command 
+          %x(#{command})
+        end
+
+        def configurations
+          @configurations ||= connection.pool.db_config.configuration_hash
+        end
+
+      end
+    end
+  end
+end

data/lib/ec/pg/schema_registry/schema_migration_cloner.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Ec 
+  module Pg 
+    module SchemaRegistry
+      class SchemaMigrationCloner < Cloner
+        def default_schema_dump
+          with_pg_env { 
+            shell_command(
+              %(
+                pg_dump -a --inserts -t #{Ec::Pg.configuration.default_schema}.schema_migrations -t #{Ec::Pg.configuration.default_schema}.ar_internal_metadata #{configurations[:database]}
+              )
+            )
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ec/pg/schema_registry_mixin.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative 'schema_registry/mixin'
+require_relative 'schema_registry/cloner'
+require_relative 'schema_registry/schema_migration_cloner'
+
+module Ec
+  module Pg
+    module SchemaRegistryMixin
+      extend ActiveSupport::Concern
+      include SchemaRegistry::Mixin
+
+      class SchemaAlreadyExists < StandardError; end
+      class SchemaNotFound      < StandardError; end
+
+      class_methods do 
+        def create_schema!(shard: nil, schema: schema)
+          Ec::Pg.switch(shard: shard) do 
+            validate_schema_name!(schema)
+
+            if connection.schema_exists?(schema)
+              raise SchemaAlreadyExists, "Cannot create existing schema '#{schema}'"
+            end
+            connection.execute(%{CREATE SCHEMA "#{schema}"})
+
+            Ec::Pg.switch(schema: schema) do
+              SchemaRegistry::Cloner.new(connection: connection, schema: schema).call
+              SchemaRegistry::SchemaMigrationCloner.new(connection: connection, schema: schema).call
+            end
+
+          rescue ::ActiveRecord::ActiveRecordError, PG::Error => exception
+            raise SchemaAlreadyExists, "Error while creating tenant #{tenant}: #{ exception.message }"
+          end
+        end
+
+        def drop_schema!(shard: nil, schema: schema)
+          Ec::Pg.switch(shard: shard) do 
+            validate_schema_name!(schema)
+
+            if connection.schema_exists?(schema)
+              connection.execute(%{DROP SCHEMA "#{schema}" CASCADE})
+            end
+          end
+
+        rescue ::ActiveRecord::ActiveRecordError, PG::Error => exception
+          raise SchemaNotFound, "Error while dropping schema #{schema}: #{exception.message}"
+        end
+
+        # Returns all non-system PostgreSQL schema names, sorted alphabetically.
+        #
+        # @return {'shard_1': ['schema1', 'schema2']}
+        def schemas
+          {}.tap do |hash|
+            Ec::Pg.each_shard do |shard|
+              hash[shard] = connection.execute(<<~SQL).column_values(0)
+                SELECT schema_name
+                FROM   information_schema.schemata
+                WHERE  schema_name NOT IN ('information_schema')
+                AND    schema_name NOT LIKE 'pg_%'
+                ORDER  BY schema_name
+              SQL
+            end
+          end
+        end
+
+        def validate_schema_name!(schema_name)
+          SchemaManager.validate_schema_name!(schema_name)
+        end
+      end
+    end
+  end
+end

data/lib/ec/pg/shard_manager.rb

@@ -44,8 +44,8 @@ module Ec
         assert_ar_version!
 
         Context.with(shard: shard_name) do
-          klass.prohibit_shard_swapping(true) do
-            klass.connected_to(shard: shard_name, role: role, &block)
+          klass.connected_to(shard: shard_name, role: role) do
+            klass.prohibit_shard_swapping(true, &block) 
           end
         end
       rescue ActiveRecord::ConnectionNotEstablished => e

data/lib/ec/pg/shard_mixin.rb

@@ -38,9 +38,6 @@ module Ec
           class_attribute :writing_database_identifier,   default: writing_database_identifier
           class_attribute :reading_database_identifier,   default: reading_database_identifier
 
-          # include InstanceMethods
-          # extend  QueryMethods
-
           self.is_sharded = true
           self.abstract_class = true
           self.connects_to(shards: shards_hash)
@@ -49,23 +46,22 @@ module Ec
         private
         def shards_hash
           {}.tap do |hash|
-            Ec::Pg.configuration.number_of_shards.times do |index|
-              shard_key = "shard_#{index + 1}"
-              hash[shard_key] = {
-                writing: database_identifier_for(writing_database_identifier, index),
-                reading: database_identifier_for(reading_database_identifier, index)
+            Ec::Pg.shards.each do |shard|
+              hash[shard] = {
+                writing: database_identifier_for(writing_database_identifier, shard),
+                reading: database_identifier_for(reading_database_identifier, shard)
               }.compact
             end
           end.symbolize_keys
         end
 
-        def database_identifier_for(database_identifier, index)
+        def database_identifier_for(database_identifier, shard)
           return unless database_identifier.present?
 
           if tenant_mode.to_sym == :solo
             database_identifier
           else
-            [database_identifier, "shard", index + 1].join('_')
+            [database_identifier, shard].join('_')
           end.to_sym
         end
       end

data/lib/ec/pg/version.rb

@@ -2,6 +2,6 @@
 
 module Ec
   module Pg
-    VERSION = "0.1.2"
+    VERSION = "0.1.3"
   end
 end

data/lib/ec/pg.rb

@@ -2,6 +2,7 @@
 
 require "active_record"
 require "active_support/concern"
+require "colorize"
 require_relative "pg/version"
 require_relative "pg/context"
 require_relative "pg/tenant_context"
@@ -22,16 +23,25 @@ module Ec
     class Error < StandardError; end
     class InvalidType < Error; end
 
+    autoload :Mixin, 'ec/pg/mixin.rb'
     autoload :SchemaMixin, 'ec/pg/schema_mixin.rb'
     autoload :SchemaManager, 'ec/pg/schema_manager.rb'
     autoload :ShardMixin, 'ec/pg/shard_mixin.rb'
     autoload :ShardManager, 'ec/pg/shard_manager.rb'
     autoload :RlsMixin, 'ec/pg/rls_mixin.rb'
     autoload :RlsManager, 'ec/pg/rls_manager.rb'
-    autoload :ContextSwitcher, 'ec/pg/middleware/context_switcher.rb'
+    autoload :ContextSwitcher,  'ec/pg/middleware/context_switcher.rb'
+    autoload :SchemaRegistryMixin,   'ec/pg/schema_registry_mixin.rb'
+    autoload :Migrator,         'ec/pg/migrator.rb'
 
     module_function 
 
+    def dprint(*args)
+      if ENV['ECPG_DEBUG']
+        puts args
+      end
+    end
+
     def configure
       yield configuration
     end
@@ -44,6 +54,20 @@ module Ec
       TenantContext.switch(shard: shard, schema: schema, &block)
     end
 
+    def shards 
+      @shards ||= configuration.number_of_shards.times.map do |index|
+        "shard_#{index + 1}"
+      end
+    end
+
+    def each_shard(&block)
+      shards.each do |shard|
+        Ec::Pg.switch(shard: shard) do 
+          yield(shard)
+        end
+      end
+    end
+
     def current_shard = TenantContext.current_shard
     def current_schema = TenantContext.current_schema
 

data/lib/tasks/db.rake

@@ -0,0 +1,8 @@
+namespace :db do
+  namespace :rspec do 
+    desc "Prepares test db for rspec"
+    task prepare: :environment do 
+
+    end
+  end
+end

data/lib/tasks/ec_pg_migrate.rake

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+namespace :ec_pg do
+  # ---------------------------------------------------------------------------
+  # Migrations
+  # ---------------------------------------------------------------------------
+  namespace :migrate do
+    task preload_models: :environment do  
+      if ENV['CPG_DEBUG']
+        ActiveRecord::Base.logger = Logger.new(STDOUT)
+      end
+
+      Dir[Rails.root.join('app/models/**/*.rb')].each do |file| 
+        require file 
+      end
+    end
+
+    desc "Migrate a single schema.  Usage: rake 'ec_pg:migrate:schema[name]'"
+    task :schema, [:name] => :environment do |_, args|
+      name = args[:name] or abort "Usage: rake 'ec_pg:migrate:schema[schema_name]'"
+      Ec::Pg::Migrator.migrate_schema(name)
+      puts "Schema '#{name}' migrated."
+    end
+
+    desc "Migrate comma-separated schemas.  Usage: rake 'ec_pg:migrate:schemas[tenant_a,tenant_b]'"
+    task :schemas => :preload_models do 
+      Ec::Pg::Migrator.migrate_all_schemas
+    end
+
+    desc "Roll back a schema.  Usage: rake 'ec_pg:migrate:rollback_schema[name]' or '[name,2]'"
+    task :rollback_schema, [:name, :steps] => :environment do |_, args|
+      name  = args[:name]  or abort "Usage: rake 'ec_pg:migrate:rollback_schema[name]'"
+      steps = args[:steps]&.to_i || 1
+      Ec::Pg::Migrator.rollback_schema(name, steps: steps)
+      puts "Rolled back #{steps} migration(s) in schema '#{name}'."
+    end
+
+    desc "Migrate a single shard.  Usage: rake 'ec_pg:migrate:shard[shard_one]'"
+    task :shard, [:name] => :environment do |_, args|
+      name = args[:name] or abort "Usage: rake 'ec_pg:migrate:shard[shard_name]'"
+      Ec::Pg::Migrator.migrate_shard(name.to_sym)
+      puts "Shard '#{name}' migrated."
+    end
+
+    desc "Migrate all shards (derived from configuration.number_of_shards, or explicit list)"
+    task :shards, [:names] => :environment do |_, args|
+      shards = args[:names]&.split(",")&.map { |s| s.strip.to_sym }
+      Ec::Pg::Migrator.migrate_each_shard(shards)
+      puts "All shards migrated."
+    end
+
+    desc "Roll back a shard.  Usage: rake 'ec_pg:migrate:rollback_shard[shard_one]' or '[shard_one,2]'"
+    task :rollback_shard, [:name, :steps] => :environment do |_, args|
+      name  = args[:name]  or abort "Usage: rake 'ec_pg:migrate:rollback_shard[name]'"
+      steps = args[:steps]&.to_i || 1
+      Ec::Pg::Migrator.rollback_shard(name.to_sym, steps: steps)
+      puts "Rolled back #{steps} migration(s) in shard '#{name}'."
+    end
+  end
+end

data/lib/tasks/ec_pg_schema.rake

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+namespace :ec_pg do
+  # ---------------------------------------------------------------------------
+  # Schema DDL
+  # ---------------------------------------------------------------------------
+  namespace :schema do
+    desc "Create a PostgreSQL schema.  Usage: rake 'ec_pg:schema:create[name]'"
+    task :create, [:model_class, :shard, :schema_name] => :environment do |_, args|
+      model = args[:model_class].constantize
+      shard = args[:shard]
+      schema = args[:schema_name]
+
+      unless shard.present? && schema.present?
+        abort "Usage: rake 'ec_pg:schema:create[Some::ApplicationRecord,shard_1,schema_name]"
+      end
+      model.create_schema!(shard: shard, schema: schema)
+    end
+
+    desc "Drop a PostgreSQL schema.  Usage: rake 'ec_pg:schema:drop[name]' or 'ec_pg:schema:drop[name,cascade]'"
+    task :drop, [:name, :cascade] => :environment do |_, args|
+      name    = args[:name] or abort "Usage: rake 'ec_pg:schema:drop[schema_name]'"
+      cascade = args[:cascade]&.casecmp?("true") || false
+      Ec::Pg::SchemaRegistry.drop!(name, cascade: cascade)
+      puts "Schema '#{name}' dropped."
+    end
+
+    desc "List all non-system PostgreSQL schemas"
+    task list: :environment do
+      Ec::Pg::SchemaRegistry.all.each { |s| puts s }
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ec-pg
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - gmhawash
@@ -23,6 +23,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -107,6 +121,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner-active_record
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Multitenant implemntations using shards, schemas and RLS
 email:
 - gmhawash@gmail.com
@@ -120,22 +148,29 @@ files:
 - README.md
 - Rakefile
 - config/locales/en.yml
-- ec-pg-0.1.0.gem
-- ec-pg-0.1.1.gem
 - images/stand-with-palestine.webp
 - lib/ec/pg.rb
 - lib/ec/pg/configuration.rb
 - lib/ec/pg/context.rb
 - lib/ec/pg/middleware/context_switcher.rb
+- lib/ec/pg/migrator.rb
+- lib/ec/pg/mixin.rb
 - lib/ec/pg/railtie.rb
 - lib/ec/pg/rls_manager.rb
 - lib/ec/pg/rls_mixin.rb
 - lib/ec/pg/schema_manager.rb
 - lib/ec/pg/schema_mixin.rb
+- lib/ec/pg/schema_registry/cloner.rb
+- lib/ec/pg/schema_registry/mixin.rb
+- lib/ec/pg/schema_registry/schema_migration_cloner.rb
+- lib/ec/pg/schema_registry_mixin.rb
 - lib/ec/pg/shard_manager.rb
 - lib/ec/pg/shard_mixin.rb
 - lib/ec/pg/tenant_context.rb
 - lib/ec/pg/version.rb
+- lib/tasks/db.rake
+- lib/tasks/ec_pg_migrate.rake
+- lib/tasks/ec_pg_schema.rake
 - sig/ec/pg.rbs
 homepage: https://github.com/binnablus/ec-pg
 licenses: