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

package/dist/cli/index.d.ts

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

package/dist/cli/index.js

@@ -0,0 +1,644 @@
+#!/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, connectionId) {
+  const envVarName = entry.envVars[key];
+  if (!envVarName) {
+    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 connection "${connectionId}", key "${key}") is not set`);
+  }
+  return value;
+}
+
+// src/connector-client/bigquery.ts
+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 connection "${connectionId}"`
+    );
+  }
+  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, 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) {
+      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(connectionId) {
+    const connections = loadConnections();
+    const entry = connections[connectionId];
+    if (!entry) {
+      throw new Error(`connection '${connectionId}' not found in .squadbase/connections.json`);
+    }
+    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 (connectorSlug === "bigquery") {
+      return { client: createBigQueryClient(entry, connectionId), connectorSlug };
+    }
+    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 connection '${connectionId}'`);
+      }
+      const connectionUrl = process.env[urlEnvName];
+      if (!connectionUrl) {
+        throw new Error(
+          `environment variable '${urlEnvName}' (mapped from connection '${connectionId}') is not set`
+        );
+      }
+      const client = createPostgreSQLClient(connectionUrl);
+      clientCache.set(connectionId, client);
+      return { client, connectorSlug };
+    }
+    throw new Error(
+      `connector type '${connectorSlug}' 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, connectorSlug } = await getClient(def.connectionId);
+    const isExternal = connectorSlug === "snowflake" || connectorSlug === "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);
+});

package/dist/index.js

@@ -41,7 +41,7 @@ function resolveEnvVar(entry, key, connectionId) {
 // src/connector-client/bigquery.ts
 function createBigQueryClient(entry, connectionId) {
   const projectId = resolveEnvVar(entry, "project-id", connectionId);
-  const serviceAccountJsonBase64 = resolveEnvVar(entry, "service-account-json-base64", connectionId);
+  const serviceAccountJsonBase64 = resolveEnvVar(entry, "service-account-key-json-base64", connectionId);
   const serviceAccountJson = Buffer.from(serviceAccountJsonBase64, "base64").toString("utf-8");
   let gcpCredentials;
   try {
@@ -110,7 +110,7 @@ function createConnectorRegistry() {
   let connectionsCache = null;
   const clientCache = /* @__PURE__ */ new Map();
   function getConnectionsFilePath() {
-    return process.env.CONNECTIONS_PATH ?? path.join(process.cwd(), "../../.squadbase/connections.json");
+    return process.env.CONNECTIONS_PATH ?? path.join(process.cwd(), ".squadbase/connections.json");
   }
   function loadConnections() {
     if (connectionsCache !== null) return connectionsCache;
@@ -175,7 +175,7 @@ function createConnectorRegistry() {
   }
   function watchConnectionsFile2() {
     const filePath = getConnectionsFilePath();
-    const envPath = path.join(process.cwd(), "..", "..", ".env");
+    const envPath = path.join(process.cwd(), ".env");
     try {
       fsWatch(filePath, { persistent: false }, () => {
         console.log("[connector-client] connections.json changed, clearing cache");
@@ -726,7 +726,7 @@ apiApp.route("/data-source", data_source_default);
 apiApp.route("/data-source-meta", data_source_meta_default);
 apiApp.route("/cache", cache_default);
 apiApp.route("/", pages_default);
-reloadEnvFile(path4.join(process.cwd(), "..", "..", ".env"));
+reloadEnvFile(path4.join(process.cwd(), ".env"));
 await initialize();
 startWatching();
 watchConnectionsFile();

package/dist/main.js

@@ -41,7 +41,7 @@ function resolveEnvVar(entry, key, connectionId) {
 // src/connector-client/bigquery.ts
 function createBigQueryClient(entry, connectionId) {
   const projectId = resolveEnvVar(entry, "project-id", connectionId);
-  const serviceAccountJsonBase64 = resolveEnvVar(entry, "service-account-json-base64", connectionId);
+  const serviceAccountJsonBase64 = resolveEnvVar(entry, "service-account-key-json-base64", connectionId);
   const serviceAccountJson = Buffer.from(serviceAccountJsonBase64, "base64").toString("utf-8");
   let gcpCredentials;
   try {
@@ -110,7 +110,7 @@ function createConnectorRegistry() {
   let connectionsCache = null;
   const clientCache = /* @__PURE__ */ new Map();
   function getConnectionsFilePath() {
-    return process.env.CONNECTIONS_PATH ?? path.join(process.cwd(), "../../.squadbase/connections.json");
+    return process.env.CONNECTIONS_PATH ?? path.join(process.cwd(), ".squadbase/connections.json");
   }
   function loadConnections() {
     if (connectionsCache !== null) return connectionsCache;
@@ -175,7 +175,7 @@ function createConnectorRegistry() {
   }
   function watchConnectionsFile2() {
     const filePath = getConnectionsFilePath();
-    const envPath = path.join(process.cwd(), "..", "..", ".env");
+    const envPath = path.join(process.cwd(), ".env");
     try {
       fsWatch(filePath, { persistent: false }, () => {
         console.log("[connector-client] connections.json changed, clearing cache");
@@ -726,7 +726,7 @@ apiApp.route("/data-source", data_source_default);
 apiApp.route("/data-source-meta", data_source_meta_default);
 apiApp.route("/cache", cache_default);
 apiApp.route("/", pages_default);
-reloadEnvFile(path4.join(process.cwd(), "..", "..", ".env"));
+reloadEnvFile(path4.join(process.cwd(), ".env"));
 await initialize();
 startWatching();
 watchConnectionsFile();

package/dist/vite-plugin.js

@@ -41,7 +41,7 @@ function resolveEnvVar(entry, key, connectionId) {
 // src/connector-client/bigquery.ts
 function createBigQueryClient(entry, connectionId) {
   const projectId = resolveEnvVar(entry, "project-id", connectionId);
-  const serviceAccountJsonBase64 = resolveEnvVar(entry, "service-account-json-base64", connectionId);
+  const serviceAccountJsonBase64 = resolveEnvVar(entry, "service-account-key-json-base64", connectionId);
   const serviceAccountJson = Buffer.from(serviceAccountJsonBase64, "base64").toString("utf-8");
   let gcpCredentials;
   try {
@@ -110,7 +110,7 @@ function createConnectorRegistry() {
   let connectionsCache = null;
   const clientCache = /* @__PURE__ */ new Map();
   function getConnectionsFilePath() {
-    return process.env.CONNECTIONS_PATH ?? path.join(process.cwd(), "../../.squadbase/connections.json");
+    return process.env.CONNECTIONS_PATH ?? path.join(process.cwd(), ".squadbase/connections.json");
   }
   function loadConnections() {
     if (connectionsCache !== null) return connectionsCache;
@@ -175,7 +175,7 @@ function createConnectorRegistry() {
   }
   function watchConnectionsFile2() {
     const filePath = getConnectionsFilePath();
-    const envPath = path.join(process.cwd(), "..", "..", ".env");
+    const envPath = path.join(process.cwd(), ".env");
     try {
       fsWatch(filePath, { persistent: false }, () => {
         console.log("[connector-client] connections.json changed, clearing cache");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squadbase/vite-server",
-  "version": "0.0.1-build-5",
+  "version": "0.0.1-build-7",
   "type": "module",
   "exports": {
     ".": {
@@ -20,7 +20,9 @@
       "types": "./dist/vite-plugin.d.ts"
     }
   },
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "publishConfig": {
     "access": "public"
   },