yamchart 0.8.8 → 0.9.0

package/dist/{dev-JUA73B6D.js → dev-6QGAB4ZH.js}

@@ -1,7 +1,7 @@
 import {
   loadEnvFile,
   validateProject
-} from "./chunk-232AMQ5T.js";
+} from "./chunk-G57J2WQM.js";
 import {
   box,
   detail,
@@ -23,11 +23,11 @@ import {
   SemanticQuerySchema,
   deepMerge,
   resolveProjectConfig
-} from "./chunk-D3ELUYYE.js";
+} from "./chunk-E2QN2M7S.js";
 import {
   StreamingChatAgent,
   filterCatalogEntries
-} from "./chunk-77U26A7F.js";
+} from "./chunk-ZA6AOQVZ.js";
 import {
   AuthDatabase,
   generateSessionToken,
@@ -57,7 +57,7 @@ import {
   resolveMySQLAuth,
   resolvePostgresAuth,
   resolveSnowflakeAuth
-} from "./chunk-5N3FYFBV.js";
+} from "./chunk-CWAWATL4.js";
 import {
   SemanticModelBuilder,
   SemanticQueryCompiler,
@@ -804,12 +804,18 @@ function parseTtl2(ttl) {
 }
 
 // ../server/dist/services/query-service.js
+function quoteIdentifier(name, dialect) {
+  if (dialect === "mysql")
+    return `\`${name.replace(/`/g, "``")}\``;
+  return `"${name.replace(/"/g, '""')}"`;
+}
 var QueryService = class {
   compiler;
   connector;
   cache;
   models;
   refs;
+  dialect;
   constructor(config) {
     this.compiler = new QueryCompiler({
       models: config.models,
@@ -819,6 +825,7 @@ var QueryService = class {
     this.cache = config.cache;
     this.models = new Map(Object.entries(config.models));
     this.refs = config.refs;
+    this.dialect = config.dialect ?? "duckdb";
   }
   async executeChart(chart, params, userContext) {
     const compiled = this.compiler.compile(chart, params, userContext);
@@ -850,6 +857,120 @@ var QueryService = class {
       compiledSql: compiled.sql
     };
   }
+  /**
+   * Execute a table chart with server-side pagination.
+   * Wraps the compiled SQL with LIMIT/OFFSET and runs a parallel COUNT(*) query.
+   * Optionally computes summary aggregations for specified columns.
+   */
+  async executeChartPaginated(chart, params, options, userContext) {
+    const compiled = this.compiler.compile(chart, params, userContext);
+    const baseSql = compiled.sql;
+    const q = quoteIdentifier;
+    const d = this.dialect;
+    let orderBy = "";
+    if (options.sortField) {
+      const cleanField = options.sortField.replace(/[^\w\s]/g, "");
+      if (cleanField.length > 0) {
+        orderBy = `ORDER BY ${q(cleanField, d)} ${options.sortDirection === "desc" ? "DESC" : "ASC"}`;
+      }
+    }
+    const offset = options.page * options.pageSize;
+    const dataSql = `SELECT * FROM (${baseSql}) _t ${orderBy} LIMIT ${options.pageSize} OFFSET ${offset}`;
+    const countCacheKey = `${compiled.cacheKey}:count`;
+    let totalCount;
+    const cachedCount = await this.cache.get(countCacheKey);
+    if (cachedCount) {
+      totalCount = cachedCount.rowCount;
+    } else {
+      const countSql = `SELECT COUNT(*) AS _count FROM (${baseSql}) _t`;
+      const countResult = await this.connector.execute(countSql);
+      totalCount = Number(countResult.rows[0]?._count ?? 0);
+      await this.cache.set(countCacheKey, {
+        columns: [],
+        rows: [],
+        rowCount: totalCount,
+        durationMs: countResult.durationMs,
+        cachedAt: Date.now()
+      });
+    }
+    let summaryValues;
+    if (options.summaryColumns && options.summaryColumns.length > 0) {
+      const summaryCacheKey = `${compiled.cacheKey}:summary`;
+      const cachedSummary = await this.cache.get(summaryCacheKey);
+      if (cachedSummary && cachedSummary.rows[0]) {
+        summaryValues = cachedSummary.rows[0];
+      } else {
+        const aggExprs = options.summaryColumns.map(({ field, summary }) => {
+          const col = q(field, d);
+          switch (summary) {
+            case "sum":
+              return `SUM(${col}) AS ${q(`_sum_${field}`, d)}`;
+            case "avg":
+              return `AVG(${col}) AS ${q(`_avg_${field}`, d)}`;
+            case "min":
+              return `MIN(${col}) AS ${q(`_min_${field}`, d)}`;
+            case "max":
+              return `MAX(${col}) AS ${q(`_max_${field}`, d)}`;
+            case "count":
+              return `COUNT(${col}) AS ${q(`_count_${field}`, d)}`;
+            default:
+              return null;
+          }
+        }).filter(Boolean);
+        if (aggExprs.length > 0) {
+          const summarySql = `SELECT ${aggExprs.join(", ")} FROM (${baseSql}) _t`;
+          const summaryResult = await this.connector.execute(summarySql);
+          if (summaryResult.rows[0]) {
+            summaryValues = {};
+            for (const { field, summary } of options.summaryColumns) {
+              const key = `_${summary}_${field}`;
+              summaryValues[`${summary}:${field}`] = Number(summaryResult.rows[0][key] ?? 0);
+            }
+            await this.cache.set(summaryCacheKey, {
+              columns: [],
+              rows: [summaryValues],
+              rowCount: 0,
+              durationMs: summaryResult.durationMs,
+              cachedAt: Date.now()
+            });
+          }
+        }
+      }
+    }
+    const result = await this.connector.execute(dataSql);
+    return {
+      ...result,
+      cached: false,
+      cacheKey: compiled.cacheKey,
+      compiledSql: dataSql,
+      totalCount,
+      page: options.page,
+      pageSize: options.pageSize,
+      summaryValues
+    };
+  }
+  /**
+   * Execute a chart query for CSV export with a bounded row limit.
+   * Returns full QueryResult — caller streams to HTTP response.
+   */
+  async executeChartForExport(chart, params, maxRows, userContext) {
+    const compiled = this.compiler.compile(chart, params, userContext);
+    const sql = `SELECT * FROM (${compiled.sql}) _t LIMIT ${maxRows}`;
+    const result = await this.connector.execute(sql);
+    return {
+      ...result,
+      cached: false,
+      cacheKey: compiled.cacheKey,
+      compiledSql: sql
+    };
+  }
+  /**
+   * Compile a chart query without executing it.
+   * Returns the compiled SQL and cache key.
+   */
+  compileChart(chart, params, userContext) {
+    return this.compiler.compile(chart, params, userContext);
+  }
   invalidateChart(chartName) {
     this.cache.invalidatePattern(`${chartName}:*`);
   }
@@ -1132,6 +1253,12 @@ function classifyError(error2) {
   }
   return "query_error";
 }
+function escapeCSVField(value) {
+  if (value.includes(",") || value.includes('"') || value.includes("\n") || value.includes("\r")) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
 function getUserContext(request) {
   const user = request.user;
   if (!user)
@@ -1196,15 +1323,78 @@ async function chartRoutes(fastify, options) {
   });
   fastify.post("/api/charts/:name/query", async (request, reply) => {
     const { name } = request.params;
-    const params = request.body ?? {};
+    const rawParams = request.body ?? {};
     const includeConfig = request.query.includeConfig === "true";
     const chart = configLoader.getChartByName(name);
     if (!chart) {
       const resp = chartNotFoundResponse(configLoader, name);
       return reply.status(resp.status).send(resp.body);
     }
+    const { _page, _page_size, _sort_field, _sort_dir, _server_paginated, ...params } = rawParams;
     try {
-      const result = await queryService.executeChart(chart, params, getUserContext(request));
+      const isTable = chart.chart?.type === "table";
+      const project = configLoader.getProject();
+      const chartMaxRows = chart.chart?.max_rows;
+      const maxDisplayRows = chartMaxRows ?? project?.defaults?.table?.max_display_rows ?? 1e4;
+      const forceServerSide = chart.chart?.pagination && chart.chart.pagination?.server_side === true;
+      if (isTable && _server_paginated) {
+        const page = Number(_page) || 0;
+        const pageSize = Number(_page_size) || 50;
+        const columns = chart.chart?.columns ?? [];
+        const summaryColumns = columns.filter((c) => c.summary).map((c) => ({ field: c.field, summary: c.summary }));
+        const paginatedResult = await queryService.executeChartPaginated(chart, params, { page, pageSize, sortField: _sort_field, sortDirection: _sort_dir, summaryColumns }, getUserContext(request));
+        reply.header("X-Cache", "MISS");
+        reply.header("X-Query-Duration-Ms", paginatedResult.durationMs.toFixed(0));
+        const response2 = {
+          columns: paginatedResult.columns,
+          rows: paginatedResult.rows,
+          meta: {
+            cached: paginatedResult.cached,
+            durationMs: paginatedResult.durationMs,
+            rowCount: paginatedResult.rowCount,
+            cacheKey: paginatedResult.cacheKey,
+            compiledSql: paginatedResult.compiledSql,
+            serverPaginated: true,
+            totalCount: paginatedResult.totalCount,
+            page,
+            pageSize
+          },
+          ...paginatedResult.summaryValues ? { summaryValues: paginatedResult.summaryValues } : {}
+        };
+        if (includeConfig) {
+          response2.config = {
+            name: chart.name,
+            title: chart.title,
+            description: chart.description,
+            parameters: chart.parameters ?? [],
+            chart: chart.chart,
+            drillDown: chart.drillDown
+          };
+        }
+        return response2;
+      }
+      let result;
+      let serverPaginated = false;
+      let totalCount;
+      if (isTable) {
+        const probeResult = await queryService.executeChartForExport(chart, params, maxDisplayRows + 1, getUserContext(request));
+        if (probeResult.rowCount > maxDisplayRows || forceServerSide) {
+          serverPaginated = true;
+          if (probeResult.rowCount > maxDisplayRows) {
+            const compiled = queryService.compileChart(chart, params, getUserContext(request));
+            const countResult = await queryService.executeRawSql(`SELECT COUNT(*) AS _count FROM (${compiled.sql}) _t`);
+            totalCount = Number(countResult.rows[0]?._count ?? 0);
+            result = { ...probeResult, rows: probeResult.rows.slice(0, maxDisplayRows), rowCount: maxDisplayRows };
+          } else {
+            totalCount = probeResult.rowCount;
+            result = probeResult;
+          }
+        } else {
+          result = probeResult;
+        }
+      } else {
+        result = await queryService.executeChart(chart, params, getUserContext(request));
+      }
       let comparison = void 0;
       if (chart.chart?.type === "kpi" && chart.chart?.comparison?.period === "previous") {
         let startDate = params.start_date;
@@ -1247,6 +1437,54 @@ async function chartRoutes(fastify, options) {
           }
         }
       }
+      const compareConfig = chart.chart?.compare;
+      let compareData;
+      if (compareConfig && compareConfig.length > 0) {
+        let startDate = params.start_date;
+        let endDate = params.end_date;
+        const dateRange = params.date_range;
+        if (!startDate || !endDate) {
+          if (isRelativeDateRange(params.date_range)) {
+            const resolved = expandRelativeDateRange(params.date_range);
+            startDate = resolved.start_date;
+            endDate = resolved.end_date;
+          } else if (isCustomDateRange(params.date_range)) {
+            const resolved = expandCustomDateRange(params.date_range);
+            startDate = resolved.start_date;
+            endDate = resolved.end_date;
+          } else if (dateRange && isDatePreset(dateRange)) {
+            const resolved = expandDatePreset(dateRange);
+            if (resolved) {
+              startDate = resolved.start_date;
+              endDate = resolved.end_date;
+            }
+          }
+        }
+        if (startDate && endDate) {
+          compareData = [];
+          for (const comp of compareConfig) {
+            try {
+              const periodMap = {
+                previous_week: "last_7_days",
+                previous_month: "last_30_days",
+                previous_quarter: "last_90_days",
+                previous_year: "last_365_days"
+              };
+              const prev = computePreviousPeriod(startDate, endDate, periodMap[comp.period] ?? comp.period);
+              const prevLabel = comp.label ?? comp.period.replace(/_/g, " ");
+              const { date_range: _, ...restParams } = params;
+              const prevParams = { ...restParams, start_date: prev.start_date, end_date: prev.end_date };
+              const prevResult = await queryService.executeChart(chart, prevParams, getUserContext(request));
+              compareData.push({
+                period: comp.period,
+                label: prevLabel,
+                rows: prevResult.rows
+              });
+            } catch {
+            }
+          }
+        }
+      }
       reply.header("X-Cache", result.cached ? "HIT" : "MISS");
       reply.header("X-Query-Duration-Ms", result.durationMs.toFixed(0));
       const meta = {
@@ -1254,7 +1492,8 @@ async function chartRoutes(fastify, options) {
         durationMs: result.durationMs,
         rowCount: result.rowCount,
         cacheKey: result.cacheKey,
-        compiledSql: result.compiledSql
+        compiledSql: result.compiledSql,
+        ...serverPaginated ? { serverPaginated: true, totalCount } : {}
       };
       const response = {
         columns: result.columns,
@@ -1274,6 +1513,9 @@ async function chartRoutes(fastify, options) {
       if (comparison) {
         response.comparison = comparison;
       }
+      if (compareData && compareData.length > 0) {
+        response.compareData = compareData;
+      }
       let goalData = void 0;
       const goals = chart.chart?.goals;
       const modelGoal = goals?.find((g) => g.type === "model" && g.source?.model);
@@ -1331,6 +1573,38 @@ async function chartRoutes(fastify, options) {
       return reply.status(500).send({ error: message, errorType: classifyError(error2) });
     }
   });
+  fastify.get("/api/charts/:name/export", async (request, reply) => {
+    const { name } = request.params;
+    const params = { ...request.query };
+    const chart = configLoader.getChartByName(name);
+    if (!chart) {
+      const resp = chartNotFoundResponse(configLoader, name);
+      return reply.status(resp.status).send(resp.body);
+    }
+    const project = configLoader.getProject();
+    const chartExportConfig = chart.chart?.export;
+    if (chartExportConfig?.enabled === false) {
+      return reply.status(403).send({ error: "Export is disabled for this chart", errorType: "validation_error" });
+    }
+    const maxExportRows = chartExportConfig?.max_rows ?? project?.defaults?.table?.max_export_rows ?? 5e5;
+    try {
+      const result = await queryService.executeChartForExport(chart, params, maxExportRows, getUserContext(request));
+      reply.header("Content-Type", "text/csv; charset=utf-8");
+      reply.header("Content-Disposition", `attachment; filename="${name}.csv"`);
+      reply.header("X-Total-Rows", String(result.rowCount));
+      const columns = result.columns.map((c) => c.name);
+      const headerLine = columns.map(escapeCSVField).join(",");
+      const lines = [headerLine];
+      for (const row of result.rows) {
+        const line = columns.map((col) => escapeCSVField(String(row[col] ?? ""))).join(",");
+        lines.push(line);
+      }
+      return reply.send(lines.join("\n"));
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : "Export failed";
+      return reply.status(500).send({ error: message, errorType: classifyError(error2) });
+    }
+  });
   fastify.post("/api/charts/batch", async (request, reply) => {
     const { charts, includeConfig } = request.body;
     if (!charts || !Array.isArray(charts)) {
@@ -14317,7 +14591,7 @@ async function chatRoutes(fastify, options) {
         systemParts.push("Output ONLY the new text to insert. Do NOT repeat the existing content.");
       }
       const systemPrompt = systemParts.join("\n");
-      const { AnthropicProvider } = await import("./dist-GVNWQXFR.js");
+      const { AnthropicProvider } = await import("./dist-7CRX2GIR.js");
       const provider = new AnthropicProvider(apiKey);
       const response = await provider.chat({
         system: systemPrompt,
@@ -14653,7 +14927,8 @@ async function createServer(options) {
     connector,
     cache,
     models,
-    refs
+    refs,
+    dialect: defaultConnection.type
   });
   const semanticService = new SemanticService({
     projectDir,
@@ -14891,7 +15166,7 @@ async function runDevServer(projectDir, options) {
   try {
     const { readFileSync: readFileSync2 } = await import("fs");
     const { parse: parse2 } = await import("yaml");
-    const { resolveProjectConfig: resolveProjectConfig2, deepMerge: deepMerge3 } = await import("./dist-PINRLZVT.js");
+    const { resolveProjectConfig: resolveProjectConfig2, deepMerge: deepMerge3 } = await import("./dist-4GUE24QV.js");
     const raw = readFileSync2(resolve2(projectDir, "yamchart.yaml"), "utf-8");
     const rawConfig = parse2(raw);
     const resolvedEnv = options.env || process.env.YAMCHART_ENV || void 0;
@@ -14931,21 +15206,33 @@ async function runDevServer(projectDir, options) {
   }
   const spinner2 = spinner("Starting server...");
   let server;
-  try {
-    server = await createServer({
-      projectDir,
-      port: options.port,
-      watch: true,
-      serveStatic: !options.apiOnly,
-      localAuth,
-      env: options.env
-    });
-    await server.start();
-    spinner2.stop();
-  } catch (err) {
-    spinner2.fail("Failed to start server");
-    error(err instanceof Error ? err.message : "Unknown error");
-    process.exit(1);
+  let actualPort = options.port;
+  const MAX_PORT_ATTEMPTS = 10;
+  for (let attempt = 0; attempt < MAX_PORT_ATTEMPTS; attempt++) {
+    try {
+      server = await createServer({
+        projectDir,
+        port: actualPort,
+        watch: true,
+        serveStatic: !options.apiOnly,
+        localAuth,
+        env: options.env
+      });
+      await server.start();
+      spinner2.stop();
+      if (actualPort !== options.port) {
+        info(`Port ${options.port} is in use, starting on port ${actualPort}`);
+      }
+      break;
+    } catch (err) {
+      if (err && typeof err === "object" && "code" in err && err.code === "EADDRINUSE" && attempt < MAX_PORT_ATTEMPTS - 1) {
+        actualPort++;
+        continue;
+      }
+      spinner2.fail("Failed to start server");
+      error(err instanceof Error ? err.message : "Unknown error");
+      process.exit(1);
+    }
   }
   const project = server.configLoader.getProject();
   const charts = server.configLoader.getCharts();
@@ -14954,8 +15241,8 @@ async function runDevServer(projectDir, options) {
   box([
     `Yamchart v${options.version}`,
     ``,
-    `Dashboard:  http://localhost:${options.port}`,
-    `API:        http://localhost:${options.port}/api`,
+    `Dashboard:  http://localhost:${actualPort}`,
+    `API:        http://localhost:${actualPort}/api`,
     ``,
     `Project:    ${project.name}`,
     `Charts:     ${charts.length} loaded`,
@@ -14966,7 +15253,7 @@ async function runDevServer(projectDir, options) {
   ]);
   newline();
   if (options.open && !options.apiOnly) {
-    const url = `http://localhost:${options.port}`;
+    const url = `http://localhost:${actualPort}`;
     const { exec } = await import("child_process");
     const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
     exec(`${command} ${url}`);
@@ -14983,4 +15270,4 @@ async function runDevServer(projectDir, options) {
 export {
   runDevServer
 };
-//# sourceMappingURL=dev-JUA73B6D.js.map
+//# sourceMappingURL=dev-6QGAB4ZH.js.map