yamchart 0.9.5 → 0.10.1

package/dist/chunk-UFDQ3C7Q.js

@@ -0,0 +1,919 @@
+import { createRequire as __yamchartCreateRequire } from 'module'; if (!globalThis.require) globalThis.require = __yamchartCreateRequire(import.meta.url);
+import {
+  SemanticDefinitionSchema
+} from "./chunk-ZIY22VO7.js";
+
+// ../../packages/query/dist/presets.js
+import { subDays, subWeeks, subMonths, subYears, subQuarters, addDays, addWeeks, addMonths, addYears, addQuarters, startOfDay, startOfWeek, startOfYear, startOfMonth, startOfQuarter, endOfWeek, endOfMonth, endOfQuarter, endOfYear, differenceInDays, parseISO, 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 = [
+  "today",
+  "yesterday",
+  "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 "today":
+      return {
+        start_date: today,
+        end_date: today
+      };
+    case "yesterday": {
+      const yesterday = formatDate(subDays(now, 1));
+      return {
+        start_date: yesterday,
+        end_date: yesterday
+      };
+    }
+    case "last_7_days": {
+      const yesterday = formatDate(subDays(now, 1));
+      return {
+        start_date: formatDate(subDays(now, 7)),
+        end_date: yesterday
+      };
+    }
+    case "last_30_days": {
+      const yesterday = formatDate(subDays(now, 1));
+      return {
+        start_date: formatDate(subDays(now, 30)),
+        end_date: yesterday
+      };
+    }
+    case "last_90_days": {
+      const yesterday = formatDate(subDays(now, 1));
+      return {
+        start_date: formatDate(subDays(now, 90)),
+        end_date: yesterday
+      };
+    }
+    case "last_12_months": {
+      const yesterday = formatDate(subDays(now, 1));
+      return {
+        start_date: formatDate(subMonths(now, 12)),
+        end_date: yesterday
+      };
+    }
+    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 computePreviousPeriod(startDate, endDate, presetName) {
+  const start = parseISO(startDate);
+  const end = parseISO(endDate);
+  switch (presetName) {
+    case "today":
+    case "yesterday": {
+      return {
+        start_date: formatDate(subDays(start, 1)),
+        end_date: formatDate(subDays(end, 1))
+      };
+    }
+    case "last_7_days": {
+      return {
+        start_date: formatDate(subDays(start, 7)),
+        end_date: formatDate(subDays(end, 7))
+      };
+    }
+    case "last_30_days": {
+      return {
+        start_date: formatDate(subDays(start, 30)),
+        end_date: formatDate(subDays(end, 30))
+      };
+    }
+    case "last_90_days": {
+      return {
+        start_date: formatDate(subDays(start, 90)),
+        end_date: formatDate(subDays(end, 90))
+      };
+    }
+    case "last_12_months":
+    case "last_365_days": {
+      return {
+        start_date: formatDate(subMonths(start, 12)),
+        end_date: formatDate(subMonths(end, 12))
+      };
+    }
+    case "year_to_date": {
+      return {
+        start_date: formatDate(subYears(start, 1)),
+        end_date: formatDate(subYears(end, 1))
+      };
+    }
+    case "month_to_date": {
+      return {
+        start_date: formatDate(subMonths(start, 1)),
+        end_date: formatDate(subMonths(end, 1))
+      };
+    }
+    case "quarter_to_date": {
+      return {
+        start_date: formatDate(subQuarters(start, 1)),
+        end_date: formatDate(subQuarters(end, 1))
+      };
+    }
+    case "previous_month": {
+      const shifted = subMonths(start, 1);
+      return {
+        start_date: formatDate(startOfMonth(shifted)),
+        end_date: formatDate(endOfMonth(shifted))
+      };
+    }
+    case "previous_quarter": {
+      const shifted = subQuarters(start, 1);
+      return {
+        start_date: formatDate(startOfQuarter(shifted)),
+        end_date: formatDate(endOfQuarter(shifted))
+      };
+    }
+    case "previous_year": {
+      const shifted = subYears(start, 1);
+      return {
+        start_date: formatDate(startOfYear(shifted)),
+        end_date: formatDate(endOfYear(shifted))
+      };
+    }
+    default: {
+      const days = differenceInDays(end, start);
+      return {
+        start_date: formatDate(subDays(start, days)),
+        end_date: formatDate(subDays(end, days))
+      };
+    }
+  }
+}
+function formatPeriodLabel(startDate, endDate) {
+  const start = parseISO(startDate);
+  const end = parseISO(endDate);
+  if (startDate === endDate) {
+    return format(start, "MMM d");
+  }
+  const startYear = start.getFullYear();
+  const endYear = end.getFullYear();
+  if (startYear === endYear) {
+    return `${format(start, "MMM d")} \u2013 ${format(end, "MMM d")}`;
+  }
+  return `${format(start, "MMM d, yyyy")} \u2013 ${format(end, "MMM d, yyyy")}`;
+}
+function isDatePreset(value) {
+  return DATE_PRESETS.includes(value);
+}
+function isRelativeDateRange(value) {
+  return typeof value === "object" && value !== null && "type" in value && value.type === "relative";
+}
+function expandRelativeDateRange(rel) {
+  const now = /* @__PURE__ */ new Date();
+  const today = startOfDay(now);
+  if (rel.direction === "current") {
+    switch (rel.unit) {
+      case "day":
+        return { start_date: formatDate(today), end_date: formatDate(today) };
+      case "week":
+        return {
+          start_date: formatDate(startOfWeek(today, { weekStartsOn: 1 })),
+          end_date: formatDate(endOfWeek(today, { weekStartsOn: 1 }))
+        };
+      case "month":
+        return { start_date: formatDate(startOfMonth(today)), end_date: formatDate(endOfMonth(today)) };
+      case "quarter":
+        return { start_date: formatDate(startOfQuarter(today)), end_date: formatDate(endOfQuarter(today)) };
+      case "year":
+        return { start_date: formatDate(startOfYear(today)), end_date: formatDate(endOfYear(today)) };
+    }
+  }
+  const n = rel.value ?? 1;
+  if (rel.direction === "previous") {
+    const end2 = rel.includeToday ? today : subDays(today, 1);
+    const shiftFns2 = { day: subDays, week: subWeeks, month: subMonths, quarter: subQuarters, year: subYears };
+    const start2 = shiftFns2[rel.unit](rel.includeToday ? today : today, n);
+    return {
+      start_date: formatDate(start2 < end2 ? start2 : end2),
+      end_date: formatDate(start2 < end2 ? end2 : start2)
+    };
+  }
+  const start = rel.includeToday ? today : addDays(today, 1);
+  const shiftFns = { day: addDays, week: addWeeks, month: addMonths, quarter: addQuarters, year: addYears };
+  const end = shiftFns[rel.unit](start, n);
+  return {
+    start_date: formatDate(start < end ? start : end),
+    end_date: formatDate(start < end ? end : start)
+  };
+}
+
+// ../../packages/query/dist/semantic/field-classifier.js
+var DIMENSION_ID_PATTERN = /(_id|_key|_code)$/i;
+var DIMENSION_NAME_PATTERN = /(_name|_label|_title|_slug)$/i;
+var DIMENSION_TYPE_PATTERN = /(_type|_status|_category|_class|_group|_tier|_level|_kind|_role)$/i;
+var DIMENSION_EXACT = /* @__PURE__ */ new Set([
+  "id",
+  "name",
+  "category",
+  "channel",
+  "country",
+  "region",
+  "city",
+  "state",
+  "source",
+  "medium",
+  "campaign",
+  "status",
+  "type",
+  "tier",
+  "segment",
+  "department",
+  "team",
+  "brand",
+  "product",
+  "currency",
+  "email",
+  "url"
+]);
+var TIME_PATTERN = /(_at|_date|_time|_timestamp|_ts|_day|_week|_month|_year|_quarter)$/i;
+var TIME_EXACT = /* @__PURE__ */ new Set([
+  "date",
+  "period",
+  "timestamp",
+  "date_day",
+  "month",
+  "year",
+  "quarter",
+  "week",
+  "created",
+  "updated",
+  "deleted",
+  "started",
+  "ended"
+]);
+var MEASURE_COUNT_PATTERN = /(_count$|^count_|^num_|^number_of_|_total_count$)/i;
+var MEASURE_AMOUNT_PATTERN = /(_amount$|_total$|_revenue$|_cost$|_price$|_spend$|_profit$|_margin$|_fee$|_tax$|_discount$|_balance$|_qty$|_quantity$|_sum$|_volume$|_weight$|_size$|_value$|_rate$|_ratio$|_score$|_percent$|_pct$)/i;
+var MEASURE_EXACT = /* @__PURE__ */ new Set([
+  "quantity",
+  "revenue",
+  "amount",
+  "total",
+  "cost",
+  "price",
+  "profit",
+  "margin",
+  "balance",
+  "score",
+  "rate",
+  "ratio",
+  "volume",
+  "weight",
+  "spend",
+  "fee"
+]);
+var MEASURE_AVG_PATTERN = /(_avg$|_average$|_mean$|^avg_|^average_|^mean_)/i;
+var MEASURE_MIN_PATTERN = /(^min_|_min$)/i;
+var MEASURE_MAX_PATTERN = /(^max_|_max$)/i;
+var NUMERIC_TYPES = /^(number|numeric|int|integer|bigint|smallint|tinyint|float|double|decimal|real|money)/i;
+var STRING_TYPES = /^(varchar|text|string|char|nchar|nvarchar|clob|binary|varbinary)/i;
+var TIME_TYPES = /^(date|time|timestamp|datetime|interval)/i;
+var BOOLEAN_TYPES = /^(bool|boolean|bit)/i;
+var MEASURE_DESCRIPTION_KEYWORDS = /\b(total|sum of|count of|number of|amount|revenue|average|aggregate)\b/i;
+function classifyField(input) {
+  const name = input.name.toLowerCase();
+  if (TIME_PATTERN.test(name) || TIME_EXACT.has(name)) {
+    return { role: "dimension", dimensionType: "time" };
+  }
+  if (DIMENSION_ID_PATTERN.test(name) || DIMENSION_NAME_PATTERN.test(name) || DIMENSION_TYPE_PATTERN.test(name) || DIMENSION_EXACT.has(name)) {
+    return { role: "dimension", dimensionType: "string" };
+  }
+  if (MEASURE_COUNT_PATTERN.test(name)) {
+    return { role: "measure", measureType: "count" };
+  }
+  if (MEASURE_AVG_PATTERN.test(name)) {
+    return { role: "measure", measureType: "avg" };
+  }
+  if (MEASURE_MIN_PATTERN.test(name)) {
+    return { role: "measure", measureType: "min" };
+  }
+  if (MEASURE_MAX_PATTERN.test(name)) {
+    return { role: "measure", measureType: "max" };
+  }
+  if (MEASURE_AMOUNT_PATTERN.test(name) || MEASURE_EXACT.has(name)) {
+    return { role: "measure", measureType: "sum" };
+  }
+  if (input.data_type) {
+    if (TIME_TYPES.test(input.data_type)) {
+      return { role: "dimension", dimensionType: "time" };
+    }
+    if (BOOLEAN_TYPES.test(input.data_type)) {
+      return { role: "dimension", dimensionType: "boolean" };
+    }
+    if (NUMERIC_TYPES.test(input.data_type)) {
+      return { role: "measure", measureType: "sum" };
+    }
+    if (STRING_TYPES.test(input.data_type)) {
+      return { role: "dimension", dimensionType: "string" };
+    }
+  }
+  if (input.description && MEASURE_DESCRIPTION_KEYWORDS.test(input.description)) {
+    return { role: "measure", measureType: "sum" };
+  }
+  return { role: "dimension", dimensionType: "string" };
+}
+function inferAggregationType(name) {
+  const lower = name.toLowerCase();
+  if (MEASURE_COUNT_PATTERN.test(lower) || lower.startsWith("num_"))
+    return "count";
+  if (MEASURE_AVG_PATTERN.test(lower))
+    return "avg";
+  if (MEASURE_MIN_PATTERN.test(lower))
+    return "min";
+  if (MEASURE_MAX_PATTERN.test(lower))
+    return "max";
+  return "sum";
+}
+function classifyCatalogColumns(columns) {
+  const measures = [];
+  const dimensions = [];
+  for (const col of columns) {
+    const result = classifyField({
+      name: col.name,
+      data_type: col.data_type,
+      description: col.description
+    });
+    if (result.role === "measure") {
+      measures.push({
+        name: col.name,
+        type: result.measureType ?? "sum",
+        description: col.description || void 0
+      });
+    } else {
+      dimensions.push({
+        name: col.name,
+        type: result.dimensionType ?? "string",
+        description: col.description || void 0
+      });
+    }
+  }
+  return { measures, dimensions };
+}
+
+// ../../packages/query/dist/semantic/model-builder.js
+var DEFAULT_FILTER = {
+  paths: ["gold/", "marts/", "core/"],
+  prefixes: ["dim_", "fct_", "fact_"]
+};
+var SemanticModelBuilder = class {
+  filter;
+  constructor(config) {
+    this.filter = config?.include ?? DEFAULT_FILTER;
+  }
+  build(input) {
+    const { catalog, models, chartHints } = input;
+    const catalogEntities = catalog ? this.buildCatalogEntities(catalog) : [];
+    const modelEntities = models ? this.buildModelEntities(models) : [];
+    const allEntities = [...catalogEntities, ...modelEntities];
+    if (chartHints) {
+      this.applyChartHints(allEntities, chartHints);
+    }
+    const merged = this.mergeEntities(catalogEntities, modelEntities);
+    const relationships = catalog ? this.extractRelationships(catalog, merged) : [];
+    return {
+      entities: merged,
+      relationships,
+      generated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  isGoldModel(entry) {
+    const path = entry.path?.toLowerCase() ?? "";
+    const name = entry.name.toLowerCase();
+    const pathMatch = this.filter.paths.some((p) => path.includes(p.toLowerCase()));
+    const prefixMatch = this.filter.prefixes.some((p) => name.startsWith(p.toLowerCase()));
+    return pathMatch || prefixMatch;
+  }
+  buildCatalogEntities(catalog) {
+    return catalog.models.filter((entry) => this.isGoldModel(entry)).filter((entry) => entry.table).map((entry) => {
+      const { measures, dimensions } = classifyCatalogColumns(entry.columns ?? []);
+      return {
+        name: entry.name,
+        description: entry.description && entry.description !== "No description" ? entry.description : void 0,
+        source: "catalog",
+        source_table: entry.table,
+        measures,
+        dimensions
+      };
+    });
+  }
+  buildModelEntities(models) {
+    return models.filter((m) => m.metadata.returns && m.metadata.returns.length > 0).map((m) => {
+      const measures = [];
+      const dimensions = [];
+      for (const col of m.metadata.returns) {
+        const colType = col.type?.toLowerCase();
+        if (colType === "number") {
+          measures.push({
+            name: col.name,
+            type: this.inferAggType(col.name)
+          });
+        } else if (colType === "date" || colType === "datetime" || colType === "timestamp") {
+          dimensions.push({ name: col.name, type: "time" });
+        } else {
+          dimensions.push({ name: col.name, type: "string" });
+        }
+      }
+      const parameters = m.metadata.params?.map((p) => ({
+        name: p.name,
+        type: p.type,
+        default: p.default,
+        options: p.options
+      }));
+      return {
+        name: m.name,
+        description: m.description ?? m.metadata.description,
+        source: "model",
+        source_table: m.sourceTable ?? m.name,
+        measures,
+        dimensions,
+        parameters: parameters?.length ? parameters : void 0
+      };
+    });
+  }
+  inferAggType(name) {
+    const lower = name.toLowerCase();
+    if (/(_count$|^count_|^num_)/.test(lower))
+      return "count";
+    if (/(_avg$|_average$|_mean$|^avg_)/.test(lower))
+      return "avg";
+    if (/(^min_|_min$)/.test(lower))
+      return "min";
+    if (/(^max_|_max$)/.test(lower))
+      return "max";
+    return "sum";
+  }
+  applyChartHints(entities, hints) {
+    for (const hint of hints) {
+      const entity = entities.find((e) => e.name === hint.modelName || e.source_table.toLowerCase().includes(hint.modelName.toLowerCase()));
+      if (!entity)
+        continue;
+      for (const measureName of hint.measures) {
+        const dimIdx = entity.dimensions.findIndex((d) => d.name === measureName);
+        if (dimIdx !== -1) {
+          const dim = entity.dimensions.splice(dimIdx, 1)[0];
+          entity.measures.push({ name: dim.name, type: this.inferAggType(dim.name) });
+        }
+      }
+      for (const timeDim of hint.timeDimensions) {
+        const dim = entity.dimensions.find((d) => d.name === timeDim);
+        if (dim)
+          dim.type = "time";
+      }
+      for (const [field, format2] of Object.entries(hint.formats)) {
+        const measure = entity.measures.find((m) => m.name === field);
+        if (measure)
+          measure.format = format2;
+      }
+    }
+  }
+  mergeEntities(catalogEntities, modelEntities) {
+    const modelTables = new Set(modelEntities.map((e) => e.source_table.toLowerCase()));
+    const filteredCatalog = catalogEntities.filter((e) => !modelTables.has(e.source_table.toLowerCase()));
+    return [...filteredCatalog, ...modelEntities];
+  }
+  extractRelationships(catalog, entities) {
+    const entityNames = new Set(entities.map((e) => e.name));
+    const relationships = [];
+    for (const entry of catalog.models) {
+      if (!entityNames.has(entry.name))
+        continue;
+      if (!entry.dependsOn)
+        continue;
+      for (const dep of entry.dependsOn) {
+        const parts = dep.split(".");
+        const depName = parts[parts.length - 1];
+        if (!entityNames.has(depName))
+          continue;
+        const fromEntity = entities.find((e) => e.name === entry.name);
+        const toEntity = entities.find((e) => e.name === depName);
+        if (!fromEntity || !toEntity)
+          continue;
+        const fromFields = [...fromEntity.measures, ...fromEntity.dimensions].map((f) => f.name.toLowerCase());
+        const toFields = [...toEntity.measures, ...toEntity.dimensions].map((f) => f.name.toLowerCase());
+        const shared = fromFields.filter((f) => toFields.includes(f) && f.endsWith("_id"));
+        if (shared.length > 0) {
+          relationships.push({
+            from: { entity: entry.name, field: shared[0] },
+            to: { entity: depName, field: shared[0] },
+            type: "many_to_one"
+          });
+        }
+      }
+    }
+    return relationships;
+  }
+};
+
+// ../../packages/query/dist/semantic/query-compiler.js
+var SemanticQueryCompiler = class {
+  compile(model, query) {
+    const entity = model.entities.find((e) => e.name === query.model);
+    if (!entity)
+      throw new Error(`Entity '${query.model}' not found`);
+    const selectParts = [];
+    const groupByParts = [];
+    for (const dimName of query.dimensions) {
+      selectParts.push(`"${dimName}"`);
+      groupByParts.push(`"${dimName}"`);
+    }
+    for (const measureName of query.measures) {
+      const measure = entity.measures.find((m) => m.name === measureName);
+      if (!measure)
+        throw new Error(`Measure '${measureName}' not found`);
+      selectParts.push(`${this.formatMeasure(measure.type, measureName)} AS "${measureName}"`);
+    }
+    const parts = [];
+    parts.push(`SELECT ${selectParts.join(", ")}`);
+    parts.push(`FROM ${entity.source_table}`);
+    if (query.filters.length > 0) {
+      const conditions = query.filters.map((f) => this.compileFilter(f));
+      parts.push(`WHERE ${conditions.join(" AND ")}`);
+    }
+    if (groupByParts.length > 0) {
+      parts.push(`GROUP BY ${groupByParts.join(", ")}`);
+    }
+    if (query.order_by) {
+      parts.push(`ORDER BY "${query.order_by.field}" ${query.order_by.direction.toUpperCase()}`);
+    }
+    parts.push(`LIMIT ${query.limit}`);
+    return parts.join("\n");
+  }
+  formatMeasure(type, column) {
+    if (type === "count_distinct") {
+      return `COUNT(DISTINCT "${column}")`;
+    }
+    return `${this.aggFunction(type)}("${column}")`;
+  }
+  aggFunction(type) {
+    switch (type) {
+      case "sum":
+        return "SUM";
+      case "count":
+        return "COUNT";
+      case "avg":
+        return "AVG";
+      case "min":
+        return "MIN";
+      case "max":
+        return "MAX";
+    }
+  }
+  compileFilter(filter) {
+    const field = `"${filter.dimension}"`;
+    const value = filter.value;
+    switch (filter.operator) {
+      case "equals":
+        return `${field} = ${this.quoteValue(value)}`;
+      case "not_equals":
+        return `${field} != ${this.quoteValue(value)}`;
+      case "contains":
+        return `${field} LIKE '%${this.escapeString(String(value))}%'`;
+      case "gt":
+        return `${field} > ${this.quoteValue(value)}`;
+      case "gte":
+        return `${field} >= ${this.quoteValue(value)}`;
+      case "lt":
+        return `${field} < ${this.quoteValue(value)}`;
+      case "lte":
+        return `${field} <= ${this.quoteValue(value)}`;
+      case "in":
+        return `${field} IN (${value.map((v) => this.quoteValue(v)).join(", ")})`;
+      case "not_in":
+        return `${field} NOT IN (${value.map((v) => this.quoteValue(v)).join(", ")})`;
+      default:
+        throw new Error(`Unknown filter operator: ${filter.operator}`);
+    }
+  }
+  quoteValue(value) {
+    if (typeof value === "number")
+      return String(value);
+    if (typeof value === "boolean")
+      return String(value);
+    return `'${this.escapeString(String(value))}'`;
+  }
+  escapeString(value) {
+    return value.replace(/'/g, "''");
+  }
+};
+
+// ../../packages/query/dist/semantic/validators.js
+var SemanticValidationError = class extends Error {
+  code;
+  available;
+  constructor(code, message, available) {
+    super(message);
+    this.name = "SemanticValidationError";
+    this.code = code;
+    this.available = available;
+  }
+};
+function validateSemanticQuery(model, query) {
+  const entity = model.entities.find((e) => e.name === query.model);
+  if (!entity) {
+    throw new SemanticValidationError("unknown_model", `Unknown model '${query.model}'. Available models: ${model.entities.map((e) => e.name).join(", ")}`, model.entities.map((e) => e.name));
+  }
+  const measureNames = entity.measures.map((m) => m.name);
+  const dimensionNames = entity.dimensions.map((d) => d.name);
+  const allFields = [...measureNames, ...dimensionNames];
+  for (const m of query.measures) {
+    if (!measureNames.includes(m)) {
+      throw new SemanticValidationError("unknown_measure", `Unknown measure '${m}' on entity '${query.model}'. Available measures: ${measureNames.join(", ")}`, measureNames);
+    }
+  }
+  for (const d of query.dimensions) {
+    if (!dimensionNames.includes(d)) {
+      throw new SemanticValidationError("unknown_dimension", `Unknown dimension '${d}' on entity '${query.model}'. Available dimensions: ${dimensionNames.join(", ")}`, dimensionNames);
+    }
+  }
+  for (const f of query.filters) {
+    if (!dimensionNames.includes(f.dimension)) {
+      throw new SemanticValidationError("unknown_filter_dimension", `Unknown filter dimension '${f.dimension}' on entity '${query.model}'. Available dimensions: ${dimensionNames.join(", ")}`, dimensionNames);
+    }
+  }
+  if (query.order_by) {
+    if (!allFields.includes(query.order_by.field)) {
+      throw new SemanticValidationError("unknown_order_field", `Unknown order_by field '${query.order_by.field}' on entity '${query.model}'. Available fields: ${allFields.join(", ")}`, allFields);
+    }
+  }
+}
+
+// ../../packages/query/dist/semantic/loader.js
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { join } from "path";
+import { parse as parseYaml } from "yaml";
+function toResolvedEntity(def, resolveTable) {
+  const sourceRef = def.source.table ?? resolveTable(def.source.model);
+  return {
+    name: def.entity,
+    sourceRef,
+    timeDimension: def.time_dimension,
+    dimensions: def.dimensions,
+    filters: def.filters ?? {},
+    metrics: def.metrics
+  };
+}
+function buildSemanticLayer(defs, resolveTable = (m) => m) {
+  const entities = defs.map((d) => toResolvedEntity(d, resolveTable));
+  const byMetricKey = /* @__PURE__ */ new Map();
+  const list = [];
+  for (const entity of entities) {
+    for (const metric of entity.metrics) {
+      const resolved = { metric, entity };
+      byMetricKey.set(metric.name.toLowerCase(), resolved);
+      for (const syn of metric.synonyms ?? []) {
+        if (!byMetricKey.has(syn.toLowerCase()))
+          byMetricKey.set(syn.toLowerCase(), resolved);
+      }
+      list.push({
+        name: metric.name,
+        label: metric.label,
+        description: metric.description,
+        entity: entity.name,
+        agg: metric.agg,
+        synonyms: metric.synonyms ?? [],
+        format: metric.format,
+        dimensions: entity.dimensions.map((d) => d.name)
+      });
+    }
+  }
+  return {
+    listMetrics: () => list,
+    resolveMetric: (key) => byMetricKey.get(key.toLowerCase()),
+    getEntity: (name) => entities.find((e) => e.name === name)
+  };
+}
+function loadSemanticDefinitions(projectDir) {
+  const dir = join(projectDir, "semantic");
+  if (!existsSync(dir))
+    return [];
+  const defs = [];
+  for (const file of readdirSync(dir)) {
+    if (!/\.ya?ml$/.test(file))
+      continue;
+    const raw = parseYaml(readFileSync(join(dir, file), "utf8"));
+    const entries = Array.isArray(raw?.entities) ? raw.entities : [raw];
+    for (const entry of entries) {
+      defs.push(SemanticDefinitionSchema.parse(entry));
+    }
+  }
+  return defs;
+}
+
+// ../../packages/query/dist/semantic/dialect.js
+var stringFirst = {
+  dateTrunc: (col, grain) => `date_trunc('${grain}', ${col})`,
+  quoteIdent: (id) => `"${id}"`
+};
+var bigquery = {
+  dateTrunc: (col, grain) => `DATE_TRUNC(${col}, ${grain.toUpperCase()})`,
+  quoteIdent: (id) => "`" + id + "`"
+};
+function getDialect(connectionType) {
+  switch ((connectionType || "").toLowerCase()) {
+    case "bigquery":
+      return bigquery;
+    case "duckdb":
+    case "postgres":
+    case "snowflake":
+    case "mysql":
+      return stringFirst;
+    default:
+      return stringFirst;
+  }
+}
+
+// ../../packages/query/dist/semantic/metric-compiler.js
+var AGG_FN = {
+  sum: "SUM",
+  count: "COUNT",
+  avg: "AVG",
+  min: "MIN",
+  max: "MAX",
+  count_distinct: "COUNT(DISTINCT"
+};
+function aggExpr(metric, filterSql) {
+  if (metric.sql)
+    return `${metric.sql} AS ${metric.name}`;
+  const inner = filterSql ? `CASE WHEN ${filterSql} THEN ${metric.field} END` : metric.field;
+  if (metric.agg === "count_distinct")
+    return `COUNT(DISTINCT ${inner}) AS ${metric.name}`;
+  return `${AGG_FN[metric.agg]}(${inner}) AS ${metric.name}`;
+}
+function sqlLiteral(value) {
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  if (Array.isArray(value))
+    return `(${value.map(sqlLiteral).join(", ")})`;
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+var OPERATORS = {
+  equals: "=",
+  not_equals: "!=",
+  gt: ">",
+  gte: ">=",
+  lt: "<",
+  lte: "<=",
+  in: "IN",
+  not_in: "NOT IN"
+};
+var DATE_RE = /^\d{4}-\d{2}-\d{2}([ T]\d{2}:\d{2}(:\d{2}(\.\d+)?)?Z?)?$/;
+function compileMetricQuery(entity, query, connectionType) {
+  const dialect = getDialect(connectionType);
+  const select = [];
+  const groupCols = [];
+  for (const dimName of query.dimensions ?? []) {
+    const dim = entity.dimensions.find((d) => d.name === dimName);
+    if (!dim)
+      throw new Error(`Unknown dimension "${dimName}" on entity "${entity.name}".`);
+    if (dim.type === "time" && query.grain) {
+      select.push(`${dialect.dateTrunc(dim.name, query.grain)} AS ${dim.name}`);
+    } else {
+      select.push(dim.name);
+    }
+    groupCols.push(dim.name);
+  }
+  if (query.grain && entity.timeDimension && !(query.dimensions ?? []).includes(entity.timeDimension)) {
+    select.unshift(`${dialect.dateTrunc(entity.timeDimension, query.grain)} AS ${entity.timeDimension}`);
+    groupCols.unshift(entity.timeDimension);
+  }
+  const resolvedMetrics = [];
+  for (const metricName of query.metrics) {
+    const metric = entity.metrics.find((m) => m.name === metricName);
+    if (!metric)
+      throw new Error(`Unknown metric "${metricName}" on entity "${entity.name}".`);
+    const filterSql = metric.filter ? entity.filters[metric.filter]?.sql : void 0;
+    if (metric.filter && !filterSql) {
+      throw new Error(`Metric "${metricName}" references unknown filter "${metric.filter}".`);
+    }
+    select.push(aggExpr(metric, filterSql));
+    resolvedMetrics.push(metric);
+  }
+  const where = [];
+  if (query.time_range && entity.timeDimension) {
+    let start_date;
+    let end_date;
+    if ("preset" in query.time_range) {
+      const expanded = expandDatePreset(query.time_range.preset);
+      if (!expanded) {
+        throw new Error(`Unrecognized date preset "${query.time_range.preset}".`);
+      }
+      start_date = expanded.start_date;
+      end_date = expanded.end_date;
+    } else {
+      start_date = query.time_range.start;
+      end_date = query.time_range.end;
+      if (!DATE_RE.test(start_date) || !DATE_RE.test(end_date)) {
+        throw new Error("time_range.start and time_range.end must be YYYY-MM-DD (optionally with a time).");
+      }
+    }
+    where.push(`${entity.timeDimension} >= '${start_date}'`);
+    where.push(`${entity.timeDimension} <= '${end_date}'`);
+  }
+  for (const f of query.filters ?? []) {
+    const op = OPERATORS[f.operator];
+    if (!op)
+      throw new Error(`Unsupported filter operator "${f.operator}".`);
+    if (!entity.dimensions.some((d) => d.name === f.dimension)) {
+      throw new Error(`Unknown filter dimension "${f.dimension}" on entity "${entity.name}".`);
+    }
+    where.push(`${dialect.quoteIdent(f.dimension)} ${op} ${sqlLiteral(f.value)}`);
+  }
+  const lines = [`SELECT ${select.join(", ")}`, `FROM ${entity.sourceRef}`];
+  if (where.length)
+    lines.push(`WHERE ${where.join(" AND ")}`);
+  if (groupCols.length)
+    lines.push(`GROUP BY ${groupCols.map((_, i) => i + 1).join(", ")}`);
+  if (query.order_by) {
+    const selectable = /* @__PURE__ */ new Set([...groupCols, ...resolvedMetrics.map((m) => m.name)]);
+    if (!selectable.has(query.order_by.field)) {
+      throw new Error(`order_by.field "${query.order_by.field}" is not a selected column. Choose one of: ${[...selectable].join(", ")}.`);
+    }
+    lines.push(`ORDER BY ${dialect.quoteIdent(query.order_by.field)} ${(query.order_by.direction ?? "asc").toUpperCase()}`);
+  }
+  lines.push(`LIMIT ${query.limit ?? 1e3}`);
+  return { sql: lines.join("\n"), metrics: resolvedMetrics, groupCols };
+}
+
+export {
+  isCustomDateRange,
+  expandCustomDateRange,
+  DATE_PRESETS,
+  expandDatePreset,
+  computePreviousPeriod,
+  formatPeriodLabel,
+  isDatePreset,
+  isRelativeDateRange,
+  expandRelativeDateRange,
+  classifyField,
+  inferAggregationType,
+  classifyCatalogColumns,
+  SemanticModelBuilder,
+  SemanticQueryCompiler,
+  SemanticValidationError,
+  validateSemanticQuery,
+  buildSemanticLayer,
+  loadSemanticDefinitions,
+  getDialect,
+  compileMetricQuery
+};
+//# sourceMappingURL=chunk-UFDQ3C7Q.js.map