tenant_partition 0.1.1 → 0.1.3

data/lib/tenant_partition/configuration.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
+# Namespace principal de la gema.
 module TenantPartition
+  # Clase contenedora de la configuración global de la gema.
   class Configuration
-    # @return [Symbol, nil] Columna de base de datos (ej: :isp_id)
+    # @return [Symbol, nil] Columna de base de datos usada para particionar (ej: :isp_id).
     attr_accessor :partition_key
 
-    # @return [String, nil] Nombre del Header HTTP personalizado (ej: 'X-Tenant-ID')
+    # @return [String, nil] Nombre del Header HTTP para identificación (ej: 'X-Tenant-ID').
     attr_accessor :header_name
 
     def initialize
@@ -13,21 +15,27 @@ module TenantPartition
       @header_name = nil
     end
 
+    # Valida si la configuración mínima requerida está presente.
+    # @return [Boolean] true si es válida.
     def valid?
       !partition_key.nil?
     end
   end
 
   class << self
+    # @return [TenantPartition::Configuration] La instancia actual de configuración.
     attr_accessor :configuration
 
+    # Punto de entrada para configurar la gema.
+    # @yieldparam [TenantPartition::Configuration] config
+    # @raise [TenantPartition::Error] Si la configuración resultante es inválida.
     def configure
       self.configuration ||= Configuration.new
       yield(configuration)
 
-      unless configuration.valid?
-        raise TenantPartition::Error, "Debe configurar un 'partition_key' en el inicializador de TenantPartition."
-      end
+      return if configuration.valid?
+
+      raise TenantPartition::Error, "Debe configurar un 'partition_key' en el inicializador de TenantPartition."
     end
   end
 end

data/lib/tenant_partition/maintenance.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module TenantPartition
+  # Módulo Mixin que agrega capacidades de mantenimiento (Auditoría y Limpieza)
+  # a la fachada principal.
+  module Maintenance
+    # Audita todas las tablas DEFAULT del sistema buscando registros huérfanos.
+    # Un registro huérfano es aquel que cayó en la tabla default porque su partición no existía.
+    #
+    # @return [Hash{String => Integer}] Reporte con nombre del modelo y cantidad de huérfanos.
+    def audit
+      ensure_models_loaded!
+      log_info "AUDIT", "Iniciando auditoría de tablas DEFAULT..."
+
+      partitionable_models.each_with_object({}) do |model, report|
+        count = count_default_rows(model)
+        report[model.name] = count
+        log_audit_result(model, count)
+      end
+    end
+
+    # Ejecuta el proceso de limpieza global.
+    # Identifica registros huérfanos y los mueve a sus particiones correspondientes.
+    #
+    # @return [void]
+    def cleanup!
+      ensure_models_loaded!
+      key = configuration.partition_key
+      log_info "CLEANUP", "Iniciando proceso de limpieza global..."
+
+      partitionable_models.each do |model|
+        process_cleanup_for_model(model, key)
+      end
+    end
+
+    private
+
+    # Registra el resultado de una auditoría en el log.
+    def log_audit_result(model, count)
+      if count.positive?
+        log_warn "ALERTA", "#{model.name}: #{count} registros huérfanos encontrados."
+      else
+        log_info "OK", "#{model.name}: Tabla default limpia."
+      end
+    end
+
+    # Orquesta la limpieza para un modelo específico.
+    def process_cleanup_for_model(model, key)
+      orphan_ids = fetch_orphan_ids(model, key)
+      return log_info("OK", "#{model.name}: Sin datos huérfanos.") if orphan_ids.empty?
+
+      log_warn "FIX", "#{model.name}: Procesando #{orphan_ids.count} tenants con datos huérfanos."
+      orphan_ids.each { |id| move_orphans(model, id) }
+    end
+
+    # Mueve los huérfanos de un tenant específico.
+    def move_orphans(model, id)
+      partition = model.find(id)
+      if partition
+        moved = partition.populate_from_default
+        log_info "MOVE", "  -> ID #{id}: #{moved} registros recuperados."
+      else
+        log_error "ERROR", "  -> ID #{id}: La partición física no existe. Cree el tenant primero."
+      end
+    end
+
+    # Cuenta las filas en la tabla default de un modelo.
+    def count_default_rows(model)
+      model.connection.select_value("SELECT count(*) FROM #{model.default_table}").to_i
+    rescue ActiveRecord::StatementInvalid
+      0
+    end
+
+    # Obtiene los IDs únicos de los registros atrapados en la tabla default.
+    def fetch_orphan_ids(model, key)
+      sql = "SELECT DISTINCT #{key} FROM #{model.default_table} WHERE #{key} IS NOT NULL"
+      model.connection.execute(sql).map { |r| r[key.to_s] }
+    rescue ActiveRecord::StatementInvalid
+      []
+    end
+  end
+end

