@squadbase/vite-server 0.1.9-dev.f236b23 → 0.1.10-dev.9dac57b

package/dist/connectors/jdbc.js

@@ -20254,6 +20254,150 @@ var ParameterDefinition = class {
   }
 };
 
+// ../connectors/src/lib/ssh-tunnel.ts
+var sshTunnelParameters = {
+  sshHost: new ParameterDefinition({
+    slug: "ssh-host",
+    name: "SSH Tunnel Host",
+    description: "Optional. Hostname of the SSH bastion to tunnel through. Leave empty to connect directly.",
+    envVarBaseKey: "SSH_TUNNEL_HOST",
+    type: "text",
+    secret: false,
+    required: false
+  }),
+  sshPort: new ParameterDefinition({
+    slug: "ssh-port",
+    name: "SSH Tunnel Port",
+    description: "Optional. SSH port of the bastion host (default: 22).",
+    envVarBaseKey: "SSH_TUNNEL_PORT",
+    type: "text",
+    secret: false,
+    required: false
+  }),
+  sshUsername: new ParameterDefinition({
+    slug: "ssh-username",
+    name: "SSH Tunnel Username",
+    description: "Optional. Username for SSH authentication. Required when SSH Tunnel Host is set.",
+    envVarBaseKey: "SSH_TUNNEL_USERNAME",
+    type: "text",
+    secret: false,
+    required: false
+  }),
+  sshPrivateKeyBase64: new ParameterDefinition({
+    slug: "ssh-private-key-base64",
+    name: "SSH Private Key",
+    description: "Optional. Private key (PEM, base64-encoded) used for SSH authentication. Required when SSH Tunnel Host is set.",
+    envVarBaseKey: "SSH_TUNNEL_PRIVATE_KEY_BASE64",
+    type: "base64EncodedText",
+    secret: true,
+    required: false
+  }),
+  sshPassphrase: new ParameterDefinition({
+    slug: "ssh-passphrase",
+    name: "SSH Private Key Passphrase",
+    description: "Optional. Passphrase for the SSH private key, if it is encrypted.",
+    envVarBaseKey: "SSH_TUNNEL_PASSPHRASE",
+    type: "text",
+    secret: true,
+    required: false
+  })
+};
+var NOOP_TUNNEL = (connectionUrl) => ({
+  connectionUrl,
+  close: async () => {
+  }
+});
+var NOOP_TUNNEL_HOSTPORT = (host, port) => ({
+  host,
+  port,
+  close: async () => {
+  }
+});
+function connectionParamsToRecord(connection2) {
+  const out = {};
+  for (const p of connection2.parameters) {
+    if (p.value != null) out[p.parameterSlug] = p.value;
+  }
+  return out;
+}
+async function maybeOpenSshTunnelHostPort(params, dbHost, dbPort) {
+  const sshHost = params[sshTunnelParameters.sshHost.slug];
+  if (!sshHost) return NOOP_TUNNEL_HOSTPORT(dbHost, dbPort);
+  const sshUsername = params[sshTunnelParameters.sshUsername.slug];
+  const sshPrivateKeyBase64 = params[sshTunnelParameters.sshPrivateKeyBase64.slug];
+  if (!sshUsername || !sshPrivateKeyBase64) {
+    throw new Error(
+      "SSH tunnel requires `ssh-username` and `ssh-private-key-base64` when `ssh-host` is set."
+    );
+  }
+  const sshPort = Number(params[sshTunnelParameters.sshPort.slug] || "22") || 22;
+  const sshPassphrase = params[sshTunnelParameters.sshPassphrase.slug];
+  const [{ Client }, net] = await Promise.all([
+    Promise.resolve().then(() => __toESM(require_lib3(), 1)),
+    import("net")
+  ]);
+  const sshClient = new Client();
+  await new Promise((resolve, reject) => {
+    sshClient.once("ready", () => resolve());
+    sshClient.once("error", reject);
+    sshClient.connect({
+      host: sshHost,
+      port: sshPort,
+      username: sshUsername,
+      privateKey: Buffer.from(sshPrivateKeyBase64, "base64"),
+      passphrase: sshPassphrase || void 0,
+      readyTimeout: 1e4
+    });
+  });
+  const server = net.createServer((socket) => {
+    sshClient.forwardOut(
+      socket.remoteAddress ?? "127.0.0.1",
+      socket.remotePort ?? 0,
+      dbHost,
+      dbPort,
+      (err, stream) => {
+        if (err) {
+          socket.destroy(err);
+          return;
+        }
+        socket.pipe(stream).pipe(socket);
+      }
+    );
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => resolve());
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    server.close();
+    sshClient.end();
+    throw new Error("Failed to allocate local port for SSH tunnel.");
+  }
+  return {
+    host: "127.0.0.1",
+    port: address.port,
+    close: async () => {
+      await new Promise((resolve) => server.close(() => resolve()));
+      sshClient.end();
+    }
+  };
+}
+async function maybeOpenSshTunnel(params, connectionUrl, defaultDbPort) {
+  const sshHost = params[sshTunnelParameters.sshHost.slug];
+  if (!sshHost) return NOOP_TUNNEL(connectionUrl);
+  const url = new URL(connectionUrl);
+  const dbHost = url.hostname;
+  const dbPort = url.port ? Number(url.port) : defaultDbPort;
+  const tunnel = await maybeOpenSshTunnelHostPort(params, dbHost, dbPort);
+  url.hostname = tunnel.host;
+  url.port = String(tunnel.port);
+  return {
+    connectionUrl: url.toString(),
+    close: tunnel.close
+  };
+}
+
 // ../connectors/src/connectors/sqlserver/utils.ts
 var SQLSERVER_PREFIX_RE = /^(?:jdbc:)?sqlserver:\/\//i;
 var TRUE_VALUES = /* @__PURE__ */ new Set(["true", "1", "yes"]);
