diff --git a/apps/desktop/src/lib/__tests__/imports/navicatImport.spec.ts b/apps/desktop/src/lib/__tests__/imports/navicatImport.spec.ts
index 9f5da1872f..b1c1d7397b 100644
--- a/apps/desktop/src/lib/__tests__/imports/navicatImport.spec.ts
+++ b/apps/desktop/src/lib/__tests__/imports/navicatImport.spec.ts
@@ -17,7 +17,7 @@ class TestDocument {
private readonly elements: TestElement[];
constructor(xml: string) {
- this.elements = Array.from(xml.matchAll(//gi)).map((match) => new TestElement("Connection", parseAttributes(match[1] || "")));
+ this.elements = flattenTestElements(parseTestConnections(xml));
}
querySelector(selector: string) {
@@ -29,6 +29,28 @@ class TestDocument {
}
}
+function flattenTestElements(elements: TestElement[]): TestElement[] {
+ return elements.flatMap((element) => [element, ...flattenTestElements(element.children)]);
+}
+
+function parseTestConnections(xml: string): TestElement[] {
+ const result: TestElement[] = [];
+ // Handle self-closing and paired so / children are reachable.
+ const connectionRe = /]*?)(\/>|>([\s\S]*?)<\/Connection>)/gi;
+ for (const match of xml.matchAll(connectionRe)) {
+ const connection = new TestElement("Connection", parseAttributes(match[1] || ""));
+ const inner = match[3] || "";
+ for (const memberMatch of inner.matchAll(/]*?)\/>/gi)) {
+ connection.children.push(new TestElement("Member", parseAttributes(memberMatch[1] || "")));
+ }
+ for (const advanceMatch of inner.matchAll(/]*?)(?:\/>|><\/Advance>)/gi)) {
+ connection.children.push(new TestElement("Advance", parseAttributes(advanceMatch[1] || "")));
+ }
+ result.push(connection);
+ }
+ return result;
+}
+
class TestDOMParser {
parseFromString(xml: string) {
return new TestDocument(xml);
@@ -184,4 +206,90 @@ describe("parseNavicatConnections", () => {
expect(connections).toHaveLength(3);
expect(connections.map((connection) => connection.transport_layers)).toEqual([[], [], []]);
});
+
+ it("rebuilds a MongoDB replica-set connection as a multi-host URL from seeds", async () => {
+ const password = await encryptNavicatPassword("replica-secret");
+ const [connection] = await parseNavicatConnections(`
+
+
+
+
+`);
+
+ expect(connection?.db_type).toBe("mongodb");
+ expect(connection?.name).toBe("rs-single-demo");
+ expect(connection?.host).toBe("replica-1.example.test");
+ expect(connection?.port).toBe(3717);
+ expect(connection?.username).toBe("mongouser");
+ expect(connection?.password).toBe("replica-secret");
+ expect(connection?.database).toBe("appdb");
+ expect(connection?.connection_string).toBe("mongodb://mongouser:replica-secret@replica-1.example.test:3717/appdb?retryWrites=true&retryReads=true");
+ });
+
+ it("joins every seed with commas and keeps the first as the form host", async () => {
+ const password = await encryptNavicatPassword("multi-secret");
+ const [connection] = await parseNavicatConnections(`
+
+
+
+
+
+`);
+
+ expect(connection?.host).toBe("replica-a.example.test");
+ expect(connection?.port).toBe(27017);
+ expect(connection?.connection_string).toBe("mongodb://mongouser:multi-secret@replica-a.example.test:27017,replica-b.example.test:27017/appdb?replicaSet=rs0&authSource=admin&retryWrites=true");
+ });
+
+ it("preserves explicitly disabled MongoDB retry settings", async () => {
+ const [connection] = await parseNavicatConnections(`
+
+
+
+`);
+
+ expect(connection?.connection_string).toBe("mongodb://replica.example.test:27017?retryWrites=false&retryReads=false");
+ });
+
+ it("does not turn replica-set children into standalone connections", async () => {
+ const password = await encryptNavicatPassword("solo-secret");
+ const connections = await parseNavicatConnections(`
+
+
+
+
+`);
+
+ // Previously the 27017-port was misdetected as a second MongoDB connection.
+ expect(connections).toHaveLength(1);
+ expect(connections[0]?.name).toBe("rs-no-leak-demo");
+ expect(connections[0]?.host).toBe("replica.example.test");
+ });
+
+ it("percent-encodes reserved characters in the MongoDB password", async () => {
+ const password = await encryptNavicatPassword("p@ss:w/d");
+ const [connection] = await parseNavicatConnections(`
+
+
+
+
+`);
+
+ expect(connection?.password).toBe("p@ss:w/d");
+ expect(connection?.connection_string).toBe("mongodb://mongouser:p%40ss%3Aw%2Fd@replica-1.example.test:27017/appdb");
+ });
+
+ it("keeps a member-less standalone MongoDB connection in form mode", async () => {
+ const password = await encryptNavicatPassword("standalone-secret");
+ const [connection] = await parseNavicatConnections(`
+
+`);
+
+ expect(connection?.db_type).toBe("mongodb");
+ expect(connection?.host).toBe("mongo.example.test");
+ expect(connection?.port).toBe(27018);
+ expect(connection?.username).toBe("mongouser");
+ expect(connection?.password).toBe("standalone-secret");
+ expect(connection?.connection_string).toBeUndefined();
+ });
});
diff --git a/apps/desktop/src/lib/imports/navicatImport.ts b/apps/desktop/src/lib/imports/navicatImport.ts
index e878695d27..4b3e79ec84 100644
--- a/apps/desktop/src/lib/imports/navicatImport.ts
+++ b/apps/desktop/src/lib/imports/navicatImport.ts
@@ -3,9 +3,12 @@ import { uuid } from "@/lib/common/utils";
type PartialConnection = Omit;
+type MongoReplicaMember = { host: string; port: number };
+
type ParsedNode = {
tag: string;
values: Record;
+ members: MongoReplicaMember[];
};
const typeMap: Record = {
@@ -63,6 +66,10 @@ function truthyNavicatFlag(value: string) {
return ["1", "true", "yes", "y", "on", "checked"].includes(normalized);
}
+function optionalNavicatFlag(value: string): boolean | undefined {
+ return value.trim() ? truthyNavicatFlag(value) : undefined;
+}
+
function hexToBytes(hex: string) {
const clean = hex.trim();
if (!clean || clean.length % 2 !== 0 || /[^0-9a-f]/i.test(clean)) return null;
@@ -151,11 +158,23 @@ function inferProfile(rawType: string, tag: string, port?: number) {
function readNode(element: Element): ParsedNode {
const values: Record = {};
+ const members: MongoReplicaMember[] = [];
for (const attr of Array.from(element.attributes)) {
values[normalizeKey(attr.name)] = attr.value;
}
for (const child of Array.from(element.children)) {
+ const childTag = normalizeKey(child.tagName);
+ if (childTag === "member") {
+ const childValues = valuesFromElement(child);
+ const memberHost = getAny(childValues, ["hostname", "host", "address"]);
+ if (memberHost) {
+ members.push({ host: memberHost, port: parseNavicatPort(getAny(childValues, ["port"]), 27017) });
+ }
+ // Skip flattening so multiple members don't collapse onto one key.
+ continue;
+ }
+
const key = getAny(valuesFromElement(child), ["name", "key", "property", "field"]);
const value = getAny(valuesFromElement(child), ["value", "val", "text", "data"]) || child.textContent?.trim() || "";
if (key && value) values[normalizeKey(key)] = value;
@@ -168,7 +187,7 @@ function readNode(element: Element): ParsedNode {
}
}
- return { tag: element.tagName, values };
+ return { tag: element.tagName, values, members };
}
function valuesFromElement(element: Element) {
@@ -180,6 +199,8 @@ function valuesFromElement(element: Element) {
}
function isConnectionCandidate(node: ParsedNode) {
+ // / are nested metadata, not standalone connections.
+ if (["member", "advance"].includes(normalizeKey(node.tag))) return false;
const type = getAny(node.values, ["connType", "databaseType", "driver", "connectionType", "type"]);
const name = getAny(node.values, ["name", "connectionName", "connName", "caption", "title"]);
const host = getAny(node.values, ["host", "server", "hostname", "serverHost", "address"]);
@@ -187,6 +208,66 @@ function isConnectionCandidate(node: ParsedNode) {
return !!(name || host || file) && !!(type || host || file);
}
+function encodeMongoUrlPart(value: string): string {
+ return encodeURIComponent(value);
+}
+
+function normalizeMongoAuthMechanism(value: string): string {
+ const trimmed = value.trim();
+ if (!trimmed) return "";
+ // "Password" is the SCRAM default; let the driver negotiate it.
+ if (/^(password|default|none|scram)$/i.test(trimmed)) return "";
+ return trimmed.toUpperCase();
+}
+
+function normalizeMongoReadPreference(value: string): string {
+ const trimmed = value.trim();
+ if (!trimmed || /^primary$/i.test(trimmed)) return "";
+ return trimmed.charAt(0).toLowerCase() + trimmed.slice(1);
+}
+
+function buildMongoReplicaSetConnectionString(opts: {
+ useSrv: boolean;
+ username: string;
+ password: string;
+ members: MongoReplicaMember[];
+ database: string;
+ replicaSet: string;
+ authSource: string;
+ authMechanism: string;
+ readPreference: string;
+ retryReads?: boolean;
+ retryWrites?: boolean;
+ ssl: boolean;
+}): string {
+ const scheme = opts.useSrv ? "mongodb+srv://" : "mongodb://";
+ const userInfo = opts.username ? `${encodeMongoUrlPart(opts.username)}:${encodeMongoUrlPart(opts.password)}@` : "";
+
+ let hosts: string;
+ if (opts.useSrv) {
+ // SRV forbids ports; DNS resolves the seed list.
+ const srvHost = opts.members[0]?.host ?? "";
+ hosts = encodeMongoUrlPart(srvHost);
+ } else {
+ hosts = opts.members.map((member) => (member.host.includes(":") ? `[${member.host}]:${member.port}` : `${member.host}:${member.port}`)).join(",");
+ }
+
+ const path = opts.database ? `/${encodeMongoUrlPart(opts.database)}` : "";
+ const params = new URLSearchParams();
+ if (opts.replicaSet) params.set("replicaSet", opts.replicaSet);
+ if (opts.authSource) params.set("authSource", opts.authSource);
+ const authMechanism = normalizeMongoAuthMechanism(opts.authMechanism);
+ if (authMechanism) params.set("authMechanism", authMechanism);
+ const readPreference = normalizeMongoReadPreference(opts.readPreference);
+ if (readPreference) params.set("readPreference", readPreference);
+ if (opts.retryWrites !== undefined) params.set("retryWrites", String(opts.retryWrites));
+ if (opts.retryReads !== undefined) params.set("retryReads", String(opts.retryReads));
+ if (opts.ssl) params.set("tls", "true");
+ const query = params.toString();
+
+ return `${scheme}${userInfo}${hosts}${path}${query ? `?${query}` : ""}`;
+}
+
async function parseConnection(node: ParsedNode): Promise {
const rawType = getAny(node.values, ["connType", "databaseType", "driver", "dbType", "connectionType", "type"]);
const portValue = Number(getAny(node.values, ["port", "serverPort"]));
@@ -253,6 +334,31 @@ async function parseConnection(node: ParsedNode): Promise as a "localhost" placeholder; rebuild a
+ // multi-host URL from the real seeds.
+ if (effectiveProfile.dbType === "mongodb" && node.members.length > 0) {
+ const replicaDatabase = getAny(node.values, ["advanceDatabase", "database", "databaseName"]);
+ const useSrv = truthyNavicatFlag(getAny(node.values, ["useSRVRecord", "srvRecord"]));
+ config.connection_string = buildMongoReplicaSetConnectionString({
+ useSrv,
+ username,
+ password,
+ members: node.members,
+ database: replicaDatabase,
+ replicaSet: getAny(node.values, ["replicaSetName", "replicaSet"]),
+ authSource: getAny(node.values, ["authSource"]),
+ authMechanism: getAny(node.values, ["authMechanism"]),
+ readPreference: getAny(node.values, ["readPreference"]),
+ retryReads: optionalNavicatFlag(getAny(node.values, ["retryReads"])),
+ retryWrites: optionalNavicatFlag(getAny(node.values, ["retryWrites"])),
+ ssl: truthyNavicatFlag(getAny(node.values, ["ssl", "useSsl"])),
+ });
+ config.host = node.members[0].host;
+ config.port = node.members[0].port;
+ config.database = replicaDatabase || undefined;
+ config.url_params = "";
+ }
+
return { ...config, id: uuid() };
}
@@ -268,7 +374,7 @@ export async function parseNavicatConnections(content: string): Promise