data/lib/tenant_partition/safety_guard.rb

@@ -1,48 +1,47 @@
 # frozen_string_literal: true
 
 module TenantPartition
-  # Clase encargada de validar que el entorno y la configuración sean aptos
-  # para el funcionamiento de TenantPartition.
+  # Clase interna encargada de validar prerequisitos del entorno y base de datos.
   class SafetyGuard
-    # Versión mínima de PostgreSQL soportada para particionamiento nativo estable.
+    # Versión mínima de PostgreSQL requerida.
     MIN_POSTGRES_VERSION = 13.0
 
-    # Ejecuta todas las validaciones de seguridad.
-    # @raise [TenantPartition::Error] Si alguna validación falla.
-    # @return [void]
-    def self.validate!
-      check_configuration!
-      return unless defined?(Rails) && Rails.env.to_s != 'test'
+    class << self
+      # Ejecuta todas las validaciones de seguridad.
+      # @raise [TenantPartition::Error] Si alguna validación falla.
+      def validate!
+        check_configuration!
+        return unless defined?(Rails) && Rails.env.to_s != "test"
 
-      check_database_adapter!
-      check_postgres_version!
-    end
+        check_database_adapter!
+        check_postgres_version!
+      end
 
-    private
+      private
+
+      def check_configuration!
+        return unless TenantPartition.configuration.partition_key.nil?
 
-    # Verifica que la clave de partición esté presente.
-    def self.check_configuration!
-      if TenantPartition.configuration.partition_key.nil?
         raise TenantPartition::Error, "Falta configuración: 'partition_key' no ha sido definido."
       end
-    end
 
-    # Asegura que se esté utilizando PostgreSQL.
-    def self.check_database_adapter!
-      adapter = ActiveRecord::Base.connection_db_config.adapter
-      unless adapter == "postgresql"
-        raise TenantPartition::Error, "Adaptador incompatible: TenantPartition solo soporta PostgreSQL (usando: #{adapter})."
+      def check_database_adapter!
+        adapter = ActiveRecord::Base.connection_db_config.adapter
+        return if adapter == "postgresql"
+
+        raise TenantPartition::Error, "Adaptador incompatible: TenantPartition solo soporta " \
+                                      "PostgreSQL (usando: #{adapter})."
       end
-    end
 
-    # Verifica la versión de PostgreSQL mediante una consulta directa al motor.
-    def self.check_postgres_version!
-      version = ActiveRecord::Base.connection.select_value("SHOW server_version").to_f
-      if version < MIN_POSTGRES_VERSION
-        raise TenantPartition::Error, "Versión de PostgreSQL insuficiente: Se requiere v#{MIN_POSTGRES_VERSION}+ (detectada: #{version})."
+      def check_postgres_version!
+        version = ActiveRecord::Base.connection.select_value("SHOW server_version").to_f
+        return if version >= MIN_POSTGRES_VERSION
+
+        raise TenantPartition::Error, "Versión de PostgreSQL insuficiente: Se requiere " \
+                                      "v#{MIN_POSTGRES_VERSION}+ (detectada: #{version})."
+      rescue ActiveRecord::StatementInvalid, ActiveRecord::ConnectionNotEstablished
+        # Si no hay conexión aún, se posterga la validación hasta el primer uso real
       end
-    rescue ActiveRecord::StatementInvalid, ActiveRecord::ConnectionNotEstablished
-      # Si no hay conexión aún, se posterga la validación
     end
   end
 end

