@squadbase/vite-server 0.0.1-build-3 → 0.0.1-build-5

package/dist/index.js

@@ -26,34 +26,29 @@ function createPostgreSQLClient(connectionString) {
 }
 
 // src/connector-client/env.ts
-function resolveEnvVar(entry, key, slug) {
+function resolveEnvVar(entry, key, connectionId) {
   const envVarName = entry.envVars[key];
   if (!envVarName) {
-    throw new Error(`Connector "${slug}" is missing envVars mapping for key "${key}"`);
+    throw new Error(`Connection "${connectionId}" is missing envVars mapping for key "${key}"`);
   }
   const value = process.env[envVarName];
   if (!value) {
-    throw new Error(`Environment variable "${envVarName}" (for "${slug}.${key}") is not set`);
+    throw new Error(`Environment variable "${envVarName}" (for connection "${connectionId}", key "${key}") is not set`);
   }
   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) {
-  const projectId = resolveEnvVar(entry, "project-id", slug);
-  const serviceAccountJsonBase64 = resolveEnvVar(entry, "service-account-json-base64", slug);
+function createBigQueryClient(entry, connectionId) {
+  const projectId = resolveEnvVar(entry, "project-id", connectionId);
+  const serviceAccountJsonBase64 = resolveEnvVar(entry, "service-account-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 slug "${slug}"`
+      `BigQuery service account JSON (decoded from base64) is not valid JSON for connection "${connectionId}"`
     );
   }
   return {
@@ -68,12 +63,12 @@ function createBigQueryClient(entry, slug) {
 }
 
 // src/connector-client/snowflake.ts
-function createSnowflakeClient(entry, slug) {
-  const accountIdentifier = resolveEnvVar(entry, "account", slug);
-  const user = resolveEnvVar(entry, "user", slug);
-  const role = resolveEnvVar(entry, "role", slug);
-  const warehouse = resolveEnvVar(entry, "warehouse", slug);
-  const privateKeyBase64 = resolveEnvVar(entry, "private-key-base64", slug);
+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) {
@@ -110,176 +105,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;
@@ -287,7 +112,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 {
@@ -298,67 +123,38 @@ function createConnectorRegistry() {
     }
     return connectionsCache;
   }
-  async function getClient2(connectorSlug, connectorType) {
-    if (!connectorSlug) {
-      const cacheKey = "__squadbase-db__";
-      const cached2 = clientCache.get(cacheKey);
-      if (cached2) return cached2;
-      const url = process.env.SQUADBASE_POSTGRESQL_URL;
-      if (!url) throw new Error("SQUADBASE_POSTGRESQL_URL environment variable is not set");
-      const client = createPostgreSQLClient(url);
-      clientCache.set(cacheKey, client);
-      return client;
-    }
-    const cached = clientCache.get(connectorSlug);
-    if (cached) return cached;
-    const connections = loadConnections2();
-    const entry = connections[connectorSlug];
+  async function getClient2(connectionId) {
+    const connections = loadConnections();
+    const entry = connections[connectionId];
     if (!entry) {
-      throw new Error(`connector slug '${connectorSlug}' not found in .squadbase/connections.json`);
-    }
-    const resolvedType = connectorType ?? entry.connectorType;
-    if (!resolvedType) {
-      throw new Error(
-        `connector type could not be determined for slug '${connectorSlug}'. Specify connectorType in the data-source JSON or in .squadbase/connections.json.`
-      );
+      throw new Error(`connection '${connectionId}' not found in .squadbase/connections.json`);
     }
-    if (resolvedType === "snowflake") {
-      return createSnowflakeClient(entry, connectorSlug);
+    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 (resolvedType === "bigquery") {
-      return createBigQueryClient(entry, connectorSlug);
+    if (connectorSlug === "bigquery") {
+      return { client: createBigQueryClient(entry, connectionId), 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") {
+    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 connector '${connectorSlug}'`);
+        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 connector '${connectorSlug}') is not set`
+          `environment variable '${urlEnvName}' (mapped from connection '${connectionId}') is not set`
         );
       }
       const client = createPostgreSQLClient(connectionUrl);
-      clientCache.set(connectorSlug, client);
-      return client;
+      clientCache.set(connectionId, client);
+      return { client, connectorSlug };
     }
     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 '${connectorSlug}' is not supported. Supported: "snowflake", "bigquery", "postgresql", "squadbase-db"`
     );
   }
   function reloadEnvFile2(envPath) {
@@ -390,276 +186,15 @@ function createConnectorRegistry() {
     } catch {
     }
   }
-  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;
-    }
-  };
+  return { getClient: getClient2, reloadEnvFile: reloadEnvFile2, watchConnectionsFile: watchConnectionsFile2 };
 }
 
 // src/connector-client/index.ts
-var { getClient, loadConnections, reloadEnvFile, watchConnectionsFile } = createConnectorRegistry();
+var { getClient, reloadEnvFile, watchConnectionsFile } = createConnectorRegistry();
 
 // src/registry.ts
 var dataSources = /* @__PURE__ */ new Map();
+var currentDirPath = "";
 var viteServer = null;
 function validateHandlerPath(dirPath, handlerPath) {
   const absolute = path2.resolve(dirPath, handlerPath);
@@ -714,6 +249,7 @@ async function initialize() {
   );
   dataSources.clear();
   const dirPath = process.env.DATA_SOURCE_DIR || defaultDataSourceDir;
+  currentDirPath = dirPath;
   await mkdir(dirPath, { recursive: true });
   const files = await readdir(dirPath);
   const jsonFiles = files.filter((f) => f.endsWith(".json"));
@@ -726,6 +262,10 @@ async function initialize() {
         console.warn(`[registry] Skipping ${file}: missing description`);
         return;
       }
+      if (!def.connectionId) {
+        console.warn(`[registry] Skipping ${file}: missing connectionId`);
+        return;
+      }
       if (def.type === "typescript") {
         if (!def.handlerPath) {
           console.warn(`[registry] Skipping ${file}: missing handlerPath`);
@@ -736,6 +276,7 @@ async function initialize() {
           description: def.description,
           parameters: def.parameters ?? [],
           response: def.response,
+          connectionId: def.connectionId,
           cacheConfig: def.cache,
           handler: async () => {
             throw new Error("TypeScript handler must be called via _tsHandlerPath");
@@ -755,14 +296,15 @@ async function initialize() {
           description: sqlDef.description,
           parameters: sqlDef.parameters ?? [],
           response: sqlDef.response,
-          connectorSlug: sqlDef.connectorSlug,
+          connectionId: sqlDef.connectionId,
           cacheConfig: sqlDef.cache,
+          _query: sqlDef.query,
           handler: async (runtimeParams) => {
-            const client = await getClient(sqlDef.connectorSlug, sqlDef.connectorType);
-            const isLiteralConnector = sqlDef.connectorType === "snowflake" || sqlDef.connectorType === "bigquery" || sqlDef.connectorType === "athena" || sqlDef.connectorType === "redshift" || sqlDef.connectorType === "databricks";
+            const { client, connectorSlug } = await getClient(sqlDef.connectionId);
+            const isExternalConnector = connectorSlug === "snowflake" || connectorSlug === "bigquery";
             let queryText;
             let queryValues;
-            if (isLiteralConnector) {
+            if (isExternalConnector) {
               const defaults = new Map(
                 (sqlDef.parameters ?? []).map((p) => [p.name, p.default ?? null])
               );
@@ -780,14 +322,6 @@ async function initialize() {
                 }
               );
               queryValues = [];
-            } else if (sqlDef.connectorType === "mysql") {
-              const built = buildQuery(
-                sqlDef.query,
-                sqlDef.parameters ?? [],
-                runtimeParams
-              );
-              queryText = built.text.replace(/\$(\d+)/g, "?");
-              queryValues = built.values;
             } else {
               const built = buildQuery(
                 sqlDef.query,
@@ -838,25 +372,28 @@ function startWatching() {
 function getDataSource(slug) {
   return dataSources.get(slug);
 }
-function getAllMeta() {
-  return Array.from(dataSources.entries()).map(([slug, def]) => ({
+function buildMeta(slug, def) {
+  return {
     slug,
     description: def.description,
+    type: def._isTypescript ? "typescript" : "sql",
     parameters: def.parameters,
     response: def.response,
-    connectorSlug: def.connectorSlug
-  }));
+    query: def._query,
+    connectionId: def.connectionId,
+    handlerPath: def._tsHandlerPath ? path2.relative(currentDirPath, def._tsHandlerPath) : void 0,
+    cache: def.cacheConfig
+  };
+}
+function getAllMeta() {
+  return Array.from(dataSources.entries()).map(
+    ([slug, def]) => buildMeta(slug, def)
+  );
 }
 function getMeta(slug) {
   const def = dataSources.get(slug);
   if (!def) return void 0;
-  return {
-    slug,
-    description: def.description,
-    parameters: def.parameters,
-    response: def.response,
-    connectorSlug: def.connectorSlug
-  };
+  return buildMeta(slug, def);
 }
 
 // src/routes/data-source.ts
@@ -1198,12 +735,5 @@ app5.get("/healthz", (c) => c.json({ status: "ok" }));
 app5.route("/api", apiApp);
 var src_default = app5;
 export {
-  createAirtableClient,
-  createDbtClient,
-  createGoogleAnalyticsClient,
-  createKintoneClient,
-  createWixStoreClient,
-  src_default as default,
-  getClient,
-  loadConnections
+  src_default as default
 };