@squadbase/vite-server 0.0.1-build-13 → 0.0.1-build-15

package/dist/index.js

@@ -13,19 +13,7 @@ import path2 from "path";
 import { readFileSync, watch as fsWatch } from "fs";
 import { readFile } from "fs/promises";
 import path from "path";
-
-// src/connector-client/postgresql.ts
-import pg from "pg";
-var { Pool } = pg;
-function createPostgreSQLClient(connectionString) {
-  const pool = new Pool({ connectionString, ssl: { rejectUnauthorized: false } });
-  return {
-    async query(sql, params) {
-      const result = await pool.query(sql, params);
-      return { rows: result.rows };
-    }
-  };
-}
+import { connectors } from "@squadbase/connectors";
 
 // src/connector-client/env.ts
 function resolveEnvVar(entry, key, connectionId) {
@@ -45,433 +33,8 @@ function resolveEnvVarOptional(entry, key) {
   return process.env[envVarName] || void 0;
 }
 
-// src/connector-client/bigquery.ts
-function createBigQueryClient(entry, connectionId) {
-  const projectId = resolveEnvVar(entry, "project-id", connectionId);
-  const serviceAccountJsonBase64 = resolveEnvVar(entry, "service-account-key-json-base64", connectionId);
-  const serviceAccountJson = Buffer.from(serviceAccountJsonBase64, "base64").toString("utf-8");
-  let gcpCredentials;
-  try {
-    gcpCredentials = JSON.parse(serviceAccountJson);
-  } catch {
-    throw new Error(
-      `BigQuery service account JSON (decoded from base64) is not valid JSON for connectionId "${connectionId}"`
-    );
-  }
-  return {
-    async query(sql) {
-      const { BigQuery } = await import("@google-cloud/bigquery");
-      const bq = new BigQuery({ projectId, credentials: gcpCredentials });
-      const [job] = await bq.createQueryJob({ query: sql });
-      const [allRows] = await job.getQueryResults({ timeoutMs: 3e4 });
-      return { rows: allRows };
-    }
-  };
-}
-
-// src/connection.ts
-import { getContext } from "hono/context-storage";
-import { getCookie } from "hono/cookie";
-var APP_SESSION_COOKIE_NAME = "__Host-squadbase-session";
-var PREVIEW_SESSION_COOKIE_NAME = "squadbase-preview-session";
-var APP_BASE_DOMAIN = "squadbase.app";
-var PREVIEW_BASE_DOMAIN = "preview.app.squadbase.dev";
-var SANDBOX_ID_ENV_NAME = "INTERNAL_SQUADBASE_SANDBOX_ID";
-var MACHINE_CREDENTIAL_ENV_NAME = "INTERNAL_SQUADBASE_OAUTH_MACHINE_CREDENTIAL";
-function resolveProxyUrl(connectionId) {
-  const connectionPath = `/_sqcore/connections/${connectionId}/request`;
-  const sandboxId = process.env[SANDBOX_ID_ENV_NAME];
-  if (sandboxId) {
-    const baseDomain2 = process.env["SQUADBASE_PREVIEW_BASE_DOMAIN"] ?? PREVIEW_BASE_DOMAIN;
-    return `https://${sandboxId}.${baseDomain2}${connectionPath}`;
-  }
-  const projectId = process.env["SQUADBASE_PROJECT_ID"];
-  if (!projectId) {
-    throw new Error(
-      "Project ID is required. Please set SQUADBASE_PROJECT_ID environment variable."
-    );
-  }
-  const baseDomain = process.env["SQUADBASE_APP_BASE_DOMAIN"] ?? APP_BASE_DOMAIN;
-  return `https://${projectId}.${baseDomain}${connectionPath}`;
-}
-function resolveAuthHeaders() {
-  const machineCredential = process.env[MACHINE_CREDENTIAL_ENV_NAME];
-  if (machineCredential) {
-    return { Authorization: `Bearer ${machineCredential}` };
-  }
-  const c = getContext();
-  const cookies = getCookie(c);
-  const previewSession = cookies[PREVIEW_SESSION_COOKIE_NAME];
-  if (previewSession) {
-    return {
-      Cookie: `${PREVIEW_SESSION_COOKIE_NAME}=${previewSession}`
-    };
-  }
-  const appSession = cookies[APP_SESSION_COOKIE_NAME];
-  if (appSession) {
-    return { Authorization: `Bearer ${appSession}` };
-  }
-  throw new Error(
-    "No authentication method available for connection proxy. Expected one of: INTERNAL_SQUADBASE_OAUTH_MACHINE_CREDENTIAL env var, preview session cookie, or app session cookie."
-  );
-}
-function connection(connectionId) {
-  return {
-    async fetch(url, options) {
-      const proxyUrl = resolveProxyUrl(connectionId);
-      const authHeaders = resolveAuthHeaders();
-      return await fetch(proxyUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          ...authHeaders
-        },
-        body: JSON.stringify({
-          url,
-          method: options?.method,
-          headers: options?.headers,
-          body: options?.body,
-          timeoutMs: options?.timeoutMs
-        })
-      });
-    }
-  };
-}
-
-// src/connector-client/bigquery-oauth.ts
-var MAX_RESULTS = 1e4;
-var POLL_INTERVAL_MS = 1e3;
-var POLL_TIMEOUT_MS = 12e4;
-function flattenRows(fields, rows) {
-  return rows.map((row) => {
-    const obj = {};
-    for (let i = 0; i < fields.length; i++) {
-      obj[fields[i].name] = row.f[i].v;
-    }
-    return obj;
-  });
-}
-function createBigQueryOAuthClient(entry, connectionId) {
-  const projectId = resolveEnvVar(entry, "project-id", connectionId);
-  const baseUrl = `https://bigquery.googleapis.com/bigquery/v2/projects/${projectId}`;
-  return {
-    async query(sql) {
-      const conn = connection(connectionId);
-      const res = await conn.fetch(`${baseUrl}/queries`, {
-        method: "POST",
-        body: {
-          query: sql,
-          useLegacySql: false,
-          maxResults: MAX_RESULTS
-        }
-      });
-      if (!res.ok) {
-        const text = await res.text().catch(() => res.statusText);
-        throw new Error(`BigQuery query failed: HTTP ${res.status} ${text}`);
-      }
-      let data = await res.json();
-      if (data.errors?.length) {
-        throw new Error(
-          `BigQuery query error: ${data.errors.map((e) => e.message).join("; ")}`
-        );
-      }
-      if (!data.jobComplete) {
-        const jobId = data.jobReference.jobId;
-        const location = data.jobReference.location;
-        const deadline = Date.now() + POLL_TIMEOUT_MS;
-        while (!data.jobComplete) {
-          if (Date.now() > deadline) {
-            throw new Error(
-              `BigQuery query timed out after ${POLL_TIMEOUT_MS / 1e3}s (jobId: ${jobId})`
-            );
-          }
-          await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
-          const params = new URLSearchParams({
-            maxResults: String(MAX_RESULTS)
-          });
-          if (location) params.set("location", location);
-          const pollRes = await conn.fetch(
-            `${baseUrl}/queries/${jobId}?${params}`,
-            { method: "GET" }
-          );
-          if (!pollRes.ok) {
-            const text = await pollRes.text().catch(() => pollRes.statusText);
-            throw new Error(
-              `BigQuery poll failed: HTTP ${pollRes.status} ${text}`
-            );
-          }
-          data = await pollRes.json();
-          if (data.errors?.length) {
-            throw new Error(
-              `BigQuery query error: ${data.errors.map((e) => e.message).join("; ")}`
-            );
-          }
-        }
-      }
-      const fields = data.schema?.fields ?? [];
-      const rawRows = data.rows ?? [];
-      return { rows: flattenRows(fields, rawRows) };
-    }
-  };
-}
-
-// src/connector-client/snowflake.ts
-function createSnowflakeClient(entry, connectionId) {
-  const accountIdentifier = resolveEnvVar(entry, "account", connectionId);
-  const user = resolveEnvVar(entry, "user", connectionId);
-  const role = resolveEnvVar(entry, "role", connectionId);
-  const warehouse = resolveEnvVar(entry, "warehouse", connectionId);
-  const privateKeyBase64 = resolveEnvVar(entry, "private-key-base64", connectionId);
-  const privateKey = Buffer.from(privateKeyBase64, "base64").toString("utf-8");
-  return {
-    async query(sql) {
-      const snowflake = (await import("snowflake-sdk")).default;
-      snowflake.configure({ logLevel: "ERROR" });
-      const connection2 = snowflake.createConnection({
-        account: accountIdentifier,
-        username: user,
-        role,
-        warehouse,
-        authenticator: "SNOWFLAKE_JWT",
-        privateKey
-      });
-      await new Promise((resolve, reject) => {
-        connection2.connect((err) => {
-          if (err) reject(new Error(`Snowflake connect failed: ${err.message}`));
-          else resolve();
-        });
-      });
-      const rows = await new Promise((resolve, reject) => {
-        connection2.execute({
-          sqlText: sql,
-          complete: (err, _stmt, rows2) => {
-            if (err) reject(new Error(`Snowflake query failed: ${err.message}`));
-            else resolve(rows2 ?? []);
-          }
-        });
-      });
-      connection2.destroy((err) => {
-        if (err) console.warn(`[connector-client] Snowflake destroy error: ${err.message}`);
-      });
-      return { rows };
-    }
-  };
-}
-
-// src/connector-client/snowflake-pat.ts
-function createSnowflakePatClient(entry, connectionId) {
-  const accountIdentifier = resolveEnvVar(entry, "account", connectionId);
-  const user = resolveEnvVar(entry, "user", connectionId);
-  const role = resolveEnvVar(entry, "role", connectionId);
-  const warehouse = resolveEnvVar(entry, "warehouse", connectionId);
-  const password = resolveEnvVar(entry, "pat", connectionId);
-  return {
-    async query(sql) {
-      const snowflake = (await import("snowflake-sdk")).default;
-      snowflake.configure({ logLevel: "ERROR" });
-      const connection2 = snowflake.createConnection({
-        account: accountIdentifier,
-        username: user,
-        role,
-        warehouse,
-        password
-      });
-      await new Promise((resolve, reject) => {
-        connection2.connect((err) => {
-          if (err) reject(new Error(`Snowflake connect failed: ${err.message}`));
-          else resolve();
-        });
-      });
-      const rows = await new Promise((resolve, reject) => {
-        connection2.execute({
-          sqlText: sql,
-          complete: (err, _stmt, rows2) => {
-            if (err) reject(new Error(`Snowflake query failed: ${err.message}`));
-            else resolve(rows2 ?? []);
-          }
-        });
-      });
-      connection2.destroy((err) => {
-        if (err) console.warn(`[connector-client] Snowflake destroy error: ${err.message}`);
-      });
-      return { rows };
-    }
-  };
-}
-
-// src/connector-client/mysql.ts
-function createMySQLClient(entry, connectionId) {
-  const connectionUrl = resolveEnvVar(entry, "connection-url", connectionId);
-  let poolPromise = null;
-  function getPool() {
-    if (!poolPromise) {
-      poolPromise = import("mysql2/promise").then(
-        (mysql) => mysql.default.createPool(connectionUrl)
-      );
-    }
-    return poolPromise;
-  }
-  return {
-    async query(sql, params) {
-      const pool = await getPool();
-      const [rows] = await pool.execute(sql, params);
-      return { rows };
-    }
-  };
-}
-
-// src/connector-client/aws-athena.ts
-function createAthenaClient(entry, connectionId) {
-  const region = resolveEnvVar(entry, "aws-region", connectionId);
-  const accessKeyId = resolveEnvVar(entry, "aws-access-key-id", connectionId);
-  const secretAccessKey = resolveEnvVar(entry, "aws-secret-access-key", connectionId);
-  const workgroup = resolveEnvVarOptional(entry, "workgroup") ?? "primary";
-  const outputLocation = resolveEnvVarOptional(entry, "output-location");
-  return {
-    async query(sql) {
-      const {
-        AthenaClient,
-        StartQueryExecutionCommand,
-        GetQueryExecutionCommand,
-        GetQueryResultsCommand
-      } = await import("@aws-sdk/client-athena");
-      const client = new AthenaClient({
-        region,
-        credentials: { accessKeyId, secretAccessKey }
-      });
-      const startParams = {
-        QueryString: sql,
-        WorkGroup: workgroup
-      };
-      if (outputLocation) {
-        startParams.ResultConfiguration = { OutputLocation: outputLocation };
-      }
-      const { QueryExecutionId } = await client.send(
-        new StartQueryExecutionCommand(startParams)
-      );
-      if (!QueryExecutionId) throw new Error("Athena: failed to start query execution");
-      while (true) {
-        const { QueryExecution } = await client.send(
-          new GetQueryExecutionCommand({ QueryExecutionId })
-        );
-        const state = QueryExecution?.Status?.State;
-        if (state === "SUCCEEDED") break;
-        if (state === "FAILED") {
-          throw new Error(
-            `Athena query failed: ${QueryExecution?.Status?.StateChangeReason ?? "unknown"}`
-          );
-        }
-        if (state === "CANCELLED") throw new Error("Athena query was cancelled");
-        await new Promise((r) => setTimeout(r, 500));
-      }
-      const { ResultSet } = await client.send(
-        new GetQueryResultsCommand({ QueryExecutionId })
-      );
-      const resultRows = ResultSet?.Rows ?? [];
-      if (resultRows.length === 0) return { rows: [] };
-      const headers = resultRows[0].Data?.map((d) => d.VarCharValue ?? "") ?? [];
-      const rows = resultRows.slice(1).map((row) => {
-        const obj = {};
-        row.Data?.forEach((d, i) => {
-          obj[headers[i]] = d.VarCharValue ?? null;
-        });
-        return obj;
-      });
-      return { rows };
-    }
-  };
-}
-
-// src/connector-client/redshift.ts
-function createRedshiftClient(entry, connectionId) {
-  const region = resolveEnvVar(entry, "aws-region", connectionId);
-  const accessKeyId = resolveEnvVar(entry, "aws-access-key-id", connectionId);
-  const secretAccessKey = resolveEnvVar(entry, "aws-secret-access-key", connectionId);
-  const database = resolveEnvVar(entry, "database", connectionId);
-  const clusterIdentifier = resolveEnvVarOptional(entry, "cluster-identifier");
-  const workgroupName = resolveEnvVarOptional(entry, "workgroup-name");
-  const secretArn = resolveEnvVarOptional(entry, "secret-arn");
-  const dbUser = resolveEnvVarOptional(entry, "db-user");
-  return {
-    async query(sql) {
-      const {
-        RedshiftDataClient,
-        ExecuteStatementCommand,
-        DescribeStatementCommand,
-        GetStatementResultCommand
-      } = await import("@aws-sdk/client-redshift-data");
-      const client = new RedshiftDataClient({
-        region,
-        credentials: { accessKeyId, secretAccessKey }
-      });
-      const executeParams = {
-        Sql: sql,
-        Database: database
-      };
-      if (clusterIdentifier) executeParams.ClusterIdentifier = clusterIdentifier;
-      if (workgroupName) executeParams.WorkgroupName = workgroupName;
-      if (secretArn) executeParams.SecretArn = secretArn;
-      if (dbUser) executeParams.DbUser = dbUser;
-      const { Id } = await client.send(
-        new ExecuteStatementCommand(executeParams)
-      );
-      if (!Id) throw new Error("Redshift: failed to start statement execution");
-      while (true) {
-        const desc = await client.send(new DescribeStatementCommand({ Id }));
-        const status = desc.Status;
-        if (status === "FINISHED") break;
-        if (status === "FAILED") {
-          throw new Error(`Redshift query failed: ${desc.Error ?? "unknown"}`);
-        }
-        if (status === "ABORTED") throw new Error("Redshift query was aborted");
-        await new Promise((r) => setTimeout(r, 500));
-      }
-      const result = await client.send(new GetStatementResultCommand({ Id }));
-      const columns = result.ColumnMetadata?.map((c) => c.name ?? "") ?? [];
-      const rows = (result.Records ?? []).map((record) => {
-        const obj = {};
-        record.forEach((field, i) => {
-          const col = columns[i];
-          const value = field.stringValue ?? field.longValue ?? field.doubleValue ?? field.booleanValue ?? (field.isNull ? null : field.blobValue ?? null);
-          obj[col] = value;
-        });
-        return obj;
-      });
-      return { rows };
-    }
-  };
-}
-
-// src/connector-client/databricks.ts
-function createDatabricksClient(entry, connectionId) {
-  const host = resolveEnvVar(entry, "host", connectionId);
-  const httpPath = resolveEnvVar(entry, "http-path", connectionId);
-  const token = resolveEnvVar(entry, "token", connectionId);
-  return {
-    async query(sql) {
-      const { DBSQLClient } = await import("@databricks/sql");
-      const client = new DBSQLClient();
-      await client.connect({ host, path: httpPath, token });
-      try {
-        const session = await client.openSession();
-        try {
-          const operation = await session.executeStatement(sql);
-          const result = await operation.fetchAll();
-          await operation.close();
-          return { rows: result };
-        } finally {
-          await session.close();
-        }
-      } finally {
-        await client.close();
-      }
-    }
-  };
-}
-
 // src/connector-client/registry.ts
 function createConnectorRegistry() {
-  const clientCache = /* @__PURE__ */ new Map();
   function getConnectionsFilePath() {
     return process.env.CONNECTIONS_PATH ?? path.join(process.cwd(), ".squadbase/connections.json");
   }
@@ -484,59 +47,28 @@ function createConnectorRegistry() {
       return {};
     }
   }