data/lib/tenant_partition/schema/statements.rb

@@ -2,65 +2,65 @@
 
 module TenantPartition
   module Schema
-    # Proporciona métodos adicionales para las migraciones de ActiveRecord
-    # enfocados en la automatización del particionamiento nativo de PostgreSQL.
+    # Módulo que extiende ActiveRecord::Migration con DSL para particionamiento.
     module Statements
-      # Crea una tabla padre particionada por lista y genera automáticamente
-      # su partición por defecto (DEFAULT).
+      # Crea una tabla particionada por lista y su tabla DEFAULT asociada.
+      # Configura automáticamente Primary Keys Compuestas para compatibilidad con Postgres.
       #
-      # CORRECCIÓN IMPORTANTE: Configura una Primary Key Compuesta (id + partition_key)
-      # para cumplir con los requisitos de unicidad de PostgreSQL en tablas particionadas.
-      #
-      # @param table_name [Symbol, String] El nombre de la tabla a crear.
-      # @param options [Hash] Opciones estándar + :partition_key opcional.
-      # @yield [t] Bloque para definir las columnas de la tabla.
+      # @param table_name [Symbol] Nombre de la tabla.
+      # @param options [Hash] Opciones de migración estándar.
+      # @option options [Symbol] :partition_key Clave opcional para sobreescribir la global.
+      # @yield [t] Bloque de definición de tabla (ActiveRecord::ConnectionAdapters::TableDefinition).
       def create_partitioned_table(table_name, **options, &block)
-        # Prioridad: 1. Opción pasada al método, 2. Configuración global
         key = options.delete(:partition_key) || TenantPartition.configuration&.partition_key
+        raise TenantPartition::Error, "Falta 'partition_key'." unless key
+
+        configure_pk_and_options(options, key)
 
-        unless key
-          raise TenantPartition::Error, "Debe configurar 'partition_key' globalmente o pasarlo como opción."
+        create_table(table_name, **options) do |t|
+          setup_partitioning(t, key, block)
         end
 
-        # --- LÓGICA DE PRIMARY KEY COMPUESTA ---
-        # 1. Desactivamos la creación automática del ID simple, ya que Postgres fallaría.
-        options[:id] = false
+        create_default_partition(table_name)
+      end
 
-        # 2. Definimos explícitamente que la PK está formada por el ID y la CLAVE DE PARTICIÓN.
-        # Esto genera en SQL: PRIMARY KEY (id, isp_id)
-        options[:primary_key] = [:id, key]
+      # Elimina una tabla particionada en cascada.
+      # @param table_name [Symbol] Nombre de la tabla.
+      def drop_partitioned_table(table_name)
+        drop_table(table_name, cascade: true)
+      end
 
-        # 3. Inyectamos la estrategia de particionamiento
-        options[:options] = "PARTITION BY LIST (#{key})"
+      private
 
-        # Crear la tabla padre
-        create_table(table_name, **options) do |t|
-          # A. Como desactivamos id: false, debemos crear la columna ID manualmente.
-          # Usamos gen_random_uuid() para que sea autogenerado.
-          t.uuid :id, null: false, default: -> { "gen_random_uuid()" }
+      # Configura las columnas y definiciones dentro del bloque create_table.
+      def setup_partitioning(table, key, block)
+        table.uuid :id, null: false, default: -> { "gen_random_uuid()" }
+        block.call(table)
+        ensure_partition_column(table, key)
+      end
 
-          # B. Ejecutamos las definiciones del usuario
-          block.call(t)
+      # Prepara las opciones de PK compuesta y tipo de partición.
+      def configure_pk_and_options(options, key)
+        options[:id] = false
+        options[:primary_key] = [:id, key]
+        options[:options] = "PARTITION BY LIST (#{key})"
+      end
 
-          # C. Inyección automática del atributo de partición si el usuario no lo definió.
-          # Nota: Si el usuario ya puso `t.uuid :isp_id` en su migración, esta línea la salta.
-          unless t.columns.any? { |c| c.name == key.to_s }
-            t.column key, :string, null: false
-          end
-        end
+      # Asegura que la columna de partición exista si el usuario olvidó definirla.
+      def ensure_partition_column(table, key)
+        return if table.columns.any? { |c| c.name == key.to_s }
 
