fix(import): rebuild Navicat MongoDB replica-set URLs

This commit is contained in:
Gadfly authored and GitHub committed 2026-07-28 21:36:56 +08:00
1 parent 89c69ebe65
commit c54b95e274
2 files changed
+217 -3

No files matched your search

+109 -1
View File
@@ -17,7 +17,7 @@ class TestDocument {
private readonly elements: TestElement[];
constructor(xml: string) {
this.elements = Array.from(xml.matchAll(/<Connection\b([\s\S]*?)\/>/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 <Connection> so <Member>/<Advance> children are reachable.
const connectionRe = /<Connection\b([^>]*?)(\/>|>([\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(/<Member\b([^>]*?)\/>/gi)) {
connection.children.push(new TestElement("Member", parseAttributes(memberMatch[1] || "")));
}
for (const advanceMatch of inner.matchAll(/<Advance\b([^>]*?)(?:\/>|><\/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 <Member> seeds", async () => {
const password = await encryptNavicatPassword("replica-secret");
const [connection] = await parseNavicatConnections(`<Connections>
<Connection ConnectionName="rs-single-demo" ConnType="MONGODB" Host="localhost" UseSRVRecord="false" Port="27017" AuthMechanism="Password" AuthSource="" ConnMethod="ReplicaSet" RetryReads="true" RetryWrites="true" ReadPreference="Primary" ReplicaSetName="" UserName="mongouser" Password="${password}">
<Member Hostname="replica-1.example.test" Port="3717"/>
<Advance Database="appdb" UserName="" Password=""/>
</Connection>
</Connections>`);
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 <Member> seed with commas and keeps the first as the form host", async () => {
const password = await encryptNavicatPassword("multi-secret");
const [connection] = await parseNavicatConnections(`<Connections>
<Connection ConnectionName="rs-multi-demo" ConnType="MONGODB" Host="localhost" Port="27017" ConnMethod="ReplicaSet" ReplicaSetName="rs0" AuthSource="admin" AuthMechanism="Password" RetryWrites="true" UserName="mongouser" Password="${password}">
<Member Hostname="replica-a.example.test" Port="27017"/>
<Member Hostname="replica-b.example.test" Port="27017"/>
<Advance Database="appdb"/>
</Connection>
</Connections>`);
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(`<Connections>
<Connection ConnectionName="rs-no-retry" ConnType="MONGODB" Host="localhost" Port="27017" ConnMethod="ReplicaSet" RetryReads="false" RetryWrites="false">
<Member Hostname="replica.example.test" Port="27017"/>
</Connection>
</Connections>`);
expect(connection?.connection_string).toBe("mongodb://replica.example.test:27017?retryWrites=false&retryReads=false");
});
it("does not turn replica-set <Member> children into standalone connections", async () => {
const password = await encryptNavicatPassword("solo-secret");
const connections = await parseNavicatConnections(`<Connections>
<Connection ConnectionName="rs-no-leak-demo" ConnType="MONGODB" Host="localhost" Port="27017" ConnMethod="ReplicaSet" UserName="mongouser" Password="${password}">
<Member Hostname="replica.example.test" Port="27017"/>
<Advance Database="appdb"/>
</Connection>
</Connections>`);
// Previously the 27017-port <Member> 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(`<Connections>
<Connection ConnectionName="rs-special-chars" ConnType="MONGODB" Host="localhost" Port="27017" ConnMethod="ReplicaSet" UserName="mongouser" Password="${password}">
<Member Hostname="replica-1.example.test" Port="27017"/>
<Advance Database="appdb"/>
</Connection>
</Connections>`);
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(`<Connections>
<Connection ConnectionName="standalone-demo" ConnType="MONGODB" Host="mongo.example.test" Port="27018" ConnMethod="Standalone" UserName="mongouser" Password="${password}"/>
</Connections>`);
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();
});
});
+108 -2
View File
@@ -3,9 +3,12 @@ import { uuid } from "@/lib/common/utils";
type PartialConnection = Omit<ConnectionConfig, "id">;
type MongoReplicaMember = { host: string; port: number };
type ParsedNode = {
tag: string;
values: Record<string, string>;
members: MongoReplicaMember[];
};
const typeMap: Record<string, { dbType: DatabaseType; profile: string; label: string; port: number; user: string }> = {
@@ -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<string, string> = {};
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) {
// <Member>/<Advance> 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<ConnectionConfig | null> {
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<ConnectionConfig | nul
jdbc_driver_paths: [],
};
// Navicat leaves <Connection Host> as a "localhost" placeholder; rebuild a
// multi-host URL from the real <Member> 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<Connecti
if (!isConnectionCandidate(node)) continue;
const config = await parseConnection(node);
if (!config) continue;
const key = [config.name, config.db_type, config.host, config.port, config.database || ""].join("\u0000");
const key = [config.name, config.db_type, config.host, config.port, config.database || "", config.connection_string || ""].join("\u0000");
if (seen.has(key)) continue;
seen.add(key);
configs.push(config);