fix: use string literal imports and exact package name matching

- Use load functions with string literal import() paths so the bundler
  can statically analyze and code-split connector modules
- Drop subpath matching — only exact driver package name triggers skip
- Add loadConnectors behavior tests: missing driver logs and continues,
  non-driver errors are rethrown

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: tianzhou

src/__tests__/load-connectors.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, vi } from "vitest";
 import { isDriverNotInstalled } from "../utils/module-loader.js";
 
 describe("isDriverNotInstalled", () => {
@@ -20,13 +20,13 @@ describe("isDriverNotInstalled", () => {
     expect(isDriverNotInstalled(err, "mysql2")).toBe(false);
   });
 
-  it("should return true for driver subpath imports", () => {
+  it("should return false for driver subpath imports", () => {
     const err = new Error(
       "Cannot find package 'mysql2/promise' imported from /fake/path"
     );
     (err as NodeJS.ErrnoException).code = "ERR_MODULE_NOT_FOUND";
 
-    expect(isDriverNotInstalled(err, "mysql2")).toBe(true);
+    expect(isDriverNotInstalled(err, "mysql2")).toBe(false);
   });
 
   it("should return false when missing module name only contains driver as a substring", () => {
@@ -59,3 +59,66 @@ describe("isDriverNotInstalled", () => {
     expect(isDriverNotInstalled(undefined, "pg")).toBe(false);
   });
 });
+
+describe("loadConnectors", () => {
+  it("should log and continue when a driver is missing", async () => {
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+    // Mock a connector module that throws ERR_MODULE_NOT_FOUND for its driver
+    const driverErr = new Error("Cannot find package 'pg' imported from /fake/path");
+    (driverErr as NodeJS.ErrnoException).code = "ERR_MODULE_NOT_FOUND";
+
+    const connectorModules = [
+      { load: () => Promise.reject(driverErr), name: "PostgreSQL", driver: "pg" },
+    ];
+
+    // Inline the loadConnectors logic to test without importing index.ts
+    // (which triggers side effects)
+    await Promise.all(
+      connectorModules.map(async ({ load, name, driver }) => {
+        try {
+          await load();
+        } catch (err) {
+          if (isDriverNotInstalled(err, driver)) {
+            console.error(
+              `Skipping ${name} connector: driver package "${driver}" not installed.`
+            );
+          } else {
+            throw err;
+          }
+        }
+      })
+    );
+
+    expect(errorSpy).toHaveBeenCalledWith(
+      'Skipping PostgreSQL connector: driver package "pg" not installed.'
+    );
+    errorSpy.mockRestore();
+  });
+
+  it("should rethrow non-driver errors", async () => {
+    const runtimeErr = new Error("Unexpected syntax error");
+
+    const connectorModules = [
+      { load: () => Promise.reject(runtimeErr), name: "PostgreSQL", driver: "pg" },
+    ];
+
+    await expect(
+      Promise.all(
+        connectorModules.map(async ({ load, name, driver }) => {
+          try {
+            await load();
+          } catch (err) {
+            if (isDriverNotInstalled(err, driver)) {
+              console.error(
+                `Skipping ${name} connector: driver package "${driver}" not installed.`
+              );
+            } else {
+              throw err;
+            }
+          }
+        })
+      )
+    ).rejects.toThrow("Unexpected syntax error");
+  });
+});

src/index.ts

@@ -1,24 +1,24 @@
 #!/usr/bin/env node
 
 import { main } from "./server.js";
+import { isDriverNotInstalled } from "./utils/module-loader.js";
 
 // Dynamically import connector modules so missing driver packages
 // (e.g. when only one database type is needed) don't crash the server.
+// Each load function uses a string literal so the bundler can resolve it.
 const connectorModules = [
-  { modulePath: "./connectors/postgres/index.js", name: "PostgreSQL", driver: "pg" },
-  { modulePath: "./connectors/sqlserver/index.js", name: "SQL Server", driver: "mssql" },
-  { modulePath: "./connectors/sqlite/index.js", name: "SQLite", driver: "better-sqlite3" },
-  { modulePath: "./connectors/mysql/index.js", name: "MySQL", driver: "mysql2" },
-  { modulePath: "./connectors/mariadb/index.js", name: "MariaDB", driver: "mariadb" },
+  { load: () => import("./connectors/postgres/index.js"), name: "PostgreSQL", driver: "pg" },
+  { load: () => import("./connectors/sqlserver/index.js"), name: "SQL Server", driver: "mssql" },
+  { load: () => import("./connectors/sqlite/index.js"), name: "SQLite", driver: "better-sqlite3" },
+  { load: () => import("./connectors/mysql/index.js"), name: "MySQL", driver: "mysql2" },
+  { load: () => import("./connectors/mariadb/index.js"), name: "MariaDB", driver: "mariadb" },
 ];
 
-import { isDriverNotInstalled } from "./utils/module-loader.js";
-
 export async function loadConnectors(): Promise<void> {
   await Promise.all(
-    connectorModules.map(async ({ modulePath, name, driver }) => {
+    connectorModules.map(async ({ load, name, driver }) => {
       try {
-        await import(modulePath);
+        await load();
       } catch (err) {
         if (isDriverNotInstalled(err, driver)) {
           console.error(

src/utils/module-loader.ts

@@ -23,9 +23,5 @@ export function isDriverNotInstalled(err: unknown, driver: string): boolean {
   }
 
   const missingSpecifier = match[1];
-  // Match the exact driver package or a subpath import (e.g. "mysql2/promise")
-  return (
-    missingSpecifier === driver ||
-    missingSpecifier.startsWith(`${driver}/`)
-  );
+  return missingSpecifier === driver;
 }