@squadbase/vite-server 0.0.1-build-12 → 0.0.1-build-14

package/dist/cli/index.js

@@ -88,19 +88,7 @@ import { readFile as readFile4 } from "fs/promises";
 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) {
@@ -120,392 +108,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/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");
   }
@@ -518,56 +122,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") {
-      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 {
@@ -590,18 +166,31 @@ 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/index.ts
-var { getClient, loadConnections, reloadEnvFile, watchConnectionsFile } = createConnectorRegistry();
+var { getQuery, loadConnections, reloadEnvFile, watchConnectionsFile } = createConnectorRegistry();
 
 // src/cli/env-loader.ts
 import { readFileSync as readFileSync2 } from "fs";
@@ -682,24 +271,20 @@ var anyJsonDataSourceSchema = z.union([
 ]);
 
 // src/registry.ts
-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");
 
@@ -735,39 +320,16 @@ function createStubContext(params) {
 async function runSqlDataSource(slug, def, params, limit) {
   const start = Date.now();
   try {
-    const { client, connectorSlug } = await getClient(def.connectionId);
-    const isLiteralConnector = connectorSlug === "snowflake" || connectorSlug === "bigquery" || connectorSlug === "athena" || connectorSlug === "redshift" || connectorSlug === "databricks";
-    let queryText;
-    let queryValues;
-    if (isLiteralConnector) {
-      const defaults = new Map(
-        (def.parameters ?? []).map((p) => [p.name, p.default ?? null])
-      );
-      queryText = def.query.replace(/\{\{(\w+)\}\}/g, (_match, name) => {
-        const value = Object.prototype.hasOwnProperty.call(params, name) ? params[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(def.query, def.parameters ?? [], params);
-      queryText = built.text.replace(/\$(\d+)/g, "?");
-      queryValues = built.values;
-    } else {
-      const built = buildQuery(def.query, def.parameters ?? [], params);
-      queryText = built.text;
-      queryValues = built.values;
-    }
-    const result = await client.query(queryText, queryValues);
+    const query = await getQuery(def.connectionId);
+    const namedParams = applyDefaults(def.parameters ?? [], params);
+    const result = await query(def.query, namedParams);
     const rows = result.rows.slice(0, limit);
     return {
       slug,
       rows,
       rowCount: result.rows.length,
       durationMs: Date.now() - start,
-      query: queryText,
-      queryValues
+      query: def.query
     };
   } catch (error) {
     return {

package/dist/index.d.ts

@@ -1,11 +1,6 @@
 import * as hono_types from 'hono/types';
 import { Hono } from 'hono';
 
-interface DatabaseClient {
-    query(sql: string, params?: unknown[]): Promise<{
-        rows: Record<string, unknown>[];
-    }>;
-}
 interface ConnectionEntry {
     connector: {
         slug: string;
@@ -15,6 +10,10 @@ interface ConnectionEntry {
 }
 type ConnectionsMap = Record<string, ConnectionEntry>;
 
+type QueryFn = (sql: string, namedParams?: Record<string, unknown>) => Promise<{
+    rows: Record<string, unknown>[];
+}>;
+
 interface AirtableClient {
     listRecords(tableIdOrName: string, options?: {
         fields?: string[];
@@ -120,10 +119,7 @@ interface DbtClient {
 }
 declare function createDbtClient(entry: ConnectionEntry, slug: string): DbtClient;
 
-declare const getClient: (connectionId: string) => Promise<{
-    client: DatabaseClient;
-    connectorSlug: string;
-}>;
+declare const getQuery: (connectionId: string) => Promise<QueryFn>;
 declare const loadConnections: () => Promise<ConnectionsMap>;
 
 type ConnectionFetchOptions = {
@@ -138,4 +134,4 @@ declare function connection(connectionId: string): {
 
 declare const app: Hono<hono_types.BlankEnv, hono_types.BlankSchema, "/">;
 
-export { type AirtableClient, type AirtableRecord, type ConnectionEntry, type ConnectionFetchOptions, type ConnectionsMap, type DatabaseClient, type DbtClient, type GoogleAnalyticsClient, type KintoneClient, type WixStoreClient, connection, createAirtableClient, createDbtClient, createGoogleAnalyticsClient, createKintoneClient, createWixStoreClient, app as default, getClient, loadConnections };
+export { type AirtableClient, type AirtableRecord, type ConnectionEntry, type ConnectionFetchOptions, type ConnectionsMap, type DbtClient, type GoogleAnalyticsClient, type KintoneClient, type QueryFn, type WixStoreClient, connection, createAirtableClient, createDbtClient, createGoogleAnalyticsClient, createKintoneClient, createWixStoreClient, app as default, getQuery, loadConnections };