yamchart 0.1.4 → 0.3.3

package/dist/chunk-LL3VKMZM.js

@@ -0,0 +1,1265 @@
+import {
+  __require
+} from "./chunk-DGUM43GV.js";
+
+// ../../packages/query/dist/parser.js
+function parseModelMetadata(sql) {
+  const lines = sql.split("\n");
+  const metadataLines = [];
+  const sqlLines = [];
+  let inMetadata = true;
+  let inMultiline = null;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("-- @") || inMultiline && trimmed.startsWith("--")) {
+      metadataLines.push(trimmed);
+      inMetadata = true;
+    } else if (trimmed.startsWith("--") && inMetadata && metadataLines.length > 0) {
+      metadataLines.push(trimmed);
+    } else if (trimmed === "" && inMetadata) {
+      continue;
+    } else {
+      inMetadata = false;
+      sqlLines.push(line);
+    }
+  }
+  const metadata = parseMetadataLines(metadataLines);
+  if (!metadata.name) {
+    throw new Error("Model must have a @name");
+  }
+  return {
+    ...metadata,
+    name: metadata.name,
+    sql: sqlLines.join("\n").trim()
+  };
+}
+function parseMetadataLines(lines) {
+  const result = {};
+  const params = [];
+  const returns = [];
+  const tests = [];
+  let currentMultiline = null;
+  for (const line of lines) {
+    const content = line.replace(/^--\s*/, "").trim();
+    if (currentMultiline && content.startsWith("- ")) {
+      const itemContent = content.slice(2).trim();
+      if (currentMultiline === "returns") {
+        const returnCol = parseReturnColumn(itemContent);
+        if (returnCol)
+          returns.push(returnCol);
+      } else if (currentMultiline === "tests") {
+        tests.push(itemContent);
+      }
+      continue;
+    }
+    if (content.startsWith("@")) {
+      currentMultiline = null;
+      if (content.startsWith("@name:")) {
+        result.name = content.slice(6).trim();
+      } else if (content.startsWith("@description:")) {
+        result.description = content.slice(13).trim();
+      } else if (content.startsWith("@owner:")) {
+        result.owner = content.slice(7).trim();
+      } else if (content.startsWith("@tags:")) {
+        result.tags = parseTags(content.slice(6).trim());
+      } else if (content.startsWith("@param")) {
+        const param = parseParam(content.slice(6).trim());
+        if (param)
+          params.push(param);
+      } else if (content.startsWith("@returns:")) {
+        currentMultiline = "returns";
+      } else if (content.startsWith("@tests:")) {
+        currentMultiline = "tests";
+      }
+    }
+  }
+  if (params.length > 0)
+    result.params = params;
+  if (returns.length > 0)
+    result.returns = returns;
+  if (tests.length > 0)
+    result.tests = tests;
+  return result;
+}
+function parseTags(input) {
+  const match = input.match(/\[(.*)\]/);
+  if (!match?.[1])
+    return [];
+  return match[1].split(",").map((t) => t.trim());
+}
+function parseParam(input) {
+  const match = input.match(/^(\w+):\s*(\w+(?:\[\])?)\s*(?:=\s*([^{]+))?\s*(?:\{([^}]+)\})?/);
+  if (!match)
+    return null;
+  const [, name, type, defaultValue, options] = match;
+  if (!name || !type)
+    return null;
+  const param = {
+    name: name.trim(),
+    type: type.trim()
+  };
+  if (defaultValue) {
+    param.default = defaultValue.trim();
+  }
+  if (options) {
+    param.options = options.split(",").map((o) => o.trim());
+  }
+  return param;
+}
+function parseReturnColumn(input) {
+  const match = input.match(/^(\w+):\s*(\w+)\s*(?:--\s*(.+))?/);
+  if (!match)
+    return null;
+  const [, name, type, description] = match;
+  if (!name || !type)
+    return null;
+  const col = {
+    name: name.trim(),
+    type: type.trim()
+  };
+  if (description) {
+    col.description = description.trim();
+  }
+  return col;
+}
+
+// ../../packages/query/dist/presets.js
+import { subDays, subMonths, subYears, startOfYear, startOfMonth, startOfQuarter, endOfMonth, endOfQuarter, endOfYear, format } from "date-fns";
+function isCustomDateRange(value) {
+  return typeof value === "object" && value !== null && "type" in value && value.type === "custom" && "start" in value && "end" in value;
+}
+function expandCustomDateRange(range) {
+  return {
+    start_date: range.start,
+    end_date: range.end
+  };
+}
+var DATE_PRESETS = [
+  "last_7_days",
+  "last_30_days",
+  "last_90_days",
+  "last_12_months",
+  "year_to_date",
+  "month_to_date",
+  "quarter_to_date",
+  "previous_month",
+  "previous_quarter",
+  "previous_year"
+];
+var DATE_FORMAT = "yyyy-MM-dd";
+function formatDate(date) {
+  return format(date, DATE_FORMAT);
+}
+function expandDatePreset(preset) {
+  const now = /* @__PURE__ */ new Date();
+  const today = formatDate(now);
+  switch (preset) {
+    case "last_7_days":
+      return {
+        start_date: formatDate(subDays(now, 7)),
+        end_date: today
+      };
+    case "last_30_days":
+      return {
+        start_date: formatDate(subDays(now, 30)),
+        end_date: today
+      };
+    case "last_90_days":
+      return {
+        start_date: formatDate(subDays(now, 90)),
+        end_date: today
+      };
+    case "last_12_months":
+      return {
+        start_date: formatDate(subMonths(now, 12)),
+        end_date: today
+      };
+    case "year_to_date":
+      return {
+        start_date: formatDate(startOfYear(now)),
+        end_date: today
+      };
+    case "month_to_date":
+      return {
+        start_date: formatDate(startOfMonth(now)),
+        end_date: today
+      };
+    case "quarter_to_date":
+      return {
+        start_date: formatDate(startOfQuarter(now)),
+        end_date: today
+      };
+    case "previous_month": {
+      const lastMonth = subMonths(now, 1);
+      return {
+        start_date: formatDate(startOfMonth(lastMonth)),
+        end_date: formatDate(endOfMonth(lastMonth))
+      };
+    }
+    case "previous_quarter": {
+      const lastQuarter = subMonths(now, 3);
+      return {
+        start_date: formatDate(startOfQuarter(lastQuarter)),
+        end_date: formatDate(endOfQuarter(lastQuarter))
+      };
+    }
+    case "previous_year": {
+      const lastYear = subYears(now, 1);
+      return {
+        start_date: formatDate(startOfYear(lastYear)),
+        end_date: formatDate(endOfYear(lastYear))
+      };
+    }
+    default:
+      return null;
+  }
+}
+function isDatePreset(value) {
+  return DATE_PRESETS.includes(value);
+}
+
+// ../../packages/query/dist/template.js
+import nunjucks from "nunjucks";
+var env = new nunjucks.Environment(null, {
+  autoescape: false,
+  // SQL doesn't need HTML escaping
+  throwOnUndefined: false
+  // user.x may be undefined for RLS
+});
+function createTemplateContext(params, refs = {}, userContext) {
+  return {
+    ...params,
+    user: userContext ?? {},
+    ref: (name) => {
+      const resolved = refs[name];
+      if (resolved === void 0) {
+        throw new Error(`Unknown model reference: ${name}`);
+      }
+      return resolved;
+    }
+  };
+}
+function renderTemplate(template, context) {
+  const rendered = env.renderString(template, context);
+  return rendered.split("\n").map((line) => line.trimEnd()).filter((line, i, arr) => {
+    if (line === "" && arr[i - 1] === "")
+      return false;
+    return true;
+  }).join("\n").trim();
+}
+function templateHasVariable(template, varName) {
+  const regex = new RegExp(`\\{\\{\\s*${varName}(?:\\s*\\|[^}]+)?\\s*\\}\\}`, "g");
+  return regex.test(template);
+}
+function extractTemplateVariables(template) {
+  const variables = /* @__PURE__ */ new Set();
+  const regex = /\{\{\s*(\w+)(?:\s*\|[^}]+)?\s*\}\}/g;
+  let match;
+  while ((match = regex.exec(template)) !== null) {
+    const varName = match[1];
+    if (varName && varName !== "ref" && varName !== "loop") {
+      variables.add(varName);
+    }
+  }
+  return Array.from(variables);
+}
+
+// ../../packages/query/dist/compiler.js
+import { createHash } from "crypto";
+import { format as format2 } from "date-fns";
+function resolveDynamicDefault(value) {
+  if (typeof value !== "string")
+    return value;
+  const trimmed = value.trim().toLowerCase();
+  if (trimmed === "current_date()" || trimmed === "current_date" || trimmed === "now()") {
+    return format2(/* @__PURE__ */ new Date(), "yyyy-MM-dd");
+  }
+  if (trimmed.includes("current_date")) {
+    return format2(/* @__PURE__ */ new Date(), "yyyy-MM-dd");
+  }
+  return value;
+}
+var QueryCompiler = class {
+  models;
+  refs;
+  constructor(config) {
+    this.models = new Map(Object.entries(config.models));
+    this.refs = config.refs;
+  }
+  /**
+   * Compile a chart definition into an executable SQL query.
+   */
+  compile(chart, inputParams, userContext) {
+    const { sql, modelParams } = this.getSQL(chart);
+    const params = this.resolveParams(chart, modelParams, inputParams);
+    const expandedParams = this.expandPresets(params);
+    const context = createTemplateContext(expandedParams, this.refs, userContext);
+    const renderedSQL = renderTemplate(sql, context);
+    const cacheKey = this.generateCacheKey(chart.name, renderedSQL, expandedParams, userContext);
+    return {
+      sql: renderedSQL,
+      params: expandedParams,
+      cacheKey,
+      chartName: chart.name
+    };
+  }
+  getSQL(chart) {
+    if (chart.source.sql) {
+      return { sql: chart.source.sql, modelParams: void 0 };
+    }
+    if (chart.source.model) {
+      const model = this.models.get(chart.source.model);
+      if (!model) {
+        throw new Error(`Unknown model: ${chart.source.model}`);
+      }
+      return { sql: model.sql, modelParams: model.metadata.params };
+    }
+    throw new Error("Chart source must specify either model or sql");
+  }
+  resolveParams(chart, modelParams, inputParams) {
+    const params = {};
+    if (modelParams) {
+      for (const param of modelParams) {
+        if (param.default !== void 0) {
+          params[param.name] = resolveDynamicDefault(param.default);
+        }
+      }
+    }
+    if (chart.parameters) {
+      for (const param of chart.parameters) {
+        if (param.default !== void 0) {
+          params[param.name] = resolveDynamicDefault(param.default);
+        }
+      }
+    }
+    Object.assign(params, inputParams);
+    return params;
+  }
+  expandPresets(params) {
+    const expanded = { ...params };
+    if (isCustomDateRange(params.date_range)) {
+      const dateRange = expandCustomDateRange(params.date_range);
+      expanded.start_date = dateRange.start_date;
+      expanded.end_date = dateRange.end_date;
+    } else if (typeof params.date_range === "string" && isDatePreset(params.date_range)) {
+      const dateRange = expandDatePreset(params.date_range);
+      if (dateRange) {
+        expanded.start_date = dateRange.start_date;
+        expanded.end_date = dateRange.end_date;
+      }
+    }
+    return expanded;
+  }
+  generateCacheKey(chartName, sql, params, userContext) {
+    const sqlHash = createHash("sha256").update(sql).digest("hex").slice(0, 8);
+    const paramsHash = createHash("sha256").update(JSON.stringify(params, Object.keys(params).sort())).digest("hex").slice(0, 8);
+    let key = `${chartName}:${sqlHash}:${paramsHash}`;
+    if (userContext && Object.keys(userContext).length > 0) {
+      const userHash = createHash("sha256").update(JSON.stringify(userContext, Object.keys(userContext).sort())).digest("hex").slice(0, 8);
+      key += `:${userHash}`;
+    }
+    return key;
+  }
+  /**
+   * Add or update a model in the compiler.
+   */
+  addModel(name, metadata, sql) {
+    this.models.set(name, { metadata, sql });
+  }
+  /**
+   * Add or update a ref mapping.
+   */
+  addRef(name, target) {
+    this.refs[name] = target;
+  }
+};
+
+// ../../packages/query/dist/connectors/duckdb.js
+import duckdb from "duckdb";
+import { performance as performance2 } from "perf_hooks";
+var DuckDBConnector = class {
+  config;
+  db = null;
+  connection = null;
+  constructor(config) {
+    this.config = config;
+  }
+  async connect() {
+    return new Promise((resolve, reject) => {
+      this.db = new duckdb.Database(this.config.path, (err) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        this.connection = this.db.connect();
+        resolve();
+      });
+    });
+  }
+  async disconnect() {
+    return new Promise((resolve) => {
+      if (this.connection) {
+        this.connection.close(() => {
+          this.connection = null;
+        });
+      }
+      if (this.db) {
+        this.db.close(() => {
+          this.db = null;
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+  async execute(sql) {
+    if (!this.connection) {
+      throw new Error("Not connected to database");
+    }
+    const startTime = performance2.now();
+    return new Promise((resolve, reject) => {
+      const stmt = this.connection.prepare(sql, (prepErr) => {
+        if (prepErr) {
+          reject(prepErr);
+          return;
+        }
+        const columnInfo = stmt.columns();
+        stmt.all((err, rows) => {
+          const durationMs = performance2.now() - startTime;
+          if (err) {
+            reject(err);
+            return;
+          }
+          const typedRows = rows;
+          const serializedRows = typedRows.map((row) => this.serializeRow(row));
+          const columns = columnInfo.map((col) => ({
+            name: col.name,
+            type: col.type.sql_type
+          }));
+          stmt.finalize();
+          resolve({
+            columns,
+            rows: serializedRows,
+            rowCount: serializedRows.length,
+            durationMs
+          });
+        });
+      });
+    });
+  }
+  isConnected() {
+    return this.connection !== null;
+  }
+  async explain(sql) {
+    if (!this.connection) {
+      throw new Error("Not connected to database");
+    }
+    return new Promise((resolve) => {
+      this.connection.all(`EXPLAIN ${sql}`, (err) => {
+        if (err) {
+          resolve({ valid: false, error: err.message });
+        } else {
+          resolve({ valid: true });
+        }
+      });
+    });
+  }
+  serializeRow(row) {
+    const result = {};
+    for (const [key, value] of Object.entries(row)) {
+      if (typeof value === "bigint") {
+        result[key] = Number(value);
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+};
+
+// ../../packages/query/dist/connectors/postgres.js
+import { Pool, types } from "pg";
+import { performance as performance3 } from "perf_hooks";
+types.setTypeParser(20, (val) => {
+  if (val === null)
+    return null;
+  return BigInt(val);
+});
+function escapeIdentifier(identifier) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(identifier)) {
+    throw new Error(`Invalid identifier: ${identifier}`);
+  }
+  return `"${identifier}"`;
+}
+var PostgresConnector = class {
+  config;
+  pool = null;
+  constructor(config) {
+    this.config = config;
+  }
+  async connect() {
+    const poolConfig = {
+      host: this.config.host,
+      port: this.config.port,
+      database: this.config.database,
+      user: this.config.user,
+      password: this.config.password,
+      ssl: this.config.ssl,
+      min: this.config.min ?? 2,
+      max: this.config.max ?? 10,
+      idleTimeoutMillis: this.config.idleTimeoutMillis ?? 3e4,
+      connectionTimeoutMillis: this.config.connectTimeoutMillis ?? 1e4
+    };
+    if (this.config.statementTimeout) {
+      poolConfig.statement_timeout = this.config.statementTimeout;
+    }
+    this.pool = new Pool(poolConfig);
+    this.pool.on("error", (err) => {
+      console.error("Unexpected postgres pool error:", err.message);
+    });
+    if (this.config.schema) {
+      const schema = escapeIdentifier(this.config.schema);
+      this.pool.on("connect", (client2) => {
+        client2.query(`SET search_path TO ${schema}`).catch((err) => {
+          console.error("Failed to set search_path:", err.message);
+        });
+      });
+    }
+    const client = await this.pool.connect();
+    client.release();
+  }
+  async disconnect() {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = null;
+    }
+  }
+  isConnected() {
+    return this.pool !== null;
+  }
+  async execute(sql) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const start = performance3.now();
+    const result = await this.pool.query(sql);
+    const durationMs = performance3.now() - start;
+    return {
+      columns: this.extractColumns(result),
+      rows: result.rows.map((row) => this.serializeRow(row)),
+      rowCount: result.rowCount ?? result.rows.length,
+      durationMs
+    };
+  }
+  async explain(sql) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      await this.pool.query(`EXPLAIN ${sql}`);
+      return { valid: true };
+    } catch (err) {
+      return {
+        valid: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  extractColumns(result) {
+    return result.fields.map((field) => ({
+      name: field.name,
+      type: this.pgTypeToString(field.dataTypeID)
+    }));
+  }
+  pgTypeToString(oid) {
+    const typeMap = {
+      16: "boolean",
+      // bool
+      20: "integer",
+      // int8
+      21: "integer",
+      // int2
+      23: "integer",
+      // int4
+      700: "number",
+      // float4
+      701: "number",
+      // float8
+      1700: "number",
+      // numeric
+      25: "string",
+      // text
+      1043: "string",
+      // varchar
+      1082: "date",
+      // date
+      1114: "date",
+      // timestamp
+      1184: "date",
+      // timestamptz
+      114: "unknown",
+      // json
+      3802: "unknown"
+      // jsonb
+    };
+    return typeMap[oid] ?? "unknown";
+  }
+  serializeRow(row) {
+    const serialized = {};
+    for (const [key, value] of Object.entries(row)) {
+      serialized[key] = this.serializeValue(value);
+    }
+    return serialized;
+  }
+  serializeValue(value) {
+    if (value === null || value === void 0) {
+      return null;
+    }
+    if (typeof value === "bigint") {
+      if (value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER) {
+        return value.toString();
+      }
+      return Number(value);
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    return value;
+  }
+};
+
+// ../../packages/query/dist/connectors/mysql.js
+import { createPool } from "mysql2/promise";
+import { performance as performance4 } from "perf_hooks";
+var MySQLConnector = class {
+  config;
+  pool = null;
+  constructor(config) {
+    this.config = config;
+  }
+  async connect() {
+    const poolConfig = {
+      host: this.config.host,
+      port: this.config.port,
+      database: this.config.database,
+      user: this.config.user,
+      password: this.config.password,
+      ssl: this.config.ssl ? {} : void 0,
+      waitForConnections: true,
+      connectionLimit: this.config.max ?? 10,
+      queueLimit: 0,
+      connectTimeout: this.config.connectTimeoutMillis ?? 1e4
+    };
+    this.pool = createPool(poolConfig);
+    const connection = await this.pool.getConnection();
+    connection.release();
+  }
+  async disconnect() {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = null;
+    }
+  }
+  isConnected() {
+    return this.pool !== null;
+  }
+  async execute(sql) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    const start = performance4.now();
+    const [rows, fields] = await this.pool.query(sql);
+    const durationMs = performance4.now() - start;
+    return {
+      columns: this.extractColumns(fields),
+      rows: rows.map((row) => this.serializeRow(row)),
+      rowCount: rows.length,
+      durationMs
+    };
+  }
+  async explain(sql) {
+    if (!this.pool) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      await this.pool.query(`EXPLAIN ${sql}`);
+      return { valid: true };
+    } catch (err) {
+      return {
+        valid: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  extractColumns(fields) {
+    return fields.map((field) => ({
+      name: field.name,
+      type: this.mysqlTypeToString(field.type)
+    }));
+  }
+  mysqlTypeToString(type) {
+    const typeMap = {
+      0: "number",
+      // DECIMAL
+      1: "integer",
+      // TINY
+      2: "integer",
+      // SHORT
+      3: "integer",
+      // LONG
+      4: "number",
+      // FLOAT
+      5: "number",
+      // DOUBLE
+      7: "date",
+      // TIMESTAMP
+      8: "integer",
+      // LONGLONG
+      9: "integer",
+      // INT24
+      10: "date",
+      // DATE
+      11: "string",
+      // TIME
+      12: "date",
+      // DATETIME
+      13: "integer",
+      // YEAR
+      15: "string",
+      // VARCHAR
+      245: "unknown",
+      // JSON
+      246: "number",
+      // NEWDECIMAL
+      252: "string",
+      // BLOB
+      253: "string",
+      // VAR_STRING
+      254: "string"
+      // STRING
+    };
+    return typeMap[type ?? 0] ?? "unknown";
+  }
+  serializeRow(row) {
+    const serialized = {};
+    for (const [key, value] of Object.entries(row)) {
+      serialized[key] = this.serializeValue(value);
+    }
+    return serialized;
+  }
+  serializeValue(value) {
+    if (value === null || value === void 0) {
+      return null;
+    }
+    if (typeof value === "bigint") {
+      if (value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER) {
+        return value.toString();
+      }
+      return Number(value);
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (Buffer.isBuffer(value)) {
+      return value.toString("utf-8");
+    }
+    return value;
+  }
+};
+
+// ../../packages/query/dist/connectors/sqlite.js
+import Database from "better-sqlite3";
+import { performance as performance5 } from "perf_hooks";
+var SQLiteConnector = class {
+  config;
+  db = null;
+  constructor(config) {
+    this.config = config;
+  }
+  async connect() {
+    this.db = new Database(this.config.path, {
+      readonly: this.config.readonly ?? false
+    });
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+  }
+  async disconnect() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+  isConnected() {
+    return this.db !== null;
+  }
+  async execute(sql) {
+    if (!this.db) {
+      throw new Error("Not connected to database");
+    }
+    const start = performance5.now();
+    const stmt = this.db.prepare(sql);
+    const rows = stmt.all();
+    const durationMs = performance5.now() - start;
+    const columns = stmt.columns().map((col) => ({
+      name: col.name,
+      type: this.sqliteTypeToString(col.type)
+    }));
+    return {
+      columns,
+      rows: rows.map((row) => this.serializeRow(row)),
+      rowCount: rows.length,
+      durationMs
+    };
+  }
+  async explain(sql) {
+    if (!this.db) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      this.db.prepare(`EXPLAIN ${sql}`);
+      return { valid: true };
+    } catch (err) {
+      return {
+        valid: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  sqliteTypeToString(type) {
+    if (!type)
+      return "unknown";
+    const upperType = type.toUpperCase();
+    if (upperType.includes("INT"))
+      return "integer";
+    if (upperType.includes("CHAR") || upperType.includes("TEXT") || upperType.includes("CLOB"))
+      return "string";
+    if (upperType.includes("BLOB"))
+      return "unknown";
+    if (upperType.includes("REAL") || upperType.includes("FLOA") || upperType.includes("DOUB"))
+      return "number";
+    if (upperType.includes("NUMERIC") || upperType.includes("DECIMAL"))
+      return "number";
+    if (upperType.includes("DATE") || upperType.includes("TIME"))
+      return "date";
+    if (upperType.includes("BOOL"))
+      return "boolean";
+    return "unknown";
+  }
+  serializeRow(row) {
+    const serialized = {};
+    for (const [key, value] of Object.entries(row)) {
+      serialized[key] = this.serializeValue(value);
+    }
+    return serialized;
+  }
+  serializeValue(value) {
+    if (value === null || value === void 0) {
+      return null;
+    }
+    if (typeof value === "bigint") {
+      if (value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER) {
+        return value.toString();
+      }
+      return Number(value);
+    }
+    if (Buffer.isBuffer(value)) {
+      return value.toString("base64");
+    }
+    return value;
+  }
+};
+
+// ../../packages/query/dist/connectors/snowflake.js
+import snowflake from "snowflake-sdk";
+import { performance as performance6 } from "perf_hooks";
+var SnowflakeConnector = class {
+  config;
+  connection = null;
+  constructor(config) {
+    this.config = config;
+  }
+  async connect() {
+    const connectionOptions = {
+      account: this.config.account,
+      username: this.config.username,
+      password: this.config.password,
+      privateKey: this.config.privateKey,
+      warehouse: this.config.warehouse,
+      database: this.config.database,
+      schema: this.config.schema,
+      role: this.config.role,
+      timeout: this.config.connectTimeoutMillis ?? 6e4
+    };
+    this.connection = snowflake.createConnection(connectionOptions);
+    return new Promise((resolve, reject) => {
+      this.connection.connect((err) => {
+        if (err) {
+          this.connection = null;
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+  async disconnect() {
+    if (this.connection) {
+      return new Promise((resolve, reject) => {
+        this.connection.destroy((err) => {
+          this.connection = null;
+          if (err) {
+            reject(err);
+          } else {
+            resolve();
+          }
+        });
+      });
+    }
+  }
+  isConnected() {
+    return this.connection !== null && this.connection.isUp();
+  }
+  async execute(sql) {
+    if (!this.connection) {
+      throw new Error("Not connected to database");
+    }
+    const start = performance6.now();
+    return new Promise((resolve, reject) => {
+      this.connection.execute({
+        sqlText: sql,
+        complete: (err, stmt, rows) => {
+          const durationMs = performance6.now() - start;
+          if (err) {
+            reject(err);
+            return;
+          }
+          const columns = stmt ? stmt.getColumns().map((col) => ({
+            name: col.getName(),
+            type: this.snowflakeTypeToString(col.getType())
+          })) : [];
+          resolve({
+            columns,
+            rows: (rows || []).map((row) => this.serializeRow(row)),
+            rowCount: rows?.length ?? 0,
+            durationMs
+          });
+        }
+      });
+    });
+  }
+  async explain(sql) {
+    if (!this.connection) {
+      throw new Error("Not connected to database");
+    }
+    try {
+      await this.execute(`EXPLAIN ${sql}`);
+      return { valid: true };
+    } catch (err) {
+      return {
+        valid: false,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  snowflakeTypeToString(type) {
+    const typeMap = {
+      "NUMBER": "number",
+      "DECIMAL": "number",
+      "NUMERIC": "number",
+      "INT": "integer",
+      "INTEGER": "integer",
+      "BIGINT": "integer",
+      "SMALLINT": "integer",
+      "TINYINT": "integer",
+      "BYTEINT": "integer",
+      "FLOAT": "number",
+      "FLOAT4": "number",
+      "FLOAT8": "number",
+      "DOUBLE": "number",
+      "DOUBLE PRECISION": "number",
+      "REAL": "number",
+      "VARCHAR": "string",
+      "CHAR": "string",
+      "CHARACTER": "string",
+      "STRING": "string",
+      "TEXT": "string",
+      "BINARY": "unknown",
+      "VARBINARY": "unknown",
+      "BOOLEAN": "boolean",
+      "DATE": "date",
+      "DATETIME": "date",
+      "TIME": "string",
+      "TIMESTAMP": "date",
+      "TIMESTAMP_LTZ": "date",
+      "TIMESTAMP_NTZ": "date",
+      "TIMESTAMP_TZ": "date",
+      "VARIANT": "unknown",
+      "OBJECT": "unknown",
+      "ARRAY": "unknown"
+    };
+    const upperType = type.toUpperCase();
+    return typeMap[upperType] ?? "unknown";
+  }
+  serializeRow(row) {
+    const serialized = {};
+    for (const [key, value] of Object.entries(row)) {
+      serialized[key] = this.serializeValue(value);
+    }
+    return serialized;
+  }
+  serializeValue(value) {
+    if (value === null || value === void 0) {
+      return null;
+    }
+    if (typeof value === "bigint") {
+      if (value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER) {
+        return value.toString();
+      }
+      return Number(value);
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    return value;
+  }
+};
+
+// ../../packages/query/dist/connectors/auth.js
+function resolvePostgresAuth(connection) {
+  const auth = connection.auth;
+  if (!auth) {
+    return {
+      user: process.env.PGUSER ?? "postgres",
+      password: process.env.PGPASSWORD ?? ""
+    };
+  }
+  if (auth.type === "env") {
+    const user = process.env[auth.user_var];
+    const password = process.env[auth.password_var];
+    if (!user) {
+      throw new Error(`Missing environment variable: ${auth.user_var}`);
+    }
+    return { user, password: password ?? "" };
+  }
+  throw new Error(`Auth type "${auth.type}" not yet implemented`);
+}
+function resolveMySQLAuth(connection) {
+  const auth = connection.auth;
+  if (!auth) {
+    return {
+      user: process.env.MYSQL_USER ?? "root",
+      password: process.env.MYSQL_PASSWORD ?? ""
+    };
+  }
+  if (auth.type === "env") {
+    const user = process.env[auth.user_var];
+    const password = process.env[auth.password_var];
+    if (!user) {
+      throw new Error(`Missing environment variable: ${auth.user_var}`);
+    }
+    return { user, password: password ?? "" };
+  }
+  throw new Error(`Auth type "${auth.type}" not yet implemented`);
+}
+function resolveSnowflakeAuth(connection) {
+  const auth = connection.auth;
+  if (auth.type === "env") {
+    const username = process.env[auth.user_var];
+    const password = process.env[auth.password_var];
+    if (!username) {
+      throw new Error(`Missing environment variable: ${auth.user_var}`);
+    }
+    return { username, password: password ?? void 0 };
+  }
+  if (auth.type === "key_pair") {
+    const username = process.env[auth.user_var];
+    if (!username) {
+      throw new Error(`Missing environment variable: ${auth.user_var}`);
+    }
+    const fs = __require("fs");
+    const privateKey = fs.readFileSync(auth.private_key_path, "utf-8");
+    return { username, privateKey };
+  }
+  throw new Error(`Auth type "${auth.type}" not yet implemented for Snowflake`);
+}
+
+// ../../packages/query/dist/test-runner.js
+var TYPE_MAP = {
+  date: ["date", "timestamp", "datetime", "timestamptz", "timestamp with time zone"],
+  number: ["integer", "int", "bigint", "float", "double", "decimal", "numeric", "real", "smallint", "tinyint", "hugeint", "int4", "int8", "float4", "float8"],
+  integer: ["integer", "int", "bigint", "smallint", "tinyint", "hugeint", "int4", "int8"],
+  string: ["varchar", "text", "char", "string", "character varying", "nvarchar"],
+  boolean: ["boolean", "bool"]
+};
+function typesMatch(expectedType, actualType) {
+  const expected = expectedType.toLowerCase();
+  const actual = actualType.toLowerCase();
+  if (expected === actual)
+    return true;
+  const acceptedTypes = TYPE_MAP[expected];
+  if (acceptedTypes)
+    return acceptedTypes.includes(actual);
+  return false;
+}
+function expandThis(assertionSql, compiledSql) {
+  return assertionSql.replace(/\{\{\s*this\s*\}\}/g, compiledSql);
+}
+var MAX_SAMPLE_VIOLATIONS = 5;
+async function runAssertion(compiledSql, assertionSql, connector) {
+  const warning = !/\{\{\s*this\s*\}\}/.test(assertionSql) ? "Test assertion does not reference {{this}} \u2014 did you mean to include it?" : void 0;
+  const expandedSql = expandThis(assertionSql, compiledSql);
+  try {
+    const result = await connector.execute(expandedSql);
+    return {
+      sql: assertionSql,
+      passed: result.rowCount === 0,
+      violationCount: result.rowCount,
+      sampleViolations: result.rows.slice(0, MAX_SAMPLE_VIOLATIONS),
+      warning
+    };
+  } catch (err) {
+    return {
+      sql: assertionSql,
+      passed: false,
+      error: err instanceof Error ? err.message : String(err),
+      warning
+    };
+  }
+}
+async function runModel(compiledSql, metadata, connector) {
+  const start = performance.now();
+  const hasReturns = metadata.returns && metadata.returns.length > 0;
+  const hasTests = metadata.tests && metadata.tests.length > 0;
+  if (!hasReturns && !hasTests) {
+    return {
+      modelName: metadata.name,
+      assertions: [],
+      durationMs: performance.now() - start
+    };
+  }
+  let schemaCheckResult;
+  if (hasReturns) {
+    try {
+      schemaCheckResult = await checkSchema(compiledSql, connector, metadata.returns);
+    } catch (err) {
+      return {
+        modelName: metadata.name,
+        assertions: [],
+        durationMs: performance.now() - start,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  const assertions = [];
+  if (hasTests) {
+    for (const testSql of metadata.tests) {
+      const result = await runAssertion(compiledSql, testSql, connector);
+      assertions.push(result);
+    }
+  }
+  return {
+    modelName: metadata.name,
+    schemaCheck: schemaCheckResult,
+    assertions,
+    durationMs: performance.now() - start
+  };
+}
+async function runAll(models, connector) {
+  const start = performance.now();
+  const results = [];
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+  for (const model of models) {
+    const result = await runModel(model.compiledSql, model.metadata, connector);
+    results.push(result);
+    const hasAnyCheck = result.schemaCheck || result.assertions.length > 0;
+    if (!hasAnyCheck && !result.error) {
+      skipped++;
+      continue;
+    }
+    if (result.error) {
+      failed++;
+      continue;
+    }
+    if (result.schemaCheck) {
+      if (result.schemaCheck.passed)
+        passed++;
+      else
+        failed++;
+    }
+    for (const assertion of result.assertions) {
+      if (assertion.passed)
+        passed++;
+      else
+        failed++;
+    }
+  }
+  return {
+    models: results,
+    passed,
+    failed,
+    skipped,
+    durationMs: performance.now() - start
+  };
+}
+async function checkSchema(compiledSql, connector, expectedReturns) {
+  const wrappedSql = `SELECT * FROM (${compiledSql}) AS _model LIMIT 0`;
+  const result = await connector.execute(wrappedSql);
+  const actualColumns = result.columns.map((c) => c.name);
+  const expectedColumns = expectedReturns.map((c) => c.name);
+  const missingColumns = expectedColumns.filter((name) => !actualColumns.includes(name));
+  const extraColumns = actualColumns.filter((name) => !expectedColumns.includes(name));
+  const typeMismatches = [];
+  for (const expected of expectedReturns) {
+    const actual = result.columns.find((c) => c.name === expected.name);
+    if (actual && !typesMatch(expected.type, actual.type)) {
+      typeMismatches.push({
+        column: expected.name,
+        expected: expected.type,
+        actual: actual.type
+      });
+    }
+  }
+  return {
+    passed: missingColumns.length === 0 && typeMismatches.length === 0,
+    expectedColumns,
+    actualColumns,
+    missingColumns,
+    extraColumns,
+    typeMismatches
+  };
+}
+
+// ../../packages/query/dist/index.js
+var VERSION = "0.1.0";
+
+export {
+  parseModelMetadata,
+  isCustomDateRange,
+  expandCustomDateRange,
+  DATE_PRESETS,
+  expandDatePreset,
+  isDatePreset,
+  createTemplateContext,
+  renderTemplate,
+  templateHasVariable,
+  extractTemplateVariables,
+  QueryCompiler,
+  DuckDBConnector,
+  PostgresConnector,
+  MySQLConnector,
+  SQLiteConnector,
+  SnowflakeConnector,
+  resolvePostgresAuth,
+  resolveMySQLAuth,
+  resolveSnowflakeAuth,
+  expandThis,
+  runAssertion,
+  runModel,
+  runAll,
+  checkSchema,
+  VERSION
+};
+//# sourceMappingURL=chunk-LL3VKMZM.js.map