procbay-schema 1.0.0

package/scripts/sync-schemas.js

@@ -0,0 +1,865 @@
+#!/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 instead of chalk
+import { connectionManager } from "../prisma/seeders/utils/connection-manager.js";
+import { TENANT_EMAILS } from "../prisma/seeders/utils/config.js";
+
+// Get current directory
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// 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",
+      DATABASE_CONNECTION_FAILED: "DATABASE_CONNECTION_FAILED",
+      PRISMA_OPERATION_FAILED: "PRISMA_OPERATION_FAILED",
+      FILE_UPDATE_FAILED: "FILE_UPDATE_FAILED",
+      INVALID_DATABASE_NAME: "INVALID_DATABASE_NAME",
+    };
+  }
+}
+
+// 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 and DEFAULT
+      if (
+        !CONFIG.targetDatabase ||
+        name === CONFIG.targetDatabase.toUpperCase() ||
+        name === CONFIG.defaultDbName
+      ) {
+        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}`);
+    }
+  } 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);
+
+      // Use connection manager for db operations
+      if (
+        command.startsWith("db") ||
+        command === "migrate deploy" ||
+        command === "migrate dev"
+      ) {
+        await connectionManager.executeWithConnection(
+          dbName,
+          databaseUrl,
+          async (prisma) => {
+            // 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
+              )})`
+            );
+
+            try {
+              // 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;
+            } catch (err) {
+              // Restore the original env var in case of error
+              process.env.DEFAULT_DATABASE_URL = originalDbUrl;
+              throw err;
+            }
+          },
+          { autoRelease: false } // Don't auto-release, we'll manage connection closure later
+        );
+      } else {
+        // For commands that don't need a live connection, 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 test database connection using 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;
+  }
+};
+
+// Main function to sync schemas
+const syncSchemas = async () => {
+  Logger.info(colors.header("🔄 Starting schema synchronization 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()
+          )}`
+        )
+      );
+
+      // Check if target database exists
+      const targetDb = databaseUrls.find(
+        (db) => db.name === CONFIG.targetDatabase.toUpperCase()
+      );
+      if (!targetDb) {
+        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(", ")
+          )}`
+        )
+      );
+    }
+
+    // Find the default database (DEFAULT_DATABASE_URL)
+    const defaultDb = databaseUrls.find(
+      (db) => db.name === CONFIG.defaultDbName
+    );
+    if (!defaultDb) {
+      throw new SchemaError(
+        `${CONFIG.defaultDbName}_DATABASE_URL not found in prisma/.env file!`,
+        SchemaError.codes.DATABASE_URL_NOT_FOUND
+      );
+    }
+
+    // Step 1: Run migration on default database
+    Logger.info(colors.bold("\nStep 1: Setting up default database"));
+    await runPrismaCommand("migrate dev", defaultDb.url, defaultDb.name);
+    await runPrismaCommand("generate", defaultDb.url, defaultDb.name);
+
+    // Step 2: Process each additional database
+    const nonDefaultDbs = databaseUrls.filter(
+      (db) => db.name !== CONFIG.defaultDbName
+    );
+
+    if (nonDefaultDbs.length > 0) {
+      Logger.info(
+        colors.bold(
+          `\nStep 2: Processing ${nonDefaultDbs.length} additional databases`
+        )
+      );
+
+      const progress = Logger.progressBar(
+        nonDefaultDbs.length,
+        "Database processing"
+      );
+
+      for (const [index, db] of nonDefaultDbs.entries()) {
+        Logger.info(
+          colors.bold(
+            `\nProcessing database ${index + 1}/${
+              nonDefaultDbs.length
+            }: ${colors.highlight(db.name)}`
+          )
+        );
+
+        // Deploy migrations
+        await runPrismaCommand("migrate deploy", db.url, db.name);
+
+        // Generate Prisma Client
+        await runPrismaCommand("generate", db.url, db.name);
+
+        // Uncomment if seeding is needed
+        // Logger.info('Updating admin email for seeding...');
+        // updateAdminEmail(db.name);
+        // Logger.info('Running seed...');
+        // await runPrismaCommand('db seed', db.url, db.name);
+
+        progress.update();
+      }
+
+      progress.complete();
+    } else {
+      Logger.info(colors.debug("\nNo additional databases to process"));
+    }
+
+    // Step 3: Finalize and cleanup
+    Logger.info(colors.bold("\nStep 3: Finalizing and cleanup"));
+
+    // Reset admin email back to default
+    updateAdminEmail(CONFIG.defaultDbName);
+
+    // Restore original schema.prisma file
+    await restoreSchemaUrl();
+
+    // Run final operations on default database
+    Logger.info("Running final operations on default database...");
+    await runPrismaCommand("migrate deploy", defaultDb.url, defaultDb.name);
+    await runPrismaCommand("generate", defaultDb.url, defaultDb.name);
+
+    // Update Prisma client files with correct paths
+    await updatePrismaClientFiles();
+
+    // Close all database connections
+    await connectionManager.closeAllConnections();
+
+    // Display success message
+    Logger.info(colors.debug("\n──────────────────────────────────────────"));
+    if (CONFIG.targetDatabase) {
+      Logger.success(
+        colors.bold(
+          colors.success(
+            `Schema synchronization for ${CONFIG.targetDatabase.toUpperCase()} completed successfully! 🎉`
+          )
+        )
+      );
+    } else {
+      Logger.success(
+        colors.bold(
+          colors.success(
+            `Schema synchronization for all databases completed successfully! 🎉`
+          )
+        )
+      );
+    }
+  } catch (error) {
+    Logger.info(colors.debug("\n──────────────────────────────────────────"));
+    Logger.error(
+      colors.bold(colors.error("Schema synchronization 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 Schema Synchronization Tool")}
+${colors.debug("──────────────────────────────────────────")}
+
+${colors.bold("Usage:")}
+  npm run sync-database                 Sync all databases
+  npm run sync-database -- --db NAME    Sync specific database (NAME)
+
+${colors.bold("Examples:")}
+  npm run sync-database
+  npm run sync-database -- --db default
+
+${colors.debug("──────────────────────────────────────────")}
+  `);
+};
+
+// Display help if requested
+if (args.includes("--help") || args.includes("-h")) {
+  printUsage();
+  process.exit(0);
+}
+
+// Execute the main function
+syncSchemas()
+  .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);
+});