@@ -20332,17 +20476,27 @@ async function importMssql() {
 }
 async function runMssqlQuery(parsed, sql, options = {}) {
   const sqlMod = await importMssql();
-  const config = toMssqlConfig(parsed, {
-    encrypt: options.forceEncrypt
-  });
-  const pool = new sqlMod.ConnectionPool(config);
-  await pool.connect();
+  const tunnel = options.tunnelParams ? await maybeOpenSshTunnelHostPort(
+    options.tunnelParams,
+    parsed.server,
+    parsed.port
+  ) : null;
   try {
-    const result = await pool.request().query(sql);
-    const recordset = result.recordset ?? [];
-    return { rows: recordset };
+    const tunneled = tunnel ? { ...parsed, server: tunnel.host, port: tunnel.port } : parsed;
+    const config = toMssqlConfig(tunneled, {
+      encrypt: options.forceEncrypt
+    });
+    const pool = new sqlMod.ConnectionPool(config);
+    await pool.connect();
+    try {
+      const result = await pool.request().query(sql);
+      const recordset = result.recordset ?? [];
+      return { rows: recordset };
+    } finally {
+      await pool.close();
+    }
   } finally {
-    await pool.close();
+    await tunnel?.close();
   }
 }
 async function checkMssqlConnection(url, credentials, options = {}) {
@@ -20430,35 +20584,69 @@ function parseOracleJdbcUrl(jdbcUrl, options = {}) {
 function redactOracleUrl(jdbcUrl) {
   return jdbcUrl.replace(/(:\/\/)([^@/]+)@/, "$1***@").replace(/(thin:)([^@]+)@/i, "$1***@");
 }
+function parseOracleConnectStringHostPort(connectString) {
+  const m = /^([^:/]+):(\d+)(.*)$/.exec(connectString);
+  if (!m) return null;
+  return { host: m[1], port: Number(m[2]), trailing: m[3] };
+}
+function rewriteOracleConnectStringHostPort(connectString, host, port) {
+  const parts = parseOracleConnectStringHostPort(connectString);
+  if (!parts) return connectString;
+  return `${host}:${port}${parts.trailing}`;
+}
 
 // ../connectors/src/lib/oracle-runner.ts
 async function importOracleDb() {
   const mod = await import("oracledb");
   return mod.default ?? mod;
 }
-async function runOracleQuery(parsed, sql) {
+async function runOracleQuery(parsed, sql, options = {}) {
   const oracledb = await importOracleDb();
-  const connection2 = await oracledb.getConnection({
-    user: parsed.user,
-    password: parsed.password,
-    connectString: parsed.connectString
-  });
+  let tunnel = null;
+  if (options.tunnelParams) {
+    const hostPort = parseOracleConnectStringHostPort(parsed.connectString);
+    if (hostPort) {
+      tunnel = await maybeOpenSshTunnelHostPort(
+        options.tunnelParams,
+        hostPort.host,
+        hostPort.port
+      );
+    }
+  }
   try {
-    const result = await connection2.execute(sql, [], {
-      outFormat: oracledb.OUT_FORMAT_OBJECT,
-      // Bound by the connector's own row cap, but keep the driver from
-      // streaming arbitrarily large result sets.
-      maxRows: 5e3
+    const connectString = tunnel ? rewriteOracleConnectStringHostPort(
+      parsed.connectString,
+      tunnel.host,
+      tunnel.port
+    ) : parsed.connectString;
+    const connection2 = await oracledb.getConnection({
+      user: parsed.user,
+      password: parsed.password,
+      connectString
     });
-    return { rows: result.rows ?? [] };
-  } finally {
     try {
-      await connection2.close();
-    } catch {
+      const result = await connection2.execute(
+        sql,
+        [],
+        {
+          outFormat: oracledb.OUT_FORMAT_OBJECT,
+          // Bound by the connector's own row cap, but keep the driver from
+          // streaming arbitrarily large result sets.
+          maxRows: 5e3
+        }
+      );
+      return { rows: result.rows ?? [] };
+    } finally {
+      try {
+        await connection2.close();
+      } catch {
+      }
     }
+  } finally {
+    await tunnel?.close();
   }
 }
-async function checkOracleConnection(url, credentials) {
+async function checkOracleConnection(url, credentials, options = {}) {
   let parsed;
   try {
     parsed = parseOracleJdbcUrl(url, credentials);
@@ -20469,7 +20657,7 @@ async function checkOracleConnection(url, credentials) {
     };
   }
   try {
-    await runOracleQuery(parsed, "SELECT 1 FROM DUAL");
+    await runOracleQuery(parsed, "SELECT 1 FROM DUAL", options);
     return { success: true };
   } catch (err) {
     let msg = err instanceof Error ? err.message : String(err);
@@ -20478,134 +20666,6 @@ async function checkOracleConnection(url, credentials) {
   }
 }
 
-// ../connectors/src/lib/ssh-tunnel.ts
-var sshTunnelParameters = {
-  sshHost: new ParameterDefinition({
-    slug: "ssh-host",
-    name: "SSH Tunnel Host",
-    description: "Optional. Hostname of the SSH bastion to tunnel through. Leave empty to connect directly.",
-    envVarBaseKey: "SSH_TUNNEL_HOST",
-    type: "text",
-    secret: false,
-    required: false
-  }),
-  sshPort: new ParameterDefinition({
-    slug: "ssh-port",
-    name: "SSH Tunnel Port",
-    description: "Optional. SSH port of the bastion host (default: 22).",
-    envVarBaseKey: "SSH_TUNNEL_PORT",
-    type: "text",
-    secret: false,
-    required: false
-  }),
-  sshUsername: new ParameterDefinition({
-    slug: "ssh-username",
-    name: "SSH Tunnel Username",
-    description: "Optional. Username for SSH authentication. Required when SSH Tunnel Host is set.",
-    envVarBaseKey: "SSH_TUNNEL_USERNAME",
-    type: "text",
-    secret: false,
-    required: false
-  }),
-  sshPrivateKeyBase64: new ParameterDefinition({
-    slug: "ssh-private-key-base64",
-    name: "SSH Private Key",
-    description: "Optional. Private key (PEM, base64-encoded) used for SSH authentication. Required when SSH Tunnel Host is set.",
-    envVarBaseKey: "SSH_TUNNEL_PRIVATE_KEY_BASE64",
-    type: "base64EncodedText",
-    secret: true,
-    required: false
-  }),
-  sshPassphrase: new ParameterDefinition({
-    slug: "ssh-passphrase",
-    name: "SSH Private Key Passphrase",
-    description: "Optional. Passphrase for the SSH private key, if it is encrypted.",
-    envVarBaseKey: "SSH_TUNNEL_PASSPHRASE",
-    type: "text",
-    secret: true,
-    required: false
-  })
-};
-var NOOP_TUNNEL = (connectionUrl) => ({
-  connectionUrl,
-  close: async () => {
-  }
-});
-function connectionParamsToRecord(connection2) {
-  const out = {};
-  for (const p of connection2.parameters) {
-    if (p.value != null) out[p.parameterSlug] = p.value;
-  }
-  return out;
-}
-async function maybeOpenSshTunnel(params, connectionUrl, defaultDbPort) {
-  const sshHost = params[sshTunnelParameters.sshHost.slug];
-  if (!sshHost) return NOOP_TUNNEL(connectionUrl);
-  const sshUsername = params[sshTunnelParameters.sshUsername.slug];
-  const sshPrivateKeyBase64 = params[sshTunnelParameters.sshPrivateKeyBase64.slug];
-  if (!sshUsername || !sshPrivateKeyBase64) {
-    throw new Error(
-      "SSH tunnel requires `ssh-username` and `ssh-private-key-base64` when `ssh-host` is set."
-    );
-  }
-  const sshPort = Number(params[sshTunnelParameters.sshPort.slug] || "22") || 22;
-  const sshPassphrase = params[sshTunnelParameters.sshPassphrase.slug];
-  const url = new URL(connectionUrl);
-  const dbHost = url.hostname;
-  const dbPort = url.port ? Number(url.port) : defaultDbPort;
-  const [{ Client }, net] = await Promise.all([
-    Promise.resolve().then(() => __toESM(require_lib3(), 1)),
-    import("net")
-  ]);
-  const sshClient = new Client();
-  await new Promise((resolve, reject) => {
-    sshClient.once("ready", () => resolve());
-    sshClient.once("error", reject);
-    sshClient.connect({
-      host: sshHost,
-      port: sshPort,
-      username: sshUsername,
-      privateKey: Buffer.from(sshPrivateKeyBase64, "base64"),
-      passphrase: sshPassphrase || void 0,
-      readyTimeout: 1e4
-    });
-  });
-  const server = net.createServer((socket) => {
-    sshClient.forwardOut(
-      socket.remoteAddress ?? "127.0.0.1",
-      socket.remotePort ?? 0,
-      dbHost,
-      dbPort,
-      (err, stream) => {
-        if (err) {
-          socket.destroy(err);
-          return;
-        }
-        socket.pipe(stream).pipe(socket);
-      }
-    );
-  });
-  await new Promise((resolve, reject) => {
-    server.once("error", reject);
-    server.listen(0, "127.0.0.1", () => resolve());
-  });
-  const address = server.address();
-  if (!address || typeof address === "string") {
-    server.close();
-    sshClient.end();
-    throw new Error("Failed to allocate local port for SSH tunnel.");
-  }
-  url.hostname = "127.0.0.1";
-  url.port = String(address.port);
-  return {
-    connectionUrl: url.toString(),
-    close: async () => {
-      await new Promise((resolve) => server.close(() => resolve()));
-      sshClient.end();
-    }
-  };
-}
-
 // ../connectors/src/connectors/jdbc/parameters.ts
 var parameters = {
   jdbcUrl: new ParameterDefinition({
@@ -20749,7 +20809,9 @@ function createClient(params) {
           username,
           password
         });
-        const result = await runMssqlQuery(mssqlParsed, sql);
+        const result = await runMssqlQuery(mssqlParsed, sql, {
+          tunnelParams: params
+        });
         return result.rows;
       }
       if (parsed.driver === "oracle") {
@@ -20763,7 +20825,9 @@ function createClient(params) {
           password
         });
         const cleanSql = sql.replace(/;\s*$/, "");
-        const result = await runOracleQuery(oracleParsed, cleanSql);
+        const result = await runOracleQuery(oracleParsed, cleanSql, {
+          tunnelParams: params
+        });
         return result.rows;
       }
       const tunnel = await maybeOpenSshTunnel(
@@ -21042,12 +21106,13 @@ Always bound results: LIMIT for PG/MySQL/Redshift, TOP for SQL Server, FETCH FIR
       };
     }
     try {
+      const tunnelParams = connectionParamsToRecord(connection2);
       if (parsed.driver === "sqlserver") {
         const mssqlParsed = parseSqlServerJdbcUrl(parsed.originalUrl, {
           username,
           password
         });
-        const result = await runMssqlQuery(mssqlParsed, sql);
+        const result = await runMssqlQuery(mssqlParsed, sql, { tunnelParams });
         const rows = result.rows;
         return {
           success: true,
@@ -21062,7 +21127,9 @@ Always bound results: LIMIT for PG/MySQL/Redshift, TOP for SQL Server, FETCH FIR
           password
         });
         const cleanSql = sql.replace(/;\s*$/, "");
-        const result = await runOracleQuery(oracleParsed, cleanSql);
+        const result = await runOracleQuery(oracleParsed, cleanSql, {
+          tunnelParams
+        });
         const rows = result.rows;
         return {
           success: true,
@@ -21074,7 +21141,7 @@ Always bound results: LIMIT for PG/MySQL/Redshift, TOP for SQL Server, FETCH FIR
       let tunnel;
       try {
         tunnel = await maybeOpenSshTunnel(
-          connectionParamsToRecord(connection2),
+          tunnelParams,
           parsed.nativeUrl,
           parsed.defaultPort
         );
@@ -21248,10 +21315,18 @@ JDBC URL \u306E\u30D7\u30EC\u30D5\u30A3\u30C3\u30AF\u30B9\u306B\u3088\u308A\u65B
       };
     }
     if (parsed.driver === "sqlserver") {
-      return checkMssqlConnection(parsed.originalUrl, { username, password });
+      return checkMssqlConnection(
+        parsed.originalUrl,
+        { username, password },
+        { tunnelParams: params }
+      );
     }
     if (parsed.driver === "oracle") {
-      return checkOracleConnection(parsed.originalUrl, { username, password });
+      return checkOracleConnection(
+        parsed.originalUrl,
+        { username, password },
+        { tunnelParams: params }
+      );
     }
     const tunnel = await maybeOpenSshTunnel(
       params,
@@ -21308,10 +21383,12 @@ JDBC URL \u306E\u30D7\u30EC\u30D5\u30A3\u30C3\u30AF\u30B9\u306B\u3088\u308A\u65B
       });
       const sample = unwrapSampleLimit(sql);
       if (sample) {
-        const result = await runMssqlQuery(mssqlParsed, sample.inner);
+        const result = await runMssqlQuery(mssqlParsed, sample.inner, {
+          tunnelParams: params
+        });
         return { rows: result.rows.slice(0, sample.limit) };
       }
-      return runMssqlQuery(mssqlParsed, sql);
+      return runMssqlQuery(mssqlParsed, sql, { tunnelParams: params });
     }
     if (parsed.driver === "oracle") {
       const oracleParsed = parseOracleJdbcUrl(parsed.originalUrl, {
@@ -21321,11 +21398,13 @@ JDBC URL \u306E\u30D7\u30EC\u30D5\u30A3\u30C3\u30AF\u30B9\u306B\u3088\u308A\u65B
       const sample = unwrapSampleLimit(sql);
       if (sample) {
         const inner = sample.inner.replace(/;\s*$/, "");
-        const result = await runOracleQuery(oracleParsed, inner);
+        const result = await runOracleQuery(oracleParsed, inner, {
+          tunnelParams: params
+        });
         return { rows: result.rows.slice(0, sample.limit) };
       }
       const cleanSql = sql.replace(/;\s*$/, "");
-      return runOracleQuery(oracleParsed, cleanSql);
+      return runOracleQuery(oracleParsed, cleanSql, { tunnelParams: params });
     }
     const tunnel = await maybeOpenSshTunnel(
       params,