procbay-schema 1.0.0

package/scripts/seed-databases.js

@@ -0,0 +1,873 @@
+#!/usr/bin/env node
+
+import { execSync } from "child_process";
+import dotenv from "dotenv";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import colors from "colors"; // Using colors library for enhanced UI
+import { PrismaClient } from "../src/prisma/index.js";
+import { connectionManager } from "../prisma/seeders/utils/connection-manager.js";
+import { TENANT_EMAILS } from "../prisma/seeders/utils/config.js";
+
+// Process command line arguments
+const args = process.argv.slice(2);
+let targetDatabase = null;
+
+// Parse for --db flag
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "--db" && i + 1 < args.length) {
+    targetDatabase = args[i + 1];
+    break;
+  }
+}
+
+// Configuration
+const CONFIG = {
+  envPath: path.join("prisma", ".env"),
+  prismaDir: path.join("src", "prisma"),
+  schemaPath: path.join("prisma", "schema.prisma"),
+  constantPath: path.join("prisma", "seeders", "utils", "config.js"),
+  defaultDbName: "DEFAULT",
+  retryAttempts: 3,
+  retryDelay: 2000,
+  successDelay: 1000,
+  targetDatabase: targetDatabase,
+  logLevel: process.env.LOG_LEVEL || "info", // debug, info, warn, error
+};
+
+// Load environment variables from prisma/.env
+dotenv.config({ path: CONFIG.envPath });
+
+// 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 SchemaError extends Error {
+  constructor(message, code, details = {}) {
+    super(message);
+    this.name = "SchemaError";
+    this.code = code;
+    this.details = details;
+  }
+
+  static get codes() {
+    return {
+      ENV_FILE_NOT_FOUND: "ENV_FILE_NOT_FOUND",
+      SCHEMA_FILE_NOT_FOUND: "SCHEMA_FILE_NOT_FOUND",
+      DATABASE_URL_NOT_FOUND: "DATABASE_URL_NOT_FOUND",
+      PRISMA_OPERATION_FAILED: "PRISMA_OPERATION_FAILED",
+      FILE_UPDATE_FAILED: "FILE_UPDATE_FAILED",
+      INVALID_DATABASE_NAME: "INVALID_DATABASE_NAME",
+      SEEDING_FAILED: "SEEDING_FAILED",
+    };
+  }
+}
+
+// Custom error class for Prisma operations (enhanced)
+class PrismaOperationError extends SchemaError {
+  constructor(operation, dbName, originalError) {
+    super(
+      `Error during '${operation}' on database ${dbName}`,
+      SchemaError.codes.PRISMA_OPERATION_FAILED,
+      { operation, dbName, originalError }
+    );
+    this.name = "PrismaOperationError";
+  }
+}
+
+// Function to delay execution
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// 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 update Prisma client files
+const updatePrismaClientFiles = async () => {
+  const spinner = Logger.startSpinner("Updating Prisma client files");
+  try {
+    const files = ["edge.js", "index.js"];
+    let updatedCount = 0;
+
+    for (const file of files) {
+      const filePath = path.join(CONFIG.prismaDir, file);
+
+      if (!existsSync(filePath)) {
+        Logger.warn(`File ${filePath} does not exist, skipping update`);
+        continue;
+      }
+
+      Logger.debug(`Reading file: ${filePath}`);
+      let content = readFileSync(filePath, "utf8");
+
+      // Update output object
+      const newContent = content
+        .replace(
+          /"output":\s*{\s*"value":\s*"[^"]*",\s*"fromEnvVar":\s*[^}]*}/,
+          '"output": { "value": "/schema/src/prisma", "fromEnvVar": null }'
+        )
+        .replace(
+          /"sourceFilePath":\s*"[^"]*"/,
+          '"sourceFilePath": "/schema/prisma/schema.prisma"'
+        );
+
+      if (content !== newContent) {
+        writeFileSync(filePath, newContent);
+        updatedCount++;
+        Logger.debug(`Updated ${file} with new paths`);
+      } else {
+        Logger.debug(`No changes needed for ${file}`);
+      }
+    }
+
+    spinner.stop(true, `Updated ${updatedCount} files`);
+    return updatedCount;
+  } catch (error) {
+    spinner.stop(false, error.message);
+    throw new SchemaError(
+      `Error updating Prisma client files: ${error.message}`,
+      SchemaError.codes.FILE_UPDATE_FAILED,
+      { error }
+    );
+  }
+};
+
+// Function to get all database URLs from .env file
+const getDatabaseUrls = () => {
+  const spinner = Logger.startSpinner("Reading database URLs from .env");
+  try {
+    if (!existsSync(CONFIG.envPath)) {
+      spinner.stop(false, `Environment file not found at ${CONFIG.envPath}`);
+      throw new SchemaError(
+        `Environment file not found at ${CONFIG.envPath}`,
+        SchemaError.codes.ENV_FILE_NOT_FOUND
+      );
+    }
+
+    const envContent = readFileSync(CONFIG.envPath, "utf8");
+    const databaseUrls = [];
+
+    // Find all *_DATABASE_URL variables
+    const matches = envContent.matchAll(/(\w+)_DATABASE_URL="([^"]+)"/g);
+    for (const match of matches) {
+      const [, name, url] = match;
+      // Validate DB name format (simple check to prevent injection)
+      if (!/^[A-Z0-9_]+$/.test(name)) {
+        Logger.warn(`Skipping database with invalid name format: ${name}`);
+        continue;
+      }
+
+      // If targetDatabase is specified, only include that database
+      // Use case-insensitive comparison by converting targetDatabase to uppercase
+      if (
+        !CONFIG.targetDatabase ||
+        name === CONFIG.targetDatabase.toUpperCase()
+      ) {
+        databaseUrls.push({ name, url });
+        Logger.debug(`Found database: ${name} (${maskDatabaseUrl(url)})`);
+      }
+    }
+
+    spinner.stop(true, `Found ${databaseUrls.length} databases`);
+    return databaseUrls;
+  } catch (error) {
+    if (!(error instanceof SchemaError)) {
+      spinner.stop(false, error.message);
+      throw new SchemaError(
+        `Error reading database URLs: ${error.message}`,
+        SchemaError.codes.DATABASE_URL_NOT_FOUND,
+        { error }
+      );
+    }
+    throw error;
+  }
+};
+
+// Function to update CURRENT_ADMIN_USER_EMAIL in config.js
+const updateAdminEmail = (dbName) => {
+  const spinner = Logger.startSpinner(`Updating admin email for ${dbName}`);
+  try {
+    if (!existsSync(CONFIG.constantPath)) {
+      spinner.stop(false, `Constant file not found at ${CONFIG.constantPath}`);
+      throw new SchemaError(
+        `Constant file not found at ${CONFIG.constantPath}`,
+        SchemaError.codes.FILE_UPDATE_FAILED
+      );
+    }
+
+    let content = readFileSync(CONFIG.constantPath, "utf8");
+
+    // Get tenant email from config
+    const getTenantEmail = (tenantName) => {
+      // Convert tenant name to lowercase for comparison
+      const lowerTenantName = tenantName.toLowerCase();
+
+      // Look for the tenant in TENANT_EMAILS array
+      const tenantConfig = TENANT_EMAILS.find(
+        (tenant) => Object.keys(tenant)[0] === lowerTenantName
+      );
+
+      if (tenantConfig) {
+        const key = Object.keys(tenantConfig)[0];
+        return tenantConfig[key];
+      }
+
+      // Fallback to default email if tenant not found
+      const defaultConfig = TENANT_EMAILS.find(
+        (tenant) => Object.keys(tenant)[0] === "default"
+      );
+
+      return defaultConfig ? defaultConfig.default : "admin@gmail.com";
+    };
+
+    // Get email from tenant configuration
+    const email = getTenantEmail(
+      dbName === CONFIG.defaultDbName ? "default" : dbName
+    );
+
+    // Replace CURRENT_ADMIN_USER_EMAIL
+    const newContent = content.replace(
+      /CURRENT_ADMIN_USER_EMAIL\s*=\s*['"]([^'"]*)['"]/,
+      `CURRENT_ADMIN_USER_EMAIL = '${email}'`
+    );
+
+    if (content !== newContent) {
+      writeFileSync(CONFIG.constantPath, newContent);
+      spinner.stop(true, `Set to ${email}`);
+      Logger.debug(`Updated CURRENT_ADMIN_USER_EMAIL to: ${email}`);
+    } else {
+      spinner.stop(true, `Already set to ${email}`);
+    }
+
+    return email;
+  } catch (error) {
+    if (!(error instanceof SchemaError)) {
+      spinner.stop(false, error.message);
+      throw new SchemaError(
+        `Error updating admin email: ${error.message}`,
+        SchemaError.codes.FILE_UPDATE_FAILED,
+        { error }
+      );
+    }
+    throw error;
+  }
+};
+
+// Function to update database URL in schema.prisma
+const updateSchemaUrl = (dbName) => {
+  const spinner = Logger.startSpinner(`Updating schema URL for ${dbName}`);
+  try {
+    if (!existsSync(CONFIG.schemaPath)) {
+      spinner.stop(false, `Schema file not found at ${CONFIG.schemaPath}`);
+      throw new SchemaError(
+        `Schema file not found at ${CONFIG.schemaPath}`,
+        SchemaError.codes.SCHEMA_FILE_NOT_FOUND
+      );
+    }
+
+    let content = readFileSync(CONFIG.schemaPath, "utf8");
+
+    // Replace the database URL in the datasource block with the environment variable reference
+    const newEnvVar = `${dbName}_DATABASE_URL`;
+    const newContent = content.replace(
+      /url\s*=\s*env\("([^"]+)"\)/,
+      `url = env("${newEnvVar}")`
+    );
+
+    if (content !== newContent) {
+      writeFileSync(CONFIG.schemaPath, newContent);
+      spinner.stop(true, `Now using ${newEnvVar}`);
+      Logger.debug(`Updated database URL in schema.prisma to use ${newEnvVar}`);
+    } else {
+      spinner.stop(true, `Already using ${newEnvVar}`);
+    }
+  } catch (error) {
+    if (!(error instanceof SchemaError)) {
+      spinner.stop(false, error.message);
+      throw new SchemaError(
+        `Error updating schema URL: ${error.message}`,
+        SchemaError.codes.FILE_UPDATE_FAILED,
+        { error, dbName }
+      );
+    }
+    throw error;
+  }
+};
+
+// Function to restore original schema.prisma
+const restoreSchemaUrl = async () => {
+  const spinner = Logger.startSpinner("Restoring original schema.prisma");
+  try {
+    if (!existsSync(CONFIG.schemaPath)) {
+      spinner.stop(false, `Schema file not found at ${CONFIG.schemaPath}`);
+      throw new SchemaError(
+        `Schema file not found at ${CONFIG.schemaPath}`,
+        SchemaError.codes.SCHEMA_FILE_NOT_FOUND
+      );
+    }
+
+    let content = readFileSync(CONFIG.schemaPath, "utf8");
+    const defaultEnvVar = `${CONFIG.defaultDbName}_DATABASE_URL`;
+
+    // Restore the original environment variable reference
+    const newContent = content.replace(
+      /url\s*=\s*env\("([^"]+)"\)/,
+      `url = env("${defaultEnvVar}")`
+    );
+
+    if (content !== newContent) {
+      writeFileSync(CONFIG.schemaPath, newContent);
+      spinner.stop(true, `Set to ${defaultEnvVar}`);
+      Logger.debug(
+        `Restored original database URL in schema.prisma to ${defaultEnvVar}`
+      );
+    } else {
+      spinner.stop(true, `Already using ${defaultEnvVar}`);
+    }
+  } catch (error) {
+    if (!(error instanceof SchemaError)) {
+      spinner.stop(false, error.message);
+      throw new SchemaError(
+        `Error restoring schema URL: ${error.message}`,
+        SchemaError.codes.FILE_UPDATE_FAILED,
+        { error }
+      );
+    }
+    throw error;
+  }
+};
+
+// Function to run Prisma commands with retry mechanism and connection management
+const runPrismaCommand = async (
+  command,
+  databaseUrl,
+  dbName,
+  maxRetries = CONFIG.retryAttempts
+) => {
+  let lastError;
+  const commandDisplay =
+    command.length > 30 ? `${command.substring(0, 27)}...` : command;
+
+  Logger.info(
+    `Running '${colors.highlight(commandDisplay)}' for database: ${colors.warn(
+      dbName
+    )}`
+  );
+
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    const spinner = Logger.startSpinner(
+      `Prisma ${commandDisplay} (attempt ${attempt}/${maxRetries})`
+    );
+
+    try {
+      // Update schema.prisma with the current database environment variable
+      await updateSchemaUrl(dbName);
+
+      if (command === "db seed") {
+        try {
+          // Wrap seeding in a try/catch with proper error capture
+          const result = await connectionManager.executeWithConnection(
+            dbName,
+            databaseUrl,
+            async (prisma) => {
+              // Set environment variables
+              const originalDbUrl = process.env.DEFAULT_DATABASE_URL;
+              process.env.DEFAULT_DATABASE_URL = databaseUrl;
+
+              try {
+                // Add a pre-seed delay to ensure connections are ready
+                await delay(1000);
+
+                // Capture standard output to preserve detailed seeding logs
+                process.env.DETAILED_LOGGING = "true";
+
+                // Restore the important NODE_OPTIONS memory limit
+                const originalNodeOptions = process.env.NODE_OPTIONS;
+                process.env.NODE_OPTIONS = "--max-old-space-size=4096";
+                process.env.PRISMA_CLIENT_CONNECTION_REUSE = "true";
+
+                // Execute the seed process directly instead of using execSync
+                // so we can capture all detailed logs
+                Logger.info(colors.bold(`\n===== DETAILED SEEDING LOGS =====`));
+
+                // Import the seed module dynamically
+                const { main: seedDatabase } = await import(
+                  "../prisma/seeders/seed.js"
+                );
+                const success = await seedDatabase();
+
+                Logger.info(
+                  colors.bold(`\n===== END OF DETAILED SEEDING LOGS =====\n`)
+                );
+
+                // Restore original NODE_OPTIONS
+                process.env.NODE_OPTIONS = originalNodeOptions;
+
+                if (!success) {
+                  throw new Error("Seeding process returned failure status");
+                }
+
+                return { success: true };
+              } catch (err) {
+                // Capture and log detailed error information
+                const errorOutput = err.message || "Unknown error";
+                Logger.error(`Seeding error details: ${errorOutput}`);
+                throw new Error(`Seeding failed: ${errorOutput}`);
+              } finally {
+                // Restore env var
+                process.env.DEFAULT_DATABASE_URL = originalDbUrl;
+              }
+            },
+            { autoRelease: false }
+          );
+        } catch (error) {
+          throw error;
+        }
+      } else {
+        // For non-seeding commands, use the original approach
+        // Set the DATABASE_URL environment variable temporarily for this command
+        const originalDbUrl = process.env.DEFAULT_DATABASE_URL;
+        process.env.DEFAULT_DATABASE_URL = databaseUrl;
+
+        // Log the action but mask sensitive info
+        Logger.debug(
+          `Executing: npx prisma ${command} (using DB: ${maskDatabaseUrl(
+            databaseUrl
+          )})`
+        );
+
+        // Execute the Prisma command
+        execSync(`npx prisma ${command}`, {
+          stdio: "inherit",
+          env: {
+            ...process.env,
+            PRISMA_CLIENT_CONNECTION_REUSE: "true",
+          },
+        });
+
+        // Restore the original env var
+        process.env.DEFAULT_DATABASE_URL = originalDbUrl;
+      }
+
+      spinner.stop(true, "Completed successfully");
+
+      // Add delay after successful command
+      await delay(CONFIG.successDelay);
+      return;
+    } catch (error) {
+      // Restore the original env var in case of error
+      process.env.DEFAULT_DATABASE_URL = process.env.DEFAULT_DATABASE_URL || "";
+
+      lastError = error;
+      spinner.stop(false, `Failed`);
+
+      if (attempt < maxRetries) {
+        Logger.warn(`Retrying in ${CONFIG.retryDelay / 1000} seconds...`);
+        await delay(CONFIG.retryDelay);
+      }
+    }
+  }
+
+  // Create sanitized error details to avoid logging sensitive info
+  const errorDetails = {
+    message: lastError?.message ?? "Unknown error",
+    code: lastError?.code,
+    signal: lastError?.signal,
+  };
+
+  // Log detailed error info for debugging but sanitize URLs
+  const errorMessage =
+    lastError?.stderr?.toString() || lastError?.message || "Unknown error";
+  const sanitizedMessage = errorMessage.replace(
+    /(postgres|mysql|mongodb):\/\/[^@\s]+@/g,
+    "$1://***:***@"
+  );
+  Logger.debug(`Prisma command error details: ${sanitizedMessage}`);
+
+  throw new PrismaOperationError(command, dbName, errorDetails);
+};
+
+// Function to validate schema before seeding
+const validateSchema = async (databaseUrl, dbName) => {
+  const spinner = Logger.startSpinner(`Validating schema for ${dbName}`);
+  try {
+    // Set the DATABASE_URL environment variable temporarily
+    const originalDbUrl = process.env.DEFAULT_DATABASE_URL;
+    process.env.DEFAULT_DATABASE_URL = databaseUrl;
+
+    // Use validate command to check schema
+    const result = execSync(`npx prisma validate`, { stdio: "pipe" });
+
+    // Restore the original env var
+    process.env.DEFAULT_DATABASE_URL = originalDbUrl;
+
+    spinner.stop(true, "Schema is valid");
+    return true;
+  } catch (error) {
+    // Restore the original env var in case of error
+    process.env.DEFAULT_DATABASE_URL = process.env.DEFAULT_DATABASE_URL || "";
+
+    spinner.stop(false, "Schema validation failed");
+
+    // Sanitize error message
+    const errorMessage = error.message || "Unknown error";
+    const sanitizedMessage = errorMessage.replace(
+      /(postgres|mysql|mongodb):\/\/[^@\s]+@/g,
+      "$1://***:***@"
+    );
+    Logger.debug(`Schema validation error: ${sanitizedMessage}`);
+
+    return false;
+  }
+};
+
+// Main function to seed databases
+const seedDatabases = async () => {
+  Logger.info(colors.header("🌱 Starting database seeding process"));
+  Logger.info(colors.debug("──────────────────────────────────────────"));
+
+  try {
+    // Step 0: Get database URLs and validate
+    const databaseUrls = getDatabaseUrls();
+
+    if (databaseUrls.length === 0) {
+      throw new SchemaError(
+        "No matching database URLs found in prisma/.env file!",
+        SchemaError.codes.DATABASE_URL_NOT_FOUND
+      );
+    }
+
+    if (CONFIG.targetDatabase) {
+      Logger.info(
+        colors.bold(
+          `Target database: ${colors.highlight(
+            CONFIG.targetDatabase.toUpperCase()
+          )}`
+        )
+      );
+
+      // Validate target database exists
+      if (databaseUrls.length === 0) {
+        throw new SchemaError(
+          `Target database ${CONFIG.targetDatabase.toUpperCase()}_DATABASE_URL not found in .env file!`,
+          SchemaError.codes.DATABASE_URL_NOT_FOUND
+        );
+      }
+    } else {
+      Logger.info(
+        colors.bold(
+          `Processing all databases: ${colors.highlight(
+            databaseUrls.map((db) => db.name).join(", ")
+          )}`
+        )
+      );
+    }
+
+    // Display progress header
+    Logger.info(colors.bold("\n🛠️ Starting database seeding operations"));
+    Logger.info(colors.debug("──────────────────────────────────────────"));
+
+    // Process each database
+    const progress = Logger.progressBar(
+      databaseUrls.length,
+      "Database seeding progress"
+    );
+
+    for (const [index, db] of databaseUrls.entries()) {
+      Logger.info(
+        colors.bold(
+          `\nProcessing database ${index + 1}/${
+            databaseUrls.length
+          }: ${colors.highlight(db.name)}`
+        )
+      );
+
+      // Validate schema before proceeding
+      const isSchemaValid = await validateSchema(db.url, db.name);
+      if (!isSchemaValid) {
+        Logger.warn(
+          `Schema validation failed for ${db.name}, but proceeding with caution`
+        );
+      }
+
+      // Update admin email for seeding
+      const email = updateAdminEmail(db.name);
+      Logger.info(`Admin email set to: ${email}`);
+
+      // Generate Prisma Client
+      await runPrismaCommand("generate", db.url, db.name);
+
+      // Run seed
+      await runPrismaCommand("db seed", db.url, db.name);
+
+      progress.update();
+    }
+
+    progress.complete();
+
+    // Cleanup and finalization
+    Logger.info(colors.bold("\nFinalizing and cleaning up"));
+
+    // Reset admin email back to default and restore schema if we've made changes
+    if (
+      databaseUrls.length > 0 &&
+      (!CONFIG.targetDatabase ||
+        CONFIG.targetDatabase.toUpperCase() !== CONFIG.defaultDbName)
+    ) {
+      // Reset admin email back to default
+      updateAdminEmail(CONFIG.defaultDbName);
+
+      // Restore original schema.prisma file
+      await restoreSchemaUrl();
+
+      // Get the default database URL for final generate, if not already in our filtered list
+      if (!databaseUrls.some((db) => db.name === CONFIG.defaultDbName)) {
+        const allDbs = getDatabaseUrls();
+        const defaultDb = allDbs.find((db) => db.name === CONFIG.defaultDbName);
+        if (defaultDb) {
+          // Run final generate with default settings
+          Logger.info("Running final generate with default settings...");
+          await runPrismaCommand(
+            "generate",
+            defaultDb.url,
+            CONFIG.defaultDbName
+          );
+        }
+      }
+
+      // Update Prisma client files with correct paths
+      await updatePrismaClientFiles();
+    }
+
+    // Step 3: Finalize and cleanup
+    Logger.info(colors.bold("\nStep 3: Finalizing and cleanup"));
+
+    // Close all database connections
+    await connectionManager.closeAllConnections();
+
+    // Display success message
+    Logger.info(colors.debug("\n──────────────────────────────────────────"));
+    if (CONFIG.targetDatabase) {
+      Logger.success(
+        colors.bold(
+          `Database seeding for ${CONFIG.targetDatabase.toUpperCase()} completed successfully! 🎉`
+        )
+      );
+    } else {
+      Logger.success(
+        colors.bold(
+          `Database seeding for all databases completed successfully! 🎉`
+        )
+      );
+    }
+  } catch (error) {
+    Logger.info(colors.debug("\n──────────────────────────────────────────"));
+    Logger.error(colors.bold(colors.error("Database seeding failed! 💥")));
+
+    if (error instanceof SchemaError) {
+      Logger.error(`Error code: ${colors.warn(error.code)}`);
+      Logger.error(`Message: ${error.message}`);
+
+      if (error instanceof PrismaOperationError) {
+        Logger.error(`Operation: ${colors.warn(error.details.operation)}`);
+        Logger.error(`Database: ${colors.warn(error.details.dbName)}`);
+        if (error.details.originalError) {
+          Logger.debug(
+            "Error details:",
+            JSON.stringify(error.details.originalError, null, 2)
+          );
+        }
+      } else if (error.details && Object.keys(error.details).length > 0) {
+        Logger.debug("Error details:", JSON.stringify(error.details, null, 2));
+      }
+    } else {
+      Logger.error(error.stack || error.message);
+    }
+
+    // Try to restore schema file if possible
+    try {
+      await restoreSchemaUrl();
+      Logger.info("Schema file restored to default state");
+    } catch (cleanupError) {
+      Logger.warn(`Failed to restore schema file: ${cleanupError.message}`);
+    }
+
+    // Ensure connections are closed even on error
+    await connectionManager.closeAllConnections();
+
+    process.exit(1);
+  }
+};
+
+// Print usage information
+const printUsage = () => {
+  console.log(`
+${colors.header("Prisma Database Seeding Tool")}
+${colors.debug("──────────────────────────────────────────")}
+
+${colors.bold("Usage:")}
+  npm run seed-database                 Seed all databases
+  npm run seed-database -- --db NAME    Seed specific database (NAME)
+
+${colors.bold("Examples:")}
+  npm run seed-database
+  npm run seed-database -- --db default
+
+${colors.debug("──────────────────────────────────────────")}
+  `);
+};
+
+// Display help if requested
+if (args.includes("--help") || args.includes("-h")) {
+  printUsage();
+  process.exit(0);
+}
+
+// Execute the main function
+seedDatabases()
+  .catch((error) => {
+    process.exit(1);
+  })
+  .finally(async () => {
+    // Final cleanup to ensure all connections are closed
+    await connectionManager.closeAllConnections();
+  });
+
+// Graceful exit on SIGINT
+process.on("SIGINT", async () => {
+  Logger.info("\nScript interrupted. Cleaning up...");
+  try {
+    await restoreSchemaUrl();
+    Logger.success("Schema restored. Exiting...");
+  } catch (error) {
+    Logger.error("Failed to restore schema:", error.message);
+  }
+  process.exit(0);
+});