-        # Crear la partición DEFAULT
+        table.column key, :string, null: false
+      end
+
+      # Crea la tabla _default para capturar datos sin partición asignada.
+      def create_default_partition(table_name)
         default_name = "#{table_name}_default"
         execute <<-SQL.squish
           CREATE TABLE IF NOT EXISTS #{default_name}
           PARTITION OF #{table_name} DEFAULT;
         SQL
       end
-
-      # Elimina una tabla particionada y su tabla por defecto asociada.
-      def drop_partitioned_table(table_name)
-        drop_table(table_name, cascade: true)
-      end
     end
   end
 end

data/lib/tenant_partition/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TenantPartition
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

data/lib/tenant_partition.rb

@@ -4,211 +4,113 @@ require "active_record"
 require "active_model"
 require "active_support/all"
 
-# Carga de la versión y componentes internos
 require_relative "tenant_partition/version"
 require_relative "tenant_partition/configuration"
 require_relative "tenant_partition/safety_guard"
 require_relative "tenant_partition/base"
+require_relative "tenant_partition/maintenance"
 require_relative "tenant_partition/concerns/partitioned"
 require_relative "tenant_partition/concerns/controller"
 
-# Integración con Ruby on Rails
 require_relative "tenant_partition/railtie" if defined?(Rails)
 
-# TenantPartition es el punto de entrada principal para la gestión de particionamiento
-# en PostgreSQL dentro de aplicaciones Rails.
-#
-# Actúa como una **Fachada** que centraliza:
-# 1. Configuración de la gema.
-# 2. Orquestación del ciclo de vida de los tenants (Crear/Borrar particiones).
-# 3. Mantenimiento y limpieza de datos huérfanos.
+# Fachada principal para la gestión y orquestación de particionamiento en PostgreSQL.
+# Centraliza la configuración, creación de particiones y mantenimiento.
 module TenantPartition
-  # Error base para todas las excepciones de la gema.
   class Error < StandardError; end
 
+  # Incorpora las funcionalidades de Auditoría y Limpieza.
+  extend Maintenance
+
   class << self
-    # @return [TenantPartition::Configuration] El objeto de configuración global.
+    # @return [TenantPartition::Configuration] Objeto de configuración global.
     attr_accessor :configuration
 
-    # Configura la gema mediante un bloque e inicializa las validaciones de seguridad.
-    #
+    # Bloque de configuración e inicialización.
     # @yieldparam [TenantPartition::Configuration] config
-    # @return [void]
     def configure
       self.configuration ||= Configuration.new
       yield(configuration)
       SafetyGuard.validate!
     end
 
-    # =========================================================================
-    # GRUPO 1: ORQUESTACIÓN DE TENANTS (Ciclo de Vida)
-    # =========================================================================
-
-    # Crea las particiones físicas para un tenant específico en TODOS los modelos registrados.
-    #
-    # Este método es **idempotente**: verifica si la partición existe antes de intentar crearla,
-    # evitando errores de SQL.
-    #
-    # @param partition_id [String, Integer] El ID del tenant (ej: el UUID del ISP).
-    # @return [void]
+    # Crea las particiones físicas para un tenant en todos los modelos registrados.
+    # @param partition_id [String, Integer] Identificador del tenant.
     def create!(partition_id)
       ensure_models_loaded!
-
       log_info "CREATE", "Iniciando aprovisionamiento para ID: #{partition_id}"
 
       partitionable_models.each do |model|
-        if model.exists?(partition_id)
-          log_info "SKIP", "#{model.name}: La partición ya existe."
-        else
-          model.create(partition_id)
-          log_info "OK", "#{model.name}: Partición creada exitosamente."
-        end
+        process_creation(model, partition_id)
       end
     end
 
