procbay-schema 1.0.0

package/scripts/truncate-tables.js

@@ -0,0 +1,1048 @@
+#!/usr/bin/env node
+
+import { PrismaClient } from "../src/prisma/index.js";
+import dotenv from "dotenv";
+import colors from "colors";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import readline from "readline";
+import { execSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { connectionManager } from "../prisma/seeders/utils/connection-manager.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Load environment variables
+dotenv.config({ path: path.resolve(__dirname, "../prisma/.env") });
+
+// Configuration
+const CONFIG = {
+  logLevel: process.env.LOG_LEVEL || "info", // debug, info, warn, error
+  retryAttempts: 3,
+  retryDelay: 2000,
+  requireConfirmation: true,
+};
+
+// Configure colors theme
+colors.setTheme({
+  debug: "grey",
+  info: "white",
+  success: "green",
+  warn: "yellow",
+  error: "red",
+  highlight: "cyan",
+  bold: "bold",
+  header: ["bold", "cyan"],
+});
+
+// Logger implementation
+class Logger {
+  static LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    silent: 4,
+  };
+
+  static #currentLevel = Logger.LEVELS[CONFIG.logLevel] || Logger.LEVELS.info;
+  static #startTime = Date.now();
+
+  static #formatTime() {
+    const elapsed = ((Date.now() - Logger.#startTime) / 1000).toFixed(2);
+    return `[${elapsed}s]`;
+  }
+
+  static debug(message, ...args) {
+    if (Logger.#currentLevel <= Logger.LEVELS.debug) {
+      console.debug(
+        colors.debug(`${Logger.#formatTime()} 🔍 DEBUG: ${message}`),
+        ...args
+      );
+    }
+  }
+
+  static info(message, ...args) {
+    if (Logger.#currentLevel <= Logger.LEVELS.info) {
+      console.log(
+        colors.info(`${Logger.#formatTime()} ℹ️ ${message}`),
+        ...args
+      );
+    }
+  }
+
+  static success(message, ...args) {
+    if (Logger.#currentLevel <= Logger.LEVELS.info) {
+      console.log(
+        colors.success(`${Logger.#formatTime()} ✅ ${message}`),
+        ...args
+      );
+    }
+  }
+
+  static warn(message, ...args) {
+    if (Logger.#currentLevel <= Logger.LEVELS.warn) {
+      console.warn(
+        colors.warn(`${Logger.#formatTime()} ⚠️ WARNING: ${message}`),
+        ...args
+      );
+    }
+  }
+
+  static error(message, ...args) {
+    if (Logger.#currentLevel <= Logger.LEVELS.error) {
+      console.error(
+        colors.error(`${Logger.#formatTime()} ❌ ERROR: ${message}`),
+        ...args
+      );
+    }
+  }
+
+  static startSpinner(message) {
+    if (Logger.#currentLevel <= Logger.LEVELS.info) {
+      process.stdout.write(
+        colors.highlight(`${Logger.#formatTime()} ⏳ ${message}... `)
+      );
+    }
+    return {
+      stop: (success = true, result = "") => {
+        if (Logger.#currentLevel <= Logger.LEVELS.info) {
+          const icon = success ? colors.success("✅") : colors.error("❌");
+          process.stdout.write(`${icon} ${result}\n`);
+        }
+      },
+    };
+  }
+
+  static progressBar(total, message = "Progress") {
+    if (Logger.#currentLevel > Logger.LEVELS.info)
+      return { update: () => {}, complete: () => {} };
+
+    let current = 0;
+    const width = 30;
+    const update = (increment = 1) => {
+      current += increment;
+      const percent = Math.min(Math.floor((current / total) * 100), 100);
+      const filled = Math.floor((width * current) / total);
+      const bar = "█".repeat(filled) + "░".repeat(width - filled);
+      process.stdout.write(
+        `\r${Logger.#formatTime()} ${message}: ${colors.highlight(
+          bar
+        )} ${percent}% (${current}/${total})`
+      );
+    };
+
+    return {
+      update,
+      complete: () => {
+        update(total - current);
+        process.stdout.write("\n");
+      },
+    };
+  }
+}
+
+// Enhanced error handling with structured errors
+class TruncationError extends Error {
+  constructor(message, code, details = {}) {
+    super(message);
+    this.name = "TruncationError";
+    this.code = code;
+    this.details = details;
+  }
+
+  static get codes() {
+    return {
+      INVALID_ARGUMENTS: "INVALID_ARGUMENTS",
+      DATABASE_NOT_FOUND: "DATABASE_NOT_FOUND",
+      TABLE_NOT_FOUND: "TABLE_NOT_FOUND",
+      CONNECTION_FAILED: "CONNECTION_FAILED",
+      TRUNCATION_FAILED: "TRUNCATION_FAILED",
+      AUTHENTICATION_FAILED: "AUTHENTICATION_FAILED",
+      OPERATION_CANCELLED: "OPERATION_CANCELLED",
+    };
+  }
+}
+
+/**
+ * Function to mask sensitive information in URLs for logging
+ */
+const maskDatabaseUrl = (url) => {
+  if (!url) return "[NO URL]";
+  try {
+    const parsedUrl = new URL(url);
+    if (parsedUrl.password) {
+      parsedUrl.password = "***";
+    }
+    return parsedUrl.toString();
+  } catch (err) {
+    return url.replace(/:[^:@]+@/, ":***@");
+  }
+};
+
+/**
+ * Function to validate a table name to prevent SQL injection
+ * Returns sanitized table name or throws error if invalid
+ */
+const validateTableName = (tableName) => {
+  // Table names should only contain alphanumeric characters, underscores, or specific allowed symbols
+  // This is a strict validation for PostgreSQL table names
+  if (!/^[a-zA-Z0-9_"]+$/.test(tableName)) {
+    throw new TruncationError(
+      `Invalid table name: "${tableName}". Table names should only contain alphanumeric characters and underscores.`,
+      TruncationError.codes.INVALID_ARGUMENTS
+    );
+  }
+
+  // Remove any double quotes to prevent SQL injection via quote escaping
+  // We'll add our own quotes when constructing the query
+  return tableName.replace(/"/g, "");
+};
+
+/**
+ * Create a readline interface for user input
+ */
+const getReadlineInterface = () => {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+};
+
+/**
+ * Ask for user confirmation
+ */
+const confirmAction = async (message) => {
+  const rl = getReadlineInterface();
+  return new Promise((resolve) => {
+    rl.question(`${message} (y/N): `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y");
+    });
+  });
+};
+
+/**
+ * Parse command line arguments to get tables and target database
+ */
+const parseArguments = () => {
+  // Get all arguments after the script name
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
+    showUsage();
+    process.exit(args.includes("--help") || args.includes("-h") ? 0 : 1);
+  }
+
+  // Initialize with default values
+  let targetDb = null;
+  let tableNames = [];
+  let excludedTables = [];
+  let dryRun = false;
+  let noCascade = false;
+  let noConfirm = false;
+  let interactive = false;
+  let noRestartIdentity = false;
+
+  // Loop through arguments to find flags and their values
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    // Handle database flag
+    if (arg === "--db") {
+      if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
+        // The next argument is the database name
+        targetDb = args[i + 1].toUpperCase();
+        i++; // Skip the next argument since we've processed it
+      }
+      // If --db is specified without a value, it means all databases
+    }
+
+    // Handle tables flag
+    else if (arg === "--tables" || arg === "-t") {
+      if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
+        // The next argument contains the table names
+        const tableString = args[i + 1];
+        tableNames = tableString
+          .split(",")
+          .map((name) => name.trim())
+          .filter((name) => name !== "");
+        i++; // Skip the next argument since we've processed it
+      }
+    }
+
+    // Handle exclude tables flag
+    else if (arg === "--exclude" || arg === "-e") {
+      if (i + 1 < args.length && !args[i + 1].startsWith("--")) {
+        // The next argument contains the excluded table names
+        const tableString = args[i + 1];
+        excludedTables = tableString
+          .split(",")
+          .map((name) => name.trim())
+          .filter((name) => name !== "");
+        i++; // Skip the next argument since we've processed it
+      }
+    }
+
+    // Handle dry-run flag
+    else if (arg === "--dry-run") {
+      dryRun = true;
+    }
+
+    // Handle no-cascade flag
+    else if (arg === "--no-cascade") {
+      noCascade = true;
+    }
+
+    // Handle no-confirm flag
+    else if (arg === "--no-confirm") {
+      noConfirm = true;
+    }
+
+    // Handle no-restart-identity flag
+    else if (arg === "--no-restart-identity") {
+      noRestartIdentity = true;
+    }
+
+    // Handle interactive flag
+    else if (arg === "--interactive" || arg === "-i") {
+      interactive = true;
+    }
+  }
+
+  // Validate that we have table names (unless in interactive mode)
+  if (tableNames.length === 0 && !interactive) {
+    Logger.error("No tables specified");
+    showUsage();
+    process.exit(1);
+  }
+
+  // Filter out excluded tables
+  if (excludedTables.length > 0) {
+    tableNames = tableNames.filter((table) => !excludedTables.includes(table));
+    if (tableNames.length === 0) {
+      throw new TruncationError(
+        "All specified tables were excluded. No tables left to truncate.",
+        TruncationError.codes.INVALID_ARGUMENTS
+      );
+    }
+  }
+
+  return {
+    tableNames,
+    targetDb,
+    dryRun,
+    noCascade,
+    noConfirm: noConfirm,
+    interactive,
+    excludedTables,
+    noRestartIdentity,
+  };
+};
+
+/**
+ * Show usage instructions
+ */
+const showUsage = () => {
+  console.log(`
+${colors.header("Database Table Truncation Tool")}
+${colors.debug("──────────────────────────────────────────")}
+
+${colors.bold("Description:")}
+  Truncates specified tables in one or more databases.
+
+${colors.bold("Usage:")}
+  npm run truncate-tables -- [options]
+
+${colors.bold("Options:")}
+  --help, -h          Show this help message
+  --db [DATABASE]     Specify target database (omit value for all databases)
+  --tables, -t        Comma-separated list of tables to truncate
+  --exclude, -e       Comma-separated list of tables to exclude
+  --dry-run           Show what would be truncated without executing
+  --no-cascade        Disable CASCADE option in truncate statement
+  --no-confirm        Skip confirmation prompts
+  --no-restart-identity Do not reset identity columns after truncation
+  --interactive, -i   Select tables interactively
+
+${colors.bold("Examples:")}
+  npm run truncate-tables -- --db --tables countries,cities,states
+  npm run truncate-tables -- --db ARVIND --tables countries,cities,states
+  npm run truncate-tables -- --db DEFAULT --tables all --exclude migrations,_prisma_migrations
+  npm run truncate-tables -- --interactive
+  npm run truncate-tables -- --db DEFAULT --dry-run --tables users,posts
+  npm run truncate-tables -- --db DEFAULT --tables all --no-restart-identity
+
+${colors.debug("──────────────────────────────────────────")}
+  `);
+};
+
+/**
+ * Get all database URLs from environment variables
+ * Looks for variables ending with _DATABASE_URL
+ * If targetDb is specified, filter to only include that database
+ */
+const getDatabaseUrls = (targetDb) => {
+  const spinner = Logger.startSpinner("Reading database configurations");
+  try {
+    const databaseEnvVars = Object.keys(process.env)
+      .filter((key) => key.endsWith("_DATABASE_URL"))
+      .sort();
+
+    if (databaseEnvVars.length === 0) {
+      spinner.stop(false, "No database URLs found");
+      throw new TruncationError(
+        "No database URLs found in environment variables",
+        TruncationError.codes.DATABASE_NOT_FOUND
+      );
+    }
+
+    const dbConfigs = databaseEnvVars.map((envVar) => ({
+      name: envVar.replace("_DATABASE_URL", ""),
+      url: process.env[envVar],
+    }));
+
+    Logger.debug(
+      `Found ${dbConfigs.length} databases: ${dbConfigs
+        .map((db) => db.name)
+        .join(", ")}`
+    );
+
+    // If targetDb specified, filter to only that database
+    if (targetDb) {
+      const filteredDbs = dbConfigs.filter(
+        (db) => db.name.toUpperCase() === targetDb
+      );
+
+      if (filteredDbs.length === 0) {
+        spinner.stop(false, `Database '${targetDb}' not found`);
+        throw new TruncationError(
+          `Database '${targetDb}' not found in environment variables. Available databases: ${dbConfigs
+            .map((db) => db.name)
+            .join(", ")}`,
+          TruncationError.codes.DATABASE_NOT_FOUND
+        );
+      }
+
+      spinner.stop(true, `Found database: ${targetDb}`);
+      return filteredDbs;
+    }
+
+    spinner.stop(true, `Found ${dbConfigs.length} databases`);
+    return dbConfigs;
+  } catch (error) {
+    if (!(error instanceof TruncationError)) {
+      spinner.stop(false, error.message);
+      throw new TruncationError(
+        `Error retrieving database configurations: ${error.message}`,
+        TruncationError.codes.DATABASE_NOT_FOUND,
+        { originalError: error }
+      );
+    }
+    throw error;
+  }
+};
+
+/**
+ * Function to test database connection using the connection manager
+ */
+const testDatabaseConnection = async (url, dbName) => {
+  const spinner = Logger.startSpinner(
+    `Testing connection to ${dbName} database`
+  );
+  try {
+    // Don't expose URL in command/logs
+    const maskedUrl = maskDatabaseUrl(url);
+    Logger.debug(`Testing connection to: ${maskedUrl}`);
+
+    // Use connection manager to test connection
+    await connectionManager.executeWithConnection(
+      dbName,
+      url,
+      async (prisma) => {
+        // Just connect and execute a simple query
+        await prisma.$queryRaw`SELECT 1 as connected`;
+      },
+      { autoRelease: true } // Auto-release after test
+    );
+
+    spinner.stop(true, "Connection successful");
+    return true;
+  } catch (error) {
+    const sanitizedError = error.message.replace(
+      /(postgres|mysql|mongodb):\/\/[^@\s]+@/g,
+      "$1://***:***@"
+    );
+    spinner.stop(false, "Connection failed");
+    Logger.error(`Failed to connect to ${dbName} database: ${sanitizedError}`);
+
+    return false;
+  }
+};
+
+/**
+ * Function to get all tables in database using the connection manager
+ */
+const getAllTables = async (url, dbName) => {
+  const spinner = Logger.startSpinner(`Retrieving tables from ${dbName}`);
+  try {
+    // Use connection manager to get tables
+    const tables = await connectionManager.executeWithConnection(
+      dbName,
+      url,
+      async (prisma) => {
+        // First, check if the tables we know exist are in the public schema
+        const specificTablesCheck = await prisma.$queryRaw`
+          SELECT EXISTS (
+            SELECT 1 FROM pg_catalog.pg_tables 
+            WHERE tablename = 'vendors' AND schemaname = 'public'
+          ) as exists_in_public;
+        `;
+
+        const existsInPublic = specificTablesCheck[0]?.exists_in_public;
+        Logger.debug(`Tables exist in public schema: ${existsInPublic}`);
+
+        // If tables don't exist in public schema, we need to find what schema they're in
+        let tablesResult;
+
+        if (existsInPublic) {
+          // Query for tables in the public schema
+          tablesResult = await prisma.$queryRaw`
+            SELECT tablename as table_name
+            FROM pg_catalog.pg_tables 
+            WHERE schemaname = 'public'
+              AND tablename NOT IN ('_prisma_migrations', 'migrations')
+            ORDER BY tablename;
+          `;
+        } else {
+          // Get all available schemas
+          const schemas = await prisma.$queryRaw`
+            SELECT schema_name 
+            FROM information_schema.schemata
+            WHERE schema_name NOT IN ('pg_catalog', 'information_schema');
+          `;
+
+          Logger.debug(
+            `Available schemas: ${schemas.map((s) => s.schema_name).join(", ")}`
+          );
+
+          // Try to find in which schema the 'vendors' table exists
+          const tableSchemaCheck = await prisma.$queryRaw`
+            SELECT table_schema, table_name 
+            FROM information_schema.tables 
+            WHERE table_name = 'vendors';
+          `;
+
+          if (tableSchemaCheck.length > 0) {
+            const schema = tableSchemaCheck[0].table_schema;
+            Logger.debug(`Found 'vendors' table in schema: ${schema}`);
+
+            // Get all tables from that schema
+            tablesResult = await prisma.$queryRaw`
+              SELECT table_name
+              FROM information_schema.tables 
+              WHERE table_schema = ${schema}
+                AND table_type = 'BASE TABLE' 
+                AND table_name NOT IN ('_prisma_migrations', 'migrations')
+              ORDER BY table_name;
+            `;
+          } else {
+            // Fallback to direct check for the specific tables we know exist
+            tablesResult = await prisma.$queryRaw`
+              SELECT ARRAY['vendors', 'vendor_status'] as table_name;
+            `;
+          }
+        }
+
+        return tablesResult.map((r) => r.table_name);
+      },
+      { autoRelease: true } // Auto-release after getting tables
+    );
+
+    spinner.stop(true, `Found ${tables.length} tables`);
+    Logger.debug(`Tables found: ${tables.join(", ")}`);
+    return tables;
+  } catch (error) {
+    spinner.stop(false, "Failed to retrieve tables");
+    Logger.error(`Error retrieving tables from ${dbName}: ${error.message}`);
+    return [];
+  }
+};
+
+/**
+ * Simple delay function for rate limiting
+ * @param {number} ms - Milliseconds to delay
+ * @returns {Promise} - Promise that resolves after the delay
+ */
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+/**
+ * Function to truncate tables using the connection manager
+ */
+const truncateTables = async (url, dbName, tables, options = {}) => {
+  const {
+    dryRun = false,
+    noCascade = false,
+    noRestartIdentity = false,
+  } = options;
+
+  if (tables.length === 0) {
+    Logger.warn("No tables to truncate");
+    return { tablesProcessed: 0 };
+  }
+
+  if (dryRun) {
+    Logger.info(
+      colors.yellow(
+        `[DRY RUN] Would truncate these tables in ${dbName}: ${tables.join(
+          ", "
+        )}`
+      )
+    );
+    return { tablesProcessed: tables.length };
+  }
+
+  Logger.info(
+    `Truncating ${tables.length} tables in ${colors.highlight(dbName)}`
+  );
+
+  try {
+    const truncateMode = noCascade ? "" : "CASCADE";
+    const identityMode = noRestartIdentity ? "" : "RESTART IDENTITY";
+    let processedCount = 0;
+
+    // Use connection manager for truncation operations
+    await connectionManager.executeWithConnection(
+      dbName,
+      url,
+      async (prisma) => {
+        // For each table, execute truncate and log result
+        for (const table of tables) {
+          const spinner = Logger.startSpinner(`Truncating ${table}`);
+          try {
+            // Raw SQL query for truncation with RESTART IDENTITY (if enabled)
+            await prisma.$executeRawUnsafe(
+              `TRUNCATE TABLE "${table}" ${identityMode} ${truncateMode};`
+            );
+            spinner.stop(true, "Truncated");
+            processedCount++;
+          } catch (err) {
+            spinner.stop(false, "Failed");
+            Logger.error(`Error truncating ${table}: ${err.message}`);
+            throw err;
+          }
+          // Small delay to avoid overwhelming the database
+          await delay(100);
+        }
+      },
+      { autoRelease: true } // Auto-release after truncation
+    );
+
+    Logger.success(
+      `Successfully truncated ${processedCount} tables in ${dbName}`
+    );
+    return { tablesProcessed: processedCount };
+  } catch (error) {
+    Logger.error(`Error truncating tables in ${dbName}: ${error.message}`);
+    throw error;
+  }
+};
+
+/**
+ * Function to interactively select tables
+ */
+async function selectTablesInteractively(dbName, url) {
+  const allTables = await getAllTables(url, dbName);
+
+  if (allTables.length === 0) {
+    return [];
+  }
+
+  // Create interface for user input
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  console.log(colors.cyan("\nAvailable tables:"));
+  allTables.forEach((table, index) => {
+    console.log(`${index + 1}. ${table}`);
+  });
+  console.log(colors.yellow("0. Select all tables"));
+
+  const question = (query) =>
+    new Promise((resolve) => rl.question(query, resolve));
+
+  const selectedTables = [];
+  let selecting = true;
+
+  while (selecting) {
+    const answer = await question(
+      colors.green(
+        "\nEnter table numbers to truncate (comma separated, 0 for all, or 'done' to finish): "
+      )
+    );
+
+    if (answer.toLowerCase() === "done") {
+      selecting = false;
+    } else if (answer === "0") {
+      selectedTables.push(...allTables);
+      selecting = false;
+    } else {
+      const selections = answer.split(",").map((s) => s.trim());
+      for (const selection of selections) {
+        const index = parseInt(selection, 10) - 1;
+        if (
+          !isNaN(index) &&
+          index >= 0 &&
+          index < allTables.length &&
+          !selectedTables.includes(allTables[index])
+        ) {
+          selectedTables.push(allTables[index]);
+          console.log(colors.green(`Added ${allTables[index]} to selection`));
+        } else if (!isNaN(index)) {
+          console.log(
+            colors.red(`Invalid selection: ${selection}. Please try again.`)
+          );
+        }
+      }
+    }
+
+    // Show current selection
+    if (selectedTables.length > 0) {
+      console.log(
+        colors.cyan(
+          `\nCurrently selected (${
+            selectedTables.length
+          } tables): ${selectedTables.join(", ")}`
+        )
+      );
+    }
+  }
+
+  rl.close();
+  return selectedTables;
+}
+
+/**
+ * Function to truncate specified tables in a single database
+ * @param {Object} dbConfig - Database configuration with url and name
+ * @param {Array<string>} tableNames - List of tables to truncate
+ * @param {Object} options - Additional options for truncation
+ * @returns {Object} - Result of truncation operation
+ */
+async function truncateTablesInDatabase(dbConfig, tableNames, options = {}) {
+  const { url, name: dbName } = dbConfig;
+  const { dryRun, noCascade, interactive, excludedTables, noRestartIdentity } =
+    options;
+  let tablesProcessed = 0;
+  let tablesToProcess = [...tableNames];
+  let allTablesRequested = tablesToProcess.includes("all");
+
+  try {
+    Logger.info(colors.cyan(`\nProcessing database: ${dbName}`));
+
+    // Test connection to database
+    const spinner = Logger.startSpinner(`Testing connection to ${dbName}`);
+    try {
+      await testDatabaseConnection(url, dbName);
+      spinner.stop(true, "Connected");
+    } catch (error) {
+      spinner.stop(false, "Failed");
+      return {
+        database: dbName,
+        success: false,
+        error: `Connection failed: ${error.message}`,
+      };
+    }
+
+    // Get all available tables if in interactive mode, if 'all' was specified, or if we need to filter out excluded tables
+    if (interactive || excludedTables.length > 0 || allTablesRequested) {
+      const allTablesSpinner = Logger.startSpinner(
+        `Fetching tables from ${dbName}`
+      );
+      try {
+        const allTables = await getAllTables(url, dbName);
+        allTablesSpinner.stop(true, `Found ${allTables.length} tables`);
+
+        if (interactive) {
+          // Let user select tables interactively
+          tablesToProcess = await selectTablesInteractively(dbName, url);
+
+          // If no tables selected, skip this database
+          if (tablesToProcess.length === 0) {
+            Logger.info(
+              colors.yellow(`No tables selected for ${dbName}, skipping`)
+            );
+            return {
+              database: dbName,
+              success: true,
+              tablesProcessed: 0,
+              cancelled: true,
+            };
+          }
+        } else if (allTablesRequested) {
+          // Replace the 'all' keyword with the actual list of all tables
+          if (allTables.length === 0) {
+            Logger.warn(
+              `No tables found in database ${dbName}. Check your connection details.`
+            );
+          } else {
+            tablesToProcess = allTables;
+            Logger.info(
+              colors.yellow(`Using all tables: ${tablesToProcess.join(", ")}`)
+            );
+          }
+        }
+
+        // Always filter out excluded tables after getting all tables
+        if (excludedTables.length > 0) {
+          tablesToProcess = tablesToProcess.filter(
+            (table) => !excludedTables.includes(table)
+          );
+        }
+      } catch (error) {
+        allTablesSpinner.stop(false, "Failed");
+        return {
+          database: dbName,
+          success: false,
+          error: `Failed to get tables: ${error.message}`,
+        };
+      }
+    }
+
+    // Remove 'all' from tablesToProcess if it's still there
+    tablesToProcess = tablesToProcess.filter((table) => table !== "all");
+
+    if (tablesToProcess.length === 0) {
+      Logger.warn(`No tables to truncate in database ${dbName}`);
+      return {
+        database: dbName,
+        success: true,
+        tablesProcessed: 0,
+      };
+    }
+
+    // Confirm truncation if required and not in dry run mode
+    if (CONFIG.requireConfirmation && !dryRun && !options.noConfirm) {
+      const shouldProceed = await confirmAction(
+        colors.yellow(
+          `Are you sure you want to truncate ${tablesToProcess.length} tables in ${dbName}?`
+        )
+      );
+
+      if (!shouldProceed) {
+        Logger.warn(`Operation cancelled for database ${dbName}`);
+        return {
+          database: dbName,
+          success: true,
+          tablesProcessed: 0,
+          cancelled: true,
+        };
+      }
+    }
+
+    // Truncate tables
+    try {
+      const truncateResults = await truncateTables(
+        url,
+        dbName,
+        tablesToProcess,
+        {
+          dryRun,
+          noCascade,
+          noRestartIdentity,
+        }
+      );
+      tablesProcessed = truncateResults.tablesProcessed;
+
+      return {
+        database: dbName,
+        success: true,
+        tablesProcessed,
+        dryRun,
+      };
+    } catch (error) {
+      return {
+        database: dbName,
+        success: false,
+        error: `Truncation failed: ${error.message}`,
+      };
+    }
+  } catch (error) {
+    return {
+      database: dbName,
+      success: false,
+      error: `Processing failed: ${error.message}`,
+    };
+  }
+}
+
+/**
+ * Main function to truncate specified tables in all databases
+ */
+async function truncateTablesInAllDatabases() {
+  try {
+    Logger.info(colors.header("🗑️ Database Table Truncation Tool"));
+    Logger.info(colors.debug("──────────────────────────────────────────"));
+
+    // Parse arguments to get table names and target database
+    const options = parseArguments();
+    const { tableNames, targetDb, dryRun, noCascade, interactive } = options;
+
+    // Get database configurations (filtered by targetDb if specified)
+    const databaseConfigs = getDatabaseUrls(targetDb);
+
+    if (dryRun) {
+      Logger.info(colors.yellow("DRY RUN MODE - No tables will be truncated"));
+    }
+
+    if (noCascade) {
+      Logger.info(
+        colors.yellow("CASCADE option disabled for TRUNCATE statements")
+      );
+    }
+
+    if (!interactive) {
+      Logger.info(colors.cyan("Starting table truncation process..."));
+      Logger.info(
+        colors.yellow(`Tables to truncate: ${tableNames.join(", ")}`)
+      );
+
+      if (options.excludedTables.length > 0) {
+        Logger.info(
+          colors.yellow(
+            `Tables to exclude: ${options.excludedTables.join(", ")}`
+          )
+        );
+      }
+    } else {
+      Logger.info(
+        colors.cyan(
+          "Interactive mode enabled - you will select tables to truncate"
+        )
+      );
+    }
+
+    Logger.info(
+      colors.yellow(
+        `Databases to process: ${databaseConfigs
+          .map((db) => db.name)
+          .join(", ")}`
+      )
+    );
+
+    const results = [];
+
+    // Process each database sequentially
+    const dbProgressBar = Logger.progressBar(
+      databaseConfigs.length,
+      "Overall progress"
+    );
+
+    for (const dbConfig of databaseConfigs) {
+      const result = await truncateTablesInDatabase(
+        dbConfig,
+        tableNames,
+        options
+      );
+      results.push(result);
+      dbProgressBar.update();
+
+      // If the operation was cancelled, ask if user wants to continue with other DBs
+      if (result.cancelled && databaseConfigs.length > 1) {
+        const continueWithOthers = await confirmAction(
+          colors.warn("Continue with remaining databases?")
+        );
+
+        if (!continueWithOthers) {
+          Logger.info("Operation cancelled by user. Exiting...");
+          break;
+        }
+      }
+    }
+
+    dbProgressBar.complete();
+
+    // Log summary
+    Logger.info(colors.cyan("\n=== Truncation Summary ==="));
+    const successful = results.filter((r) => r.success).length;
+    const failed = results.filter((r) => !r.success).length;
+    const totalTablesProcessed = results.reduce(
+      (sum, r) => sum + (r.tablesProcessed || 0),
+      0
+    );
+
+    results.forEach((result) => {
+      if (result.success) {
+        if (result.dryRun) {
+          Logger.info(
+            colors.yellow(
+              `🔍 ${result.database}: Would truncate ${result.tablesProcessed} tables (dry run)`
+            )
+          );
+        } else {
+          Logger.success(
+            `✅ ${result.database}: Successfully truncated ${
+              result.tablesProcessed || 0
+            } tables`
+          );
+        }
+      } else if (result.cancelled) {
+        Logger.warn(`⏹️ ${result.database}: Operation cancelled by user`);
+      } else {
+        Logger.error(`❌ ${result.database}: Failed - ${result.error}`);
+      }
+    });
+
+    Logger.info(
+      colors.cyan(
+        `\nProcessed ${results.length} databases: ${successful} successful, ${failed} failed`
+      )
+    );
+
+    if (dryRun) {
+      Logger.info(
+        colors.yellow(
+          `Would truncate ${totalTablesProcessed} tables across all databases (dry run)`
+        )
+      );
+    } else {
+      Logger.info(
+        colors.cyan(
+          `Truncated ${totalTablesProcessed} tables across all databases`
+        )
+      );
+    }
+
+    Logger.info(colors.debug("──────────────────────────────────────────"));
+
+    if (failed > 0) {
+      process.exit(1);
+    }
+  } catch (error) {
+    Logger.error(colors.bold.red("Truncation process failed!"));
+
+    if (error instanceof TruncationError) {
+      Logger.error(`Error code: ${error.code}`);
+      Logger.error(`Message: ${error.message}`);
+
+      if (error.details && Object.keys(error.details).length > 0) {
+        Logger.debug("Error details:", JSON.stringify(error.details, null, 2));
+      }
+    } else {
+      Logger.error(`Unexpected error: ${error.message}`);
+      Logger.debug(error.stack);
+    }
+
+    process.exit(1);
+  }
+}
+
+// Execute the main function
+truncateTablesInAllDatabases().catch((e) => {
+  console.error(colors.red(`Failed to truncate tables: ${e.message}`));
+  process.exit(1);
+});