@squadbase/vite-server 0.0.1-build-7 → 0.0.1-build-9

package/dist/index.js

@@ -4,12 +4,13 @@ import { cors } from "hono/cors";
 import path4 from "path";
 
 // src/registry.ts
-import { readdir, readFile, mkdir } from "fs/promises";
+import { readdir, readFile as readFile2, mkdir } from "fs/promises";
 import { watch as fsWatch2 } from "fs";
 import path2 from "path";
 
 // src/connector-client/registry.ts
 import { readFileSync, watch as fsWatch } from "fs";
+import { readFile } from "fs/promises";
 import path from "path";
 
 // src/connector-client/postgresql.ts
@@ -37,6 +38,11 @@ function resolveEnvVar(entry, key, connectionId) {
   }
   return value;
 }
+function resolveEnvVarOptional(entry, key) {
+  const envVarName = entry.envVars[key];
+  if (!envVarName) return void 0;
+  return process.env[envVarName] || void 0;
+}
 
 // src/connector-client/bigquery.ts
 function createBigQueryClient(entry, connectionId) {
@@ -48,7 +54,7 @@ function createBigQueryClient(entry, connectionId) {
     gcpCredentials = JSON.parse(serviceAccountJson);
   } catch {
     throw new Error(
-      `BigQuery service account JSON (decoded from base64) is not valid JSON for connection "${connectionId}"`
+      `BigQuery service account JSON (decoded from base64) is not valid JSON for connectionId "${connectionId}"`
     );
   }
   return {
@@ -105,26 +111,193 @@ function createSnowflakeClient(entry, connectionId) {
   };
 }
 
+// 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() {
-  let connectionsCache = null;
   const clientCache = /* @__PURE__ */ new Map();
   function getConnectionsFilePath() {
     return process.env.CONNECTIONS_PATH ?? path.join(process.cwd(), ".squadbase/connections.json");
   }
-  function loadConnections() {
-    if (connectionsCache !== null) return connectionsCache;
+  async function loadConnections2() {
     const filePath = getConnectionsFilePath();
     try {
-      const raw = readFileSync(filePath, "utf-8");
-      connectionsCache = JSON.parse(raw);
+      const raw = await readFile(filePath, "utf-8");
+      return JSON.parse(raw);
     } catch {
-      connectionsCache = {};
+      return {};
     }
-    return connectionsCache;
   }
   async function getClient2(connectionId) {
-    const connections = loadConnections();
+    const connections = await loadConnections2();
     const entry = connections[connectionId];
     if (!entry) {
       throw new Error(`connection '${connectionId}' not found in .squadbase/connections.json`);
@@ -138,6 +311,20 @@ function createConnectorRegistry() {
     if (connectorSlug === "bigquery") {
       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 };
+    }
+    if (connectorSlug === "mysql") {
+      const client = createMySQLClient(entry, connectionId);
+      clientCache.set(connectionId, client);
+      return { client, connectorSlug };
+    }
     if (connectorSlug === "postgresql" || connectorSlug === "squadbase-db") {
       const urlEnvName = entry.envVars["connection-url"];
       if (!urlEnvName) {
@@ -154,7 +341,7 @@ function createConnectorRegistry() {
       return { client, connectorSlug };
     }
     throw new Error(
-      `connector type '${connectorSlug}' is not supported. Supported: "snowflake", "bigquery", "postgresql", "squadbase-db"`
+      `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.`
     );
   }
   function reloadEnvFile2(envPath) {
@@ -178,19 +365,280 @@ function createConnectorRegistry() {
     const envPath = path.join(process.cwd(), ".env");
     try {
       fsWatch(filePath, { persistent: false }, () => {
-        console.log("[connector-client] connections.json changed, clearing cache");
-        connectionsCache = null;
+        console.log("[connector-client] connections.json changed, clearing client cache");
         clientCache.clear();
         setImmediate(() => reloadEnvFile2(envPath));
       });
     } catch {
     }
   }
-  return { getClient: getClient2, reloadEnvFile: reloadEnvFile2, watchConnectionsFile: watchConnectionsFile2 };
+  return { getClient: getClient2, loadConnections: loadConnections2, reloadEnvFile: reloadEnvFile2, watchConnectionsFile: watchConnectionsFile2 };
+}
+
+// src/connector-client/airtable.ts
+function createAirtableClient(entry, slug) {
+  const baseId = resolveEnvVar(entry, "base-id", slug);
+  const apiKey = resolveEnvVar(entry, "api-key", slug);
+  const baseUrl = `https://api.airtable.com/v0/${baseId}`;
+  const headers = {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json"
+  };
+  return {
+    async listRecords(tableIdOrName, options) {
+      const params = new URLSearchParams();
+      if (options?.filterByFormula) params.set("filterByFormula", options.filterByFormula);
+      if (options?.maxRecords) params.set("maxRecords", String(options.maxRecords));
+      if (options?.pageSize) params.set("pageSize", String(options.pageSize));
+      if (options?.offset) params.set("offset", options.offset);
+      options?.fields?.forEach((f) => params.append("fields[]", f));
+      options?.sort?.forEach((s, i) => {
+        params.set(`sort[${i}][field]`, s.field);
+        if (s.direction) params.set(`sort[${i}][direction]`, s.direction);
+      });
+      const qs = params.toString();
+      const url = `${baseUrl}/${encodeURIComponent(tableIdOrName)}${qs ? `?${qs}` : ""}`;
+      const res = await fetch(url, { headers });
+      if (!res.ok) throw new Error(`Airtable API error: ${res.status} ${await res.text()}`);
+      return res.json();
+    },
+    async getRecord(tableIdOrName, recordId) {
+      const url = `${baseUrl}/${encodeURIComponent(tableIdOrName)}/${recordId}`;
+      const res = await fetch(url, { headers });
+      if (!res.ok) throw new Error(`Airtable API error: ${res.status} ${await res.text()}`);
+      return res.json();
+    }
+  };
+}
+
+// src/connector-client/google-analytics.ts
+function createGoogleAnalyticsClient(entry, slug) {
+  const serviceAccountJsonBase64 = resolveEnvVar(entry, "service-account-json-base64", slug);
+  const propertyId = resolveEnvVar(entry, "property-id", slug);
+  const serviceAccountJson = Buffer.from(serviceAccountJsonBase64, "base64").toString("utf-8");
+  let credentials;
+  try {
+    credentials = JSON.parse(serviceAccountJson);
+  } catch {
+    throw new Error(
+      `Google Analytics service account JSON (decoded from base64) is not valid JSON for slug "${slug}"`
+    );
+  }
+  return {
+    async runReport(request) {
+      const { BetaAnalyticsDataClient } = await import("@google-analytics/data");
+      const client = new BetaAnalyticsDataClient({
+        credentials: {
+          client_email: credentials.client_email,
+          private_key: credentials.private_key
+        }
+      });
+      const response = await client.runReport({
+        property: `properties/${propertyId}`,
+        dateRanges: request.dateRanges,
+        dimensions: request.dimensions,
+        metrics: request.metrics,
+        limit: request.limit != null ? String(request.limit) : void 0,
+        offset: request.offset != null ? String(request.offset) : void 0
+      });
+      const reportResponse = Array.isArray(response) ? response[0] : response;
+      const rawRows = reportResponse.rows;
+      const rows = (rawRows ?? []).map((row) => ({
+        dimensionValues: (row.dimensionValues ?? []).map((d) => ({
+          value: d.value ?? ""
+        })),
+        metricValues: (row.metricValues ?? []).map((m) => ({
+          value: m.value ?? ""
+        }))
+      }));
+      return {
+        rows,
+        rowCount: Number(reportResponse.rowCount ?? 0)
+      };
+    }
+  };
+}
+
+// src/connector-client/kintone.ts
+function createKintoneClient(entry, slug) {
+  const baseUrl = resolveEnvVar(entry, "base-url", slug);
+  const username = resolveEnvVar(entry, "username", slug);
+  const password = resolveEnvVar(entry, "password", slug);
+  return {
+    async getRecords(appId, options) {
+      const { KintoneRestAPIClient } = await import("@kintone/rest-api-client");
+      const client = new KintoneRestAPIClient({
+        baseUrl,
+        auth: { username, password }
+      });
+      const result = await client.record.getRecords({
+        app: appId,
+        query: options?.query,
+        fields: options?.fields,
+        totalCount: options?.totalCount
+      });
+      return {
+        records: result.records,
+        totalCount: result.totalCount
+      };
+    },
+    async getRecord(appId, recordId) {
+      const { KintoneRestAPIClient } = await import("@kintone/rest-api-client");
+      const client = new KintoneRestAPIClient({
+        baseUrl,
+        auth: { username, password }
+      });
+      const result = await client.record.getRecord({
+        app: appId,
+        id: recordId
+      });
+      return { record: result.record };
+    },
+    async listApps(options) {
+      const { KintoneRestAPIClient } = await import("@kintone/rest-api-client");
+      const client = new KintoneRestAPIClient({
+        baseUrl,
+        auth: { username, password }
+      });
+      const result = await client.app.getApps({
+        ids: options?.ids,
+        name: options?.name,
+        limit: options?.limit,
+        offset: options?.offset
+      });
+      return { apps: result.apps };
+    }
+  };
+}
+
+// src/connector-client/wix-store.ts
+function createWixStoreClient(entry, slug) {
+  const siteId = resolveEnvVar(entry, "site-id", slug);
+  const apiKey = resolveEnvVar(entry, "api-key", slug);
+  const headers = {
+    Authorization: apiKey,
+    "wix-site-id": siteId,
+    "Content-Type": "application/json"
+  };
+  return {
+    async queryProducts(options) {
+      const body = {};
+      if (options?.query) body.query = options.query;
+      if (options?.limit) {
+        body.query = { ...body.query ?? {}, paging: { limit: options.limit, offset: options?.offset ?? 0 } };
+      }
+      const res = await fetch(
+        "https://www.wixapis.com/stores/v1/products/query",
+        { method: "POST", headers, body: JSON.stringify(body) }
+      );
+      if (!res.ok) throw new Error(`Wix Store API error: ${res.status} ${await res.text()}`);
+      const data = await res.json();
+      return { products: data.products ?? [], totalResults: data.totalResults ?? 0 };
+    },
+    async queryOrders(options) {
+      const body = {};
+      if (options?.query) body.query = options.query;
+      if (options?.limit) {
+        body.query = { ...body.query ?? {}, paging: { limit: options.limit, offset: options?.offset ?? 0 } };
+      }
+      const res = await fetch(
+        "https://www.wixapis.com/stores/v2/orders/query",
+        { method: "POST", headers, body: JSON.stringify(body) }
+      );
+      if (!res.ok) throw new Error(`Wix Store API error: ${res.status} ${await res.text()}`);
+      const data = await res.json();
+      return { orders: data.orders ?? [], totalResults: data.totalResults ?? 0 };
+    }
+  };
+}
+
+// src/connector-client/dbt.ts
+function createDbtClient(entry, slug) {
+  const host = resolveEnvVar(entry, "host", slug);
+  const prodEnvId = resolveEnvVar(entry, "prod-env-id", slug);
+  const token = resolveEnvVar(entry, "token", slug);
+  const discoveryUrl = `https://${host}/graphql`;
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json"
+  };
+  async function gqlRequest(query, variables) {
+    const res = await fetch(discoveryUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ query, variables })
+    });
+    if (!res.ok) throw new Error(`dbt Discovery API error: ${res.status} ${await res.text()}`);
+    const json = await res.json();
+    if (json.errors) {
+      throw new Error(`dbt Discovery API GraphQL error: ${JSON.stringify(json.errors)}`);
+    }
+    return json.data ?? {};
+  }
+  return {
+    query: gqlRequest,
+    async getModels(options) {
+      const limit = options?.limit ?? 100;
+      const data = await gqlRequest(
+        `query ($environmentId: BigInt!, $first: Int) {
+          environment(id: $environmentId) {
+            applied {
+              models(first: $first) {
+                edges {
+                  node {
+                    uniqueId
+                    name
+                    description
+                    materializedType
+                    database
+                    schema
+                    alias
+                  }
+                }
+              }
+            }
+          }
+        }`,
+        { environmentId: Number(prodEnvId), first: limit }
+      );
+      const env = data.environment;
+      const applied = env?.applied;
+      const models = applied?.models;
+      return models?.edges.map((e) => e.node) ?? [];
+    },
+    async getModelByName(uniqueId) {
+      const data = await gqlRequest(
+        `query ($environmentId: BigInt!, $uniqueId: String!) {
+          environment(id: $environmentId) {
+            applied {
+              modelByUniqueId(uniqueId: $uniqueId) {
+                uniqueId
+                name
+                description
+                materializedType
+                database
+                schema
+                alias
+                columns {
+                  name
+                  description
+                  type
+                }
+              }
+            }
+          }
+        }`,
+        { environmentId: Number(prodEnvId), uniqueId }
+      );
+      const env = data.environment;
+      const applied = env?.applied;
+      return applied?.modelByUniqueId ?? null;
+    }
+  };
 }
 
 // src/connector-client/index.ts
-var { getClient, reloadEnvFile, watchConnectionsFile } = createConnectorRegistry();
+var { getClient, loadConnections, reloadEnvFile, watchConnectionsFile } = createConnectorRegistry();
 
 // src/registry.ts
 var dataSources = /* @__PURE__ */ new Map();
@@ -256,7 +704,7 @@ async function initialize() {
   const results = await Promise.allSettled(
     jsonFiles.map(async (file) => {
       const slug = file.replace(/\.json$/, "");
-      const raw = await readFile(`${dirPath}/${file}`, "utf-8");
+      const raw = await readFile2(`${dirPath}/${file}`, "utf-8");
       const def = JSON.parse(raw);
       if (!def.description) {
         console.warn(`[registry] Skipping ${file}: missing description`);
@@ -301,10 +749,10 @@ async function initialize() {
           _query: sqlDef.query,
           handler: async (runtimeParams) => {
             const { client, connectorSlug } = await getClient(sqlDef.connectionId);
-            const isExternalConnector = connectorSlug === "snowflake" || connectorSlug === "bigquery";
+            const isLiteralConnector = connectorSlug === "snowflake" || connectorSlug === "bigquery" || connectorSlug === "athena" || connectorSlug === "redshift" || connectorSlug === "databricks";
             let queryText;
             let queryValues;
-            if (isExternalConnector) {
+            if (isLiteralConnector) {
               const defaults = new Map(
                 (sqlDef.parameters ?? []).map((p) => [p.name, p.default ?? null])
               );
@@ -322,6 +770,14 @@ async function initialize() {
                 }
               );
               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,
@@ -735,5 +1191,12 @@ app5.get("/healthz", (c) => c.json({ status: "ok" }));
 app5.route("/api", apiApp);
 var src_default = app5;
 export {
-  src_default as default
+  createAirtableClient,
+  createDbtClient,
+  createGoogleAnalyticsClient,
+  createKintoneClient,
+  createWixStoreClient,
+  src_default as default,
+  getClient,
+  loadConnections
 };