drizzle-cube 0.1.3 → 0.1.5

package/dist/server/index.js

@@ -1,168 +1,249 @@
-var kr = Object.defineProperty;
-var eo = (n, e, t) => e in n ? kr(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
-var r = (n, e, t) => eo(n, typeof e != "symbol" ? e + "" : e, t);
-import { and as B, sql as y, eq as di, count as Y, max as to, min as no, avg as so, sum as io, countDistinct as ro, or as oo, gt as re, lt as oe, gte as ae, lte as ue, isNull as ao, isNotNull as uo, ne as co, relations as J } from "drizzle-orm";
-import { parse as lo, stringify as mo } from "yaml";
-function Sa(n, e) {
+var z = Object.defineProperty;
+var U = (s, e, t) => e in s ? z(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var C = (s, e, t) => U(s, typeof e != "symbol" ? e + "" : e, t);
+import { sql as f, and as p, eq as v, count as y, max as B, min as O, avg as R, sum as I, countDistinct as Y, or as J, gt as A, lt as F, gte as w, lte as N, isNull as W, isNotNull as K, notInArray as H, ne as V, inArray as Z } from "drizzle-orm";
+import { parse as G, stringify as P } from "yaml";
+function we(s, e) {
   return {
     ...e,
     name: e.name
   };
 }
-class ee {
+class x {
   constructor(e, t) {
     this.db = e, this.schema = t;
   }
 }
-class fo extends ee {
-  async execute(e) {
+class X extends x {
+  async execute(e, t) {
     if (e && typeof e == "object") {
       if (typeof e.execute == "function") {
-        const s = await e.execute();
-        return Array.isArray(s) ? s.map((i) => this.convertNumericFields(i)) : s;
+        const n = await e.execute();
+        return Array.isArray(n) ? n.map((o) => this.convertNumericFields(o, t)) : n;
       }
       if (this.db && typeof this.db.execute == "function")
         try {
-          const s = await this.db.execute(e);
-          return Array.isArray(s) ? s.map((i) => this.convertNumericFields(i)) : s;
-        } catch (s) {
+          const n = await this.db.execute(e);
+          return Array.isArray(n) ? n.map((o) => this.convertNumericFields(o, t)) : n;
+        } catch (n) {
           if (typeof e.getSQL == "function") {
-            const i = e.getSQL(), o = await this.db.execute(i);
-            return Array.isArray(o) ? o.map((l) => this.convertNumericFields(l)) : o;
+            const o = e.getSQL(), a = await this.db.execute(o);
+            return Array.isArray(a) ? a.map((r) => this.convertNumericFields(r, t)) : a;
           }
-          throw s;
+          throw n;
         }
     }
     if (!this.db.execute)
       throw new Error("PostgreSQL database instance must have an execute method");
-    const t = await this.db.execute(e);
-    return Array.isArray(t) ? t.map((s) => this.convertNumericFields(s)) : t;
+    const i = await this.db.execute(e);
+    return Array.isArray(i) ? i.map((n) => this.convertNumericFields(n, t)) : i;
   }
   /**
-   * Convert numeric string fields to numbers
+   * Convert numeric string fields to numbers (only for measure fields)
    */
-  convertNumericFields(e) {
+  convertNumericFields(e, t) {
     if (!e || typeof e != "object") return e;
-    const t = {};
-    for (const [s, i] of Object.entries(e))
-      typeof i == "string" && /^\d+(\.\d+)?$/.test(i) ? t[s] = i.includes(".") ? parseFloat(i) : parseInt(i, 10) : t[s] = i;
-    return t;
+    const i = {};
+    for (const [n, o] of Object.entries(e))
+      t && t.includes(n) ? i[n] = this.coerceToNumber(o) : i[n] = o;
+    return i;
+  }
+  /**
+   * Coerce a value to a number if it represents a numeric type
+   */
+  coerceToNumber(e) {
+    var t, i;
+    if (e == null || typeof e == "number") return e;
+    if (typeof e == "bigint") return Number(e);
+    if (e && typeof e == "object") {
+      if (typeof e.toString == "function") {
+        const n = e.toString();
+        if (/^-?\d+(\.\d+)?$/.test(n))
+          return n.includes(".") ? parseFloat(n) : parseInt(n, 10);
+      }
+      if (((t = e.constructor) == null ? void 0 : t.name) === "Numeric" || ((i = e.constructor) == null ? void 0 : i.name) === "Decimal" || "digits" in e || "sign" in e) {
+        const n = e.toString();
+        return parseFloat(n);
+      }
+      return e;
+    }
+    if (typeof e == "string") {
+      if (/^-?\d+(\.\d+)?$/.test(e))
+        return e.includes(".") ? parseFloat(e) : parseInt(e, 10);
+      if (!isNaN(parseFloat(e)) && isFinite(parseFloat(e)))
+        return parseFloat(e);
+    }
+    return e;
   }
   getEngineType() {
     return "postgres";
   }
 }
-class po extends ee {
-  async execute(e) {
-    if (e && typeof e == "object" && typeof e.execute == "function")
-      return await e.execute();
+class q extends x {
+  async execute(e, t) {
+    if (e && typeof e == "object" && typeof e.execute == "function") {
+      const i = await e.execute();
+      return Array.isArray(i) ? i.map((n) => this.convertNumericFields(n, t)) : i;
+    }
     try {
-      if (this.db.all)
-        return this.db.all(e);
-      if (this.db.run)
-        return this.db.run(e);
-      throw new Error("SQLite database instance must have an all() or run() method");
-    } catch (t) {
-      throw new Error(`SQLite execution failed: ${t instanceof Error ? t.message : "Unknown error"}`);
+      if (this.db.all) {
+        const i = this.db.all(e);
+        return Array.isArray(i) ? i.map((n) => this.convertNumericFields(n, t)) : i;
+      } else {
+        if (this.db.run)
+          return this.db.run(e);
+        throw new Error("SQLite database instance must have an all() or run() method");
+      }
+    } catch (i) {
+      throw new Error(`SQLite execution failed: ${i instanceof Error ? i.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Convert numeric string fields to numbers (only for measure fields)
+   */
+  convertNumericFields(e, t) {
+    if (!e || typeof e != "object") return e;
+    const i = {};
+    for (const [n, o] of Object.entries(e))
+      t && t.includes(n) ? i[n] = this.coerceToNumber(o) : i[n] = o;
+    return i;
+  }
+  /**
+   * Coerce a value to a number if it represents a numeric type
+   */
+  coerceToNumber(e) {
+    if (e == null || typeof e == "number") return e;
+    if (typeof e == "string") {
+      if (/^-?\d+(\.\d+)?$/.test(e))
+        return e.includes(".") ? parseFloat(e) : parseInt(e, 10);
+      if (!isNaN(parseFloat(e)) && isFinite(parseFloat(e)))
+        return parseFloat(e);
     }
+    return e;
   }
   getEngineType() {
     return "sqlite";
   }
 }
-class ho extends ee {
-  async execute(e) {
-    if (e && typeof e == "object" && typeof e.execute == "function")
-      return await e.execute();
+class ee extends x {
+  async execute(e, t) {
+    if (e && typeof e == "object" && typeof e.execute == "function") {
+      const n = await e.execute();
+      return Array.isArray(n) ? n.map((o) => this.convertNumericFields(o, t)) : n;
+    }
     if (!this.db.execute)
       throw new Error("MySQL database instance must have an execute method");
-    return await this.db.execute(e);
+    const i = await this.db.execute(e);
+    return Array.isArray(i) ? i.map((n) => this.convertNumericFields(n, t)) : i;
+  }
+  /**
+   * Convert numeric string fields to numbers (only for measure fields)
+   */
+  convertNumericFields(e, t) {
+    if (!e || typeof e != "object") return e;
+    const i = {};
+    for (const [n, o] of Object.entries(e))
+      t && t.includes(n) ? i[n] = this.coerceToNumber(o) : i[n] = o;
+    return i;
+  }
+  /**
+   * Coerce a value to a number if it represents a numeric type
+   */
+  coerceToNumber(e) {
+    if (e == null || typeof e == "number") return e;
+    if (typeof e == "string") {
+      if (/^-?\d+(\.\d+)?$/.test(e))
+        return e.includes(".") ? parseFloat(e) : parseInt(e, 10);
+      if (!isNaN(parseFloat(e)) && isFinite(parseFloat(e)))
+        return parseFloat(e);
+    }
+    return e;
   }
   getEngineType() {
     return "mysql";
   }
 }
-function ce(n, e) {
-  return new fo(n, e);
+function S(s, e) {
+  return new X(s, e);
 }
-function le(n, e) {
-  return new po(n, e);
+function M(s, e) {
+  return new q(s, e);
 }
-function go(n, e) {
-  return new ho(n, e);
+function te(s, e) {
+  return new ee(s, e);
 }
-function me(n, e, t) {
+function _(s, e, t) {
   if (t)
     switch (t) {
       case "postgres":
-        return ce(n, e);
+        return S(s, e);
       case "mysql":
-        return go(n, e);
+        return te(s, e);
       case "sqlite":
-        return le(n, e);
+        return M(s, e);
     }
-  if (n.all && n.run)
-    return le(n, e);
-  if (n.execute)
-    return ce(n, e);
+  if (s.all && s.run)
+    return M(s, e);
+  if (s.execute)
+    return S(s, e);
   throw new Error("Unable to determine database engine type. Please specify engineType parameter.");
 }
-function Pa(n, e) {
+function Ne(s, e) {
   return {
-    name: n,
+    name: s,
     ...e
   };
 }
-function v(n, e) {
-  return typeof n == "function" ? n(e) : n;
+function b(s, e) {
+  return typeof s == "function" ? s(e) : s;
 }
-function bo(n, e, t) {
+function ne(s, e, t) {
   return {
-    ...n,
+    ...s,
     cubes: e,
     currentCube: t
   };
 }
-class yo {
+class ie {
   /**
    * Analyze a semantic query to determine which cubes are involved
    */
   analyzeCubeUsage(e) {
     const t = /* @__PURE__ */ new Set();
     if (e.measures)
-      for (const s of e.measures) {
-        const [i] = s.split(".");
-        t.add(i);
+      for (const i of e.measures) {
+        const [n] = i.split(".");
+        t.add(n);
       }
     if (e.dimensions)
-      for (const s of e.dimensions) {
-        const [i] = s.split(".");
-        t.add(i);
+      for (const i of e.dimensions) {
+        const [n] = i.split(".");
+        t.add(n);
       }
     if (e.timeDimensions)
-      for (const s of e.timeDimensions) {
-        const [i] = s.dimension.split(".");
-        t.add(i);
+      for (const i of e.timeDimensions) {
+        const [n] = i.dimension.split(".");
+        t.add(n);
       }
     return t;
   }
   /**
    * Build a multi-cube query plan
    */
-  buildMultiCubeQueryPlan(e, t, s) {
-    const i = this.analyzeCubeUsage(t), o = Array.from(i);
+  buildMultiCubeQueryPlan(e, t, i) {
+    const n = this.analyzeCubeUsage(t), o = Array.from(n);
     if (o.length === 1)
       throw new Error("Single cube query should use QueryExecutor directly");
-    const l = this.choosePrimaryCube(o, t), a = e.get(l);
-    if (!a)
-      throw new Error(`Primary cube '${l}' not found`);
-    const m = this.buildJoinPlan(e, a, o, s.securityContext), d = this.buildMultiCubeSelections(e, t, s.securityContext), u = this.buildMultiCubeWhereConditions(e, t, s), f = this.buildMultiCubeGroupByFields(e, t, s.securityContext);
+    const a = this.choosePrimaryCube(o, t), r = e.get(a);
+    if (!r)
+      throw new Error(`Primary cube '${a}' not found`);
+    const c = this.buildJoinPlan(e, r, o, i.securityContext), l = this.buildMultiCubeSelections(e, t, i.securityContext), u = this.buildMultiCubeWhereConditions(e, t, i), m = this.buildMultiCubeGroupByFields(e, t, i.securityContext);
     return {
-      primaryCube: a,
-      joinCubes: m,
-      selections: d,
+      primaryCube: r,
+      joinCubes: c,
+      selections: l,
       whereConditions: u,
-      groupByFields: f
+      groupByFields: m
     };
   }
   /**
@@ -170,44 +251,44 @@ class yo {
    */
   choosePrimaryCube(e, t) {
     if (t.measures && t.measures.length > 0) {
-      const [s] = t.measures[0].split(".");
-      return s;
+      const [i] = t.measures[0].split(".");
+      return i;
     }
     if (t.dimensions && t.dimensions.length > 0) {
-      const [s] = t.dimensions[0].split(".");
-      return s;
+      const [i] = t.dimensions[0].split(".");
+      return i;
     }
     return e[0];
   }
   /**
    * Build join plan for multi-cube query
    */
-  buildJoinPlan(e, t, s, i) {
-    var a;
-    const o = [], l = s.filter((m) => m !== t.name);
-    for (const m of l) {
-      const d = e.get(m);
-      if (!d)
-        throw new Error(`Cube '${m}' not found`);
-      const u = (a = t.joins) == null ? void 0 : a[m];
+  buildJoinPlan(e, t, i, n) {
+    var r;
+    const o = [], a = i.filter((c) => c !== t.name);
+    for (const c of a) {
+      const l = e.get(c);
+      if (!l)
+        throw new Error(`Cube '${c}' not found`);
+      const u = (r = t.joins) == null ? void 0 : r[c];
       if (!u)
-        throw new Error(`No join definition found from '${t.name}' to '${m}'`);
-      const f = bo(
+        throw new Error(`No join definition found from '${t.name}' to '${c}'`);
+      const m = ne(
         {
           db: {},
           // Will be filled in during execution
           schema: {},
           // Will be filled in during execution
-          securityContext: i
+          securityContext: n
         },
         e,
-        d
-      ), p = u.condition(f);
+        l
+      ), d = u.condition(m);
       o.push({
-        cube: d,
-        alias: `${m.toLowerCase()}_cube`,
+        cube: l,
+        alias: `${c.toLowerCase()}_cube`,
         joinType: u.type || "left",
-        joinCondition: p
+        joinCondition: d
       });
     }
     return o;
@@ -215,128 +296,128 @@ class yo {
   /**
    * Build selections across multiple cubes
    */
-  buildMultiCubeSelections(e, t, s) {
-    const i = {}, o = {
+  buildMultiCubeSelections(e, t, i) {
+    const n = {}, o = {
       db: {},
       // Filled during execution
       schema: {},
       // Filled during execution
-      securityContext: s
+      securityContext: i
     };
     if (t.dimensions)
-      for (const l of t.dimensions) {
-        const [a, m] = l.split("."), d = e.get(a);
-        if (d && d.dimensions[m]) {
-          const u = d.dimensions[m], f = v(u.sql, o);
-          i[l] = f;
+      for (const a of t.dimensions) {
+        const [r, c] = a.split("."), l = e.get(r);
+        if (l && l.dimensions[c]) {
+          const u = l.dimensions[c], m = b(u.sql, o);
+          n[a] = f`${m}`.as(a);
         }
       }
     if (t.measures)
-      for (const l of t.measures) {
-        const [a, m] = l.split("."), d = e.get(a);
-        if (d && d.measures[m]) {
-          const u = d.measures[m], f = this.buildMeasureExpression(u, o);
-          i[l] = f;
+      for (const a of t.measures) {
+        const [r, c] = a.split("."), l = e.get(r);
+        if (l && l.measures[c]) {
+          const u = l.measures[c], m = this.buildMeasureExpression(u, o);
+          n[a] = f`${m}`.as(a);
         }
       }
     if (t.timeDimensions)
-      for (const l of t.timeDimensions) {
-        const [a, m] = l.dimension.split("."), d = e.get(a);
-        if (d && d.dimensions[m]) {
-          const u = d.dimensions[m], f = this.buildTimeDimensionExpression(
+      for (const a of t.timeDimensions) {
+        const [r, c] = a.dimension.split("."), l = e.get(r);
+        if (l && l.dimensions[c]) {
+          const u = l.dimensions[c], m = this.buildTimeDimensionExpression(
             u.sql,
-            l.granularity,
+            a.granularity,
             o
           );
-          i[l.dimension] = f;
+          n[a.dimension] = f`${m}`.as(a.dimension);
         }
       }
-    return i;
+    return n;
   }
   /**
    * Build measure expression with aggregation (similar to single-cube approach)
    */
   buildMeasureExpression(e, t) {
-    let s = v(e.sql, t);
+    let i = b(e.sql, t);
     if (e.filters && e.filters.length > 0) {
-      const i = e.filters.map((o) => o(t));
-      s = y`CASE WHEN ${B(...i)} THEN ${s} END`;
+      const n = e.filters.map((o) => o(t));
+      i = f`CASE WHEN ${p(...n)} THEN ${i} END`;
     }
     switch (e.type) {
       case "count":
-        return y`COUNT(${s})`;
+        return f`COUNT(${i})`;
       case "countDistinct":
-        return y`COUNT(DISTINCT ${s})`;
+        return f`COUNT(DISTINCT ${i})`;
       case "sum":
-        return y`SUM(${s})`;
+        return f`SUM(${i})`;
       case "avg":
-        return y`AVG(${s})`;
+        return f`AVG(${i})`;
       case "min":
-        return y`MIN(${s})`;
+        return f`MIN(${i})`;
       case "max":
-        return y`MAX(${s})`;
+        return f`MAX(${i})`;
       case "number":
-        return s;
+        return i;
       default:
-        return y`COUNT(${s})`;
+        return f`COUNT(${i})`;
     }
   }
   /**
    * Build time dimension expression (similar to single-cube approach)
    */
-  buildTimeDimensionExpression(e, t, s) {
-    const i = v(e, s);
+  buildTimeDimensionExpression(e, t, i) {
+    const n = b(e, i);
     if (!t)
-      return i;
+      return n;
     switch (t) {
       case "year":
-        return y`DATE_TRUNC('year', ${i}::timestamptz)`;
+        return f`DATE_TRUNC('year', ${n}::timestamp)`;
       case "quarter":
-        return y`DATE_TRUNC('quarter', ${i}::timestamptz)`;
+        return f`DATE_TRUNC('quarter', ${n}::timestamp)`;
       case "month":
-        return y`DATE_TRUNC('month', ${i}::timestamptz)`;
+        return f`DATE_TRUNC('month', ${n}::timestamp)`;
       case "week":
-        return y`DATE_TRUNC('week', ${i}::timestamptz)`;
+        return f`DATE_TRUNC('week', ${n}::timestamp)`;
       case "day":
-        return y`DATE_TRUNC('day', ${i}::timestamptz)`;
+        return f`DATE_TRUNC('day', ${n}::timestamp)`;
       case "hour":
-        return y`DATE_TRUNC('hour', ${i}::timestamptz)`;
+        return f`DATE_TRUNC('hour', ${n}::timestamp)`;
       case "minute":
-        return y`DATE_TRUNC('minute', ${i}::timestamptz)`;
+        return f`DATE_TRUNC('minute', ${n}::timestamp)`;
       case "second":
-        return y`DATE_TRUNC('second', ${i}::timestamptz)`;
+        return f`DATE_TRUNC('second', ${n}::timestamp)`;
       default:
-        return i;
+        return n;
     }
   }
   /**
    * Build WHERE conditions for multi-cube query
    */
-  buildMultiCubeWhereConditions(e, t, s) {
-    const i = [];
+  buildMultiCubeWhereConditions(e, t, i) {
+    const n = [];
     if (t.filters) {
       for (const o of t.filters)
         if ("member" in o) {
-          const [l] = o.member.split("."), a = e.get(l);
-          if (a) {
-            const m = this.buildFilterCondition(o, a, s);
-            m && i.push(m);
+          const [a] = o.member.split("."), r = e.get(a);
+          if (r) {
+            const c = this.buildFilterCondition(o, r, i);
+            c && n.push(c);
           }
         }
     }
-    return i;
+    return n;
   }
   /**
    * Filter condition builder (would reuse logic from DrizzleExecutor)
    */
-  buildFilterCondition(e, t, s) {
+  buildFilterCondition(e, t, i) {
     if (e.operator === "equals" && e.values && e.values.length > 0) {
-      const [i, o] = e.member.split(".");
-      if (i === t.name) {
-        const l = t.dimensions[o] || t.measures[o];
-        if (l) {
-          const a = typeof l.sql == "function" ? l.sql(s) : l.sql;
-          return di(a, e.values[0]);
+      const [n, o] = e.member.split(".");
+      if (n === t.name) {
+        const a = t.dimensions[o] || t.measures[o];
+        if (a) {
+          const r = typeof a.sql == "function" ? a.sql(i) : a.sql;
+          return v(r, e.values[0]);
         }
       }
     }
@@ -345,481 +426,658 @@ class yo {
   /**
    * Build GROUP BY fields for multi-cube query
    */
-  buildMultiCubeGroupByFields(e, t, s) {
-    const i = [];
+  buildMultiCubeGroupByFields(e, t, i) {
+    const n = [];
     if (!(t.measures && t.measures.length > 0))
       return [];
-    const l = {
+    const a = {
       db: {},
       schema: {},
-      securityContext: s
+      securityContext: i
     };
     if (t.dimensions)
-      for (const a of t.dimensions) {
-        const [m, d] = a.split("."), u = e.get(m);
-        if (u && u.dimensions[d]) {
-          const f = u.dimensions[d], p = v(f.sql, l);
-          i.push(p);
+      for (const r of t.dimensions) {
+        const [c, l] = r.split("."), u = e.get(c);
+        if (u && u.dimensions[l]) {
+          const m = u.dimensions[l], d = b(m.sql, a);
+          n.push(d);
         }
       }
     if (t.timeDimensions)
-      for (const a of t.timeDimensions) {
-        const [m, d] = a.dimension.split("."), u = e.get(m);
-        if (u && u.dimensions[d]) {
-          const f = u.dimensions[d], p = this.buildTimeDimensionExpression(
-            f.sql,
-            a.granularity,
-            l
+      for (const r of t.timeDimensions) {
+        const [c, l] = r.dimension.split("."), u = e.get(c);
+        if (u && u.dimensions[l]) {
+          const m = u.dimensions[l], d = this.buildTimeDimensionExpression(
+            m.sql,
+            r.granularity,
+            a
           );
-          i.push(p);
+          n.push(d);
         }
       }
-    return i;
+    return n;
   }
 }
-class de {
+class $ {
   constructor(e) {
-    r(this, "multiCubeBuilder");
-    this.dbExecutor = e, this.multiCubeBuilder = new yo();
+    C(this, "multiCubeBuilder");
+    this.dbExecutor = e, this.multiCubeBuilder = new ie();
   }
   /**
    * Unified query execution method that handles both single and multi-cube queries
    */
-  async execute(e, t, s) {
+  async execute(e, t, i) {
     try {
-      const i = this.multiCubeBuilder.analyzeCubeUsage(t);
-      if (i.size === 0)
+      const n = j(e, t);
+      if (!n.isValid)
+        throw new Error(`Query validation failed: ${n.errors.join(", ")}`);
+      const o = this.multiCubeBuilder.analyzeCubeUsage(t);
+      if (o.size === 0)
         throw new Error("No cubes found for query");
-      if (i.size === 1) {
-        const o = Array.from(i)[0], l = e.get(o);
-        if (!l)
-          throw new Error(`Cube '${o}' not found`);
-        return this.executeSingleCube(l, t, s);
+      if (o.size === 1) {
+        const a = Array.from(o)[0], r = e.get(a);
+        if (!r)
+          throw new Error(`Cube '${a}' not found`);
+        return this.executeSingleCube(r, t, i);
       } else
-        return this.executeMultiCube(e, t, s);
-    } catch (i) {
-      throw new Error(`Query execution failed: ${i instanceof Error ? i.message : "Unknown error"}`);
+        return this.executeMultiCube(e, t, i);
+    } catch (n) {
+      throw new Error(`Query execution failed: ${n instanceof Error ? n.message : "Unknown error"}`);
     }
   }
   /**
    * Legacy interface for single cube queries
    */
-  async executeQuery(e, t, s) {
-    const i = /* @__PURE__ */ new Map();
-    return i.set(e.name, e), this.execute(i, t, s);
+  async executeQuery(e, t, i) {
+    const n = /* @__PURE__ */ new Map();
+    return n.set(e.name, e), this.execute(n, t, i);
   }
   /**
    * Execute a single cube query
    */
-  async executeSingleCube(e, t, s) {
-    return this.executeCube(e, t, s);
+  async executeSingleCube(e, t, i) {
+    return this.executeCube(e, t, i);
   }
   /**
    * Execute a Cube query (dynamic query building)
    */
-  async executeCube(e, t, s) {
+  async executeCube(e, t, i) {
     try {
-      const i = {
+      const n = {
         db: this.dbExecutor.db,
         schema: this.dbExecutor.schema,
-        securityContext: s
-      }, o = e.sql(i), l = this.buildSelections(e, t, i);
-      let a = i.db.select(l).from(o.from);
+        securityContext: i
+      }, o = e.sql(n), a = this.buildSelections(e, t, n);
+      let r = n.db.select(a).from(o.from);
       if (o.joins)
         for (const h of o.joins)
           switch (h.type || "left") {
             case "left":
-              a = a.leftJoin(h.table, h.on);
+              r = r.leftJoin(h.table, h.on);
               break;
             case "inner":
-              a = a.innerJoin(h.table, h.on);
+              r = r.innerJoin(h.table, h.on);
               break;
             case "right":
-              a = a.rightJoin(h.table, h.on);
+              r = r.rightJoin(h.table, h.on);
               break;
             case "full":
-              a = a.fullJoin(h.table, h.on);
+              r = r.fullJoin(h.table, h.on);
               break;
           }
-      o.where && (a = a.where(o.where));
-      const m = this.buildWhereConditions(e, t, i);
-      if (m.length > 0) {
-        const h = m.length === 1 ? m[0] : B(...m);
-        a = a.where(h);
+      o.where && (r = r.where(o.where));
+      const c = this.buildWhereConditions(e, t, n);
+      if (c.length > 0) {
+        const h = c.length === 1 ? c[0] : p(...c);
+        r = r.where(h);
       }
-      const d = this.buildGroupByFields(e, t, i);
-      d.length > 0 && (a = a.groupBy(...d));
+      const l = this.buildGroupByFields(e, t, n);
+      l.length > 0 && (r = r.groupBy(...l));
       const u = this.buildOrderBy(t);
-      u.length > 0 && (a = a.orderBy(...u)), t.limit && (a = a.limit(t.limit)), t.offset && (a = a.offset(t.offset));
-      const f = await this.dbExecutor.execute(a), p = this.generateAnnotations(e, t);
+      if (u.length > 0 && (r = r.orderBy(...u)), t.limit !== void 0) {
+        if (t.limit < 0)
+          throw new Error("Limit must be non-negative");
+        r = r.limit(t.limit);
+      }
+      if (t.offset !== void 0) {
+        if (t.offset < 0)
+          throw new Error("Offset must be non-negative");
+        r = r.offset(t.offset);
+      }
+      const m = t.measures || [], d = await this.dbExecutor.execute(r, m), Q = Array.isArray(d) ? d.map((h) => {
+        const E = { ...h };
+        if (t.timeDimensions) {
+          for (const D of t.timeDimensions)
+            if (D.dimension in E) {
+              let g = E[D.dimension];
+              typeof g == "string" && g.match(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}/) && (g = g.replace(" ", "T"), !g.endsWith("Z") && !g.includes("+") && (g = g + "Z")), E[D.dimension] = g;
+            }
+        }
+        return E;
+      }) : [d], k = this.generateAnnotations(e, t);
       return {
-        data: Array.isArray(f) ? f : [f],
-        annotation: p
+        data: Q,
+        annotation: k
       };
-    } catch (i) {
-      throw new Error(`Cube query execution failed: ${i instanceof Error ? i.message : "Unknown error"}`);
+    } catch (n) {
+      throw new Error(`Cube query execution failed: ${n instanceof Error ? n.message : "Unknown error"}`);
     }
   }
   /**
    * Execute multi-cube query using JOIN resolution
    */
-  async executeMultiCube(e, t, s) {
-    const i = {
+  async executeMultiCube(e, t, i) {
+    const n = this.buildMultiCubeQuery(e, t, i), o = t.measures || [], a = await this.dbExecutor.execute(n, o), r = {
+      db: this.dbExecutor.db,
+      schema: this.dbExecutor.schema,
+      securityContext: i
+    }, c = this.multiCubeBuilder.buildMultiCubeQueryPlan(e, t, r), l = this.generateMultiCubeAnnotations(c, t);
+    return {
+      data: Array.isArray(a) ? a : [a],
+      annotation: l
+    };
+  }
+  /**
+   * Generate raw SQL for debugging (without execution)
+   */
+  async generateSQL(e, t, i) {
+    return this.generateCubeSQL(e, t, i);
+  }
+  /**
+   * Generate raw SQL for multi-cube queries without execution
+   */
+  async generateMultiCubeSQL(e, t, i) {
+    const o = this.buildMultiCubeQuery(e, t, i).toSQL();
+    return {
+      sql: o.sql,
+      params: o.params
+    };
+  }
+  /**
+   * Build multi-cube query (extracted from executeMultiCube for reuse)
+   */
+  buildMultiCubeQuery(e, t, i) {
+    const n = {
       db: this.dbExecutor.db,
       schema: this.dbExecutor.schema,
-      securityContext: s
-    }, o = this.multiCubeBuilder.buildMultiCubeQueryPlan(e, t, i), l = o.primaryCube.sql(i);
-    let a = i.db.select(o.selections).from(l.from);
-    if (l.joins)
-      for (const h of l.joins)
-        switch (h.type || "left") {
+      securityContext: i
+    }, o = this.multiCubeBuilder.buildMultiCubeQueryPlan(e, t, n), a = o.primaryCube.sql(n);
+    let r = n.db.select(o.selections).from(a.from);
+    if (a.joins)
+      for (const u of a.joins)
+        switch (u.type || "left") {
           case "left":
-            a = a.leftJoin(h.table, h.on);
+            r = r.leftJoin(u.table, u.on);
             break;
           case "inner":
-            a = a.innerJoin(h.table, h.on);
+            r = r.innerJoin(u.table, u.on);
             break;
           case "right":
-            a = a.rightJoin(h.table, h.on);
+            r = r.rightJoin(u.table, u.on);
             break;
           case "full":
-            a = a.fullJoin(h.table, h.on);
+            r = r.fullJoin(u.table, u.on);
             break;
+          default:
+            r = r.leftJoin(u.table, u.on);
         }
     if (o.joinCubes && o.joinCubes.length > 0)
-      for (const h of o.joinCubes) {
-        const A = h.cube.sql(i);
-        switch (h.joinType || "left") {
-          case "left":
-            a = a.leftJoin(A.from, h.joinCondition);
-            break;
-          case "inner":
-            a = a.innerJoin(A.from, h.joinCondition);
-            break;
-          case "right":
-            a = a.rightJoin(A.from, h.joinCondition);
-            break;
-          case "full":
-            a = a.fullJoin(A.from, h.joinCondition);
-            break;
+      for (const u of o.joinCubes) {
+        const m = u.cube.sql(n);
+        try {
+          switch (u.joinType || "left") {
+            case "left":
+              r = r.leftJoin(m.from, u.joinCondition);
+              break;
+            case "inner":
+              r = r.innerJoin(m.from, u.joinCondition);
+              break;
+            case "right":
+              r = r.rightJoin(m.from, u.joinCondition);
+              break;
+            case "full":
+              r = r.fullJoin(m.from, u.joinCondition);
+              break;
+          }
+        } catch (d) {
+          console.warn(`Multi-cube join failed for ${u.cube.name}: ${d instanceof Error ? d.message : "Unknown error"}`);
         }
       }
-    const m = [];
-    if (l.where && m.push(l.where), o.whereConditions.length > 0 && m.push(...o.whereConditions), m.length > 0) {
-      const h = m.length === 1 ? m[0] : B(...m);
-      a = a.where(h);
+    const c = [];
+    if (a.where && c.push(a.where), o.whereConditions.length > 0 && c.push(...o.whereConditions), c.length > 0) {
+      const u = c.length === 1 ? c[0] : p(...c);
+      r = r.where(u);
     }
-    o.groupByFields.length > 0 && (a = a.groupBy(...o.groupByFields));
-    const d = this.buildOrderBy(t);
-    d.length > 0 && (a = a.orderBy(...d)), t.limit && (a = a.limit(t.limit)), t.offset && (a = a.offset(t.offset));
-    const u = a, f = await this.dbExecutor.execute(u), p = this.generateMultiCubeAnnotations(o, t);
-    return {
-      data: Array.isArray(f) ? f : [f],
-      annotation: p
-    };
-  }
-  /**
-   * Generate raw SQL for debugging (without execution)
-   */
-  async generateSQL(e, t, s) {
-    return this.generateCubeSQL(e, t, s);
+    o.groupByFields.length > 0 && (r = r.groupBy(...o.groupByFields));
+    const l = this.buildOrderBy(t);
+    if (l.length > 0 && (r = r.orderBy(...l)), t.limit !== void 0) {
+      if (t.limit < 0)
+        throw new Error("Limit must be non-negative");
+      r = r.limit(t.limit);
+    }
+    if (t.offset !== void 0) {
+      if (t.offset < 0)
+        throw new Error("Offset must be non-negative");
+      r = r.offset(t.offset);
+    }
+    return r;
   }
   /**
    * Generate SQL for Cube
    */
-  async generateCubeSQL(e, t, s) {
-    const i = {
+  async generateCubeSQL(e, t, i) {
+    const n = {
       db: this.dbExecutor.db,
       schema: this.dbExecutor.schema,
-      securityContext: s
-    }, o = e.sql(i), l = this.buildSelections(e, t, i);
-    let a = i.db.select(l).from(o.from);
+      securityContext: i
+    }, o = e.sql(n), a = this.buildSelections(e, t, n);
+    let r = n.db.select(a).from(o.from);
     if (o.joins)
-      for (const p of o.joins)
-        switch (p.type || "left") {
+      for (const d of o.joins)
+        switch (d.type || "left") {
           case "left":
-            a = a.leftJoin(p.table, p.on);
+            r = r.leftJoin(d.table, d.on);
             break;
           case "inner":
-            a = a.innerJoin(p.table, p.on);
+            r = r.innerJoin(d.table, d.on);
             break;
           case "right":
-            a = a.rightJoin(p.table, p.on);
+            r = r.rightJoin(d.table, d.on);
             break;
           case "full":
-            a = a.fullJoin(p.table, p.on);
+            r = r.fullJoin(d.table, d.on);
             break;
         }
-    o.where && (a = a.where(o.where));
-    const m = this.buildWhereConditions(e, t, i);
-    if (m.length > 0) {
-      const p = m.length === 1 ? m[0] : B(...m);
-      a = a.where(p);
+    o.where && (r = r.where(o.where));
+    const c = this.buildWhereConditions(e, t, n);
+    if (c.length > 0) {
+      const d = c.length === 1 ? c[0] : p(...c);
+      r = r.where(d);
     }
-    const d = this.buildGroupByFields(e, t, i);
-    d.length > 0 && (a = a.groupBy(...d));
+    const l = this.buildGroupByFields(e, t, n);
+    l.length > 0 && (r = r.groupBy(...l));
     const u = this.buildOrderBy(t);
-    u.length > 0 && (a = a.orderBy(...u)), t.limit && (a = a.limit(t.limit)), t.offset && (a = a.offset(t.offset));
-    const f = a.toSQL();
+    if (u.length > 0 && (r = r.orderBy(...u)), t.limit !== void 0) {
+      if (t.limit < 0)
+        throw new Error("Limit must be non-negative");
+      r = r.limit(t.limit);
+    }
+    if (t.offset !== void 0) {
+      if (t.offset < 0)
+        throw new Error("Offset must be non-negative");
+      r = r.offset(t.offset);
+    }
+    const m = r.toSQL();
     return {
-      sql: f.sql,
-      params: f.params
+      sql: m.sql,
+      params: m.params
     };
   }
   /**
    * Build dynamic selections for Cube measures and dimensions
    */
-  buildSelections(e, t, s) {
-    const i = {};
+  buildSelections(e, t, i) {
+    const n = {};
     if (t.dimensions)
       for (const o of t.dimensions) {
-        const [l, a] = o.split(".");
-        if (l === e.name && e.dimensions[a]) {
-          const m = e.dimensions[a], d = v(m.sql, s);
-          i[o] = d;
+        const [a, r] = o.split(".");
+        if (a === e.name && e.dimensions[r]) {
+          const c = e.dimensions[r], l = b(c.sql, i);
+          n[o] = f`${l}`.as(o);
         }
       }
     if (t.measures)
       for (const o of t.measures) {
-        const [l, a] = o.split(".");
-        if (l === e.name && e.measures[a]) {
-          const m = e.measures[a], d = this.buildMeasureExpression(m, s);
-          i[o] = d;
+        const [a, r] = o.split(".");
+        if (a === e.name && e.measures[r]) {
+          const c = e.measures[r], l = this.buildMeasureExpression(c, i);
+          n[o] = f`${l}`.as(o);
         }
       }
     if (t.timeDimensions)
       for (const o of t.timeDimensions) {
-        const [l, a] = o.dimension.split(".");
-        if (l === e.name && e.dimensions[a]) {
-          const m = e.dimensions[a], d = this.buildTimeDimensionExpression(
-            m.sql,
+        const [a, r] = o.dimension.split(".");
+        if (a === e.name && e.dimensions[r]) {
+          const c = e.dimensions[r], l = this.buildTimeDimensionExpression(
+            c.sql,
             o.granularity,
-            s
+            i
           );
-          i[o.dimension] = d;
+          n[o.dimension] = f`${l}`.as(o.dimension);
         }
       }
-    return Object.keys(i).length === 0 && (i.count = Y()), i;
+    return Object.keys(n).length === 0 && (n.count = y()), n;
   }
   /**
    * Build measure expression with aggregation and filters for Cube
    */
   buildMeasureExpression(e, t) {
-    let s = v(e.sql, t);
+    let i = b(e.sql, t);
     if (e.filters && e.filters.length > 0) {
-      const i = e.filters.map((o) => o(t));
-      s = y`CASE WHEN ${B(...i)} THEN ${s} END`;
+      const n = e.filters.map((o) => o(t));
+      i = f`CASE WHEN ${p(...n)} THEN ${i} END`;
     }
     switch (e.type) {
       case "count":
-        return Y(s);
+        return y(i);
       case "countDistinct":
-        return ro(s);
+        return Y(i);
       case "sum":
-        return io(s);
+        return I(i);
       case "avg":
-        return so(s);
+        return R(i);
       case "min":
-        return no(s);
+        return O(i);
       case "max":
-        return to(s);
+        return B(i);
       case "number":
-        return s;
+        return i;
       default:
-        return Y(s);
+        return y(i);
     }
   }
   /**
    * Build time dimension expression with granularity
    */
-  buildTimeDimensionExpression(e, t, s) {
-    const i = v(e, s);
+  buildTimeDimensionExpression(e, t, i) {
+    const n = b(e, i);
     if (!t)
-      return i;
+      return f`${n}`;
     switch (t) {
       case "year":
-        return y`DATE_TRUNC('year', ${i}::timestamptz)`;
+        return f`DATE_TRUNC('year', ${n}::timestamp)`;
       case "quarter":
-        return y`DATE_TRUNC('quarter', ${i}::timestamptz)`;
+        return f`DATE_TRUNC('quarter', ${n}::timestamp)`;
       case "month":
-        return y`DATE_TRUNC('month', ${i}::timestamptz)`;
+        return f`DATE_TRUNC('month', ${n}::timestamp)`;
       case "week":
-        return y`DATE_TRUNC('week', ${i}::timestamptz)`;
+        return f`DATE_TRUNC('week', ${n}::timestamp)`;
       case "day":
-        return y`DATE_TRUNC('day', ${i}::timestamptz)`;
+        return f`DATE_TRUNC('day', ${n}::timestamp)::timestamp`;
       case "hour":
-        return y`DATE_TRUNC('hour', ${i}::timestamptz)`;
+        return f`DATE_TRUNC('hour', ${n}::timestamp)`;
       case "minute":
-        return y`DATE_TRUNC('minute', ${i}::timestamptz)`;
+        return f`DATE_TRUNC('minute', ${n}::timestamp)`;
       case "second":
-        return y`DATE_TRUNC('second', ${i}::timestamptz)`;
+        return f`DATE_TRUNC('second', ${n}::timestamp)`;
       default:
-        return i;
+        return n;
     }
   }
   /**
    * Build WHERE conditions from semantic query filters (Cube)
    */
-  buildWhereConditions(e, t, s) {
-    if (!t.filters || t.filters.length === 0)
-      return [];
-    const i = [];
-    for (const o of t.filters) {
-      const l = this.processFilter(o, e, s);
-      l && i.push(l);
-    }
-    return i;
+  buildWhereConditions(e, t, i) {
+    const n = [];
+    if (t.filters && t.filters.length > 0)
+      for (const o of t.filters) {
+        const a = this.processFilter(o, e, i);
+        a && n.push(a);
+      }
+    if (t.timeDimensions)
+      for (const o of t.timeDimensions) {
+        const [a, r] = o.dimension.split(".");
+        if (a === e.name && e.dimensions[r] && o.dateRange) {
+          const c = e.dimensions[r], l = b(c.sql, i), u = this.buildDateRangeCondition(l, o.dateRange);
+          u && n.push(u);
+        }
+      }
+    return n;
   }
   /**
    * Process a single filter for Cube (basic or logical)
    */
-  processFilter(e, t, s) {
+  processFilter(e, t, i) {
     if ("and" in e || "or" in e) {
-      const d = e;
-      if (d.and) {
-        const u = d.and.map((f) => this.processFilter(f, t, s)).filter((f) => f !== null);
-        return u.length > 0 ? B(...u) : null;
+      const l = e;
+      if (l.and) {
+        const u = l.and.map((m) => this.processFilter(m, t, i)).filter((m) => m !== null);
+        return u.length > 0 ? p(...u) : null;
       }
-      if (d.or) {
-        const u = d.or.map((f) => this.processFilter(f, t, s)).filter((f) => f !== null);
-        return u.length > 0 ? oo(...u) : null;
+      if (l.or) {
+        const u = l.or.map((m) => this.processFilter(m, t, i)).filter((m) => m !== null);
+        return u.length > 0 ? J(...u) : null;
       }
     }
-    const i = e, [o, l] = i.member.split(".");
+    const n = e, [o, a] = n.member.split(".");
     if (o !== t.name) return null;
-    const a = t.dimensions[l] || t.measures[l];
-    if (!a) return null;
-    const m = v(a.sql, s);
-    return this.buildFilterCondition(m, i.operator, i.values);
+    const r = t.dimensions[a] || t.measures[a];
+    if (!r) return null;
+    const c = b(r.sql, i);
+    return this.buildFilterCondition(c, n.operator, n.values);
   }
   /**
    * Build filter condition using Drizzle operators
    */
-  buildFilterCondition(e, t, s) {
-    const i = s[0];
+  buildFilterCondition(e, t, i) {
+    if (!i || i.length === 0)
+      return t === "equals" ? f`FALSE` : null;
+    const n = i.filter((a) => !(a == null || a === "" || typeof a == "string" && a.includes("\0")));
+    if (n.length === 0 && !["set", "notSet"].includes(t))
+      return t === "equals" ? f`FALSE` : null;
+    const o = n[0];
     switch (t) {
       case "equals":
-        return s.length > 1 ? y`${e} IN ${s}` : di(e, i);
+        return n.length > 1 ? Z(e, n) : n.length === 1 ? v(e, o) : f`FALSE`;
       case "notEquals":
-        return s.length > 1 ? y`${e} NOT IN ${s}` : co(e, i);
+        return n.length > 1 ? H(e, n) : n.length === 1 ? V(e, o) : null;
       case "contains":
-        return y`${e} ILIKE ${"%" + i + "%"}`;
+        return f`${e} ILIKE ${"%" + o + "%"}`;
       case "notContains":
-        return y`${e} NOT ILIKE ${"%" + i + "%"}`;
+        return f`${e} NOT ILIKE ${"%" + o + "%"}`;
       case "startsWith":
-        return y`${e} ILIKE ${i + "%"}`;
+        return f`${e} ILIKE ${o + "%"}`;
       case "endsWith":
-        return y`${e} ILIKE ${"%" + i}`;
+        return f`${e} ILIKE ${"%" + o}`;
       case "gt":
-        return re(e, i);
+        return A(e, o);
       case "gte":
-        return ae(e, i);
+        return w(e, o);
       case "lt":
-        return oe(e, i);
+        return F(e, o);
       case "lte":
-        return ue(e, i);
+        return N(e, o);
       case "set":
-        return uo(e);
+        return K(e);
       case "notSet":
-        return ao(e);
+        return W(e);
       case "inDateRange":
-        return s.length >= 2 ? B(
-          ae(e, s[0]),
-          ue(e, s[1])
-        ) : null;
-      case "beforeDate":
-        return oe(e, i);
-      case "afterDate":
-        return re(e, i);
+        if (n.length >= 2) {
+          const a = this.normalizeDate(n[0]), r = this.normalizeDate(n[1]);
+          if (a && r)
+            return p(
+              w(e, a),
+              N(e, r)
+            );
+        }
+        return null;
+      case "beforeDate": {
+        const a = this.normalizeDate(o);
+        return a ? F(e, a) : null;
+      }
+      case "afterDate": {
+        const a = this.normalizeDate(o);
+        return a ? A(e, a) : null;
+      }
       default:
         return null;
     }
   }
+  /**
+   * Build date range condition for time dimensions
+   */
+  buildDateRangeCondition(e, t) {
+    if (!t) return null;
+    if (Array.isArray(t) && t.length >= 2) {
+      const i = this.normalizeDate(t[0]), n = this.normalizeDate(t[1]);
+      return !i || !n ? null : p(
+        w(e, i),
+        N(e, n)
+      );
+    }
+    if (typeof t == "string") {
+      const i = this.parseRelativeDateRange(t);
+      if (i)
+        return p(
+          w(e, i.start),
+          N(e, i.end)
+        );
+      const n = this.normalizeDate(t);
+      if (!n) return null;
+      const o = new Date(n);
+      o.setUTCHours(0, 0, 0, 0);
+      const a = new Date(n);
+      return a.setUTCHours(23, 59, 59, 999), p(
+        w(e, o),
+        N(e, a)
+      );
+    }
+    return null;
+  }
+  /**
+   * Parse relative date range expressions like "last 7 days", "this month"
+   */
+  parseRelativeDateRange(e) {
+    const t = /* @__PURE__ */ new Date(), i = e.toLowerCase().trim(), n = i.match(/^last\s+(\d+)\s+days?$/);
+    if (n) {
+      const r = parseInt(n[1], 10), c = new Date(t);
+      c.setDate(t.getDate() - r), c.setHours(0, 0, 0, 0);
+      const l = new Date(t);
+      return l.setHours(23, 59, 59, 999), { start: c, end: l };
+    }
+    if (i === "this month") {
+      const r = new Date(t.getFullYear(), t.getMonth(), 1, 0, 0, 0, 0), c = new Date(t.getFullYear(), t.getMonth() + 1, 0, 23, 59, 59, 999);
+      return { start: r, end: c };
+    }
+    const o = i.match(/^last\s+(\d+)\s+months?$/);
+    if (o) {
+      const r = parseInt(o[1], 10), c = new Date(t.getFullYear(), t.getMonth() - r, 1, 0, 0, 0, 0), l = new Date(t);
+      return l.setHours(23, 59, 59, 999), { start: c, end: l };
+    }
+    if (i === "this year") {
+      const r = new Date(t.getFullYear(), 0, 1, 0, 0, 0, 0), c = new Date(t.getFullYear(), 11, 31, 23, 59, 59, 999);
+      return { start: r, end: c };
+    }
+    const a = i.match(/^last\s+(\d+)\s+years?$/);
+    if (a) {
+      const r = parseInt(a[1], 10), c = new Date(t.getFullYear() - r, 0, 1, 0, 0, 0, 0), l = new Date(t);
+      return l.setHours(23, 59, 59, 999), { start: c, end: l };
+    }
+    return null;
+  }
+  /**
+   * Normalize date values to handle both string and Date objects
+   * For PostgreSQL timestamp fields, Drizzle expects Date objects
+   */
+  normalizeDate(e) {
+    if (!e) return null;
+    if (e instanceof Date)
+      return isNaN(e.getTime()) ? null : e;
+    if (typeof e == "string") {
+      const i = new Date(e);
+      return isNaN(i.getTime()) ? null : i;
+    }
+    const t = new Date(e);
+    return isNaN(t.getTime()) ? null : t;
+  }
   /**
    * Build GROUP BY fields from dimensions and time dimensions (Cube)
    */
-  buildGroupByFields(e, t, s) {
-    const i = [];
+  buildGroupByFields(e, t, i) {
+    const n = [];
     if (t.dimensions)
       for (const o of t.dimensions) {
-        const [l, a] = o.split(".");
-        if (l === e.name && e.dimensions[a]) {
-          const m = e.dimensions[a], d = v(m.sql, s);
-          i.push(d);
+        const [a, r] = o.split(".");
+        if (a === e.name && e.dimensions[r]) {
+          const c = e.dimensions[r], l = b(c.sql, i);
+          n.push(l);
         }
       }
     if (t.timeDimensions)
       for (const o of t.timeDimensions) {
-        const [l, a] = o.dimension.split(".");
-        if (l === e.name && e.dimensions[a]) {
-          const m = e.dimensions[a], d = this.buildTimeDimensionExpression(
-            m.sql,
+        const [a, r] = o.dimension.split(".");
+        if (a === e.name && e.dimensions[r]) {
+          const c = e.dimensions[r], l = this.buildTimeDimensionExpression(
+            c.sql,
             o.granularity,
-            s
+            i
           );
-          i.push(d);
+          n.push(l);
         }
       }
-    return i;
+    return n;
   }
   /**
-   * Build ORDER BY clause
+   * Build ORDER BY clause with automatic time dimension sorting
    */
-  buildOrderBy(e) {
-    if (!e.order || Object.keys(e.order).length === 0)
-      return [];
-    const t = [];
-    for (const [s, i] of Object.entries(e.order)) {
-      const o = y.identifier(s), l = i === "desc" ? y`DESC` : y`ASC`;
-      t.push(y`${o} ${l}`);
+  buildOrderBy(e, t) {
+    var o;
+    const i = [], n = t || [
+      ...e.measures || [],
+      ...e.dimensions || [],
+      ...((o = e.timeDimensions) == null ? void 0 : o.map((a) => a.dimension)) || []
+    ];
+    if (e.order && Object.keys(e.order).length > 0)
+      for (const [a, r] of Object.entries(e.order)) {
+        if (!n.includes(a))
+          throw new Error(`Cannot order by '${a}': field is not selected in the query`);
+        const c = r === "desc" ? f`DESC` : f`ASC`;
+        i.push(f`${f.identifier(a)} ${c}`);
+      }
+    if (e.timeDimensions && e.timeDimensions.length > 0) {
+      const a = new Set(Object.keys(e.order || {})), r = [...e.timeDimensions].sort(
+        (c, l) => c.dimension.localeCompare(l.dimension)
+      );
+      for (const c of r)
+        a.has(c.dimension) || i.push(f`${f.identifier(c.dimension)} ASC`);
     }
-    return t;
+    return i;
   }
   /**
    * Generate annotations for UI metadata
    */
   generateAnnotations(e, t) {
-    const s = {}, i = {}, o = {};
+    const i = {}, n = {}, o = {};
     if (t.measures)
-      for (const l of t.measures) {
-        const [a, m] = l.split(".");
-        if (a === e.name && e.measures[m]) {
-          const d = e.measures[m];
-          s[l] = {
-            title: d.title || m,
-            shortTitle: d.title || m,
-            type: d.type
+      for (const a of t.measures) {
+        const [r, c] = a.split(".");
+        if (r === e.name && e.measures[c]) {
+          const l = e.measures[c];
+          i[a] = {
+            title: l.title || c,
+            shortTitle: l.title || c,
+            type: l.type
           };
         }
       }
     if (t.dimensions)
-      for (const l of t.dimensions) {
-        const [a, m] = l.split(".");
-        if (a === e.name && e.dimensions[m]) {
-          const d = e.dimensions[m];
-          i[l] = {
-            title: d.title || m,
-            shortTitle: d.title || m,
-            type: d.type
+      for (const a of t.dimensions) {
+        const [r, c] = a.split(".");
+        if (r === e.name && e.dimensions[c]) {
+          const l = e.dimensions[c];
+          n[a] = {
+            title: l.title || c,
+            shortTitle: l.title || c,
+            type: l.type
           };
         }
       }
     if (t.timeDimensions)
-      for (const l of t.timeDimensions) {
-        const [a, m] = l.dimension.split(".");
-        if (a === e.name && e.dimensions[m]) {
-          const d = e.dimensions[m];
-          o[l.dimension] = {
-            title: d.title || m,
-            shortTitle: d.title || m,
-            type: d.type,
-            granularity: l.granularity
+      for (const a of t.timeDimensions) {
+        const [r, c] = a.dimension.split(".");
+        if (r === e.name && e.dimensions[c]) {
+          const l = e.dimensions[c];
+          o[a.dimension] = {
+            title: l.title || c,
+            shortTitle: l.title || c,
+            type: l.type,
+            granularity: a.granularity
           };
         }
       }
     return {
-      measures: s,
-      dimensions: i,
+      measures: i,
+      dimensions: n,
       segments: {},
       timeDimensions: o
     };
@@ -828,57 +1086,61 @@ class de {
    * Generate annotations for multi-cube queries
    */
   generateMultiCubeAnnotations(e, t) {
-    const s = {}, i = {}, o = {}, l = [e.primaryCube];
-    if (e.joinCubes && l.push(...e.joinCubes.map((a) => a.cube)), t.measures)
-      for (const a of t.measures) {
-        const [m, d] = a.split("."), u = l.find((f) => f.name === m);
-        if (u && u.measures[d]) {
-          const f = u.measures[d];
-          s[a] = {
-            title: f.title || d,
-            shortTitle: f.title || d,
-            type: f.type
+    const i = {}, n = {}, o = {}, a = [e.primaryCube];
+    if (e.joinCubes && a.push(...e.joinCubes.map((r) => r.cube)), t.measures)
+      for (const r of t.measures) {
+        const [c, l] = r.split("."), u = a.find((m) => m.name === c);
+        if (u && u.measures[l]) {
+          const m = u.measures[l];
+          i[r] = {
+            title: m.title || l,
+            shortTitle: m.title || l,
+            type: m.type
           };
         }
       }
     if (t.dimensions)
-      for (const a of t.dimensions) {
-        const [m, d] = a.split("."), u = l.find((f) => f.name === m);
-        if (u && u.dimensions[d]) {
-          const f = u.dimensions[d];
-          i[a] = {
-            title: f.title || d,
-            shortTitle: f.title || d,
-            type: f.type
+      for (const r of t.dimensions) {
+        const [c, l] = r.split("."), u = a.find((m) => m.name === c);
+        if (u && u.dimensions[l]) {
+          const m = u.dimensions[l];
+          n[r] = {
+            title: m.title || l,
+            shortTitle: m.title || l,
+            type: m.type
           };
         }
       }
     if (t.timeDimensions)
-      for (const a of t.timeDimensions) {
-        const [m, d] = a.dimension.split("."), u = l.find((f) => f.name === m);
-        if (u && u.dimensions && u.dimensions[d]) {
-          const f = u.dimensions[d];
-          o[a.dimension] = {
-            title: f.title || d,
-            shortTitle: f.title || d,
-            type: f.type,
-            granularity: a.granularity
+      for (const r of t.timeDimensions) {
+        const [c, l] = r.dimension.split("."), u = a.find((m) => m.name === c);
+        if (u && u.dimensions && u.dimensions[l]) {
+          const m = u.dimensions[l];
+          o[r.dimension] = {
+            title: m.title || l,
+            shortTitle: m.title || l,
+            type: m.type,
+            granularity: r.granularity
           };
         }
       }
     return {
-      measures: s,
-      dimensions: i,
+      measures: i,
+      dimensions: n,
       segments: {},
       timeDimensions: o
     };
   }
 }
-class te {
+class T {
+  // 5 minutes in milliseconds
   constructor(e) {
-    r(this, "cubes", /* @__PURE__ */ new Map());
-    r(this, "dbExecutor");
-    e != null && e.databaseExecutor ? this.dbExecutor = e.databaseExecutor : e != null && e.drizzle && (this.dbExecutor = me(
+    C(this, "cubes", /* @__PURE__ */ new Map());
+    C(this, "dbExecutor");
+    C(this, "metadataCache");
+    C(this, "metadataCacheTimestamp");
+    C(this, "METADATA_CACHE_TTL", 5 * 60 * 1e3);
+    e != null && e.databaseExecutor ? this.dbExecutor = e.databaseExecutor : e != null && e.drizzle && (this.dbExecutor = _(
       e.drizzle,
       e.schema,
       e.engineType
@@ -893,8 +1155,8 @@ class te {
   /**
    * Set Drizzle instance and schema directly
    */
-  setDrizzle(e, t, s) {
-    this.dbExecutor = me(e, t, s);
+  setDrizzle(e, t, i) {
+    this.dbExecutor = _(e, t, i);
   }
   /**
    * Check if database executor is configured
@@ -906,7 +1168,7 @@ class te {
    * Register a simplified cube with dynamic query building
    */
   registerCube(e) {
-    this.cubes.set(e.name, e);
+    this.cubes.set(e.name, e), this.invalidateMetadataCache();
   }
   /**
    * Get a cube by name
@@ -932,7 +1194,7 @@ class te {
   async execute(e, t) {
     if (!this.dbExecutor)
       throw new Error("Database executor not configured");
-    return new de(this.dbExecutor).execute(this.cubes, e, t);
+    return new $(this.dbExecutor).execute(this.cubes, e, t);
   }
   /**
    * Execute a multi-cube query
@@ -943,44 +1205,58 @@ class te {
   /**
    * Execute a single cube query
    */
-  async executeQuery(e, t, s) {
+  async executeQuery(e, t, i) {
     if (!this.cubes.get(e))
       throw new Error(`Cube '${e}' not found`);
-    return this.execute(t, s);
+    return this.execute(t, i);
   }
   /**
    * Get metadata for all cubes (for API responses)
+   * Uses caching to improve performance for repeated requests
    */
   getMetadata() {
-    return Array.from(this.cubes.values()).map((e) => this.generateCubeMetadata(e));
+    const e = Date.now();
+    if (this.metadataCache && this.metadataCacheTimestamp && e - this.metadataCacheTimestamp < this.METADATA_CACHE_TTL)
+      return this.metadataCache;
+    const t = Array.from(this.cubes.values()).map((i) => this.generateCubeMetadata(i));
+    return this.metadataCache = t, this.metadataCacheTimestamp = e, t;
   }
   /**
    * Generate cube metadata for API responses from cubes
+   * Optimized version that minimizes object iterations
    */
   generateCubeMetadata(e) {
-    const t = Object.entries(e.measures).map(([i, o]) => ({
-      name: `${e.name}.${i}`,
-      title: o.title || i,
-      shortTitle: o.title || i,
-      type: o.type,
-      format: void 0,
-      // Measure doesn't have format field
-      description: o.description
-    })), s = Object.entries(e.dimensions).map(([i, o]) => ({
-      name: `${e.name}.${i}`,
-      title: o.title || i,
-      shortTitle: o.title || i,
-      type: o.type,
-      format: void 0,
-      // Dimension doesn't have format field
-      description: o.description
-    }));
+    const t = Object.keys(e.measures), i = Object.keys(e.dimensions), n = new Array(t.length), o = new Array(i.length);
+    for (let a = 0; a < t.length; a++) {
+      const r = t[a], c = e.measures[r];
+      n[a] = {
+        name: `${e.name}.${r}`,
+        title: c.title || r,
+        shortTitle: c.title || r,
+        type: c.type,
+        format: void 0,
+        // Measure doesn't have format field
+        description: c.description
+      };
+    }
+    for (let a = 0; a < i.length; a++) {
+      const r = i[a], c = e.dimensions[r];
+      o[a] = {
+        name: `${e.name}.${r}`,
+        title: c.title || r,
+        shortTitle: c.title || r,
+        type: c.type,
+        format: void 0,
+        // Dimension doesn't have format field
+        description: c.description
+      };
+    }
     return {
       name: e.name,
       title: e.title || e.name,
       description: e.description,
-      measures: t,
-      dimensions: s,
+      measures: n,
+      dimensions: o,
       segments: []
       // Add segments support later if needed
     };
@@ -988,13 +1264,21 @@ class te {
   /**
    * Get SQL for a query without executing it (debugging)
    */
-  async generateSQL(e, t, s) {
-    const i = this.getCube(e);
-    if (!i)
+  async generateSQL(e, t, i) {
+    const n = this.getCube(e);
+    if (!n)
       throw new Error(`Cube '${e}' not found`);
     if (!this.dbExecutor)
       throw new Error("Database executor not configured");
-    return new de(this.dbExecutor).generateSQL(i, t, s);
+    return new $(this.dbExecutor).generateSQL(n, t, i);
+  }
+  /**
+   * Get SQL for a multi-cube query without executing it (debugging)
+   */
+  async generateMultiCubeSQL(e, t) {
+    if (!this.dbExecutor)
+      throw new Error("Database executor not configured");
+    return new $(this.dbExecutor).generateMultiCubeSQL(this.cubes, e, t);
   }
   /**
    * Check if a cube exists
@@ -1006,13 +1290,21 @@ class te {
    * Remove a cube
    */
   removeCube(e) {
-    return this.cubes.delete(e);
+    const t = this.cubes.delete(e);
+    return t && this.invalidateMetadataCache(), t;
   }
   /**
    * Clear all cubes
    */
   clearCubes() {
-    this.cubes.clear();
+    this.cubes.clear(), this.invalidateMetadataCache();
+  }
+  /**
+   * Invalidate the metadata cache
+   * Called whenever cubes are modified
+   */
+  invalidateMetadataCache() {
+    this.metadataCache = void 0, this.metadataCacheTimestamp = void 0;
   }
   /**
    * Get cube names
@@ -1020,12 +1312,98 @@ class te {
   getCubeNames() {
     return Array.from(this.cubes.keys());
   }
+  /**
+   * Validate a query against registered cubes
+   * Ensures all referenced cubes and fields exist
+   */
+  validateQuery(e) {
+    return j(this.cubes, e);
+  }
+}
+function j(s, e) {
+  const t = [], i = /* @__PURE__ */ new Set();
+  if (e.measures)
+    for (const n of e.measures) {
+      const [o, a] = n.split(".");
+      if (!o || !a) {
+        t.push(`Invalid measure format: ${n}. Expected format: 'CubeName.fieldName'`);
+        continue;
+      }
+      i.add(o);
+      const r = s.get(o);
+      if (!r) {
+        t.push(`Cube '${o}' not found (referenced in measure '${n}')`);
+        continue;
+      }
+      r.measures[a] || t.push(`Measure '${a}' not found on cube '${o}'`);
+    }
+  if (e.dimensions)
+    for (const n of e.dimensions) {
+      const [o, a] = n.split(".");
+      if (!o || !a) {
+        t.push(`Invalid dimension format: ${n}. Expected format: 'CubeName.fieldName'`);
+        continue;
+      }
+      i.add(o);
+      const r = s.get(o);
+      if (!r) {
+        t.push(`Cube '${o}' not found (referenced in dimension '${n}')`);
+        continue;
+      }
+      r.dimensions[a] || t.push(`Dimension '${a}' not found on cube '${o}'`);
+    }
+  if (e.timeDimensions)
+    for (const n of e.timeDimensions) {
+      const [o, a] = n.dimension.split(".");
+      if (!o || !a) {
+        t.push(`Invalid timeDimension format: ${n.dimension}. Expected format: 'CubeName.fieldName'`);
+        continue;
+      }
+      i.add(o);
+      const r = s.get(o);
+      if (!r) {
+        t.push(`Cube '${o}' not found (referenced in timeDimension '${n.dimension}')`);
+        continue;
+      }
+      r.dimensions[a] || t.push(`TimeDimension '${a}' not found on cube '${o}' (must be a dimension with time type)`);
+    }
+  if (e.filters)
+    for (const n of e.filters)
+      L(n, s, t, i);
+  return i.size === 0 && t.push("Query must reference at least one cube through measures, dimensions, or filters"), {
+    isValid: t.length === 0,
+    errors: t
+  };
+}
+function L(s, e, t, i) {
+  if ("and" in s || "or" in s) {
+    const r = s.and || s.or || [];
+    for (const c of r)
+      L(c, e, t, i);
+    return;
+  }
+  if (!("member" in s)) {
+    t.push("Filter must have a member field");
+    return;
+  }
+  const [n, o] = s.member.split(".");
+  if (!n || !o) {
+    t.push(`Invalid filter member format: ${s.member}. Expected format: 'CubeName.fieldName'`);
+    return;
+  }
+  i.add(n);
+  const a = e.get(n);
+  if (!a) {
+    t.push(`Cube '${n}' not found (referenced in filter '${s.member}')`);
+    return;
+  }
+  !a.dimensions[o] && !a.measures[o] && t.push(`Filter field '${o}' not found on cube '${n}' (must be a dimension or measure)`);
 }
-function Da(n) {
-  return new te(n);
+function Ee(s) {
+  return new T(s);
 }
-const wo = new te();
-function xo(n) {
+const se = new T();
+function re(s) {
   const e = {
     valid: !0,
     errors: [],
@@ -1033,7 +1411,7 @@ function xo(n) {
     cubes: []
   };
   try {
-    const t = lo(n);
+    const t = G(s);
     if (!t)
       return e.valid = !1, e.errors.push("Invalid YAML: empty or malformed content"), e;
     if (t.cubes && Array.isArray(t.cubes))
@@ -1042,9 +1420,9 @@ function xo(n) {
       e.cubes = [t];
     else
       return e.valid = !1, e.errors.push('YAML must contain either a "cubes" array or cube properties at root level'), e;
-    for (const s of e.cubes) {
-      const i = No(s);
-      e.errors.push(...i);
+    for (const i of e.cubes) {
+      const n = oe(i);
+      e.errors.push(...n);
     }
     e.valid = e.errors.length === 0;
   } catch (t) {
@@ -1052,87 +1430,87 @@ function xo(n) {
   }
   return e;
 }
-function No(n) {
+function oe(s) {
   const e = [];
-  return n.name || e.push("Cube name is required"), !n.sql && !n.sql_table && !n.sqlTable && e.push('Cube must have either "sql", "sql_table", or "sqlTable" property'), n.dimensions && n.dimensions.forEach((t, s) => {
-    t.name || e.push(`Dimension at index ${s} is missing name`), t.type || e.push(`Dimension "${t.name}" is missing type`), t.sql || e.push(`Dimension "${t.name}" is missing sql`);
-  }), n.measures && n.measures.forEach((t, s) => {
-    t.name || e.push(`Measure at index ${s} is missing name`), t.type || e.push(`Measure "${t.name}" is missing type`), t.sql || e.push(`Measure "${t.name}" is missing sql`);
-  }), n.joins && n.joins.forEach((t, s) => {
-    t.name || e.push(`Join at index ${s} is missing name`), t.relationship || e.push(`Join "${t.name}" is missing relationship`), t.sql || e.push(`Join "${t.name}" is missing sql`);
+  return s.name || e.push("Cube name is required"), !s.sql && !s.sql_table && !s.sqlTable && e.push('Cube must have either "sql", "sql_table", or "sqlTable" property'), s.dimensions && s.dimensions.forEach((t, i) => {
+    t.name || e.push(`Dimension at index ${i} is missing name`), t.type || e.push(`Dimension "${t.name}" is missing type`), t.sql || e.push(`Dimension "${t.name}" is missing sql`);
+  }), s.measures && s.measures.forEach((t, i) => {
+    t.name || e.push(`Measure at index ${i} is missing name`), t.type || e.push(`Measure "${t.name}" is missing type`), t.sql || e.push(`Measure "${t.name}" is missing sql`);
+  }), s.joins && s.joins.forEach((t, i) => {
+    t.name || e.push(`Join at index ${i} is missing name`), t.relationship || e.push(`Join "${t.name}" is missing relationship`), t.sql || e.push(`Join "${t.name}" is missing sql`);
   }), e;
 }
-function To(n) {
+function ae(s) {
   const e = {};
-  n.dimensions && n.dimensions.forEach((a) => {
-    e[a.name] = Co(a);
+  s.dimensions && s.dimensions.forEach((r) => {
+    e[r.name] = ce(r);
   });
   const t = {};
-  n.measures && n.measures.forEach((a) => {
-    t[a.name] = So(a);
-  });
-  const s = {};
-  n.joins && n.joins.forEach((a) => {
-    s[a.name] = vo(a);
+  s.measures && s.measures.forEach((r) => {
+    t[r.name] = le(r);
   });
   const i = {};
-  (n.pre_aggregations || n.preAggregations) && (n.pre_aggregations || n.preAggregations || []).forEach((m) => {
-    i[m.name] = Eo(m);
+  s.joins && s.joins.forEach((r) => {
+    i[r.name] = fe(r);
   });
-  let o = n.sql;
-  !o && (n.sql_table || n.sqlTable) && (o = `SELECT * FROM ${n.sql_table || n.sqlTable}`);
-  const l = n.refresh_key || n.refreshKey;
+  const n = {};
+  (s.pre_aggregations || s.preAggregations) && (s.pre_aggregations || s.preAggregations || []).forEach((c) => {
+    n[c.name] = de(c);
+  });
+  let o = s.sql;
+  !o && (s.sql_table || s.sqlTable) && (o = `SELECT * FROM ${s.sql_table || s.sqlTable}`);
+  const a = s.refresh_key || s.refreshKey;
   return {
-    name: n.name,
-    title: n.title,
-    description: n.description,
+    name: s.name,
+    title: s.title,
+    description: s.description,
     sql: o || "",
-    sqlAlias: n.sql_alias || n.sqlAlias,
-    dataSource: n.data_source || n.dataSource,
-    refreshKey: l ? {
-      every: l.every,
-      sql: l.sql
+    sqlAlias: s.sql_alias || s.sqlAlias,
+    dataSource: s.data_source || s.dataSource,
+    refreshKey: a ? {
+      every: a.every,
+      sql: a.sql
     } : void 0,
     dimensions: e,
     measures: t,
-    joins: Object.keys(s).length > 0 ? s : void 0,
-    preAggregations: Object.keys(i).length > 0 ? i : void 0,
-    meta: n.meta
+    joins: Object.keys(i).length > 0 ? i : void 0,
+    preAggregations: Object.keys(n).length > 0 ? n : void 0,
+    meta: s.meta
   };
 }
-function Co(n) {
+function ce(s) {
   return {
-    name: n.name,
-    title: n.title,
-    description: n.description,
-    type: n.type,
-    sql: n.sql,
-    primaryKey: n.primary_key || n.primaryKey,
-    shown: n.shown,
-    format: n.format,
-    meta: n.meta
+    name: s.name,
+    title: s.title,
+    description: s.description,
+    type: s.type,
+    sql: s.sql,
+    primaryKey: s.primary_key || s.primaryKey,
+    shown: s.shown,
+    format: s.format,
+    meta: s.meta
   };
 }
-function So(n) {
-  var s;
-  const e = (s = n.filters) == null ? void 0 : s.map((i) => ({
-    sql: i.sql
-  })), t = n.rolling_window || n.rollingWindow;
+function le(s) {
+  var i;
+  const e = (i = s.filters) == null ? void 0 : i.map((n) => ({
+    sql: n.sql
+  })), t = s.rolling_window || s.rollingWindow;
   return {
-    name: n.name,
-    title: n.title,
-    description: n.description,
-    type: n.type,
-    sql: n.sql,
-    format: n.format,
-    shown: n.shown,
+    name: s.name,
+    title: s.title,
+    description: s.description,
+    type: s.type,
+    sql: s.sql,
+    format: s.format,
+    shown: s.shown,
     filters: e,
     rollingWindow: t,
-    meta: n.meta
+    meta: s.meta
   };
 }
-function Po(n) {
-  switch (n) {
+function ue(s) {
+  switch (s) {
     case "one_to_one":
       return "hasOne";
     case "one_to_many":
@@ -1143,8 +1521,8 @@ function Po(n) {
       return "belongsTo";
   }
 }
-function Do(n) {
-  switch (n) {
+function me(s) {
+  switch (s) {
     case "hasOne":
       return "one_to_one";
     case "hasMany":
@@ -1155,62 +1533,62 @@ function Do(n) {
       return "many_to_one";
   }
 }
-function vo(n) {
+function fe(s) {
   return {
-    name: n.name,
-    type: n.type,
-    relationship: Po(n.relationship),
-    sql: n.sql
+    name: s.name,
+    type: s.type,
+    relationship: ue(s.relationship),
+    sql: s.sql
   };
 }
-function Eo(n) {
-  const e = n.time_dimension || n.timeDimension, t = n.refresh_key || n.refreshKey;
+function de(s) {
+  const e = s.time_dimension || s.timeDimension, t = s.refresh_key || s.refreshKey;
   return {
-    name: n.name,
-    measures: n.measures,
-    dimensions: n.dimensions,
+    name: s.name,
+    measures: s.measures,
+    dimensions: s.dimensions,
     timeDimension: e,
     refreshKey: t,
-    indexes: n.indexes
+    indexes: s.indexes
   };
 }
-async function $o() {
+async function he() {
   try {
-    const { promises: n } = await import("fs"), e = await n.readFile("non-existent-file.txt", "utf-8").catch((t) => t.message);
+    const { promises: s } = await import("fs"), e = await s.readFile("non-existent-file.txt", "utf-8").catch((t) => t.message);
     return !(typeof e == "string" && e.includes("not implemented"));
   } catch {
     return !1;
   }
 }
-function Bo(n) {
-  const e = xo(n);
+function pe(s) {
+  const e = re(s);
   if (!e.valid)
     throw new Error(`Invalid YAML cube definition:
 ${e.errors.join(`
 `)}`);
-  return e.cubes.map((t) => To(t));
+  return e.cubes.map((t) => ae(t));
 }
-async function va(n) {
-  if (!await $o())
+async function De(s) {
+  if (!await he())
     return console.log("ℹ️ YAML file loading not supported in this environment (Cloudflare Workers/Edge Runtime). Use inline YAML strings or build-time transformations instead."), [];
   try {
-    const { promises: t } = await import("fs"), s = await t.readFile(n, "utf-8");
-    return Bo(s);
+    const { promises: t } = await import("fs"), i = await t.readFile(s, "utf-8");
+    return pe(i);
   } catch (t) {
-    return console.log(`ℹ️ Could not load YAML file ${n}:`, t instanceof Error ? t.message : t), [];
+    return console.log(`ℹ️ Could not load YAML file ${s}:`, t instanceof Error ? t.message : t), [];
   }
 }
-function Ea(n) {
-  let e = n;
+function ye(s) {
+  let e = s;
   return e = e.replace(/\{CUBE\}/g, "${CUBE}"), e = e.replace(/\{([A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*)\}/g, "${$1}"), e = e.replace(/\{([A-Za-z_][A-Za-z0-9_]*)\}/g, "${$1}"), e = e.replace(/\$\$\{/g, "${"), e;
 }
-function $a(n) {
+function $e(s) {
   const e = {
-    name: n.name,
-    title: n.title,
-    description: n.description,
-    sql: typeof n.sql == "string" ? n.sql : void 0,
-    dimensions: Object.values(n.dimensions).map((t) => ({
+    name: s.name,
+    title: s.title,
+    description: s.description,
+    sql: typeof s.sql == "string" ? s.sql : void 0,
+    dimensions: Object.values(s.dimensions).map((t) => ({
       name: t.name,
       title: t.title,
       description: t.description,
@@ -1221,8 +1599,8 @@ function $a(n) {
       format: t.format,
       meta: t.meta
     })),
-    measures: Object.values(n.measures).map((t) => {
-      var s;
+    measures: Object.values(s.measures).map((t) => {
+      var i;
       return {
         name: t.name,
         title: t.title,
@@ -1231,2257 +1609,108 @@ function $a(n) {
         sql: typeof t.sql == "string" ? t.sql : "",
         format: t.format,
         shown: t.shown,
-        filters: (s = t.filters) == null ? void 0 : s.map((i) => ({
-          sql: typeof i.sql == "string" ? i.sql : ""
+        filters: (i = t.filters) == null ? void 0 : i.map((n) => ({
+          sql: typeof n.sql == "string" ? n.sql : ""
         })),
         rolling_window: t.rollingWindow,
         meta: t.meta
       };
     }),
-    joins: n.joins ? Object.values(n.joins).map((t) => ({
+    joins: s.joins ? Object.values(s.joins).map((t) => ({
       name: t.name || "",
       type: t.type,
-      relationship: Do(t.relationship),
+      relationship: me(t.relationship),
       sql: typeof t.sql == "string" ? t.sql : ""
     })) : void 0,
-    meta: n.meta
+    meta: s.meta
   };
-  return mo(e, {
+  return P(e, {
     indent: 2,
     lineWidth: 120,
     minContentWidth: 40
   });
 }
-const c = Symbol.for("drizzle:entityKind");
-function T(n, e) {
-  if (!n || typeof n != "object")
-    return !1;
-  if (n instanceof e)
-    return !0;
-  if (!Object.prototype.hasOwnProperty.call(e, c))
-    throw new Error(
-      `Class "${e.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`
-    );
-  let t = Object.getPrototypeOf(n).constructor;
-  if (t)
-    for (; t; ) {
-      if (c in t && t[c] === e[c])
-        return !0;
-      t = Object.getPrototypeOf(t);
-    }
-  return !1;
-}
-var xe;
-xe = c;
-class K {
-  constructor(e, t) {
-    r(this, "name");
-    r(this, "keyAsName");
-    r(this, "primary");
-    r(this, "notNull");
-    r(this, "default");
-    r(this, "defaultFn");
-    r(this, "onUpdateFn");
-    r(this, "hasDefault");
-    r(this, "isUnique");
-    r(this, "uniqueName");
-    r(this, "uniqueType");
-    r(this, "dataType");
-    r(this, "columnType");
-    r(this, "enumValues");
-    r(this, "generated");
-    r(this, "generatedIdentity");
-    r(this, "config");
-    this.table = e, this.config = t, this.name = t.name, this.keyAsName = t.keyAsName, this.notNull = t.notNull, this.default = t.default, this.defaultFn = t.defaultFn, this.onUpdateFn = t.onUpdateFn, this.hasDefault = t.hasDefault, this.primary = t.primaryKey, this.isUnique = t.isUnique, this.uniqueName = t.uniqueName, this.uniqueType = t.uniqueType, this.dataType = t.dataType, this.columnType = t.columnType, this.generated = t.generated, this.generatedIdentity = t.generatedIdentity;
-  }
-  mapFromDriverValue(e) {
-    return e;
-  }
-  mapToDriverValue(e) {
-    return e;
-  }
-  // ** @internal */
-  shouldDisableInsert() {
-    return this.config.generated !== void 0 && this.config.generated.type !== "byDefault";
-  }
-}
-r(K, xe, "Column");
-var Ne;
-Ne = c;
-class fi {
-  constructor(e, t, s) {
-    r(this, "config");
-    /**
-     * Alias for {@link $defaultFn}.
-     */
-    r(this, "$default", this.$defaultFn);
-    /**
-     * Alias for {@link $onUpdateFn}.
-     */
-    r(this, "$onUpdate", this.$onUpdateFn);
-    this.config = {
-      name: e,
-      keyAsName: e === "",
-      notNull: !1,
-      default: void 0,
-      hasDefault: !1,
-      primaryKey: !1,
-      isUnique: !1,
-      uniqueName: void 0,
-      uniqueType: void 0,
-      dataType: t,
-      columnType: s,
-      generated: void 0
-    };
-  }
-  /**
-   * Changes the data type of the column. Commonly used with `json` columns. Also, useful for branded types.
-   *
-   * @example
-   * ```ts
-   * const users = pgTable('users', {
-   * 	id: integer('id').$type<UserId>().primaryKey(),
-   * 	details: json('details').$type<UserDetails>().notNull(),
-   * });
-   * ```
-   */
-  $type() {
-    return this;
-  }
-  /**
-   * Adds a `not null` clause to the column definition.
-   *
-   * Affects the `select` model of the table - columns *without* `not null` will be nullable on select.
-   */
-  notNull() {
-    return this.config.notNull = !0, this;
-  }
-  /**
-   * Adds a `default <value>` clause to the column definition.
-   *
-   * Affects the `insert` model of the table - columns *with* `default` are optional on insert.
-   *
-   * If you need to set a dynamic default value, use {@link $defaultFn} instead.
-   */
-  default(e) {
-    return this.config.default = e, this.config.hasDefault = !0, this;
-  }
-  /**
-   * Adds a dynamic default value to the column.
-   * The function will be called when the row is inserted, and the returned value will be used as the column value.
-   *
-   * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
-   */
-  $defaultFn(e) {
-    return this.config.defaultFn = e, this.config.hasDefault = !0, this;
-  }
-  /**
-   * Adds a dynamic update value to the column.
-   * The function will be called when the row is updated, and the returned value will be used as the column value if none is provided.
-   * If no `default` (or `$defaultFn`) value is provided, the function will be called when the row is inserted as well, and the returned value will be used as the column value.
-   *
-   * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
-   */
-  $onUpdateFn(e) {
-    return this.config.onUpdateFn = e, this.config.hasDefault = !0, this;
-  }
-  /**
-   * Adds a `primary key` clause to the column definition. This implicitly makes the column `not null`.
-   *
-   * In SQLite, `integer primary key` implicitly makes the column auto-incrementing.
-   */
-  primaryKey() {
-    return this.config.primaryKey = !0, this.config.notNull = !0, this;
-  }
-  /** @internal Sets the name of the column to the key within the table definition if a name was not given. */
-  setName(e) {
-    this.config.name === "" && (this.config.name = e);
-  }
-}
-r(fi, Ne, "ColumnBuilder");
-const Q = Symbol.for("drizzle:Name");
-var Te;
-Te = c;
-class pi {
-  constructor(e, t) {
-    /** @internal */
-    r(this, "reference");
-    /** @internal */
-    r(this, "_onUpdate", "no action");
-    /** @internal */
-    r(this, "_onDelete", "no action");
-    this.reference = () => {
-      const { name: s, columns: i, foreignColumns: o } = e();
-      return { name: s, columns: i, foreignTable: o[0].table, foreignColumns: o };
-    }, t && (this._onUpdate = t.onUpdate, this._onDelete = t.onDelete);
-  }
-  onUpdate(e) {
-    return this._onUpdate = e === void 0 ? "no action" : e, this;
-  }
-  onDelete(e) {
-    return this._onDelete = e === void 0 ? "no action" : e, this;
-  }
-  /** @internal */
-  build(e) {
-    return new hi(e, this);
-  }
-}
-r(pi, Te, "PgForeignKeyBuilder");
-var Ce;
-Ce = c;
-class hi {
-  constructor(e, t) {
-    r(this, "reference");
-    r(this, "onUpdate");
-    r(this, "onDelete");
-    this.table = e, this.reference = t.reference, this.onUpdate = t._onUpdate, this.onDelete = t._onDelete;
-  }
-  getName() {
-    const { name: e, columns: t, foreignColumns: s } = this.reference(), i = t.map((a) => a.name), o = s.map((a) => a.name), l = [
-      this.table[Q],
-      ...i,
-      s[0].table[Q],
-      ...o
-    ];
-    return e ?? `${l.join("_")}_fk`;
-  }
-}
-r(hi, Ce, "PgForeignKey");
-function zo(n, ...e) {
-  return n(...e);
-}
-function Fo(n, e) {
-  return `${n[Q]}_${e.join("_")}_unique`;
-}
-function fe(n, e, t) {
-  for (let s = e; s < n.length; s++) {
-    const i = n[s];
-    if (i === "\\") {
-      s++;
-      continue;
-    }
-    if (i === '"')
-      return [n.slice(e, s).replace(/\\/g, ""), s + 1];
-    if (!t && (i === "," || i === "}"))
-      return [n.slice(e, s).replace(/\\/g, ""), s];
-  }
-  return [n.slice(e).replace(/\\/g, ""), n.length];
-}
-function gi(n, e = 0) {
-  const t = [];
-  let s = e, i = !1;
-  for (; s < n.length; ) {
-    const o = n[s];
-    if (o === ",") {
-      (i || s === e) && t.push(""), i = !0, s++;
-      continue;
-    }
-    if (i = !1, o === "\\") {
-      s += 2;
-      continue;
-    }
-    if (o === '"') {
-      const [m, d] = fe(n, s + 1, !0);
-      t.push(m), s = d;
-      continue;
-    }
-    if (o === "}")
-      return [t, s + 1];
-    if (o === "{") {
-      const [m, d] = gi(n, s + 1);
-      t.push(m), s = d;
-      continue;
-    }
-    const [l, a] = fe(n, s, !1);
-    t.push(l), s = a;
-  }
-  return [t, s];
-}
-function Lo(n) {
-  const [e] = gi(n, 1);
-  return e;
-}
-function bi(n) {
-  return `{${n.map((e) => Array.isArray(e) ? bi(e) : typeof e == "string" ? `"${e.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"` : `${e}`).join(",")}}`;
-}
-var Se, Pe;
-class b extends (Pe = fi, Se = c, Pe) {
-  constructor() {
-    super(...arguments);
-    r(this, "foreignKeyConfigs", []);
-  }
-  array(t) {
-    return new wi(this.config.name, this, t);
-  }
-  references(t, s = {}) {
-    return this.foreignKeyConfigs.push({ ref: t, actions: s }), this;
-  }
-  unique(t, s) {
-    return this.config.isUnique = !0, this.config.uniqueName = t, this.config.uniqueType = s == null ? void 0 : s.nulls, this;
-  }
-  generatedAlwaysAs(t) {
-    return this.config.generated = {
-      as: t,
-      type: "always",
-      mode: "stored"
-    }, this;
-  }
-  /** @internal */
-  buildForeignKeys(t, s) {
-    return this.foreignKeyConfigs.map(({ ref: i, actions: o }) => zo(
-      (l, a) => {
-        const m = new pi(() => {
-          const d = l();
-          return { columns: [t], foreignColumns: [d] };
-        });
-        return a.onUpdate && m.onUpdate(a.onUpdate), a.onDelete && m.onDelete(a.onDelete), m.build(s);
-      },
-      i,
-      o
-    ));
-  }
-  /** @internal */
-  buildExtraConfigColumn(t) {
-    return new yi(t, this.config);
-  }
-}
-r(b, Se, "PgColumnBuilder");
-var De, ve;
-class g extends (ve = K, De = c, ve) {
-  constructor(e, t) {
-    t.uniqueName || (t.uniqueName = Fo(e, [t.name])), super(e, t), this.table = e;
-  }
-}
-r(g, De, "PgColumn");
-var Ee, $e;
-class yi extends ($e = g, Ee = c, $e) {
-  constructor() {
-    super(...arguments);
-    r(this, "indexConfig", {
-      order: this.config.order ?? "asc",
-      nulls: this.config.nulls ?? "last",
-      opClass: this.config.opClass
-    });
-    r(this, "defaultConfig", {
-      order: "asc",
-      nulls: "last",
-      opClass: void 0
-    });
-  }
-  getSQLType() {
-    return this.getSQLType();
-  }
-  asc() {
-    return this.indexConfig.order = "asc", this;
-  }
-  desc() {
-    return this.indexConfig.order = "desc", this;
-  }
-  nullsFirst() {
-    return this.indexConfig.nulls = "first", this;
-  }
-  nullsLast() {
-    return this.indexConfig.nulls = "last", this;
-  }
-  /**
-   * ### PostgreSQL documentation quote
-   *
-   * > An operator class with optional parameters can be specified for each column of an index.
-   * The operator class identifies the operators to be used by the index for that column.
-   * For example, a B-tree index on four-byte integers would use the int4_ops class;
-   * this operator class includes comparison functions for four-byte integers.
-   * In practice the default operator class for the column's data type is usually sufficient.
-   * The main point of having operator classes is that for some data types, there could be more than one meaningful ordering.
-   * For example, we might want to sort a complex-number data type either by absolute value or by real part.
-   * We could do this by defining two operator classes for the data type and then selecting the proper class when creating an index.
-   * More information about operator classes check:
-   *
-   * ### Useful links
-   * https://www.postgresql.org/docs/current/sql-createindex.html
-   *
-   * https://www.postgresql.org/docs/current/indexes-opclass.html
-   *
-   * https://www.postgresql.org/docs/current/xindex.html
-   *
-   * ### Additional types
-   * If you have the `pg_vector` extension installed in your database, you can use the
-   * `vector_l2_ops`, `vector_ip_ops`, `vector_cosine_ops`, `vector_l1_ops`, `bit_hamming_ops`, `bit_jaccard_ops`, `halfvec_l2_ops`, `sparsevec_l2_ops` options, which are predefined types.
-   *
-   * **You can always specify any string you want in the operator class, in case Drizzle doesn't have it natively in its types**
-   *
-   * @param opClass
-   * @returns
-   */
-  op(t) {
-    return this.indexConfig.opClass = t, this;
-  }
-}
-r(yi, Ee, "ExtraConfigColumn");
-var Be, ze;
-class wi extends (ze = b, Be = c, ze) {
-  constructor(e, t, s) {
-    super(e, "array", "PgArray"), this.config.baseBuilder = t, this.config.size = s;
-  }
-  /** @internal */
-  build(e) {
-    const t = this.config.baseBuilder.build(e);
-    return new X(
-      e,
-      this.config,
-      t
-    );
-  }
-}
-r(wi, Be, "PgArrayBuilder");
-var Fe, Le;
-const R = class R extends (Le = g, Fe = c, Le) {
-  constructor(t, s, i, o) {
-    super(t, s);
-    r(this, "size");
-    this.baseColumn = i, this.range = o, this.size = s.size;
-  }
-  getSQLType() {
-    return `${this.baseColumn.getSQLType()}[${typeof this.size == "number" ? this.size : ""}]`;
-  }
-  mapFromDriverValue(t) {
-    return typeof t == "string" && (t = Lo(t)), t.map((s) => this.baseColumn.mapFromDriverValue(s));
-  }
-  mapToDriverValue(t, s = !1) {
-    const i = t.map(
-      (o) => o === null ? null : T(this.baseColumn, R) ? this.baseColumn.mapToDriverValue(o, !0) : this.baseColumn.mapToDriverValue(o)
-    );
-    return s ? i : bi(i);
-  }
-};
-r(R, Fe, "PgArray");
-let X = R;
-const pe = Symbol.for("drizzle:isPgEnum");
-function Ao(n) {
-  return !!n && typeof n == "function" && pe in n && n[pe] === !0;
-}
-var Ae;
-Ae = c;
-class ne {
-  constructor(e, t, s, i = !1, o = []) {
-    this._ = {
-      brand: "Subquery",
-      sql: e,
-      selectedFields: t,
-      alias: s,
-      isWith: i,
-      usedTables: o
-    };
-  }
-  // getSQL(): SQL<unknown> {
-  // 	return new SQL([this]);
-  // }
-}
-r(ne, Ae, "Subquery");
-const Qo = {
-  startActiveSpan(n, e) {
-    return e();
-  }
-}, I = Symbol.for("drizzle:ViewBaseConfig"), G = Symbol.for("drizzle:Schema"), he = Symbol.for("drizzle:Columns"), ge = Symbol.for("drizzle:ExtraConfigColumns"), H = Symbol.for("drizzle:OriginalName"), Z = Symbol.for("drizzle:BaseName"), _ = Symbol.for("drizzle:IsAlias"), be = Symbol.for("drizzle:ExtraConfigBuilder"), Vo = Symbol.for("drizzle:IsDrizzleTable");
-var Qe, Ve, Ie, je, _e, Ue, qe, Oe, Me, Re;
-Re = c, Me = Q, Oe = H, qe = G, Ue = he, _e = ge, je = Z, Ie = _, Ve = Vo, Qe = be;
-class w {
-  constructor(e, t, s) {
-    /**
-     * @internal
-     * Can be changed if the table is aliased.
-     */
-    r(this, Me);
-    /**
-     * @internal
-     * Used to store the original name of the table, before any aliasing.
-     */
-    r(this, Oe);
-    /** @internal */
-    r(this, qe);
-    /** @internal */
-    r(this, Ue);
-    /** @internal */
-    r(this, _e);
-    /**
-     *  @internal
-     * Used to store the table name before the transformation via the `tableCreator` functions.
-     */
-    r(this, je);
-    /** @internal */
-    r(this, Ie, !1);
-    /** @internal */
-    r(this, Ve, !0);
-    /** @internal */
-    r(this, Qe);
-    this[Q] = this[H] = e, this[G] = t, this[Z] = s;
-  }
-}
-r(w, Re, "Table"), /** @internal */
-r(w, "Symbol", {
-  Name: Q,
-  Schema: G,
-  OriginalName: H,
-  Columns: he,
-  ExtraConfigColumns: ge,
-  BaseName: Z,
-  IsAlias: _,
-  ExtraConfigBuilder: be
-});
-function Io(n) {
-  return n != null && typeof n.getSQL == "function";
-}
-function jo(n) {
-  var t;
-  const e = { sql: "", params: [] };
-  for (const s of n)
-    e.sql += s.sql, e.params.push(...s.params), (t = s.typings) != null && t.length && (e.typings || (e.typings = []), e.typings.push(...s.typings));
-  return e;
-}
-var Je;
-Je = c;
-class C {
-  constructor(e) {
-    r(this, "value");
-    this.value = Array.isArray(e) ? e : [e];
-  }
-  getSQL() {
-    return new N([this]);
-  }
-}
-r(C, Je, "StringChunk");
-var Ke;
-Ke = c;
-const z = class z {
-  constructor(e) {
-    /** @internal */
-    r(this, "decoder", xi);
-    r(this, "shouldInlineParams", !1);
-    /** @internal */
-    r(this, "usedTables", []);
-    this.queryChunks = e;
-    for (const t of e)
-      if (T(t, w)) {
-        const s = t[w.Symbol.Schema];
-        this.usedTables.push(
-          s === void 0 ? t[w.Symbol.Name] : s + "." + t[w.Symbol.Name]
-        );
-      }
-  }
-  append(e) {
-    return this.queryChunks.push(...e.queryChunks), this;
-  }
-  toQuery(e) {
-    return Qo.startActiveSpan("drizzle.buildSQL", (t) => {
-      const s = this.buildQueryFromSourceParams(this.queryChunks, e);
-      return t == null || t.setAttributes({
-        "drizzle.query.text": s.sql,
-        "drizzle.query.params": JSON.stringify(s.params)
-      }), s;
-    });
-  }
-  buildQueryFromSourceParams(e, t) {
-    const s = Object.assign({}, t, {
-      inlineParams: t.inlineParams || this.shouldInlineParams,
-      paramStartIndex: t.paramStartIndex || { value: 0 }
-    }), {
-      casing: i,
-      escapeName: o,
-      escapeParam: l,
-      prepareTyping: a,
-      inlineParams: m,
-      paramStartIndex: d
-    } = s;
-    return jo(e.map((u) => {
-      var f;
-      if (T(u, C))
-        return { sql: u.value.join(""), params: [] };
-      if (T(u, U))
-        return { sql: o(u.value), params: [] };
-      if (u === void 0)
-        return { sql: "", params: [] };
-      if (Array.isArray(u)) {
-        const p = [new C("(")];
-        for (const [h, A] of u.entries())
-          p.push(A), h < u.length - 1 && p.push(new C(", "));
-        return p.push(new C(")")), this.buildQueryFromSourceParams(p, s);
-      }
-      if (T(u, z))
-        return this.buildQueryFromSourceParams(u.queryChunks, {
-          ...s,
-          inlineParams: m || u.shouldInlineParams
-        });
-      if (T(u, w)) {
-        const p = u[w.Symbol.Schema], h = u[w.Symbol.Name];
-        return {
-          sql: p === void 0 || u[_] ? o(h) : o(p) + "." + o(h),
-          params: []
-        };
-      }
-      if (T(u, K)) {
-        const p = i.getColumnCasing(u);
-        if (t.invokeSource === "indexes")
-          return { sql: o(p), params: [] };
-        const h = u.table[w.Symbol.Schema];
-        return {
-          sql: u.table[_] || h === void 0 ? o(u.table[w.Symbol.Name]) + "." + o(p) : o(h) + "." + o(u.table[w.Symbol.Name]) + "." + o(p),
-          params: []
-        };
-      }
-      if (T(u, Ti)) {
-        const p = u[I].schema, h = u[I].name;
-        return {
-          sql: p === void 0 || u[I].isAlias ? o(h) : o(p) + "." + o(h),
-          params: []
-        };
-      }
-      if (T(u, se)) {
-        if (T(u.value, O))
-          return { sql: l(d.value++, u), params: [u], typings: ["none"] };
-        const p = u.value === null ? null : u.encoder.mapToDriverValue(u.value);
-        if (T(p, z))
-          return this.buildQueryFromSourceParams([p], s);
-        if (m)
-          return { sql: this.mapInlineParam(p, s), params: [] };
-        let h = ["none"];
-        return a && (h = [a(u.encoder)]), { sql: l(d.value++, p), params: [p], typings: h };
-      }
-      return T(u, O) ? { sql: l(d.value++, u), params: [u], typings: ["none"] } : T(u, z.Aliased) && u.fieldAlias !== void 0 ? { sql: o(u.fieldAlias), params: [] } : T(u, ne) ? u._.isWith ? { sql: o(u._.alias), params: [] } : this.buildQueryFromSourceParams([
-        new C("("),
-        u._.sql,
-        new C(") "),
-        new U(u._.alias)
-      ], s) : Ao(u) ? u.schema ? { sql: o(u.schema) + "." + o(u.enumName), params: [] } : { sql: o(u.enumName), params: [] } : Io(u) ? (f = u.shouldOmitSQLParens) != null && f.call(u) ? this.buildQueryFromSourceParams([u.getSQL()], s) : this.buildQueryFromSourceParams([
-        new C("("),
-        u.getSQL(),
-        new C(")")
-      ], s) : m ? { sql: this.mapInlineParam(u, s), params: [] } : { sql: l(d.value++, u), params: [u], typings: ["none"] };
-    }));
-  }
-  mapInlineParam(e, { escapeString: t }) {
-    if (e === null)
-      return "null";
-    if (typeof e == "number" || typeof e == "boolean")
-      return e.toString();
-    if (typeof e == "string")
-      return t(e);
-    if (typeof e == "object") {
-      const s = e.toString();
-      return t(s === "[object Object]" ? JSON.stringify(e) : s);
-    }
-    throw new Error("Unexpected param value: " + e);
-  }
-  getSQL() {
-    return this;
-  }
-  as(e) {
-    return e === void 0 ? this : new z.Aliased(this, e);
-  }
-  mapWith(e) {
-    return this.decoder = typeof e == "function" ? { mapFromDriverValue: e } : e, this;
-  }
-  inlineParams() {
-    return this.shouldInlineParams = !0, this;
-  }
-  /**
-   * This method is used to conditionally include a part of the query.
-   *
-   * @param condition - Condition to check
-   * @returns itself if the condition is `true`, otherwise `undefined`
-   */
-  if(e) {
-    return e ? this : void 0;
-  }
-};
-r(z, Ke, "SQL");
-let N = z;
-var We;
-We = c;
-class U {
-  constructor(e) {
-    r(this, "brand");
-    this.value = e;
-  }
-  getSQL() {
-    return new N([this]);
-  }
-}
-r(U, We, "Name");
-const xi = {
-  mapFromDriverValue: (n) => n
-}, Ni = {
-  mapToDriverValue: (n) => n
-};
-({
-  ...xi,
-  ...Ni
-});
-var Ye;
-Ye = c;
-class se {
-  /**
-   * @param value - Parameter value
-   * @param encoder - Encoder to convert the value to a driver parameter
-   */
-  constructor(e, t = Ni) {
-    r(this, "brand");
-    this.value = e, this.encoder = t;
-  }
-  getSQL() {
-    return new N([this]);
-  }
-}
-r(se, Ye, "Param");
-function q(n, ...e) {
-  const t = [];
-  (e.length > 0 || n.length > 0 && n[0] !== "") && t.push(new C(n[0]));
-  for (const [s, i] of e.entries())
-    t.push(i, new C(n[s + 1]));
-  return new N(t);
-}
-((n) => {
-  function e() {
-    return new N([]);
-  }
-  n.empty = e;
-  function t(m) {
-    return new N(m);
-  }
-  n.fromList = t;
-  function s(m) {
-    return new N([new C(m)]);
-  }
-  n.raw = s;
-  function i(m, d) {
-    const u = [];
-    for (const [f, p] of m.entries())
-      f > 0 && d !== void 0 && u.push(d), u.push(p);
-    return new N(u);
-  }
-  n.join = i;
-  function o(m) {
-    return new U(m);
-  }
-  n.identifier = o;
-  function l(m) {
-    return new O(m);
-  }
-  n.placeholder = l;
-  function a(m, d) {
-    return new se(m, d);
-  }
-  n.param = a;
-})(q || (q = {}));
-((n) => {
-  var t;
-  t = c;
-  const s = class s {
-    constructor(o, l) {
-      /** @internal */
-      r(this, "isSelectionField", !1);
-      this.sql = o, this.fieldAlias = l;
-    }
-    getSQL() {
-      return this.sql;
-    }
-    /** @internal */
-    clone() {
-      return new s(this.sql, this.fieldAlias);
-    }
-  };
-  r(s, t, "SQL.Aliased");
-  let e = s;
-  n.Aliased = e;
-})(N || (N = {}));
-var Ge;
-Ge = c;
-class O {
-  constructor(e) {
-    this.name = e;
-  }
-  getSQL() {
-    return new N([this]);
-  }
-}
-r(O, Ge, "Placeholder");
-const _o = Symbol.for("drizzle:IsDrizzleView");
-var He, Ze, Xe;
-Xe = c, Ze = I, He = _o;
-class Ti {
-  constructor({ name: e, schema: t, selectedFields: s, query: i }) {
-    /** @internal */
-    r(this, Ze);
-    /** @internal */
-    r(this, He, !0);
-    this[I] = {
-      name: e,
-      originalName: e,
-      schema: t,
-      selectedFields: s,
-      query: i,
-      isExisting: !i,
-      isAlias: !1
-    };
-  }
-  getSQL() {
-    return new N([this]);
-  }
-}
-r(Ti, Xe, "View");
-K.prototype.getSQL = function() {
-  return new N([this]);
-};
-w.prototype.getSQL = function() {
-  return new N([this]);
-};
-ne.prototype.getSQL = function() {
-  return new N([this]);
-};
-function x(n, e) {
-  return {
-    name: typeof n == "string" && n.length > 0 ? n : "",
-    config: typeof n == "object" ? n : e
-  };
-}
-var ke, et;
-class j extends (et = b, ke = c, et) {
-  generatedAlwaysAsIdentity(e) {
-    if (e) {
-      const { name: t, ...s } = e;
-      this.config.generatedIdentity = {
-        type: "always",
-        sequenceName: t,
-        sequenceOptions: s
-      };
-    } else
-      this.config.generatedIdentity = {
-        type: "always"
-      };
-    return this.config.hasDefault = !0, this.config.notNull = !0, this;
-  }
-  generatedByDefaultAsIdentity(e) {
-    if (e) {
-      const { name: t, ...s } = e;
-      this.config.generatedIdentity = {
-        type: "byDefault",
-        sequenceName: t,
-        sequenceOptions: s
-      };
-    } else
-      this.config.generatedIdentity = {
-        type: "byDefault"
-      };
-    return this.config.hasDefault = !0, this.config.notNull = !0, this;
-  }
-}
-r(j, ke, "PgIntColumnBaseBuilder");
-var tt, nt;
-class Ci extends (nt = j, tt = c, nt) {
-  constructor(e) {
-    super(e, "number", "PgBigInt53");
-  }
-  /** @internal */
-  build(e) {
-    return new Si(e, this.config);
-  }
-}
-r(Ci, tt, "PgBigInt53Builder");
-var st, it;
-class Si extends (it = g, st = c, it) {
-  getSQLType() {
-    return "bigint";
-  }
-  mapFromDriverValue(e) {
-    return typeof e == "number" ? e : Number(e);
-  }
-}
-r(Si, st, "PgBigInt53");
-var rt, ot;
-class Pi extends (ot = j, rt = c, ot) {
-  constructor(e) {
-    super(e, "bigint", "PgBigInt64");
-  }
-  /** @internal */
-  build(e) {
-    return new Di(
-      e,
-      this.config
-    );
-  }
-}
-r(Pi, rt, "PgBigInt64Builder");
-var at, ut;
-class Di extends (ut = g, at = c, ut) {
-  getSQLType() {
-    return "bigint";
-  }
-  // eslint-disable-next-line unicorn/prefer-native-coercion-functions
-  mapFromDriverValue(e) {
-    return BigInt(e);
-  }
-}
-r(Di, at, "PgBigInt64");
-function Uo(n, e) {
-  const { name: t, config: s } = x(n, e);
-  return s.mode === "number" ? new Ci(t) : new Pi(t);
-}
-var ct, lt;
-class vi extends (lt = b, ct = c, lt) {
-  constructor(e) {
-    super(e, "number", "PgBigSerial53"), this.config.hasDefault = !0, this.config.notNull = !0;
-  }
-  /** @internal */
-  build(e) {
-    return new Ei(
-      e,
-      this.config
-    );
-  }
-}
-r(vi, ct, "PgBigSerial53Builder");
-var mt, dt;
-class Ei extends (dt = g, mt = c, dt) {
-  getSQLType() {
-    return "bigserial";
-  }
-  mapFromDriverValue(e) {
-    return typeof e == "number" ? e : Number(e);
-  }
-}
-r(Ei, mt, "PgBigSerial53");
-var ft, pt;
-class $i extends (pt = b, ft = c, pt) {
-  constructor(e) {
-    super(e, "bigint", "PgBigSerial64"), this.config.hasDefault = !0;
-  }
-  /** @internal */
-  build(e) {
-    return new Bi(
-      e,
-      this.config
-    );
-  }
-}
-r($i, ft, "PgBigSerial64Builder");
-var ht, gt;
-class Bi extends (gt = g, ht = c, gt) {
-  getSQLType() {
-    return "bigserial";
-  }
-  // eslint-disable-next-line unicorn/prefer-native-coercion-functions
-  mapFromDriverValue(e) {
-    return BigInt(e);
-  }
-}
-r(Bi, ht, "PgBigSerial64");
-function qo(n, e) {
-  const { name: t, config: s } = x(n, e);
-  return s.mode === "number" ? new vi(t) : new $i(t);
-}
-var bt, yt;
-class zi extends (yt = b, bt = c, yt) {
-  constructor(e) {
-    super(e, "boolean", "PgBoolean");
-  }
-  /** @internal */
-  build(e) {
-    return new Fi(e, this.config);
-  }
-}
-r(zi, bt, "PgBooleanBuilder");
-var wt, xt;
-class Fi extends (xt = g, wt = c, xt) {
-  getSQLType() {
-    return "boolean";
-  }
-}
-r(Fi, wt, "PgBoolean");
-function ie(n) {
-  return new zi(n ?? "");
-}
-var Nt, Tt;
-class Li extends (Tt = b, Nt = c, Tt) {
-  constructor(e, t) {
-    super(e, "string", "PgChar"), this.config.length = t.length, this.config.enumValues = t.enum;
-  }
-  /** @internal */
-  build(e) {
-    return new Ai(
-      e,
-      this.config
-    );
-  }
-}
-r(Li, Nt, "PgCharBuilder");
-var Ct, St;
-class Ai extends (St = g, Ct = c, St) {
-  constructor() {
-    super(...arguments);
-    r(this, "length", this.config.length);
-    r(this, "enumValues", this.config.enumValues);
-  }
-  getSQLType() {
-    return this.length === void 0 ? "char" : `char(${this.length})`;
-  }
-}
-r(Ai, Ct, "PgChar");
-function Oo(n, e = {}) {
-  const { name: t, config: s } = x(n, e);
-  return new Li(t, s);
-}
-var Pt, Dt;
-class Qi extends (Dt = b, Pt = c, Dt) {
-  constructor(e) {
-    super(e, "string", "PgCidr");
-  }
-  /** @internal */
-  build(e) {
-    return new Vi(e, this.config);
-  }
-}
-r(Qi, Pt, "PgCidrBuilder");
-var vt, Et;
-class Vi extends (Et = g, vt = c, Et) {
-  getSQLType() {
-    return "cidr";
-  }
-}
-r(Vi, vt, "PgCidr");
-function Mo(n) {
-  return new Qi(n ?? "");
-}
-var $t, Bt;
-class Ii extends (Bt = b, $t = c, Bt) {
-  constructor(e, t, s) {
-    super(e, "custom", "PgCustomColumn"), this.config.fieldConfig = t, this.config.customTypeParams = s;
-  }
-  /** @internal */
-  build(e) {
-    return new ji(
-      e,
-      this.config
-    );
-  }
-}
-r(Ii, $t, "PgCustomColumnBuilder");
-var zt, Ft;
-class ji extends (Ft = g, zt = c, Ft) {
-  constructor(t, s) {
-    super(t, s);
-    r(this, "sqlName");
-    r(this, "mapTo");
-    r(this, "mapFrom");
-    this.sqlName = s.customTypeParams.dataType(s.fieldConfig), this.mapTo = s.customTypeParams.toDriver, this.mapFrom = s.customTypeParams.fromDriver;
-  }
-  getSQLType() {
-    return this.sqlName;
-  }
-  mapFromDriverValue(t) {
-    return typeof this.mapFrom == "function" ? this.mapFrom(t) : t;
-  }
-  mapToDriverValue(t) {
-    return typeof this.mapTo == "function" ? this.mapTo(t) : t;
-  }
-}
-r(ji, zt, "PgCustomColumn");
-function Ro(n) {
-  return (e, t) => {
-    const { name: s, config: i } = x(e, t);
-    return new Ii(s, i, n);
-  };
-}
-var Lt, At;
-class V extends (At = b, Lt = c, At) {
-  defaultNow() {
-    return this.default(q`now()`);
-  }
-}
-r(V, Lt, "PgDateColumnBaseBuilder");
-var Qt, Vt;
-class _i extends (Vt = V, Qt = c, Vt) {
-  constructor(e) {
-    super(e, "date", "PgDate");
-  }
-  /** @internal */
-  build(e) {
-    return new Ui(e, this.config);
-  }
-}
-r(_i, Qt, "PgDateBuilder");
-var It, jt;
-class Ui extends (jt = g, It = c, jt) {
-  getSQLType() {
-    return "date";
-  }
-  mapFromDriverValue(e) {
-    return new Date(e);
-  }
-  mapToDriverValue(e) {
-    return e.toISOString();
-  }
-}
-r(Ui, It, "PgDate");
-var _t, Ut;
-class qi extends (Ut = V, _t = c, Ut) {
-  constructor(e) {
-    super(e, "string", "PgDateString");
-  }
-  /** @internal */
-  build(e) {
-    return new Oi(
-      e,
-      this.config
-    );
-  }
-}
-r(qi, _t, "PgDateStringBuilder");
-var qt, Ot;
-class Oi extends (Ot = g, qt = c, Ot) {
-  getSQLType() {
-    return "date";
-  }
-}
-r(Oi, qt, "PgDateString");
-function Jo(n, e) {
-  const { name: t, config: s } = x(n, e);
-  return (s == null ? void 0 : s.mode) === "date" ? new _i(t) : new qi(t);
-}
-var Mt, Rt;
-class Mi extends (Rt = b, Mt = c, Rt) {
-  constructor(e) {
-    super(e, "number", "PgDoublePrecision");
-  }
-  /** @internal */
-  build(e) {
-    return new Ri(
-      e,
-      this.config
-    );
-  }
-}
-r(Mi, Mt, "PgDoublePrecisionBuilder");
-var Jt, Kt;
-class Ri extends (Kt = g, Jt = c, Kt) {
-  getSQLType() {
-    return "double precision";
-  }
-  mapFromDriverValue(e) {
-    return typeof e == "string" ? Number.parseFloat(e) : e;
-  }
-}
-r(Ri, Jt, "PgDoublePrecision");
-function Ko(n) {
-  return new Mi(n ?? "");
-}
-var Wt, Yt;
-class Ji extends (Yt = b, Wt = c, Yt) {
-  constructor(e) {
-    super(e, "string", "PgInet");
-  }
-  /** @internal */
-  build(e) {
-    return new Ki(e, this.config);
-  }
-}
-r(Ji, Wt, "PgInetBuilder");
-var Gt, Ht;
-class Ki extends (Ht = g, Gt = c, Ht) {
-  getSQLType() {
-    return "inet";
-  }
-}
-r(Ki, Gt, "PgInet");
-function Wo(n) {
-  return new Ji(n ?? "");
-}
-var Zt, Xt;
-class Wi extends (Xt = j, Zt = c, Xt) {
-  constructor(e) {
-    super(e, "number", "PgInteger");
-  }
-  /** @internal */
-  build(e) {
-    return new Yi(e, this.config);
-  }
-}
-r(Wi, Zt, "PgIntegerBuilder");
-var kt, en;
-class Yi extends (en = g, kt = c, en) {
-  getSQLType() {
-    return "integer";
-  }
-  mapFromDriverValue(e) {
-    return typeof e == "string" ? Number.parseInt(e) : e;
-  }
-}
-r(Yi, kt, "PgInteger");
-function D(n) {
-  return new Wi(n ?? "");
-}
-var tn, nn;
-class Gi extends (nn = b, tn = c, nn) {
-  constructor(e, t) {
-    super(e, "string", "PgInterval"), this.config.intervalConfig = t;
-  }
-  /** @internal */
-  build(e) {
-    return new Hi(e, this.config);
-  }
-}
-r(Gi, tn, "PgIntervalBuilder");
-var sn, rn;
-class Hi extends (rn = g, sn = c, rn) {
-  constructor() {
-    super(...arguments);
-    r(this, "fields", this.config.intervalConfig.fields);
-    r(this, "precision", this.config.intervalConfig.precision);
-  }
-  getSQLType() {
-    const t = this.fields ? ` ${this.fields}` : "", s = this.precision ? `(${this.precision})` : "";
-    return `interval${t}${s}`;
-  }
-}
-r(Hi, sn, "PgInterval");
-function Yo(n, e = {}) {
-  const { name: t, config: s } = x(n, e);
-  return new Gi(t, s);
-}
-var on, an;
-class Zi extends (an = b, on = c, an) {
-  constructor(e) {
-    super(e, "json", "PgJson");
-  }
-  /** @internal */
-  build(e) {
-    return new Xi(e, this.config);
-  }
-}
-r(Zi, on, "PgJsonBuilder");
-var un, cn;
-class Xi extends (cn = g, un = c, cn) {
-  constructor(e, t) {
-    super(e, t);
-  }
-  getSQLType() {
-    return "json";
-  }
-  mapToDriverValue(e) {
-    return JSON.stringify(e);
-  }
-  mapFromDriverValue(e) {
-    if (typeof e == "string")
-      try {
-        return JSON.parse(e);
-      } catch {
-        return e;
-      }
-    return e;
-  }
-}
-r(Xi, un, "PgJson");
-function Go(n) {
-  return new Zi(n ?? "");
-}
-var ln, mn;
-class ki extends (mn = b, ln = c, mn) {
-  constructor(e) {
-    super(e, "json", "PgJsonb");
-  }
-  /** @internal */
-  build(e) {
-    return new er(e, this.config);
-  }
-}
-r(ki, ln, "PgJsonbBuilder");
-var dn, fn;
-class er extends (fn = g, dn = c, fn) {
-  constructor(e, t) {
-    super(e, t);
-  }
-  getSQLType() {
-    return "jsonb";
-  }
-  mapToDriverValue(e) {
-    return JSON.stringify(e);
-  }
-  mapFromDriverValue(e) {
-    if (typeof e == "string")
-      try {
-        return JSON.parse(e);
-      } catch {
-        return e;
-      }
-    return e;
-  }
-}
-r(er, dn, "PgJsonb");
-function Ho(n) {
-  return new ki(n ?? "");
-}
-var pn, hn;
-class tr extends (hn = b, pn = c, hn) {
-  constructor(e) {
-    super(e, "array", "PgLine");
-  }
-  /** @internal */
-  build(e) {
-    return new nr(
-      e,
-      this.config
-    );
-  }
-}
-r(tr, pn, "PgLineBuilder");
-var gn, bn;
-class nr extends (bn = g, gn = c, bn) {
-  getSQLType() {
-    return "line";
-  }
-  mapFromDriverValue(e) {
-    const [t, s, i] = e.slice(1, -1).split(",");
-    return [Number.parseFloat(t), Number.parseFloat(s), Number.parseFloat(i)];
-  }
-  mapToDriverValue(e) {
-    return `{${e[0]},${e[1]},${e[2]}}`;
-  }
-}
-r(nr, gn, "PgLine");
-var yn, wn;
-class sr extends (wn = b, yn = c, wn) {
-  constructor(e) {
-    super(e, "json", "PgLineABC");
-  }
-  /** @internal */
-  build(e) {
-    return new ir(
-      e,
-      this.config
-    );
-  }
-}
-r(sr, yn, "PgLineABCBuilder");
-var xn, Nn;
-class ir extends (Nn = g, xn = c, Nn) {
-  getSQLType() {
-    return "line";
-  }
-  mapFromDriverValue(e) {
-    const [t, s, i] = e.slice(1, -1).split(",");
-    return { a: Number.parseFloat(t), b: Number.parseFloat(s), c: Number.parseFloat(i) };
-  }
-  mapToDriverValue(e) {
-    return `{${e.a},${e.b},${e.c}}`;
-  }
-}
-r(ir, xn, "PgLineABC");
-function Zo(n, e) {
-  const { name: t, config: s } = x(n, e);
-  return !(s != null && s.mode) || s.mode === "tuple" ? new tr(t) : new sr(t);
-}
-var Tn, Cn;
-class rr extends (Cn = b, Tn = c, Cn) {
-  constructor(e) {
-    super(e, "string", "PgMacaddr");
-  }
-  /** @internal */
-  build(e) {
-    return new or(e, this.config);
-  }
-}
-r(rr, Tn, "PgMacaddrBuilder");
-var Sn, Pn;
-class or extends (Pn = g, Sn = c, Pn) {
-  getSQLType() {
-    return "macaddr";
-  }
-}
-r(or, Sn, "PgMacaddr");
-function Xo(n) {
-  return new rr(n ?? "");
-}
-var Dn, vn;
-class ar extends (vn = b, Dn = c, vn) {
-  constructor(e) {
-    super(e, "string", "PgMacaddr8");
-  }
-  /** @internal */
-  build(e) {
-    return new ur(e, this.config);
-  }
-}
-r(ar, Dn, "PgMacaddr8Builder");
-var En, $n;
-class ur extends ($n = g, En = c, $n) {
-  getSQLType() {
-    return "macaddr8";
-  }
-}
-r(ur, En, "PgMacaddr8");
-function ko(n) {
-  return new ar(n ?? "");
-}
-var Bn, zn;
-class cr extends (zn = b, Bn = c, zn) {
-  constructor(e, t, s) {
-    super(e, "string", "PgNumeric"), this.config.precision = t, this.config.scale = s;
-  }
-  /** @internal */
-  build(e) {
-    return new lr(e, this.config);
-  }
-}
-r(cr, Bn, "PgNumericBuilder");
-var Fn, Ln;
-class lr extends (Ln = g, Fn = c, Ln) {
-  constructor(t, s) {
-    super(t, s);
-    r(this, "precision");
-    r(this, "scale");
-    this.precision = s.precision, this.scale = s.scale;
-  }
-  mapFromDriverValue(t) {
-    return typeof t == "string" ? t : String(t);
-  }
-  getSQLType() {
-    return this.precision !== void 0 && this.scale !== void 0 ? `numeric(${this.precision}, ${this.scale})` : this.precision === void 0 ? "numeric" : `numeric(${this.precision})`;
-  }
-}
-r(lr, Fn, "PgNumeric");
-var An, Qn;
-class mr extends (Qn = b, An = c, Qn) {
-  constructor(e, t, s) {
-    super(e, "number", "PgNumericNumber"), this.config.precision = t, this.config.scale = s;
-  }
-  /** @internal */
-  build(e) {
-    return new dr(
-      e,
-      this.config
-    );
-  }
-}
-r(mr, An, "PgNumericNumberBuilder");
-var Vn, In;
-class dr extends (In = g, Vn = c, In) {
-  constructor(t, s) {
-    super(t, s);
-    r(this, "precision");
-    r(this, "scale");
-    r(this, "mapToDriverValue", String);
-    this.precision = s.precision, this.scale = s.scale;
-  }
-  mapFromDriverValue(t) {
-    return typeof t == "number" ? t : Number(t);
-  }
-  getSQLType() {
-    return this.precision !== void 0 && this.scale !== void 0 ? `numeric(${this.precision}, ${this.scale})` : this.precision === void 0 ? "numeric" : `numeric(${this.precision})`;
-  }
-}
-r(dr, Vn, "PgNumericNumber");
-var jn, _n;
-class fr extends (_n = b, jn = c, _n) {
-  constructor(e, t, s) {
-    super(e, "bigint", "PgNumericBigInt"), this.config.precision = t, this.config.scale = s;
-  }
-  /** @internal */
-  build(e) {
-    return new pr(
-      e,
-      this.config
-    );
-  }
-}
-r(fr, jn, "PgNumericBigIntBuilder");
-var Un, qn;
-class pr extends (qn = g, Un = c, qn) {
-  constructor(t, s) {
-    super(t, s);
-    r(this, "precision");
-    r(this, "scale");
-    r(this, "mapFromDriverValue", BigInt);
-    r(this, "mapToDriverValue", String);
-    this.precision = s.precision, this.scale = s.scale;
-  }
-  getSQLType() {
-    return this.precision !== void 0 && this.scale !== void 0 ? `numeric(${this.precision}, ${this.scale})` : this.precision === void 0 ? "numeric" : `numeric(${this.precision})`;
-  }
-}
-r(pr, Un, "PgNumericBigInt");
-function hr(n, e) {
-  const { name: t, config: s } = x(n, e), i = s == null ? void 0 : s.mode;
-  return i === "number" ? new mr(t, s == null ? void 0 : s.precision, s == null ? void 0 : s.scale) : i === "bigint" ? new fr(t, s == null ? void 0 : s.precision, s == null ? void 0 : s.scale) : new cr(t, s == null ? void 0 : s.precision, s == null ? void 0 : s.scale);
-}
-const ea = hr;
-var On, Mn;
-class gr extends (Mn = b, On = c, Mn) {
-  constructor(e) {
-    super(e, "array", "PgPointTuple");
-  }
-  /** @internal */
-  build(e) {
-    return new br(
-      e,
-      this.config
-    );
-  }
-}
-r(gr, On, "PgPointTupleBuilder");
-var Rn, Jn;
-class br extends (Jn = g, Rn = c, Jn) {
-  getSQLType() {
-    return "point";
-  }
-  mapFromDriverValue(e) {
-    if (typeof e == "string") {
-      const [t, s] = e.slice(1, -1).split(",");
-      return [Number.parseFloat(t), Number.parseFloat(s)];
-    }
-    return [e.x, e.y];
-  }
-  mapToDriverValue(e) {
-    return `(${e[0]},${e[1]})`;
-  }
-}
-r(br, Rn, "PgPointTuple");
-var Kn, Wn;
-class yr extends (Wn = b, Kn = c, Wn) {
-  constructor(e) {
-    super(e, "json", "PgPointObject");
-  }
-  /** @internal */
-  build(e) {
-    return new wr(
-      e,
-      this.config
-    );
-  }
-}
-r(yr, Kn, "PgPointObjectBuilder");
-var Yn, Gn;
-class wr extends (Gn = g, Yn = c, Gn) {
-  getSQLType() {
-    return "point";
-  }
-  mapFromDriverValue(e) {
-    if (typeof e == "string") {
-      const [t, s] = e.slice(1, -1).split(",");
-      return { x: Number.parseFloat(t), y: Number.parseFloat(s) };
-    }
-    return e;
-  }
-  mapToDriverValue(e) {
-    return `(${e.x},${e.y})`;
-  }
-}
-r(wr, Yn, "PgPointObject");
-function ta(n, e) {
-  const { name: t, config: s } = x(n, e);
-  return !(s != null && s.mode) || s.mode === "tuple" ? new gr(t) : new yr(t);
-}
-function na(n) {
-  const e = [];
-  for (let t = 0; t < n.length; t += 2)
-    e.push(Number.parseInt(n.slice(t, t + 2), 16));
-  return new Uint8Array(e);
-}
-function ye(n, e) {
-  const t = new ArrayBuffer(8), s = new DataView(t);
-  for (let i = 0; i < 8; i++)
-    s.setUint8(i, n[e + i]);
-  return s.getFloat64(0, !0);
-}
-function xr(n) {
-  const e = na(n);
-  let t = 0;
-  const s = e[t];
-  t += 1;
-  const i = new DataView(e.buffer), o = i.getUint32(t, s === 1);
-  if (t += 4, o & 536870912 && (i.getUint32(t, s === 1), t += 4), (o & 65535) === 1) {
-    const l = ye(e, t);
-    t += 8;
-    const a = ye(e, t);
-    return t += 8, [l, a];
-  }
-  throw new Error("Unsupported geometry type");
-}
-var Hn, Zn;
-class Nr extends (Zn = b, Hn = c, Zn) {
-  constructor(e) {
-    super(e, "array", "PgGeometry");
-  }
-  /** @internal */
-  build(e) {
-    return new Tr(
-      e,
-      this.config
-    );
-  }
-}
-r(Nr, Hn, "PgGeometryBuilder");
-var Xn, kn;
-class Tr extends (kn = g, Xn = c, kn) {
-  getSQLType() {
-    return "geometry(point)";
-  }
-  mapFromDriverValue(e) {
-    return xr(e);
-  }
-  mapToDriverValue(e) {
-    return `point(${e[0]} ${e[1]})`;
-  }
-}
-r(Tr, Xn, "PgGeometry");
-var es, ts;
-class Cr extends (ts = b, es = c, ts) {
-  constructor(e) {
-    super(e, "json", "PgGeometryObject");
-  }
-  /** @internal */
-  build(e) {
-    return new Sr(
-      e,
-      this.config
-    );
-  }
-}
-r(Cr, es, "PgGeometryObjectBuilder");
-var ns, ss;
-class Sr extends (ss = g, ns = c, ss) {
-  getSQLType() {
-    return "geometry(point)";
-  }
-  mapFromDriverValue(e) {
-    const t = xr(e);
-    return { x: t[0], y: t[1] };
-  }
-  mapToDriverValue(e) {
-    return `point(${e.x} ${e.y})`;
-  }
-}
-r(Sr, ns, "PgGeometryObject");
-function sa(n, e) {
-  const { name: t, config: s } = x(n, e);
-  return !(s != null && s.mode) || s.mode === "tuple" ? new Nr(t) : new Cr(t);
-}
-var is, rs;
-class Pr extends (rs = b, is = c, rs) {
-  constructor(e, t) {
-    super(e, "number", "PgReal"), this.config.length = t;
-  }
-  /** @internal */
-  build(e) {
-    return new Dr(e, this.config);
-  }
-}
-r(Pr, is, "PgRealBuilder");
-var os, as;
-class Dr extends (as = g, os = c, as) {
-  constructor(t, s) {
-    super(t, s);
-    r(this, "mapFromDriverValue", (t) => typeof t == "string" ? Number.parseFloat(t) : t);
-  }
-  getSQLType() {
-    return "real";
-  }
-}
-r(Dr, os, "PgReal");
-function ia(n) {
-  return new Pr(n ?? "");
-}
-var us, cs;
-class vr extends (cs = b, us = c, cs) {
-  constructor(e) {
-    super(e, "number", "PgSerial"), this.config.hasDefault = !0, this.config.notNull = !0;
-  }
-  /** @internal */
-  build(e) {
-    return new Er(e, this.config);
-  }
-}
-r(vr, us, "PgSerialBuilder");
-var ls, ms;
-class Er extends (ms = g, ls = c, ms) {
-  getSQLType() {
-    return "serial";
-  }
-}
-r(Er, ls, "PgSerial");
-function ra(n) {
-  return new vr(n ?? "");
-}
-var ds, fs;
-class $r extends (fs = j, ds = c, fs) {
-  constructor(e) {
-    super(e, "number", "PgSmallInt");
-  }
-  /** @internal */
-  build(e) {
-    return new Br(e, this.config);
-  }
-}
-r($r, ds, "PgSmallIntBuilder");
-var ps, hs;
-class Br extends (hs = g, ps = c, hs) {
-  constructor() {
-    super(...arguments);
-    r(this, "mapFromDriverValue", (t) => typeof t == "string" ? Number(t) : t);
-  }
-  getSQLType() {
-    return "smallint";
-  }
-}
-r(Br, ps, "PgSmallInt");
-function oa(n) {
-  return new $r(n ?? "");
-}
-var gs, bs;
-class zr extends (bs = b, gs = c, bs) {
-  constructor(e) {
-    super(e, "number", "PgSmallSerial"), this.config.hasDefault = !0, this.config.notNull = !0;
-  }
-  /** @internal */
-  build(e) {
-    return new Fr(
-      e,
-      this.config
-    );
-  }
-}
-r(zr, gs, "PgSmallSerialBuilder");
-var ys, ws;
-class Fr extends (ws = g, ys = c, ws) {
-  getSQLType() {
-    return "smallserial";
-  }
-}
-r(Fr, ys, "PgSmallSerial");
-function aa(n) {
-  return new zr(n ?? "");
-}
-var xs, Ns;
-class Lr extends (Ns = b, xs = c, Ns) {
-  constructor(e, t) {
-    super(e, "string", "PgText"), this.config.enumValues = t.enum;
-  }
-  /** @internal */
-  build(e) {
-    return new Ar(e, this.config);
-  }
-}
-r(Lr, xs, "PgTextBuilder");
-var Ts, Cs;
-class Ar extends (Cs = g, Ts = c, Cs) {
-  constructor() {
-    super(...arguments);
-    r(this, "enumValues", this.config.enumValues);
-  }
-  getSQLType() {
-    return "text";
-  }
-}
-r(Ar, Ts, "PgText");
-function E(n, e = {}) {
-  const { name: t, config: s } = x(n, e);
-  return new Lr(t, s);
-}
-var Ss, Ps;
-class Qr extends (Ps = V, Ss = c, Ps) {
-  constructor(e, t, s) {
-    super(e, "string", "PgTime"), this.withTimezone = t, this.precision = s, this.config.withTimezone = t, this.config.precision = s;
-  }
-  /** @internal */
-  build(e) {
-    return new Vr(e, this.config);
-  }
-}
-r(Qr, Ss, "PgTimeBuilder");
-var Ds, vs;
-class Vr extends (vs = g, Ds = c, vs) {
-  constructor(t, s) {
-    super(t, s);
-    r(this, "withTimezone");
-    r(this, "precision");
-    this.withTimezone = s.withTimezone, this.precision = s.precision;
-  }
-  getSQLType() {
-    return `time${this.precision === void 0 ? "" : `(${this.precision})`}${this.withTimezone ? " with time zone" : ""}`;
-  }
-}
-r(Vr, Ds, "PgTime");
-function ua(n, e = {}) {
-  const { name: t, config: s } = x(n, e);
-  return new Qr(t, s.withTimezone ?? !1, s.precision);
-}
-var Es, $s;
-class Ir extends ($s = V, Es = c, $s) {
-  constructor(e, t, s) {
-    super(e, "date", "PgTimestamp"), this.config.withTimezone = t, this.config.precision = s;
-  }
-  /** @internal */
-  build(e) {
-    return new jr(e, this.config);
-  }
-}
-r(Ir, Es, "PgTimestampBuilder");
-var Bs, zs;
-class jr extends (zs = g, Bs = c, zs) {
-  constructor(t, s) {
-    super(t, s);
-    r(this, "withTimezone");
-    r(this, "precision");
-    r(this, "mapFromDriverValue", (t) => new Date(this.withTimezone ? t : t + "+0000"));
-    r(this, "mapToDriverValue", (t) => t.toISOString());
-    this.withTimezone = s.withTimezone, this.precision = s.precision;
-  }
-  getSQLType() {
-    return `timestamp${this.precision === void 0 ? "" : ` (${this.precision})`}${this.withTimezone ? " with time zone" : ""}`;
-  }
-}
-r(jr, Bs, "PgTimestamp");
-var Fs, Ls;
-class _r extends (Ls = V, Fs = c, Ls) {
-  constructor(e, t, s) {
-    super(e, "string", "PgTimestampString"), this.config.withTimezone = t, this.config.precision = s;
-  }
-  /** @internal */
-  build(e) {
-    return new Ur(
-      e,
-      this.config
-    );
-  }
-}
-r(_r, Fs, "PgTimestampStringBuilder");
-var As, Qs;
-class Ur extends (Qs = g, As = c, Qs) {
-  constructor(t, s) {
-    super(t, s);
-    r(this, "withTimezone");
-    r(this, "precision");
-    this.withTimezone = s.withTimezone, this.precision = s.precision;
-  }
-  getSQLType() {
-    return `timestamp${this.precision === void 0 ? "" : `(${this.precision})`}${this.withTimezone ? " with time zone" : ""}`;
-  }
-}
-r(Ur, As, "PgTimestampString");
-function S(n, e = {}) {
-  const { name: t, config: s } = x(n, e);
-  return (s == null ? void 0 : s.mode) === "string" ? new _r(t, s.withTimezone ?? !1, s.precision) : new Ir(t, (s == null ? void 0 : s.withTimezone) ?? !1, s == null ? void 0 : s.precision);
-}
-var Vs, Is;
-class qr extends (Is = b, Vs = c, Is) {
-  constructor(e) {
-    super(e, "string", "PgUUID");
-  }
-  /**
-   * Adds `default gen_random_uuid()` to the column definition.
-   */
-  defaultRandom() {
-    return this.default(q`gen_random_uuid()`);
-  }
-  /** @internal */
-  build(e) {
-    return new Or(e, this.config);
-  }
-}
-r(qr, Vs, "PgUUIDBuilder");
-var js, _s;
-class Or extends (_s = g, js = c, _s) {
-  getSQLType() {
-    return "uuid";
-  }
-}
-r(Or, js, "PgUUID");
-function ca(n) {
-  return new qr(n ?? "");
-}
-var Us, qs;
-class Mr extends (qs = b, Us = c, qs) {
-  constructor(e, t) {
-    super(e, "string", "PgVarchar"), this.config.length = t.length, this.config.enumValues = t.enum;
-  }
-  /** @internal */
-  build(e) {
-    return new Rr(
-      e,
-      this.config
-    );
-  }
-}
-r(Mr, Us, "PgVarcharBuilder");
-var Os, Ms;
-class Rr extends (Ms = g, Os = c, Ms) {
-  constructor() {
-    super(...arguments);
-    r(this, "length", this.config.length);
-    r(this, "enumValues", this.config.enumValues);
-  }
-  getSQLType() {
-    return this.length === void 0 ? "varchar" : `varchar(${this.length})`;
-  }
-}
-r(Rr, Os, "PgVarchar");
-function la(n, e = {}) {
-  const { name: t, config: s } = x(n, e);
-  return new Mr(t, s);
-}
-var Rs, Js;
-class Jr extends (Js = b, Rs = c, Js) {
-  constructor(e, t) {
-    super(e, "string", "PgBinaryVector"), this.config.dimensions = t.dimensions;
-  }
-  /** @internal */
-  build(e) {
-    return new Kr(
-      e,
-      this.config
-    );
-  }
-}
-r(Jr, Rs, "PgBinaryVectorBuilder");
-var Ks, Ws;
-class Kr extends (Ws = g, Ks = c, Ws) {
-  constructor() {
-    super(...arguments);
-    r(this, "dimensions", this.config.dimensions);
-  }
-  getSQLType() {
-    return `bit(${this.dimensions})`;
-  }
-}
-r(Kr, Ks, "PgBinaryVector");
-function ma(n, e) {
-  const { name: t, config: s } = x(n, e);
-  return new Jr(t, s);
-}
-var Ys, Gs;
-class Wr extends (Gs = b, Ys = c, Gs) {
-  constructor(e, t) {
-    super(e, "array", "PgHalfVector"), this.config.dimensions = t.dimensions;
-  }
-  /** @internal */
-  build(e) {
-    return new Yr(
-      e,
-      this.config
-    );
-  }
-}
-r(Wr, Ys, "PgHalfVectorBuilder");
-var Hs, Zs;
-class Yr extends (Zs = g, Hs = c, Zs) {
-  constructor() {
-    super(...arguments);
-    r(this, "dimensions", this.config.dimensions);
-  }
-  getSQLType() {
-    return `halfvec(${this.dimensions})`;
-  }
-  mapToDriverValue(t) {
-    return JSON.stringify(t);
-  }
-  mapFromDriverValue(t) {
-    return t.slice(1, -1).split(",").map((s) => Number.parseFloat(s));
-  }
-}
-r(Yr, Hs, "PgHalfVector");
-function da(n, e) {
-  const { name: t, config: s } = x(n, e);
-  return new Wr(t, s);
-}
-var Xs, ks;
-class Gr extends (ks = b, Xs = c, ks) {
-  constructor(e, t) {
-    super(e, "string", "PgSparseVector"), this.config.dimensions = t.dimensions;
-  }
-  /** @internal */
-  build(e) {
-    return new Hr(
-      e,
-      this.config
-    );
-  }
-}
-r(Gr, Xs, "PgSparseVectorBuilder");
-var ei, ti;
-class Hr extends (ti = g, ei = c, ti) {
-  constructor() {
-    super(...arguments);
-    r(this, "dimensions", this.config.dimensions);
-  }
-  getSQLType() {
-    return `sparsevec(${this.dimensions})`;
-  }
-}
-r(Hr, ei, "PgSparseVector");
-function fa(n, e) {
-  const { name: t, config: s } = x(n, e);
-  return new Gr(t, s);
-}
-var ni, si;
-class Zr extends (si = b, ni = c, si) {
-  constructor(e, t) {
-    super(e, "array", "PgVector"), this.config.dimensions = t.dimensions;
-  }
-  /** @internal */
-  build(e) {
-    return new Xr(
-      e,
-      this.config
-    );
-  }
-}
-r(Zr, ni, "PgVectorBuilder");
-var ii, ri;
-class Xr extends (ri = g, ii = c, ri) {
-  constructor() {
-    super(...arguments);
-    r(this, "dimensions", this.config.dimensions);
-  }
-  getSQLType() {
-    return `vector(${this.dimensions})`;
-  }
-  mapToDriverValue(t) {
-    return JSON.stringify(t);
-  }
-  mapFromDriverValue(t) {
-    return t.slice(1, -1).split(",").map((s) => Number.parseFloat(s));
-  }
-}
-r(Xr, ii, "PgVector");
-function pa(n, e) {
-  const { name: t, config: s } = x(n, e);
-  return new Zr(t, s);
-}
-function ha() {
-  return {
-    bigint: Uo,
-    bigserial: qo,
-    boolean: ie,
-    char: Oo,
-    cidr: Mo,
-    customType: Ro,
-    date: Jo,
-    doublePrecision: Ko,
-    inet: Wo,
-    integer: D,
-    interval: Yo,
-    json: Go,
-    jsonb: Ho,
-    line: Zo,
-    macaddr: Xo,
-    macaddr8: ko,
-    numeric: hr,
-    point: ta,
-    geometry: sa,
-    real: ia,
-    serial: ra,
-    smallint: oa,
-    smallserial: aa,
-    text: E,
-    time: ua,
-    timestamp: S,
-    uuid: ca,
-    varchar: la,
-    bit: ma,
-    halfvec: da,
-    sparsevec: fa,
-    vector: pa
-  };
-}
-const k = Symbol.for("drizzle:PgInlineForeignKeys"), we = Symbol.for("drizzle:EnableRLS");
-var oi, ai, ui, ci, li, mi;
-class M extends (mi = w, li = c, ci = k, ui = we, ai = w.Symbol.ExtraConfigBuilder, oi = w.Symbol.ExtraConfigColumns, mi) {
-  constructor() {
-    super(...arguments);
-    /**@internal */
-    r(this, ci, []);
-    /** @internal */
-    r(this, ui, !1);
-    /** @internal */
-    r(this, ai);
-    /** @internal */
-    r(this, oi, {});
-  }
-}
-r(M, li, "PgTable"), /** @internal */
-r(M, "Symbol", Object.assign({}, w.Symbol, {
-  InlineForeignKeys: k,
-  EnableRLS: we
-}));
-function ga(n, e, t, s, i = n) {
-  const o = new M(n, s, i), l = typeof e == "function" ? e(ha()) : e, a = Object.fromEntries(
-    Object.entries(l).map(([u, f]) => {
-      const p = f;
-      p.setName(u);
-      const h = p.build(o);
-      return o[k].push(...p.buildForeignKeys(h, o)), [u, h];
-    })
-  ), m = Object.fromEntries(
-    Object.entries(l).map(([u, f]) => {
-      const p = f;
-      p.setName(u);
-      const h = p.buildExtraConfigColumn(o);
-      return [u, h];
-    })
-  ), d = Object.assign(o, a);
-  return d[w.Symbol.Columns] = a, d[w.Symbol.ExtraConfigColumns] = m, Object.assign(d, {
-    enableRLS: () => (d[M.Symbol.EnableRLS] = !0, d)
-  });
-}
-const W = (n, e, t) => ga(n, e, t, void 0), P = W("organisations", {
-  id: D("id").primaryKey(),
-  name: E("name").notNull(),
-  description: E("description"),
-  createdAt: S("created_at").defaultNow(),
-  updatedAt: S("updated_at").defaultNow()
-}), F = W("departments", {
-  id: D("id").primaryKey(),
-  name: E("name").notNull(),
-  description: E("description"),
-  organisation: D("organisation").notNull().references(() => P.id),
-  createdAt: S("created_at").defaultNow(),
-  updatedAt: S("updated_at").defaultNow()
-}), L = W("suppliers", {
-  id: D("id").primaryKey(),
-  name: E("name").notNull(),
-  description: E("description"),
-  internal: ie("internal").default(!1),
-  organisation: D("organisation").notNull().references(() => P.id),
-  createdAt: S("created_at").defaultNow(),
-  updatedAt: S("updated_at").defaultNow()
-}), $ = W("employees", {
-  id: D("id").primaryKey(),
-  name: E("name").notNull(),
-  email: E("email").notNull(),
-  active: ie("active").default(!0),
-  fteBasis: ea("fte_basis", { precision: 3, scale: 2 }).default("1.00"),
-  startDate: S("start_date"),
-  endDate: S("end_date"),
-  department: D("department").references(() => F.id),
-  supplier: D("supplier").references(() => L.id),
-  organisation: D("organisation").notNull().references(() => P.id),
-  createdAt: S("created_at").defaultNow(),
-  updatedAt: S("updated_at").defaultNow()
-}), ba = J(P, ({ many: n }) => ({
-  departments: n(F),
-  suppliers: n(L),
-  employees: n($)
-})), ya = J(F, ({ one: n, many: e }) => ({
-  organisation: n(P, {
-    fields: [F.organisation],
-    references: [P.id]
-  }),
-  employees: e($)
-})), wa = J(L, ({ one: n, many: e }) => ({
-  organisation: n(P, {
-    fields: [L.organisation],
-    references: [P.id]
-  }),
-  employees: e($)
-})), xa = J($, ({ one: n }) => ({
-  organisation: n(P, {
-    fields: [$.organisation],
-    references: [P.id]
-  }),
-  department: n(F, {
-    fields: [$.department],
-    references: [F.id]
-  }),
-  supplier: n(L, {
-    fields: [$.supplier],
-    references: [L.id]
-  })
-})), Ba = {
-  organisations: P,
-  departments: F,
-  suppliers: L,
-  employees: $,
-  organisationsRelations: ba,
-  departmentsRelations: ya,
-  suppliersRelations: wa,
-  employeesRelations: xa
-}, za = wo;
-function Fa(n) {
-  return new te({
-    drizzle: n.drizzle,
-    schema: n.schema
+const xe = se;
+function Te(s) {
+  return new T({
+    drizzle: s.drizzle,
+    schema: s.schema
   });
 }
-const La = {
+const Ae = {
   /**
    * Create a simple query builder
    */
   query: () => {
-    const n = (e, t = [], s = [], i = [], o, l) => ({
+    const s = (e, t = [], i = [], n = [], o, a) => ({
       measures: e,
       dimensions: t,
-      filters: s,
-      timeDimensions: i,
+      filters: i,
+      timeDimensions: n,
       limit: o,
-      order: l
+      order: a
     });
     return {
       measures: (e) => ({
         dimensions: (t = []) => ({
-          filters: (s = []) => ({
-            timeDimensions: (i = []) => ({
+          filters: (i = []) => ({
+            timeDimensions: (n = []) => ({
               limit: (o) => ({
-                order: (l) => n(e, t, s, i, o, l)
+                order: (a) => s(e, t, i, n, o, a)
               }),
-              order: (o) => n(e, t, s, i, void 0, o)
+              order: (o) => s(e, t, i, n, void 0, o)
             }),
-            limit: (i) => ({
-              order: (o) => n(e, t, s, [], i, o)
+            limit: (n) => ({
+              order: (o) => s(e, t, i, [], n, o)
             }),
-            order: (i) => n(e, t, s, [], void 0, i)
+            order: (n) => s(e, t, i, [], void 0, n)
           }),
-          timeDimensions: (s = []) => ({
-            filters: (i = []) => ({
+          timeDimensions: (i = []) => ({
+            filters: (n = []) => ({
               limit: (o) => ({
-                order: (l) => n(e, t, i, s, o, l)
+                order: (a) => s(e, t, n, i, o, a)
               }),
-              order: (o) => n(e, t, i, s, void 0, o)
+              order: (o) => s(e, t, n, i, void 0, o)
             }),
-            limit: (i) => ({
-              order: (o) => n(e, t, [], s, i, o)
+            limit: (n) => ({
+              order: (o) => s(e, t, [], i, n, o)
             }),
-            order: (i) => n(e, t, [], s, void 0, i)
+            order: (n) => s(e, t, [], i, void 0, n)
           }),
-          limit: (s) => ({
-            order: (i) => n(e, t, [], [], s, i)
+          limit: (i) => ({
+            order: (n) => s(e, t, [], [], i, n)
           }),
-          order: (s) => n(e, t, [], [], void 0, s)
+          order: (i) => s(e, t, [], [], void 0, i)
         }),
         filters: (t = []) => ({
-          dimensions: (s = []) => ({
-            timeDimensions: (i = []) => ({
+          dimensions: (i = []) => ({
+            timeDimensions: (n = []) => ({
               limit: (o) => ({
-                order: (l) => n(e, s, t, i, o, l)
+                order: (a) => s(e, i, t, n, o, a)
               }),
-              order: (o) => n(e, s, t, i, void 0, o)
+              order: (o) => s(e, i, t, n, void 0, o)
             }),
-            limit: (i) => ({
-              order: (o) => n(e, s, t, [], i, o)
+            limit: (n) => ({
+              order: (o) => s(e, i, t, [], n, o)
             }),
-            order: (i) => n(e, s, t, [], void 0, i)
+            order: (n) => s(e, i, t, [], void 0, n)
           }),
-          timeDimensions: (s = []) => ({
-            dimensions: (i = []) => ({
+          timeDimensions: (i = []) => ({
+            dimensions: (n = []) => ({
               limit: (o) => ({
-                order: (l) => n(e, i, t, s, o, l)
+                order: (a) => s(e, n, t, i, o, a)
               }),
-              order: (o) => n(e, i, t, s, void 0, o)
+              order: (o) => s(e, n, t, i, void 0, o)
             }),
-            limit: (i) => ({
-              order: (o) => n(e, [], t, s, i, o)
+            limit: (n) => ({
+              order: (o) => s(e, [], t, i, n, o)
             }),
-            order: (i) => n(e, [], t, s, void 0, i)
+            order: (n) => s(e, [], t, i, void 0, n)
           }),
-          limit: (s) => ({
-            order: (i) => n(e, [], t, [], s, i)
+          limit: (i) => ({
+            order: (n) => s(e, [], t, [], i, n)
           }),
-          order: (s) => n(e, [], t, [], void 0, s)
+          order: (i) => s(e, [], t, [], void 0, i)
         })
       })
     };
@@ -3490,64 +1719,55 @@ const La = {
    * Create filters
    */
   filters: {
-    equals: (n, e) => ({ member: n, operator: "equals", values: [e] }),
-    notEquals: (n, e) => ({ member: n, operator: "notEquals", values: [e] }),
-    contains: (n, e) => ({ member: n, operator: "contains", values: [e] }),
-    greaterThan: (n, e) => ({ member: n, operator: "gt", values: [e] }),
-    lessThan: (n, e) => ({ member: n, operator: "lt", values: [e] }),
-    inDateRange: (n, e, t) => ({
-      member: n,
+    equals: (s, e) => ({ member: s, operator: "equals", values: [e] }),
+    notEquals: (s, e) => ({ member: s, operator: "notEquals", values: [e] }),
+    contains: (s, e) => ({ member: s, operator: "contains", values: [e] }),
+    greaterThan: (s, e) => ({ member: s, operator: "gt", values: [e] }),
+    lessThan: (s, e) => ({ member: s, operator: "lt", values: [e] }),
+    inDateRange: (s, e, t) => ({
+      member: s,
       operator: "inDateRange",
       values: [e, t]
     }),
-    set: (n) => ({ member: n, operator: "set", values: [] }),
-    notSet: (n) => ({ member: n, operator: "notSet", values: [] })
+    set: (s) => ({ member: s, operator: "set", values: [] }),
+    notSet: (s) => ({ member: s, operator: "notSet", values: [] })
   },
   /**
    * Create time dimensions
    */
   timeDimensions: {
-    create: (n, e, t) => ({
-      dimension: n,
+    create: (s, e, t) => ({
+      dimension: s,
       granularity: e,
       dateRange: t
     })
   }
 };
 export {
-  ee as BaseDatabaseExecutor,
-  yo as MultiCubeBuilder,
-  ho as MySQLExecutor,
-  fo as PostgresExecutor,
-  de as QueryExecutor,
-  po as SQLiteExecutor,
-  te as SemanticLayerCompiler,
-  La as SemanticLayerUtils,
-  Ea as convertCubeReferences,
-  me as createDatabaseExecutor,
-  Fa as createDrizzleSemanticLayer,
-  bo as createMultiCubeContext,
-  go as createMySQLExecutor,
-  ce as createPostgresExecutor,
-  le as createSQLiteExecutor,
-  Da as createSemanticLayer,
-  za as defaultSemanticLayer,
-  Pa as defineCube,
-  Sa as defineLegacyCube,
-  F as departments,
-  ya as departmentsRelations,
-  $ as employees,
-  xa as employeesRelations,
-  Ba as exampleSchema,
-  Bo as loadYamlCubes,
-  va as loadYamlCubesFromFile,
-  P as organisations,
-  ba as organisationsRelations,
-  xo as parseYamlCubes,
-  v as resolveSqlExpression,
-  $a as semanticCubeToYaml,
-  wo as semanticLayer,
-  L as suppliers,
-  wa as suppliersRelations,
-  To as yamlCubeToSemanticCube
+  x as BaseDatabaseExecutor,
+  ie as MultiCubeBuilder,
+  ee as MySQLExecutor,
+  X as PostgresExecutor,
+  $ as QueryExecutor,
+  q as SQLiteExecutor,
+  T as SemanticLayerCompiler,
+  Ae as SemanticLayerUtils,
+  ye as convertCubeReferences,
+  _ as createDatabaseExecutor,
+  Te as createDrizzleSemanticLayer,
+  ne as createMultiCubeContext,
+  te as createMySQLExecutor,
+  S as createPostgresExecutor,
+  M as createSQLiteExecutor,
+  Ee as createSemanticLayer,
+  xe as defaultSemanticLayer,
+  Ne as defineCube,
+  we as defineLegacyCube,
+  pe as loadYamlCubes,
+  De as loadYamlCubesFromFile,
+  re as parseYamlCubes,
+  b as resolveSqlExpression,
+  $e as semanticCubeToYaml,
+  se as semanticLayer,
+  ae as yamlCubeToSemanticCube
 };