Skip to content

PostgreSQL backup tool with Point-In-Time-Recovery and restore verification

9.0 KB
Raw Blame
import type { LocalizedText } from '../../../../shared/i18n';

export type ParseResult = {
  host: string;
  port: number;
  username: string;
  password: string;
  database: string;
  isHttps: boolean;
};

export type ParseError = {
  error: LocalizedText;
  format?: string;
};

export class MySqlConnectionStringParser {
  /**
   * Parses a MySQL connection string in various formats.
   *
   * Supported formats:
   * 1. Standard MySQL URI: mysql://user:pass@host:port/db
   * 2. JDBC format: jdbc:mysql://host:port/db?user=x&password=y
   * 3. Key-value format: host=x port=3306 database=db user=u password=p
   * 4. With SSL params: mysql://user:pass@host:port/db?ssl=true or ?sslMode=REQUIRED
   * 5. AWS RDS: mysql://user:[email protected]:3306/db
   * 6. PlanetScale: mysql://user:[email protected]/db?sslaccept=strict
   * 7. DigitalOcean: mysql://user:[email protected]:25060/db?ssl-mode=REQUIRED
   * 8. Azure MySQL: mysql://user@servername:[email protected]:3306/db
   * 9. Railway: mysql://user:[email protected]:port/db
   */
  static parse(connectionString: string): ParseResult | ParseError {
    const trimmed = connectionString.trim();

    if (!trimmed) {
      return { error: { key: 'databases.connectionString.errors.empty' } };
    }

    // Try JDBC format first (starts with jdbc:)
    if (trimmed.startsWith('jdbc:mysql://')) {
      return this.parseJdbc(trimmed);
    }

    // Try key-value format (contains key=value pairs without ://)
    if (this.isKeyValueFormat(trimmed)) {
      return this.parseKeyValue(trimmed);
    }

    // Try URI format (mysql://)
    if (trimmed.startsWith('mysql://')) {
      return this.parseUri(trimmed);
    }

    return {
      error: { key: 'databases.connectionString.errors.unrecognizedFormat' },
    };
  }

  private static isKeyValueFormat(str: string): boolean {
    // Key-value format has key=value pairs separated by spaces
    // Must contain at least host= or database= to be considered key-value format
    return (
      !str.includes('://') &&
      (str.includes('host=') || str.includes('database=')) &&
      str.includes('=')
    );
  }

  private static parseUri(connectionString: string): ParseResult | ParseError {
    try {
      // Handle Azure format where username contains @: user@server:pass
      // Azure format: mysql://user@servername:password@host:port/db
      const azureMatch = connectionString.match(
        /^mysql:\/\/([^@:]+)@([^:]+):([^@]+)@([^:/?]+):?(\d+)?\/([^?]+)(?:\?(.*))?$/,
      );

      if (azureMatch) {
        const [, user, , password, host, port, database, queryString] = azureMatch;
        const isHttps = this.checkSslMode(queryString);

        return {
          host: host,
          port: port ? parseInt(port, 10) : 3306,
          username: decodeURIComponent(user),
          password: decodeURIComponent(password),
          database: decodeURIComponent(database),
          isHttps,
        };
      }

      // Standard URI parsing using URL API
      const url = new URL(connectionString);

      const host = url.hostname;
      const port = url.port ? parseInt(url.port, 10) : 3306;
      const username = decodeURIComponent(url.username);
      const password = decodeURIComponent(url.password);
      const database = decodeURIComponent(url.pathname.slice(1)); // Remove leading /
      const isHttps = this.checkSslMode(url.search);

      // Validate required fields
      if (!host) {
        return { error: { key: 'databases.connectionString.errors.hostMissing' } };
      }

      if (!username) {
        return { error: { key: 'databases.connectionString.errors.usernameMissing' } };
      }

      if (!password) {
        return { error: { key: 'databases.connectionString.errors.passwordMissing' } };
      }

      if (!database) {
        return { error: { key: 'databases.connectionString.errors.databaseMissing' } };
      }

      return {
        host,
        port,
        username,
        password,
        database,
        isHttps,
      };
    } catch {
      return {
        error: { key: 'databases.connectionString.errors.parseFailed' },
        format: 'URI',
      };
    }
  }

