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

package/dist/cli/index.js

@@ -102,29 +102,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-key-json-base64", connectionId);
   const serviceAccountJson = Buffer.from(serviceAccountJsonBase64, "base64").toString("utf-8");
   let gcpCredentials;
   try {
     gcpCredentials = JSON.parse(serviceAccountJson);
   } catch {
     throw new Error(
-      `BigQuery service account JSON (decoded from base64) is not valid JSON for slug "${slug}"`
+      `BigQuery service account JSON (decoded from base64) is not valid JSON for connection "${connectionId}"`
     );
   }
   return {
@@ -139,12 +139,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) {
@@ -199,53 +199,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) {
@@ -351,8 +336,8 @@ function createStubContext(params) {
 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";
+    const { client, connectorSlug } = await getClient(def.connectionId);
+    const isExternal = connectorSlug === "snowflake" || connectorSlug === "bigquery";
     let queryText;
     let queryValues;
     if (isExternal) {

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-key-json-base64", connectionId);
   const serviceAccountJson = Buffer.from(serviceAccountJsonBase64, "base64").toString("utf-8");
   let gcpCredentials;
   try {
     gcpCredentials = JSON.parse(serviceAccountJson);
   } catch {
     throw new Error(
-      `BigQuery service account JSON (decoded from base64) is not valid JSON for 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-key-json-base64", connectionId);
   const serviceAccountJson = Buffer.from(serviceAccountJsonBase64, "base64").toString("utf-8");
   let gcpCredentials;
   try {
     gcpCredentials = JSON.parse(serviceAccountJson);
   } catch {
     throw new Error(
-      `BigQuery service account JSON (decoded from base64) is not valid JSON for 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-key-json-base64", connectionId);
   const serviceAccountJson = Buffer.from(serviceAccountJsonBase64, "base64").toString("utf-8");
   let gcpCredentials;
   try {
     gcpCredentials = JSON.parse(serviceAccountJson);
   } catch {
     throw new Error(
-      `BigQuery service account JSON (decoded from base64) is not valid JSON for 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-6",
   "type": "module",
   "exports": {
     ".": {
@@ -20,7 +20,9 @@
       "types": "./dist/vite-plugin.d.ts"
     }
   },
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "publishConfig": {
     "access": "public"
   },