yamchart 0.3.6 → 0.3.9

package/dist/{dev-PWY7UVIO.js → dev-CPZ3M5EE.js}

@@ -6,7 +6,7 @@ import {
   ScheduleSchema,
   loadEnvFile,
   validateProject
-} from "./chunk-7HKIUUVE.js";
+} from "./chunk-ENOTMVPI.js";
 import {
   AuthDatabase,
   generateSessionToken,
@@ -289,6 +289,10 @@ var ConfigLoader = class {
     return this.models.get(name);
   }
   getDefaultConnection() {
+    const envConnection = process.env.YAMCHART_CONNECTION;
+    if (envConnection) {
+      return this.connections.get(envConnection);
+    }
     const defaultName = this.project?.defaults?.connection;
     if (defaultName) {
       return this.connections.get(defaultName);
@@ -529,6 +533,49 @@ function createConnectorFromConfig(connection, options) {
       throw new Error(`Unsupported connection type: ${connection.type}`);
   }
 }
+function buildConnectionInfo(connection) {
+  const info2 = {
+    name: connection.name,
+    type: connection.type
+  };
+  switch (connection.type) {
+    case "duckdb": {
+      const c = connection;
+      info2.path = c.config.path;
+      break;
+    }
+    case "postgres": {
+      const c = connection;
+      info2.host = c.config.host;
+      info2.port = c.config.port;
+      info2.database = c.config.database;
+      info2.schema = c.config.schema;
+      break;
+    }
+    case "mysql": {
+      const c = connection;
+      info2.host = c.config.host;
+      info2.port = c.config.port;
+      info2.database = c.config.database;
+      break;
+    }
+    case "sqlite": {
+      const c = connection;
+      info2.path = c.config.path;
+      break;
+    }
+    case "snowflake": {
+      const c = connection;
+      info2.account = c.config.account;
+      info2.warehouse = c.config.warehouse;
+      info2.database = c.config.database;
+      info2.schema = c.config.schema;
+      info2.role = c.config.role;
+      break;
+    }
+  }
+  return info2;
+}
 async function testConnection(connection, options) {
   const start = performance.now();
   let connector = null;
@@ -799,12 +846,30 @@ async function dashboardRoutes(fastify, options) {
   });
   fastify.post("/api/dashboards/:id", async (request, reply) => {
     const { id } = request.params;
-    const { layout, message } = request.body;
+    const { layout, tab, tabLayout, message } = request.body;
     const dashboard = configLoader.getDashboardByName(id);
     if (!dashboard) {
       return reply.status(404).send({ error: `Dashboard not found: ${id}` });
     }
-    const updated = { ...dashboard, layout };
+    let updated;
+    if (dashboard.tabs) {
+      if (!tab || !tabLayout) {
+        return reply.status(400).send({ error: 'Tabbed dashboard requires "tab" and "tabLayout" fields' });
+      }
+      const tabIndex = dashboard.tabs.findIndex((t) => t.name === tab);
+      if (tabIndex === -1) {
+        return reply.status(400).send({ error: `Tab not found: ${tab}` });
+      }
+      const existingTab = dashboard.tabs[tabIndex];
+      const newTabs = [...dashboard.tabs];
+      newTabs[tabIndex] = { ...existingTab, layout: tabLayout };
+      updated = { ...dashboard, tabs: newTabs };
+    } else {
+      if (!layout) {
+        return reply.status(400).send({ error: 'Non-tabbed dashboard requires "layout" field' });
+      }
+      updated = { ...dashboard, layout };
+    }
     const filePath = join3(projectDir, "dashboards", `${id}.yaml`);
     await writeFile(filePath, stringifyYaml(updated));
     await configLoader.load();
@@ -818,7 +883,7 @@ async function dashboardRoutes(fastify, options) {
   });
   fastify.post("/api/dashboards/:id/warm-cache", async (request, reply) => {
     const { id } = request.params;
-    const { params = {} } = request.body;
+    const { params = {}, tab } = request.body;
     const dashboard = configLoader.getDashboardByName(id);
     if (!dashboard) {
       return reply.status(404).send({ error: `Dashboard not found: ${id}` });
@@ -827,12 +892,28 @@ async function dashboardRoutes(fastify, options) {
       return reply.status(500).send({ error: "Query service not available" });
     }
     const chartRefs = [];
-    for (const row of dashboard.layout.rows) {
-      for (const widget of row.widgets) {
-        if (widget.type === "chart" && widget.ref) {
-          chartRefs.push(widget.ref);
+    const extractFromLayout = (layout) => {
+      for (const row of layout.rows) {
+        for (const widget of row.widgets) {
+          if (widget.type === "chart" && widget.ref) {
+            chartRefs.push(widget.ref);
+          }
         }
       }
+    };
+    if (dashboard.tabs) {
+      if (tab) {
+        const matchingTab = dashboard.tabs.find((t) => t.name === tab);
+        if (matchingTab) {
+          extractFromLayout(matchingTab.layout);
+        }
+      } else {
+        for (const t of dashboard.tabs) {
+          extractFromLayout(t.layout);
+        }
+      }
+    } else if (dashboard.layout) {
+      extractFromLayout(dashboard.layout);
     }
     const results = await Promise.all(chartRefs.map(async (chartRef) => {
       const chart = configLoader.getChartByName(chartRef);
@@ -13326,32 +13407,8 @@ async function createServer(options) {
   if (!defaultConnection) {
     throw new Error("No connection configured");
   }
-  let connector;
-  if (defaultConnection.type === "duckdb") {
-    const duckdbConfig = defaultConnection;
-    const dbPath = duckdbConfig.config.path.startsWith("/") ? duckdbConfig.config.path : join4(projectDir, duckdbConfig.config.path);
-    connector = new DuckDBConnector({ path: dbPath });
-    await connector.connect();
-  } else if (defaultConnection.type === "postgres") {
-    const pgConnection = defaultConnection;
-    const credentials = resolvePostgresAuth(pgConnection);
-    connector = new PostgresConnector({
-      host: pgConnection.config.host,
-      port: pgConnection.config.port,
-      database: pgConnection.config.database,
-      schema: pgConnection.config.schema,
-      ssl: pgConnection.config.ssl,
-      user: credentials.user,
-      password: credentials.password,
-      min: pgConnection.pool?.min_connections,
-      max: pgConnection.pool?.max_connections,
-      idleTimeoutMillis: pgConnection.pool?.idle_timeout,
-      statementTimeout: pgConnection.query?.timeout
-    });
-    await connector.connect();
-  } else {
-    throw new Error(`Unsupported connection type: ${defaultConnection.type}`);
-  }
+  const connector = createConnectorFromConfig(defaultConnection, { projectDir });
+  await connector.connect();
   const project = configLoader.getProject();
   const cacheTtl = project.defaults?.cache_ttl ? parseTtl2(project.defaults.cache_ttl) : 5 * 60 * 1e3;
   const cache = new MemoryCache({
@@ -13383,26 +13440,16 @@ async function createServer(options) {
   if (schedules.length > 0) {
     schedulerService.start(schedules);
   }
-  const connectionInfo = {
-    name: defaultConnection.name,
-    type: defaultConnection.type,
-    ...defaultConnection.type === "duckdb" && {
-      path: defaultConnection.config.path
-    },
-    ...defaultConnection.type === "postgres" && {
-      host: defaultConnection.config.host,
-      port: defaultConnection.config.port,
-      database: defaultConnection.config.database,
-      schema: defaultConnection.config.schema
-    }
-  };
-  fastify.get("/api/health", async () => ({
-    status: "ok",
-    version: VERSION,
-    project: project.name,
-    environment: process.env.NODE_ENV || "development",
-    connection: connectionInfo
-  }));
+  fastify.get("/api/health", async () => {
+    const currentConnection = configLoader.getDefaultConnection();
+    return {
+      status: "ok",
+      version: VERSION,
+      project: configLoader.getProject().name,
+      environment: process.env.NODE_ENV || "development",
+      connection: currentConnection ? buildConnectionInfo(currentConnection) : void 0
+    };
+  });
   if (authDb) {
     const secureCookies = process.env.NODE_ENV === "production";
     const sessionTtlMs = options.localAuth.sessionTtlMs;
@@ -13554,24 +13601,41 @@ async function runDevServer(projectDir, options) {
   }
   success(`Validation passed (${validation.stats.passed} files)`);
   newline();
-  const spinner2 = spinner("Starting server...");
-  let server;
+  let usesBrowserAuth = false;
+  let localAuth;
   try {
-    let localAuth;
-    try {
-      const { readFileSync } = await import("fs");
-      const { parse } = await import("yaml");
-      const raw = readFileSync(resolve(projectDir, "yamchart.yaml"), "utf-8");
-      const projectConfig = parse(raw);
-      if (projectConfig?.auth?.enabled) {
-        localAuth = {
-          enabled: true,
-          dbPath: projectConfig.auth.db_path ? resolve(projectConfig.auth.db_path.replace(/^~/, homedir())) : resolve(homedir(), ".yamchart", "auth.db"),
-          sessionTtlMs: projectConfig.auth.session_ttl ? parseTtl(projectConfig.auth.session_ttl) : 30 * 24 * 60 * 60 * 1e3
-        };
+    const { readFileSync } = await import("fs");
+    const { parse } = await import("yaml");
+    const raw = readFileSync(resolve(projectDir, "yamchart.yaml"), "utf-8");
+    const projectConfig = parse(raw);
+    if (projectConfig?.auth?.enabled) {
+      localAuth = {
+        enabled: true,
+        dbPath: projectConfig.auth.db_path ? resolve(projectConfig.auth.db_path.replace(/^~/, homedir())) : resolve(homedir(), ".yamchart", "auth.db"),
+        sessionTtlMs: projectConfig.auth.session_ttl ? parseTtl(projectConfig.auth.session_ttl) : 30 * 24 * 60 * 60 * 1e3
+      };
+    }
+    const connectionDir = resolve(projectDir, "connections");
+    const targetConn = process.env.YAMCHART_CONNECTION || projectConfig?.defaults?.connection;
+    if (targetConn) {
+      try {
+        const connRaw = readFileSync(resolve(connectionDir, `${targetConn}.yaml`), "utf-8");
+        const connConfig = parse(connRaw);
+        if (connConfig?.auth?.type === "externalbrowser") {
+          usesBrowserAuth = true;
+        }
+      } catch {
       }
-    } catch {
     }
+  } catch {
+  }
+  if (usesBrowserAuth) {
+    info("Snowflake SSO \u2014 opening browser for authentication...");
+    newline();
+  }
+  const spinner2 = spinner("Starting server...");
+  let server;
+  try {
     server = await createServer({
       projectDir,
       port: options.port,
@@ -13621,4 +13685,4 @@ async function runDevServer(projectDir, options) {
 export {
   runDevServer
 };
-//# sourceMappingURL=dev-PWY7UVIO.js.map
+//# sourceMappingURL=dev-CPZ3M5EE.js.map