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

package/dist/index.js

@@ -26,29 +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;
 }
 
 // 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 {
@@ -63,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) {
@@ -123,53 +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;
+  async function getClient2(connectionId) {
     const connections = loadConnections();
-    const entry = connections[connectorSlug];
+    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 === "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. Supported: "snowflake", "bigquery", "postgresql", "squadbase-db"`
+      `connector type '${connectorSlug}' is not supported. Supported: "snowflake", "bigquery", "postgresql", "squadbase-db"`
     );
   }
   function reloadEnvFile2(envPath) {
@@ -277,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`);
@@ -287,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");
@@ -306,13 +296,12 @@ async function initialize() {
           description: sqlDef.description,
           parameters: sqlDef.parameters ?? [],
           response: sqlDef.response,
-          connectorSlug: sqlDef.connectorSlug,
+          connectionId: sqlDef.connectionId,
           cacheConfig: sqlDef.cache,
           _query: sqlDef.query,
-          _connectorType: sqlDef.connectorType,
           handler: async (runtimeParams) => {
-            const client = await getClient(sqlDef.connectorSlug, sqlDef.connectorType);
-            const isExternalConnector = sqlDef.connectorType === "snowflake" || sqlDef.connectorType === "bigquery";
+            const { client, connectorSlug } = await getClient(sqlDef.connectionId);
+            const isExternalConnector = connectorSlug === "snowflake" || connectorSlug === "bigquery";
             let queryText;
             let queryValues;
             if (isExternalConnector) {
@@ -391,8 +380,7 @@ function buildMeta(slug, def) {
     parameters: def.parameters,
     response: def.response,
     query: def._query,
-    connectorType: def._connectorType,
-    connectorSlug: def.connectorSlug,
+    connectionId: def.connectionId,
     handlerPath: def._tsHandlerPath ? path2.relative(currentDirPath, def._tsHandlerPath) : void 0,
     cache: def.cacheConfig
   };

package/dist/main.js

@@ -26,29 +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;
 }
 
 // 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 {
@@ -63,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) {
@@ -123,53 +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;
+  async function getClient2(connectionId) {
     const connections = loadConnections();
-    const entry = connections[connectorSlug];
+    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 === "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. Supported: "snowflake", "bigquery", "postgresql", "squadbase-db"`
+      `connector type '${connectorSlug}' is not supported. Supported: "snowflake", "bigquery", "postgresql", "squadbase-db"`
     );
   }
   function reloadEnvFile2(envPath) {
@@ -277,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`);
@@ -287,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");
@@ -306,13 +296,12 @@ async function initialize() {
           description: sqlDef.description,
           parameters: sqlDef.parameters ?? [],
           response: sqlDef.response,
-          connectorSlug: sqlDef.connectorSlug,
+          connectionId: sqlDef.connectionId,
           cacheConfig: sqlDef.cache,
           _query: sqlDef.query,
-          _connectorType: sqlDef.connectorType,
           handler: async (runtimeParams) => {
-            const client = await getClient(sqlDef.connectorSlug, sqlDef.connectorType);
-            const isExternalConnector = sqlDef.connectorType === "snowflake" || sqlDef.connectorType === "bigquery";
+            const { client, connectorSlug } = await getClient(sqlDef.connectionId);
+            const isExternalConnector = connectorSlug === "snowflake" || connectorSlug === "bigquery";
             let queryText;
             let queryValues;
             if (isExternalConnector) {
@@ -391,8 +380,7 @@ function buildMeta(slug, def) {
     parameters: def.parameters,
     response: def.response,
     query: def._query,
-    connectorType: def._connectorType,
-    connectorSlug: def.connectorSlug,
+    connectionId: def.connectionId,
     handlerPath: def._tsHandlerPath ? path2.relative(currentDirPath, def._tsHandlerPath) : void 0,
     cache: def.cacheConfig
   };

package/dist/types/data-source.d.ts

@@ -47,13 +47,12 @@ interface DataSourceDefinition {
     description: string;
     parameters: ParameterMeta[];
     response?: DataSourceResponse;
-    connectorSlug?: string;
+    connectionId: string;
     cacheConfig?: DataSourceCacheConfig;
     handler: (params: Record<string, unknown>) => Promise<unknown> | unknown;
     _isTypescript?: boolean;
     _tsHandlerPath?: string;
     _query?: string;
-    _connectorType?: string;
 }
 interface DataSourceMeta {
     slug: string;
@@ -62,8 +61,7 @@ interface DataSourceMeta {
     parameters: ParameterMeta[];
     response?: DataSourceResponse;
     query?: string;
-    connectorType?: string;
-    connectorSlug?: string;
+    connectionId: string;
     handlerPath?: string;
     cache?: DataSourceCacheConfig;
 }
@@ -73,14 +71,14 @@ interface JsonDataSourceDefinition {
     parameters?: ParameterMeta[];
     response?: DataSourceResponse;
     query: string;
-    connectorType?: string;
-    connectorSlug?: string;
+    connectionId: string;
     cache?: DataSourceCacheConfig;
 }
 interface JsonTypeScriptDataSourceDefinition {
     description: string;
     type: "typescript";
     handlerPath: string;
+    connectionId: string;
     parameters?: ParameterMeta[];
     response?: DataSourceResponse;
     cache?: DataSourceCacheConfig;

package/dist/vite-plugin.js

@@ -26,29 +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;
 }
 
 // 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 {
@@ -63,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) {
@@ -123,53 +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;
+  async function getClient2(connectionId) {
     const connections = loadConnections();
-    const entry = connections[connectorSlug];
+    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 === "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. Supported: "snowflake", "bigquery", "postgresql", "squadbase-db"`
+      `connector type '${connectorSlug}' is not supported. Supported: "snowflake", "bigquery", "postgresql", "squadbase-db"`
     );
   }
   function reloadEnvFile2(envPath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squadbase/vite-server",
-  "version": "0.0.1-build-4",
+  "version": "0.0.1-build-5",
   "type": "module",
   "exports": {
     ".": {

package/dist/cli/index.d.ts

@@ -1 +0,0 @@
-#!/usr/bin/env node

package/dist/cli/index.js

@@ -1,659 +0,0 @@
-#!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/cli/interactive.ts
-var interactive_exports = {};
-__export(interactive_exports, {
-  confirmRunAll: () => confirmRunAll,
-  inputParameters: () => inputParameters,
-  selectDataSource: () => selectDataSource
-});
-async function getPrompts() {
-  try {
-    const mod = await import("@clack/prompts");
-    return mod;
-  } catch {
-    throw new Error(
-      "@clack/prompts is not installed. Run: npm install @clack/prompts --save-dev"
-    );
-  }
-}
-async function selectDataSource(slugs) {
-  const { select, isCancel } = await getPrompts();
-  const result = await select({
-    message: "Select a data source to test:",
-    options: slugs.map((s) => ({ value: s, label: s }))
-  });
-  if (isCancel(result)) return null;
-  return result;
-}
-async function inputParameters(params) {
-  if (params.length === 0) return {};
-  const { text, isCancel } = await getPrompts();
-  const result = {};
-  for (const p of params) {
-    const defaultHint = p.default !== void 0 ? ` (default: ${p.default})` : "";
-    const requiredHint = p.required ? " *required*" : "";
-    const value = await text({
-      message: `${p.name}${requiredHint} [${p.type}]${defaultHint}: ${p.description}`,
-      placeholder: p.default !== void 0 ? String(p.default) : "",
-      validate: (v) => {
-        if (p.required && !v && p.default === void 0) {
-          return `${p.name} is required`;
-        }
-      }
-    });
-    if (isCancel(value)) {
-      process.exit(0);
-    }
-    const strValue = value;
-    if (!strValue && p.default !== void 0) {
-      result[p.name] = p.default;
-    } else if (strValue) {
-      if (p.type === "number") result[p.name] = Number(strValue);
-      else if (p.type === "boolean") result[p.name] = strValue === "true";
-      else result[p.name] = strValue;
-    }
-  }
-  return result;
-}
-async function confirmRunAll() {
-  const { confirm, isCancel } = await getPrompts();
-  const result = await confirm({
-    message: "Run all data sources?"
-  });
-  if (isCancel(result)) return false;
-  return result;
-}
-var init_interactive = __esm({
-  "src/cli/interactive.ts"() {
-    "use strict";
-  }
-});
-
-// src/cli/index.ts
-import { parseArgs } from "util";
-import path4 from "path";
-import { readFile as readFile3 } from "fs/promises";
-
-// src/connector-client/registry.ts
-import { readFileSync, watch as fsWatch } from "fs";
-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 };
-    }
-  };
-}
-
-// src/connector-client/env.ts
-function resolveEnvVar(entry, key, slug) {
-  const envVarName = entry.envVars[key];
-  if (!envVarName) {
-    throw new Error(`Connector "${slug}" 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`);
-  }
-  return value;
-}
-
-// 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);
-  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}"`
-    );
-  }
-  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/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);
-  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 connection = snowflake.createConnection({
-        account: accountIdentifier,
-        username: user,
-        role,
-        warehouse,
-        authenticator: "SNOWFLAKE_JWT",
-        privateKey
-      });
-      await new Promise((resolve, reject) => {
-        connection.connect((err) => {
-          if (err) reject(new Error(`Snowflake connect failed: ${err.message}`));
-          else resolve();
-        });
-      });
-      const rows = await new Promise((resolve, reject) => {
-        connection.execute({
-          sqlText: sql,
-          complete: (err, _stmt, rows2) => {
-            if (err) reject(new Error(`Snowflake query failed: ${err.message}`));
-            else resolve(rows2 ?? []);
-          }
-        });
-      });
-      connection.destroy((err) => {
-        if (err) console.warn(`[connector-client] Snowflake destroy error: ${err.message}`);
-      });
-      return { rows };
-    }
-  };
-}
-
-// 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;
-    const filePath = getConnectionsFilePath();
-    try {
-      const raw = readFileSync(filePath, "utf-8");
-      connectionsCache = JSON.parse(raw);
-    } catch {
-      connectionsCache = {};
-    }
-    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 = loadConnections();
-    const entry = connections[connectorSlug];
-    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.`
-      );
-    }
-    if (resolvedType === "snowflake") {
-      return createSnowflakeClient(entry, connectorSlug);
-    }
-    if (resolvedType === "bigquery") {
-      return createBigQueryClient(entry, connectorSlug);
-    }
-    if (resolvedType === "postgresql" || resolvedType === "squadbase-db") {
-      const urlEnvName = entry.envVars["connection-url"];
-      if (!urlEnvName) {
-        throw new Error(`'connection-url' is not defined in envVars for connector '${connectorSlug}'`);
-      }
-      const connectionUrl = process.env[urlEnvName];
-      if (!connectionUrl) {
-        throw new Error(
-          `environment variable '${urlEnvName}' (mapped from connector '${connectorSlug}') is not set`
-        );
-      }
-      const client = createPostgreSQLClient(connectionUrl);
-      clientCache.set(connectorSlug, client);
-      return client;
-    }
-    throw new Error(
-      `connector type '${resolvedType}' is not supported. Supported: "snowflake", "bigquery", "postgresql", "squadbase-db"`
-    );
-  }
-  function reloadEnvFile2(envPath) {
-    try {
-      const raw = readFileSync(envPath, "utf-8");
-      for (const line of raw.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith("#")) continue;
-        const eqIdx = trimmed.indexOf("=");
-        if (eqIdx === -1) continue;
-        const key = trimmed.slice(0, eqIdx).trim();
-        const value = trimmed.slice(eqIdx + 1).trim();
-        if (key) process.env[key] = value;
-      }
-      console.log("[connector-client] .env reloaded");
-    } catch {
-    }
-  }
-  function watchConnectionsFile2() {
-    const filePath = getConnectionsFilePath();
-    const envPath = path.join(process.cwd(), "..", "..", ".env");
-    try {
-      fsWatch(filePath, { persistent: false }, () => {
-        console.log("[connector-client] connections.json changed, clearing cache");
-        connectionsCache = null;
-        clientCache.clear();
-        setImmediate(() => reloadEnvFile2(envPath));
-      });
-    } catch {
-    }
-  }
-  return { getClient: getClient2, reloadEnvFile: reloadEnvFile2, watchConnectionsFile: watchConnectionsFile2 };
-}
-
-// src/connector-client/index.ts
-var { getClient, reloadEnvFile, watchConnectionsFile } = createConnectorRegistry();
-
-// src/cli/env-loader.ts
-import { readFileSync as readFileSync2 } from "fs";
-function loadEnvFile(envPath) {
-  reloadEnvFile(envPath);
-}
-
-// src/cli/runner.ts
-import { pathToFileURL } from "url";
-import { readFile as readFile2, readdir as readdir2 } from "fs/promises";
-import path3 from "path";
-
-// src/registry.ts
-import { readdir, readFile, mkdir } from "fs/promises";
-import { watch as fsWatch2 } from "fs";
-import path2 from "path";
-function buildQuery(queryTemplate, 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)}`;
-    }
-  );
-  return { text, values };
-}
-var defaultDataSourceDir = path2.join(process.cwd(), "data-source");
-
-// src/cli/runner.ts
-function createStubContext(params) {
-  const stub = {
-    req: {
-      json: () => Promise.resolve(params),
-      query: (name) => {
-        if (name === void 0) {
-          return Object.fromEntries(
-            Object.entries(params).map(([k, v2]) => [k, String(v2)])
-          );
-        }
-        const v = params[name];
-        return v !== void 0 ? String(v) : "";
-      },
-      param: (_name) => void 0,
-      header: (_name) => void 0,
-      raw: new Request("http://localhost/cli")
-    },
-    json: (data) => data,
-    text: (data) => data,
-    body: (data) => data,
-    env: {},
-    var: {},
-    get: (_key) => void 0,
-    set: () => {
-    }
-  };
-  return stub;
-}
-async function runSqlDataSource(slug, def, params, limit) {
-  const start = Date.now();
-  try {
-    const client = await getClient(def.connectorSlug, def.connectorType);
-    const isExternal = def.connectorType === "snowflake" || def.connectorType === "bigquery";
-    let queryText;
-    let queryValues;
-    if (isExternal) {
-      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 {
-      const built = buildQuery(def.query, def.parameters ?? [], params);
-      queryText = built.text;
-      queryValues = built.values;
-    }
-    const result = await client.query(queryText, queryValues);
-    const rows = result.rows.slice(0, limit);
-    return {
-      slug,
-      rows,
-      rowCount: result.rows.length,
-      durationMs: Date.now() - start,
-      query: queryText,
-      queryValues
-    };
-  } catch (error) {
-    return {
-      slug,
-      rows: [],
-      rowCount: 0,
-      durationMs: Date.now() - start,
-      error: error instanceof Error ? error : new Error(String(error))
-    };
-  }
-}
-async function runTypescriptDataSource(slug, handlerPath, params) {
-  const start = Date.now();
-  try {
-    const mod = await import(pathToFileURL(handlerPath).href);
-    const handler = mod.default;
-    if (typeof handler !== "function") {
-      throw new Error(`Handler must export a default function: ${handlerPath}`);
-    }
-    const ctx = createStubContext(params);
-    const raw = await handler(ctx);
-    let rows;
-    if (Array.isArray(raw)) {
-      rows = raw;
-    } else if (raw !== null && typeof raw === "object") {
-      rows = [raw];
-    } else {
-      rows = [{ result: raw }];
-    }
-    return {
-      slug,
-      rows,
-      rowCount: rows.length,
-      durationMs: Date.now() - start
-    };
-  } catch (error) {
-    return {
-      slug,
-      rows: [],
-      rowCount: 0,
-      durationMs: Date.now() - start,
-      error: error instanceof Error ? error : new Error(String(error))
-    };
-  }
-}
-async function runDataSource(slug, dirPath, params, limit) {
-  const jsonPath = path3.join(dirPath, `${slug}.json`);
-  let def;
-  try {
-    const raw = await readFile2(jsonPath, "utf-8");
-    def = JSON.parse(raw);
-  } catch {
-    return {
-      slug,
-      rows: [],
-      rowCount: 0,
-      durationMs: 0,
-      error: new Error(`Data source not found: ${jsonPath}`)
-    };
-  }
-  if (def.type === "typescript") {
-    const absolutePath = path3.resolve(dirPath, def.handlerPath);
-    return runTypescriptDataSource(slug, absolutePath, params);
-  }
-  return runSqlDataSource(slug, def, params, limit);
-}
-async function listSlugs(dirPath) {
-  try {
-    const files = await readdir2(dirPath);
-    return files.filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, ""));
-  } catch {
-    return [];
-  }
-}
-async function runAll(dirPath, params, limit) {
-  const slugs = await listSlugs(dirPath);
-  return Promise.all(slugs.map((slug) => runDataSource(slug, dirPath, params, limit)));
-}
-
-// src/cli/display.ts
-var RESET = "\x1B[0m";
-var BOLD = "\x1B[1m";
-var RED = "\x1B[31m";
-var GREEN = "\x1B[32m";
-var YELLOW = "\x1B[33m";
-var CYAN = "\x1B[36m";
-var DIM = "\x1B[2m";
-function truncate(value, maxLen) {
-  return value.length > maxLen ? value.slice(0, maxLen - 1) + "\u2026" : value;
-}
-function formatValue(value) {
-  if (value === null || value === void 0) return DIM + "null" + RESET;
-  if (typeof value === "object") return JSON.stringify(value);
-  return String(value);
-}
-function displayTable(rows, limit) {
-  if (rows.length === 0) {
-    console.log(DIM + "  (no rows)" + RESET);
-    return;
-  }
-  const display = rows.slice(0, limit);
-  const columns = Object.keys(display[0] ?? {});
-  const colWidths = columns.map((col) => {
-    const maxData = Math.max(...display.map((r) => formatValue(r[col]).replace(/\x1b\[[0-9;]*m/g, "").length));
-    return Math.min(40, Math.max(col.length, maxData));
-  });
-  const header = columns.map((c, i) => BOLD + CYAN + c.padEnd(colWidths[i] ?? 0) + RESET).join("  ");
-  const divider = colWidths.map((w) => "-".repeat(w)).join("--");
-  console.log("  " + header);
-  console.log("  " + DIM + divider + RESET);
-  for (const row of display) {
-    const line = columns.map((c, i) => {
-      const raw = formatValue(row[c]);
-      const plain = raw.replace(/\x1b\[[0-9;]*m/g, "");
-      const padded = truncate(plain, colWidths[i] ?? 40).padEnd(colWidths[i] ?? 0);
-      return raw.startsWith(DIM) ? DIM + padded + RESET : padded;
-    }).join("  ");
-    console.log("  " + line);
-  }
-  if (rows.length > limit) {
-    console.log(DIM + `  \u2026 and ${rows.length - limit} more rows (use --limit to show more)` + RESET);
-  }
-}
-function displaySummary(result) {
-  const status = result.error ? RED + "\u2717 FAIL" + RESET : GREEN + "\u2713 OK" + RESET;
-  const duration = DIM + `(${result.durationMs}ms)` + RESET;
-  console.log(`
-${BOLD}[${result.slug}]${RESET} ${status} ${duration}`);
-  if (result.error) {
-    console.log(RED + `  Error: ${result.error.message}` + RESET);
-    return;
-  }
-  console.log(DIM + `  ${result.rowCount} row(s)` + RESET);
-}
-function displayDebug(result) {
-  if (result.query) {
-    console.log(YELLOW + "  Query:" + RESET);
-    console.log(DIM + `    ${result.query.replace(/\n/g, "\n    ")}` + RESET);
-  }
-  if (result.queryValues && result.queryValues.length > 0) {
-    console.log(YELLOW + "  Params:" + RESET, result.queryValues);
-  }
-}
-function displayJson(results) {
-  const output = results.map((r) => ({
-    slug: r.slug,
-    rowCount: r.rowCount,
-    durationMs: r.durationMs,
-    rows: r.rows,
-    error: r.error?.message
-  }));
-  console.log(JSON.stringify(output, null, 2));
-}
-function displayError(error) {
-  console.error(RED + "Error: " + error.message + RESET);
-}
-
-// src/cli/index.ts
-var HELP = `
-Usage: squadbase-ds-test [options]
-
-Options:
-  --slug <slug>     Run a specific data source
-  --all             Run all data sources
-  --params k=v,...  Comma-separated key=value parameters
-  --env <path>      Path to .env file (default: ../../.env)
-  --dir <path>      Data source directory (default: ./data-source)
-  --format table|json  Output format (default: table)
-  --limit <n>       Max rows to display (default: 50)
-  --debug           Show SQL query and parameter values
-  --help            Show this help
-
-Examples:
-  npx tsx src/cli/index.ts --slug sales-summary
-  npx tsx src/cli/index.ts --slug sales-summary --params year=2024,limit=10
-  npx tsx src/cli/index.ts --all --format json
-  npx tsx src/cli/index.ts  # interactive mode
-`;
-async function main() {
-  const { values } = parseArgs({
-    options: {
-      slug: { type: "string" },
-      all: { type: "boolean", default: false },
-      params: { type: "string" },
-      env: { type: "string" },
-      dir: { type: "string" },
-      format: { type: "string", default: "table" },
-      limit: { type: "string", default: "50" },
-      debug: { type: "boolean", default: false },
-      help: { type: "boolean", default: false }
-    },
-    allowPositionals: false
-  });
-  if (values.help) {
-    console.log(HELP);
-    process.exit(0);
-  }
-  const cwd = process.cwd();
-  const dirPath = values.dir ? path4.resolve(cwd, values.dir) : path4.join(cwd, "data-source");
-  const envPath = values.env ? path4.resolve(cwd, values.env) : path4.join(cwd, "../../.env");
-  const limit = parseInt(values.limit ?? "50", 10);
-  const format = values.format ?? "table";
-  loadEnvFile(envPath);
-  const params = {};
-  if (values.params) {
-    for (const pair of values.params.split(",")) {
-      const eqIdx = pair.indexOf("=");
-      if (eqIdx === -1) continue;
-      const key = pair.slice(0, eqIdx).trim();
-      const val = pair.slice(eqIdx + 1).trim();
-      params[key] = val;
-    }
-  }
-  if (values.slug) {
-    const result = await runDataSource(values.slug, dirPath, params, limit);
-    if (format === "json") {
-      displayJson([result]);
-    } else {
-      displaySummary(result);
-      if (values.debug) displayDebug(result);
-      if (!result.error) displayTable(result.rows, limit);
-    }
-    if (result.error) process.exit(1);
-  } else if (values.all) {
-    const results = await runAll(dirPath, params, limit);
-    if (format === "json") {
-      displayJson(results);
-    } else {
-      for (const r of results) {
-        displaySummary(r);
-        if (values.debug) displayDebug(r);
-        if (!r.error) displayTable(r.rows, limit);
-      }
-      const failed = results.filter((r) => r.error).length;
-      console.log(`
-Total: ${results.length}, Failed: ${failed}`);
-    }
-    const anyFailed = results.some((r) => r.error);
-    if (anyFailed) process.exit(1);
-  } else {
-    const slugs = await listSlugs(dirPath);
-    if (slugs.length === 0) {
-      displayError(new Error(`No data sources found in ${dirPath}`));
-      process.exit(1);
-    }
-    try {
-      const { selectDataSource: selectDataSource2, inputParameters: inputParameters2 } = await Promise.resolve().then(() => (init_interactive(), interactive_exports));
-      const slug = await selectDataSource2(slugs);
-      if (!slug) {
-        console.log("Cancelled.");
-        process.exit(0);
-      }
-      const jsonPath = path4.join(dirPath, `${slug}.json`);
-      let paramMeta = [];
-      try {
-        const raw = await readFile3(jsonPath, "utf-8");
-        const def = JSON.parse(raw);
-        paramMeta = def.parameters ?? [];
-      } catch {
-      }
-      const interactiveParams = await inputParameters2(paramMeta);
-      const merged = { ...interactiveParams, ...params };
-      const result = await runDataSource(slug, dirPath, merged, limit);
-      displaySummary(result);
-      if (values.debug) displayDebug(result);
-      if (!result.error) displayTable(result.rows, limit);
-      if (result.error) process.exit(1);
-    } catch (err) {
-      displayError(err instanceof Error ? err : new Error(String(err)));
-      process.exit(1);
-    }
-  }
-}
-main().catch((err) => {
-  displayError(err instanceof Error ? err : new Error(String(err)));
-  process.exit(1);
-});