From c54b95e2743c9791a46c00e5a914b4736c2b55a4 Mon Sep 17 00:00:00 2001 From: Gadfly Date: Tue, 28 Jul 2026 21:36:56 +0800 Subject: [PATCH] fix(import): rebuild Navicat MongoDB replica-set URLs --- .../__tests__/imports/navicatImport.spec.ts | 110 +++++++++++++++++- apps/desktop/src/lib/imports/navicatImport.ts | 110 +++++++++++++++++- 2 files changed, 217 insertions(+), 3 deletions(-) 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