Function parseConnectionInfoFromDSN

src/utils/dsn-obfuscate.ts:24–84

(dsn: string)

 * @returns Parsed connection info or null if parsing fails
 */
export function parseConnectionInfoFromDSN(dsn: string): ParsedConnectionInfo | null {
  if (!dsn) {
    return null;
  }

  try {
    const type = getDatabaseTypeFromDSN(dsn);
    if (typeof type === 'undefined') {
      return null;
    }

    // Handle SQLite specially - it only has a database path
    if (type === 'sqlite') {
      // SQLite DSN format: sqlite:///path
      const prefix = 'sqlite:///';
      if (dsn.length > prefix.length) {
        const rawPath = dsn.substring(prefix.length);
        // Add leading '/' for Unix absolute paths only
        // Don't add '/' for:
        // - Memory database: starts with ':'
        // - Relative paths: starts with '.' or '~'
        // - Windows absolute: second char is ':' (e.g., C:/path)
        const firstChar = rawPath[0];
        const isWindowsDrive = rawPath.length > 1 && rawPath[1] === ':';
        const isSpecialPath = firstChar === ':' || firstChar === '.' || firstChar === '~' || isWindowsDrive;
        return {
          type,
          database: isSpecialPath ? rawPath : '/' + rawPath,
        };
      }
      return { type };
    }

    // Parse other database DSNs using SafeURL
    const url = new SafeURL(dsn);

    const info: ParsedConnectionInfo = { type };

    if (url.hostname) {
      info.host = url.hostname;
    }

    if (url.port) {
      info.port = parseInt(url.port, 10);
    }

    if (url.pathname && url.pathname.length > 1) {
      // Remove leading '/' from pathname
      info.database = url.pathname.substring(1);
    }

    if (url.username) {
      info.user = url.username;
    }

    return info;
  } catch {
    // If parsing fails, return null