fix(filters): Infer database list from --include-tables and skip rdsadmin

- When --include-tables is specified without --include-databases, the
  tool now extracts database names from table specs (e.g., "db.table")
- Prevents enumerating all databases when only specific tables requested
- Also excludes AWS RDS 'rdsadmin' internal database from discovery
- Fixes pg_hba.conf rejection errors when replicating from AWS RDS

Fixes connection failures when replicating specific tables from AWS RDS.

Author: taariq

CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to this project will be documented in this file.
 
+## [5.3.11] - 2025-12-02
+
+### Fixed
+
+- **Skip AWS RDS internal database during discovery**: The `rdsadmin` database (AWS RDS's internal administration database) is now automatically excluded from database discovery, preventing "pg_hba.conf rejects connection" errors when replicating from AWS RDS sources.
+
+- **Infer database list from `--include-tables`**: When using `--include-tables` without `--include-databases`, the tool now automatically extracts database names from the table specifications (e.g., `--include-tables "mydb.table1,mydb.table2"` will only replicate the `mydb` database). Previously, all databases were enumerated even when only specific tables were requested.
+
 ## [5.3.10] - 2025-12-02
 
 ### Improved

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "database-replicator"
-version = "5.3.10"
+version = "5.3.11"
 edition = "2021"
 license = "Apache-2.0"
 description = "Universal database-to-PostgreSQL replication CLI. Supports PostgreSQL, SQLite, MongoDB, and MySQL."

Cargo.toml

@@ -104,7 +104,8 @@ pub async fn init(
             // Run pre-flight checks before any destructive operations
             tracing::info!("Running pre-flight checks...");
 
-            let databases = filter.include_databases().map(|v| v.to_vec());
+            // Get explicit database list from filters (include_databases or extracted from include_tables)
+            let databases = filter.databases_to_check();
             let preflight_result = crate::preflight::run_preflight_checks(
                 source_url,
                 target_url,

src/commands/init.rs

@@ -144,13 +144,58 @@ impl ReplicationFilter {
         self.exclude_tables.as_ref()
     }
 
+    /// Gets the explicit list of databases to check/replicate
+    ///
+    /// Returns databases from:
+    /// 1. include_databases if specified, OR
+    /// 2. database names extracted from include_tables if specified
+    ///
+    /// Returns None if no explicit database list can be determined
+    /// (meaning all databases should be enumerated).
+    pub fn databases_to_check(&self) -> Option<Vec<String>> {
+        if let Some(ref include) = self.include_databases {
+            return Some(include.clone());
+        }
+
+        if let Some(ref include_tables) = self.include_tables {
+            // Extract unique database names from "database.table" format
+            let mut databases: Vec<String> = include_tables
+                .iter()
+                .filter_map(|table| table.split('.').next().map(String::from))
+                .collect();
+            databases.sort();
+            databases.dedup();
+            if !databases.is_empty() {
+                return Some(databases);
+            }
+        }
+
+        None
+    }
+
     /// Determines if a database should be replicated
+    ///
+    /// A database is replicated if:
+    /// 1. It's in the include_databases list (if specified), OR
+    /// 2. It's referenced in include_tables (if specified and no include_databases), OR
+    /// 3. No include filters are specified (replicate all)
+    ///
+    /// AND it's not in the exclude_databases list.
     pub fn should_replicate_database(&self, db_name: &str) -> bool {
-        // If include list exists, database must be in it
+        // If include_databases list exists, database must be in it
         if let Some(ref include) = self.include_databases {
             if !include.contains(&db_name.to_string()) {
                 return false;
             }
+        } else if let Some(ref include_tables) = self.include_tables {
+            // If include_tables is specified but include_databases is not,
+            // only replicate databases referenced in include_tables
+            let db_referenced = include_tables
+                .iter()
+                .any(|table| table.split('.').next() == Some(db_name));
+            if !db_referenced {
+                return false;
+            }
         }
 
         // If exclude list exists, database must not be in it

src/filters.rs

@@ -25,13 +25,18 @@ pub struct ColumnInfo {
 }
 
 /// List all non-system databases in the cluster
+///
+/// Excludes:
+/// - PostgreSQL template databases (template0, template1)
+/// - PostgreSQL default database (postgres)
+/// - AWS RDS internal database (rdsadmin)
 pub async fn list_databases(client: &Client) -> Result<Vec<DatabaseInfo>> {
     let rows = client
         .query(
             "SELECT datname, pg_catalog.pg_get_userbyid(datdba) as owner
              FROM pg_catalog.pg_database
              WHERE datistemplate = false
-               AND datname NOT IN ('postgres', 'template0', 'template1')
+               AND datname NOT IN ('postgres', 'template0', 'template1', 'rdsadmin')
              ORDER BY datname",
             &[],
         )