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

package/dist/vite-plugin.js

@@ -14,19 +14,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) {
@@ -46,392 +34,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");
   }
@@ -444,56 +48,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 {
@@ -516,18 +92,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/types/data-source.ts
 import { z } from "zod";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squadbase/vite-server",
-  "version": "0.0.1-build-12",
+  "version": "0.0.1-build-14",
   "type": "module",
   "exports": {
     ".": {
@@ -35,6 +35,7 @@
     "build:cli": "tsup src/cli/index.ts --out-dir dist/cli --format esm --platform node --no-splitting --external pg --external snowflake-sdk --external @google-cloud/bigquery --external mysql2 --external @aws-sdk/client-athena --external @aws-sdk/client-redshift-data --external @databricks/sql --external @google-analytics/data --external @kintone/rest-api-client --external hono --external @clack/prompts"
   },
   "dependencies": {
+    "@squadbase/connectors": "^0.0.2",
     "@aws-sdk/client-athena": "^3.750.0",
     "@aws-sdk/client-redshift-data": "^3.750.0",
     "@databricks/sql": "^1.8.0",