-  async function getClient2(connectionId) {
+  async function getQuery2(connectionId) {
     const connections = await loadConnections2();
     const entry = connections[connectionId];
     if (!entry) {
-      throw new Error(`connection '${connectionId}' not found in .squadbase/connections.json`);
-    }
-    const connectorSlug = entry.connector.slug;
-    const cached = clientCache.get(connectionId);
-    if (cached) return { client: cached, connectorSlug };
-    if (connectorSlug === "snowflake") {
-      if (entry.connector.authType === "pat") {
-        return { client: createSnowflakePatClient(entry, connectionId), connectorSlug };
-      }
-      return { client: createSnowflakeClient(entry, connectionId), connectorSlug };
-    }
-    if (connectorSlug === "bigquery") {
-      if (entry.connector.authType === "oauth") {
-        return { client: createBigQueryOAuthClient(entry, connectionId), connectorSlug };
-      }
-      return { client: createBigQueryClient(entry, connectionId), connectorSlug };
-    }
-    if (connectorSlug === "athena") {
-      return { client: createAthenaClient(entry, connectionId), connectorSlug };
-    }
-    if (connectorSlug === "redshift") {
-      return { client: createRedshiftClient(entry, connectionId), connectorSlug };
-    }
-    if (connectorSlug === "databricks") {
-      return { client: createDatabricksClient(entry, connectionId), connectorSlug };
+      throw new Error(
+        `connection '${connectionId}' not found in .squadbase/connections.json`
+      );
     }
-    if (connectorSlug === "mysql") {
-      const client = createMySQLClient(entry, connectionId);
-      clientCache.set(connectionId, client);
-      return { client, connectorSlug };
+    const { slug, authType } = entry.connector;
+    const plugin = connectors.findByKey(slug, authType);
+    if (!plugin) {
+      throw new Error(
+        `connector "${slug}" (authType: ${authType ?? "none"}) is not registered in @squadbase/connectors`
+      );
     }
-    if (connectorSlug === "postgresql" || connectorSlug === "squadbase-db") {
-      const urlEnvName = entry.envVars["connection-url"];
-      if (!urlEnvName) {
-        throw new Error(`'connection-url' is not defined in envVars for connection '${connectionId}'`);
-      }
-      const connectionUrl = process.env[urlEnvName];
-      if (!connectionUrl) {
-        throw new Error(
-          `environment variable '${urlEnvName}' (mapped from connection '${connectionId}') is not set`
-        );
-      }
-      const client = createPostgreSQLClient(connectionUrl);
-      clientCache.set(connectionId, client);
-      return { client, connectorSlug };
+    if (!plugin.query) {
+      throw new Error(
+        `connector "${plugin.connectorKey}" does not support SQL queries. Non-SQL connectors (airtable, google-analytics, kintone, wix-store, dbt) should be used via TypeScript handlers.`
+      );
     }
-    throw new Error(
-      `connector type '${connectorSlug}' is not supported as a SQL connector. Supported SQL types: "postgresql", "squadbase-db", "mysql", "snowflake", "bigquery", "athena", "redshift", "databricks". Non-SQL types (airtable, google-analytics, kintone, wix-store, dbt) should be used via TypeScript handlers.`
-    );
+    const params = resolveParams(entry, connectionId, plugin);
+    return (sql, namedParams) => plugin.query(params, sql, namedParams);
   }
   function reloadEnvFile2(envPath) {
     try {
@@ -559,14 +91,27 @@ function createConnectorRegistry() {
     const envPath = path.join(process.cwd(), ".env");
     try {
       fsWatch(filePath, { persistent: false }, () => {
-        console.log("[connector-client] connections.json changed, clearing client cache");
-        clientCache.clear();
+        console.log(
+          "[connector-client] connections.json changed"
+        );
         setImmediate(() => reloadEnvFile2(envPath));
       });
     } catch {
     }
   }
-  return { getClient: getClient2, loadConnections: loadConnections2, reloadEnvFile: reloadEnvFile2, watchConnectionsFile: watchConnectionsFile2 };
+  return { getQuery: getQuery2, loadConnections: loadConnections2, reloadEnvFile: reloadEnvFile2, watchConnectionsFile: watchConnectionsFile2 };
+}
+function resolveParams(entry, connectionId, plugin) {
+  const params = {};
+  for (const param of Object.values(plugin.parameters)) {
+    if (param.required) {
+      params[param.slug] = resolveEnvVar(entry, param.slug, connectionId);
+    } else {
+      const val = resolveEnvVarOptional(entry, param.slug);
+      if (val !== void 0) params[param.slug] = val;
+    }
+  }
+  return params;
 }
 
 // src/connector-client/airtable.ts
@@ -832,7 +377,7 @@ function createDbtClient(entry, slug) {
 }
 
 // src/connector-client/index.ts
-var { getClient, loadConnections, reloadEnvFile, watchConnectionsFile } = createConnectorRegistry();
+var { getQuery, loadConnections, reloadEnvFile, watchConnectionsFile } = createConnectorRegistry();
 
 // src/types/data-source.ts
 import { z } from "zod";
@@ -927,24 +472,20 @@ async function loadTypeScriptHandler(absolutePath) {
   }
   return handler;
 }
-function buildQuery(queryTemplate, parameterMeta, runtimeParams) {
+function applyDefaults(parameterMeta, runtimeParams) {
   const defaults = new Map(
     parameterMeta.map((p) => [p.name, p.default ?? null])
   );
-  const placeholderToIndex = /* @__PURE__ */ new Map();
-  const values = [];
-  const text = queryTemplate.replace(
-    /\{\{(\w+)\}\}/g,
-    (_match, name) => {
-      if (!placeholderToIndex.has(name)) {
-        const value = Object.prototype.hasOwnProperty.call(runtimeParams, name) ? runtimeParams[name] : defaults.get(name) ?? null;
-        values.push(value);
-        placeholderToIndex.set(name, values.length);
-      }
-      return `$${placeholderToIndex.get(name)}`;
+  const result = {};
+  for (const [key, value] of Object.entries(runtimeParams)) {
+    result[key] = value;
+  }
+  for (const [key, defaultVal] of defaults) {
+    if (!(key in result)) {
+      result[key] = defaultVal;
     }
-  );
-  return { text, values };
+  }
+  return result;
 }
 var defaultDataSourceDir = path2.join(process.cwd(), "data-source");
 async function initialize() {
@@ -992,46 +533,12 @@ async function initialize() {
           cacheConfig: sqlDef.cache,
           _query: sqlDef.query,
           handler: async (runtimeParams) => {
-            const { client, connectorSlug } = await getClient(sqlDef.connectionId);
-            const isLiteralConnector = connectorSlug === "snowflake" || connectorSlug === "bigquery" || connectorSlug === "athena" || connectorSlug === "redshift" || connectorSlug === "databricks";
-            let queryText;
-            let queryValues;
-            if (isLiteralConnector) {
-              const defaults = new Map(
-                (sqlDef.parameters ?? []).map((p) => [p.name, p.default ?? null])
-              );
-              queryText = sqlDef.query.replace(
-                /\{\{(\w+)\}\}/g,
-                (_match, name) => {
-                  const value = Object.prototype.hasOwnProperty.call(
-                    runtimeParams,
-                    name
-                  ) ? runtimeParams[name] : defaults.get(name) ?? "";
-                  if (typeof value === "string")
-                    return `'${value.replace(/'/g, "''")}'`;
-                  if (value === null || value === void 0) return "NULL";
-                  return String(value);
-                }
-              );
-              queryValues = [];
-            } else if (connectorSlug === "mysql") {
-              const built = buildQuery(
-                sqlDef.query,
-                sqlDef.parameters ?? [],
-                runtimeParams
-              );
-              queryText = built.text.replace(/\$(\d+)/g, "?");
-              queryValues = built.values;
-            } else {
-              const built = buildQuery(
-                sqlDef.query,
-                sqlDef.parameters ?? [],
-                runtimeParams
-              );
-              queryText = built.text;
-              queryValues = built.values;
-            }
-            const result = await client.query(queryText, queryValues);
+            const query = await getQuery(sqlDef.connectionId);
+            const namedParams = applyDefaults(
+              sqlDef.parameters ?? [],
+              runtimeParams
+            );
+            const result = await query(sqlDef.query, namedParams);
             return result.rows;
           }
         };
@@ -1428,6 +935,75 @@ app4.get("/runtime-data", (c) => {
 });
 var pages_default = app4;
 
+// src/connection.ts
+import { getContext } from "hono/context-storage";
+import { getCookie } from "hono/cookie";
+var APP_SESSION_COOKIE_NAME = "__Host-squadbase-session";
+var PREVIEW_SESSION_COOKIE_NAME = "squadbase-preview-session";
+var APP_BASE_DOMAIN = "squadbase.app";
+var PREVIEW_BASE_DOMAIN = "preview.app.squadbase.dev";
+var SANDBOX_ID_ENV_NAME = "INTERNAL_SQUADBASE_SANDBOX_ID";
+var MACHINE_CREDENTIAL_ENV_NAME = "INTERNAL_SQUADBASE_OAUTH_MACHINE_CREDENTIAL";
+function resolveProxyUrl(connectionId) {
+  const connectionPath = `/_sqcore/connections/${connectionId}/request`;
+  const sandboxId = process.env[SANDBOX_ID_ENV_NAME];
+  if (sandboxId) {
+    const baseDomain2 = process.env["SQUADBASE_PREVIEW_BASE_DOMAIN"] ?? PREVIEW_BASE_DOMAIN;
+    return `https://${sandboxId}.${baseDomain2}${connectionPath}`;
+  }
+  const projectId = process.env["SQUADBASE_PROJECT_ID"];
+  if (!projectId) {
+    throw new Error(
+      "Project ID is required. Please set SQUADBASE_PROJECT_ID environment variable."
+    );
+  }
+  const baseDomain = process.env["SQUADBASE_APP_BASE_DOMAIN"] ?? APP_BASE_DOMAIN;
+  return `https://${projectId}.${baseDomain}${connectionPath}`;
+}
+function resolveAuthHeaders() {
+  const machineCredential = process.env[MACHINE_CREDENTIAL_ENV_NAME];
+  if (machineCredential) {
+    return { Authorization: `Bearer ${machineCredential}` };
+  }
+  const c = getContext();
+  const cookies = getCookie(c);
+  const previewSession = cookies[PREVIEW_SESSION_COOKIE_NAME];
+  if (previewSession) {
+    return {
+      Cookie: `${PREVIEW_SESSION_COOKIE_NAME}=${previewSession}`
+    };
+  }
+  const appSession = cookies[APP_SESSION_COOKIE_NAME];
+  if (appSession) {
+    return { Authorization: `Bearer ${appSession}` };
+  }
+  throw new Error(
+    "No authentication method available for connection proxy. Expected one of: INTERNAL_SQUADBASE_OAUTH_MACHINE_CREDENTIAL env var, preview session cookie, or app session cookie."
+  );
+}
+function connection(connectionId) {
+  return {
+    async fetch(url, options) {
+      const proxyUrl = resolveProxyUrl(connectionId);
+      const authHeaders = resolveAuthHeaders();
+      return await fetch(proxyUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...authHeaders
+        },
+        body: JSON.stringify({
+          url,
+          method: options?.method,
+          headers: options?.headers,
+          body: options?.body,
+          timeoutMs: options?.timeoutMs
+        })
+      });
+    }
+  };
+}
+
 // src/index.ts
 var apiApp = new Hono5();
 apiApp.use("/*", contextStorage());
@@ -1452,6 +1028,6 @@ export {
   createKintoneClient,
   createWixStoreClient,
   src_default as default,
-  getClient,
+  getQuery,
   loadConnections
 };