  private static parseJdbc(connectionString: string): ParseResult | ParseError {
    try {
      // JDBC format: jdbc:mysql://host:port/database?user=x&password=y
      const jdbcRegex = /^jdbc:mysql:\/\/([^:/?]+):?(\d+)?\/([^?]+)(?:\?(.*))?$/;
      const match = connectionString.match(jdbcRegex);

      if (!match) {
        return {
          error: {
            key: 'databases.connectionString.errors.jdbc.invalidFormat',
            params: { expectedFormat: 'jdbc:mysql://host:port/database?user=x&password=y' },
          },
          format: 'JDBC',
        };
      }

      const [, host, port, database, queryString] = match;

      if (!queryString) {
        return {
          error: { key: 'databases.connectionString.errors.jdbc.queryParametersMissing' },
          format: 'JDBC',
        };
      }

      const params = new URLSearchParams(queryString);
      const username = params.get('user');
      const password = params.get('password');
      const isHttps = this.checkSslMode(queryString);

      if (!username) {
        return {
          error: { key: 'databases.connectionString.errors.jdbc.usernameMissing' },
          format: 'JDBC',
        };
      }

      if (!password) {
        return {
          error: { key: 'databases.connectionString.errors.jdbc.passwordMissing' },
          format: 'JDBC',
        };
      }

      return {
        host,
        port: port ? parseInt(port, 10) : 3306,
        username: decodeURIComponent(username),
        password: decodeURIComponent(password),
        database: decodeURIComponent(database),
        isHttps,
      };
    } catch {
      return {
        error: { key: 'databases.connectionString.errors.jdbc.parseFailed' },
        format: 'JDBC',
      };
    }
  }

  private static parseKeyValue(connectionString: string): ParseResult | ParseError {
    try {
      // Key-value format: host=x port=3306 database=db user=u password=p
      // Values can be quoted with single quotes: password='my pass'
      const params: Record<string, string> = {};

      // Match key=value or key='quoted value'
      const regex = /(\w+)=(?:'([^']*)'|(\S+))/g;
      let match;

      while ((match = regex.exec(connectionString)) !== null) {
        const key = match[1];
        const value = match[2] !== undefined ? match[2] : match[3];
        params[key] = value;
      }

      const host = params['host'] || params['hostaddr'];
      const port = params['port'];
      const database = params['database'] || params['dbname'];
      const username = params['user'] || params['username'];
      const password = params['password'];
      const ssl = params['ssl'] || params['sslMode'] || params['ssl-mode'] || params['useSSL'];

      if (!host) {
        return {
          error: { key: 'databases.connectionString.errors.keyValue.hostMissing' },
          format: 'key-value',
        };
      }

      if (!username) {
        return {
          error: { key: 'databases.connectionString.errors.keyValue.usernameMissing' },
          format: 'key-value',
        };
      }

      if (!password) {
        return {
          error: { key: 'databases.connectionString.errors.keyValue.passwordMissing' },
          format: 'key-value',
        };
      }

      if (!database) {
        return {
          error: { key: 'databases.connectionString.errors.keyValue.databaseMissing' },
          format: 'key-value',
        };
      }

      const isHttps = this.isSslEnabled(ssl);

      return {
        host,
        port: port ? parseInt(port, 10) : 3306,
        username,
        password,
        database,
        isHttps,
      };
    } catch {
      return {
        error: { key: 'databases.connectionString.errors.keyValue.parseFailed' },
        format: 'key-value',
      };
    }
  }

  private static checkSslMode(queryString: string | undefined | null): boolean {
    if (!queryString) return false;

    const params = new URLSearchParams(
      queryString.startsWith('?') ? queryString.slice(1) : queryString,
    );

    // Check various MySQL SSL parameter names
    const ssl = params.get('ssl');
    const sslMode = params.get('sslMode');
    const sslModeHyphen = params.get('ssl-mode');
    const useSSL = params.get('useSSL');
    const sslaccept = params.get('sslaccept');

    if (ssl) return this.isSslEnabled(ssl);
    if (sslMode) return this.isSslEnabled(sslMode);
    if (sslModeHyphen) return this.isSslEnabled(sslModeHyphen);
    if (useSSL) return this.isSslEnabled(useSSL);
    if (sslaccept) return sslaccept.toLowerCase() === 'strict';

    return false;
  }

  private static isSslEnabled(sslValue: string | null | undefined): boolean {
    if (!sslValue) return false;

    const lowercased = sslValue.toLowerCase();

    // These values indicate SSL is enabled
    // eslint-disable-next-line i18next/no-literal-string -- connection string parameter values
    const enabledValues = ['true', 'required', 'verify_ca', 'verify_identity', 'yes', '1'];
    return enabledValues.includes(lowercased);
  }
}