-    # Elimina (DETACH + DROP) las particiones físicas de un tenant en TODOS los modelos.
-    #
-    # @warning Esta acción es destructiva e irreversible. Borra los datos físicos.
-    #
-    # @param partition_id [String, Integer] El ID del tenant a eliminar.
-    # @return [void]
+    # Elimina irreversiblemente las particiones y datos de un tenant.
+    # @param partition_id [String, Integer] Identificador del tenant.
     def destroy!(partition_id)
       ensure_models_loaded!
-
       log_info "DESTROY", "Eliminando infraestructura para ID: #{partition_id}"
 
       partitionable_models.each do |model|
-        if model.exists?(partition_id)
-          partition = model.find(partition_id)
-          if partition.destroy
-            log_info "DROP", "#{model.name}: Partición eliminada."
-          else
-            log_error "FAIL", "#{model.name}: No se pudo eliminar la partición."
-          end
-        else
-          log_info "SKIP", "#{model.name}: No existe partición para borrar."
-        end
-      end
-    end
-
-    # =========================================================================
-    # GRUPO 2: MANTENIMIENTO Y OPS (Audit & Cleanup)
-    # =========================================================================
-
-    # Audita todas las tablas DEFAULT buscando registros "huérfanos".
-    #
-    # Un registro huérfano es aquel que se insertó en la tabla padre pero, al no existir
-    # su partición correspondiente en ese momento, cayó en la tabla _default.
-    #
-    # @return [Hash{String => Integer}] Mapa con el nombre del modelo y la cantidad de registros huérfanos.
-    # @example
-    #   TenantPartition.audit
-    #   # => { "Partition::Message" => 150, "Partition::Log" => 0 }
-    def audit
-      ensure_models_loaded!
-      report = {}
-
-      log_info "AUDIT", "Iniciando auditoría de tablas DEFAULT..."
-
-      partitionable_models.each do |model|
-        count = count_default_rows(model)
-        report[model.name] = count
-
-        if count > 0
-          log_warn "ALERTA", "#{model.name}: #{count} registros huérfanos encontrados."
-        else
-          log_info "OK", "#{model.name}: Tabla default limpia."
-        end
+        process_destruction(model, partition_id)
       end
-
-      report
     end
 
-    # Realiza una limpieza global moviendo registros huérfanos a sus particiones correctas.
-    #
-    # 1. Identifica qué IDs de tenant tienen datos en las tablas DEFAULT.
-    # 2. Verifica si ya existe la partición física para esos IDs.
-    # 3. Mueve los datos atómicamente.
-    #
-    # @return [void]
-    def cleanup!
+    # Verifica si existe infraestructura creada para un tenant.
+    # @param partition_id [String, Integer] Identificador del tenant.
+    # @return [Boolean] true si existe al menos una tabla particionada.
+    def exists?(partition_id)
       ensure_models_loaded!
-      key = configuration.partition_key
-
-      log_info "CLEANUP", "Iniciando proceso de limpieza global..."
-
-      partitionable_models.each do |model|
-        # Obtenemos los IDs únicos presentes en la tabla default
-        orphan_ids = fetch_orphan_ids(model, key)
-
-        if orphan_ids.empty?
-          log_info "OK", "#{model.name}: Sin datos huérfanos."
-          next
-        end
-
-        log_warn "FIX", "#{model.name}: Procesando #{orphan_ids.count} tenants con datos huérfanos."
-
-        orphan_ids.each do |id|
-          partition = model.find(id)
-
-          if partition
-            moved = partition.populate_from_default
-            log_info "MOVE", "  -> ID #{id}: #{moved} registros recuperados."
-          else
-            log_error "ERROR", "  -> ID #{id}: La partición física no existe. Cree el tenant primero."
-          end
-        end
-      end
-    end
-
-    private
-
-    # Encuentra todas las clases cargadas que heredan de TenantPartition::Base.
-    # @return [Array<Class>]
-    def partitionable_models
-      ObjectSpace.each_object(Class).select { |klass| klass < TenantPartition::Base }
-    end
-
-    # Cuenta registros en la tabla default de un modelo de infraestructura.
-    # @return [Integer]
-    def count_default_rows(model)
-      model.connection.select_value("SELECT count(*) FROM #{model.default_table}").to_i
-    rescue ActiveRecord::StatementInvalid
-      0
+      partitionable_models.any? { |model| model.exists?(partition_id) }
     end
 
