@squadbase/vite-server 0.0.1-build-2 → 0.0.1-build-4

package/dist/cli/index.js

@@ -113,11 +113,6 @@ function resolveEnvVar(entry, key, slug) {
   }
   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, slug) {
@@ -186,176 +181,6 @@ function createSnowflakeClient(entry, slug) {
   };
 }
 
-// src/connector-client/mysql.ts
-function createMySQLClient(entry, slug) {
-  const connectionUrl = resolveEnvVar(entry, "connection-url", slug);
-  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, slug) {
-  const region = resolveEnvVar(entry, "aws-region", slug);
-  const accessKeyId = resolveEnvVar(entry, "aws-access-key-id", slug);
-  const secretAccessKey = resolveEnvVar(entry, "aws-secret-access-key", slug);
-  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, slug) {
-  const region = resolveEnvVar(entry, "aws-region", slug);
-  const accessKeyId = resolveEnvVar(entry, "aws-access-key-id", slug);
-  const secretAccessKey = resolveEnvVar(entry, "aws-secret-access-key", slug);
-  const database = resolveEnvVar(entry, "database", slug);
-  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, slug) {
-  const host = resolveEnvVar(entry, "host", slug);
-  const httpPath = resolveEnvVar(entry, "http-path", slug);
-  const token = resolveEnvVar(entry, "token", slug);
-  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;
@@ -363,7 +188,7 @@ function createConnectorRegistry() {
   function getConnectionsFilePath() {
     return process.env.CONNECTIONS_PATH ?? path.join(process.cwd(), "../../.squadbase/connections.json");
   }
-  function loadConnections2() {
+  function loadConnections() {
     if (connectionsCache !== null) return connectionsCache;
     const filePath = getConnectionsFilePath();
     try {
@@ -387,7 +212,7 @@ function createConnectorRegistry() {
     }
     const cached = clientCache.get(connectorSlug);
     if (cached) return cached;
-    const connections = loadConnections2();
+    const connections = loadConnections();
     const entry = connections[connectorSlug];
     if (!entry) {
       throw new Error(`connector slug '${connectorSlug}' not found in .squadbase/connections.json`);
@@ -404,20 +229,6 @@ function createConnectorRegistry() {
     if (resolvedType === "bigquery") {
       return createBigQueryClient(entry, connectorSlug);
     }
-    if (resolvedType === "athena") {
-      return createAthenaClient(entry, connectorSlug);
-    }
-    if (resolvedType === "redshift") {
-      return createRedshiftClient(entry, connectorSlug);
-    }
-    if (resolvedType === "databricks") {
-      return createDatabricksClient(entry, connectorSlug);
-    }
-    if (resolvedType === "mysql") {
-      const client = createMySQLClient(entry, connectorSlug);
-      clientCache.set(connectorSlug, client);
-      return client;
-    }
     if (resolvedType === "postgresql" || resolvedType === "squadbase-db") {
       const urlEnvName = entry.envVars["connection-url"];
       if (!urlEnvName) {
@@ -434,7 +245,7 @@ function createConnectorRegistry() {
       return client;
     }
     throw new Error(
-      `connector type '${resolvedType}' 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.`
+      `connector type '${resolvedType}' is not supported. Supported: "snowflake", "bigquery", "postgresql", "squadbase-db"`
     );
   }
   function reloadEnvFile2(envPath) {
@@ -466,11 +277,11 @@ function createConnectorRegistry() {
     } catch {
     }
   }
-  return { getClient: getClient2, loadConnections: loadConnections2, reloadEnvFile: reloadEnvFile2, watchConnectionsFile: watchConnectionsFile2 };
+  return { getClient: getClient2, reloadEnvFile: reloadEnvFile2, watchConnectionsFile: watchConnectionsFile2 };
 }
 
 // src/connector-client/index.ts
-var { getClient, loadConnections, reloadEnvFile, watchConnectionsFile } = createConnectorRegistry();
+var { getClient, reloadEnvFile, watchConnectionsFile } = createConnectorRegistry();
 
 // src/cli/env-loader.ts
 import { readFileSync as readFileSync2 } from "fs";

package/dist/index.d.ts

@@ -1,125 +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 {
-    connectorType: string;
-    envVars: Record<string, string>;
-}
-type ConnectionsMap = Record<string, ConnectionEntry>;
-
-interface AirtableClient {
-    listRecords(tableIdOrName: string, options?: {
-        fields?: string[];
-        filterByFormula?: string;
-        maxRecords?: number;
-        sort?: {
-            field: string;
-            direction?: "asc" | "desc";
-        }[];
-        pageSize?: number;
-        offset?: string;
-    }): Promise<{
-        records: AirtableRecord[];
-        offset?: string;
-    }>;
-    getRecord(tableIdOrName: string, recordId: string): Promise<AirtableRecord>;
-}
-interface AirtableRecord {
-    id: string;
-    fields: Record<string, unknown>;
-    createdTime: string;
-}
-declare function createAirtableClient(entry: ConnectionEntry, slug: string): AirtableClient;
-
-interface GoogleAnalyticsClient {
-    runReport(request: {
-        dateRanges: {
-            startDate: string;
-            endDate: string;
-        }[];
-        dimensions?: {
-            name: string;
-        }[];
-        metrics: {
-            name: string;
-        }[];
-        limit?: number;
-        offset?: number;
-        orderBys?: unknown[];
-    }): Promise<{
-        rows: {
-            dimensionValues: {
-                value: string;
-            }[];
-            metricValues: {
-                value: string;
-            }[];
-        }[];
-        rowCount: number;
-    }>;
-}
-declare function createGoogleAnalyticsClient(entry: ConnectionEntry, slug: string): GoogleAnalyticsClient;
-
-interface KintoneClient {
-    getRecords(appId: string | number, options?: {
-        query?: string;
-        fields?: string[];
-        totalCount?: boolean;
-    }): Promise<{
-        records: Record<string, unknown>[];
-        totalCount: string | null;
-    }>;
-    getRecord(appId: string | number, recordId: string | number): Promise<{
-        record: Record<string, unknown>;
-    }>;
-    listApps(options?: {
-        ids?: (string | number)[];
-        name?: string;
-        limit?: number;
-        offset?: number;
-    }): Promise<{
-        apps: Record<string, unknown>[];
-    }>;
-}
-declare function createKintoneClient(entry: ConnectionEntry, slug: string): KintoneClient;
-
-interface WixStoreClient {
-    queryProducts(options?: {
-        query?: Record<string, unknown>;
-        limit?: number;
-        offset?: number;
-    }): Promise<{
-        products: Record<string, unknown>[];
-        totalResults: number;
-    }>;
-    queryOrders(options?: {
-        query?: Record<string, unknown>;
-        limit?: number;
-        offset?: number;
-    }): Promise<{
-        orders: Record<string, unknown>[];
-        totalResults: number;
-    }>;
-}
-declare function createWixStoreClient(entry: ConnectionEntry, slug: string): WixStoreClient;
-
-interface DbtClient {
-    query(graphqlQuery: string, variables?: Record<string, unknown>): Promise<Record<string, unknown>>;
-    getModels(options?: {
-        limit?: number;
-    }): Promise<Record<string, unknown>[]>;
-    getModelByName(uniqueId: string): Promise<Record<string, unknown> | null>;
-}
-declare function createDbtClient(entry: ConnectionEntry, slug: string): DbtClient;
-
-declare const getClient: (connectorSlug?: string, connectorType?: string) => Promise<DatabaseClient>;
-declare const loadConnections: () => ConnectionsMap;
-
 declare const app: Hono<hono_types.BlankEnv, hono_types.BlankSchema, "/">;
 
-export { type AirtableClient, type AirtableRecord, type ConnectionEntry, type ConnectionsMap, type DatabaseClient, type DbtClient, type GoogleAnalyticsClient, type KintoneClient, type WixStoreClient, createAirtableClient, createDbtClient, createGoogleAnalyticsClient, createKintoneClient, createWixStoreClient, app as default, getClient, loadConnections };
+export { app as default };