-    # Obtiene los IDs de partición distintos que existen en la tabla default.
-    # @return [Array<String>]
-    def fetch_orphan_ids(model, key)
-      sql = "SELECT DISTINCT #{key} FROM #{model.default_table} WHERE #{key} IS NOT NULL"
-      model.connection.execute(sql).map { |r| r[key.to_s] }
-    rescue ActiveRecord::StatementInvalid
-      []
-    end
+    # --- Shared Helpers (Accesibles por Maintenance) ---
 
-    # Asegura que Rails haya cargado los modelos de infraestructura.
-    # Vital en modo Development donde la carga es perezosa (Lazy Loading).
+    # Fuerza la carga de los modelos de partición en entornos con Lazy Loading (Dev).
     def ensure_models_loaded!
       return unless defined?(Rails)
 
       partition_dir = Rails.root.join("app/models/partition")
       return unless Dir.exist?(partition_dir)
 
-      # Forzamos la carga de todos los archivos en app/models/partition/
       Dir[partition_dir.join("**/*.rb")].each { |file| require_dependency file }
     end
 
-    # Helpers de Logging
+    # Retorna todas las subclases de TenantPartition::Base cargadas en memoria.
+    # @return [Array<Class>] Lista de clases de modelos.
+    def partitionable_models
+      ObjectSpace.each_object(Class).select { |klass| klass < TenantPartition::Base }
+    end
+
+    # --- Logging ---
+
     def log_info(tag, msg)  = logger&.info(format_log(tag, msg))
     def log_warn(tag, msg)  = logger&.warn(format_log(tag, msg))
     def log_error(tag, msg) = logger&.error(format_log(tag, msg))
+    def format_log(tag, msg) = "[TenantPartition] [#{tag}] #{msg}"
+    def logger = (defined?(Rails) ? Rails.logger : Logger.new($stdout))
 
-    def format_log(tag, msg)
-      "[TenantPartition] [#{tag}] #{msg}"
+    private
+
+    def process_creation(model, partition_id)
+      if model.exists?(partition_id)
+        log_info "SKIP", "#{model.name}: La partición ya existe."
+      else
+        model.create(partition_id)
+        log_info "OK", "#{model.name}: Partición creada exitosamente."
+      end
     end
 
-    def logger
-      defined?(Rails) ? Rails.logger : Logger.new($stdout)
+    def process_destruction(model, partition_id)
+      if model.exists?(partition_id)
+        if model.find(partition_id).destroy
+          log_info "DROP", "#{model.name}: Partición eliminada."
+        else
+          log_error "FAIL", "#{model.name}: No se pudo eliminar la partición."
+        end
+      else
+        log_info "SKIP", "#{model.name}: No existe partición para borrar."
+      end
     end
   end
 end

metadata

@@ -1,22 +1,25 @@
 --- !ruby/object:Gem::Specification
 name: tenant_partition
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - gabriel
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-27 00:00:00.000000000 Z
+date: 2026-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activerecord
+  name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -24,13 +27,19 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
 - !ruby/object:Gem::Dependency
-  name: activemodel
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -38,6 +47,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
 description: Framework de infraestructura para Rails 7.1+ que automatiza el particionamiento
   nativo (List Partitioning). Incluye soporte para Composite Primary Keys, orquestación
   de tenants y migraciones zero-downtime.
@@ -51,11 +63,16 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- lib/generators/tenant_partition/api_controller_generator.rb
+- lib/generators/tenant_partition/templates/README
+- lib/generators/tenant_partition/templates/tenant_partitions_controller.rb.erb
 - lib/tenant_partition.rb
 - lib/tenant_partition/base.rb
 - lib/tenant_partition/concerns/controller.rb
+- lib/tenant_partition/concerns/data_mover.rb
 - lib/tenant_partition/concerns/partitioned.rb
 - lib/tenant_partition/configuration.rb
+- lib/tenant_partition/maintenance.rb
 - lib/tenant_partition/railtie.rb
 - lib/tenant_partition/safety_guard.rb
 - lib/tenant_partition/schema/statements.rb