drizzle-cube 0.1.4 → 0.1.5

package/dist/adapters/hono/index.js

@@ -1,63 +1,79 @@
-import { Hono as v } from "hono";
-var A = (y) => {
-  const c = {
+import { Hono as D } from "hono";
+var S = (q) => {
+  const d = {
     ...{
       origin: "*",
       allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"],
       allowHeaders: [],
       exposeHeaders: []
     },
-    ...y
-  }, q = /* @__PURE__ */ ((u) => typeof u == "string" ? u === "*" ? () => u : (n) => u === n ? n : null : typeof u == "function" ? u : (n) => u.includes(n) ? n : null)(c.origin), g = ((u) => typeof u == "function" ? u : Array.isArray(u) ? () => u : () => [])(c.allowMethods);
-  return async function(n, d) {
-    var e;
-    function f(r, s) {
-      n.res.headers.set(r, s);
+    ...q
+  }, A = /* @__PURE__ */ ((u) => typeof u == "string" ? u === "*" ? () => u : (n) => u === n ? n : null : typeof u == "function" ? u : (n) => u.includes(n) ? n : null)(d.origin), j = ((u) => typeof u == "function" ? u : Array.isArray(u) ? () => u : () => [])(d.allowMethods);
+  return async function(n, m) {
+    var x;
+    function p(h, f) {
+      n.res.headers.set(h, f);
     }
-    const w = q(n.req.header("origin") || "", n);
-    if (w && f("Access-Control-Allow-Origin", w), c.origin !== "*") {
-      const r = n.req.header("Vary");
-      r ? f("Vary", r) : f("Vary", "Origin");
+    const b = A(n.req.header("origin") || "", n);
+    if (b && p("Access-Control-Allow-Origin", b), d.origin !== "*") {
+      const h = n.req.header("Vary");
+      h ? p("Vary", h) : p("Vary", "Origin");
     }
-    if (c.credentials && f("Access-Control-Allow-Credentials", "true"), (e = c.exposeHeaders) != null && e.length && f("Access-Control-Expose-Headers", c.exposeHeaders.join(",")), n.req.method === "OPTIONS") {
-      c.maxAge != null && f("Access-Control-Max-Age", c.maxAge.toString());
-      const r = g(n.req.header("origin") || "", n);
-      r.length && f("Access-Control-Allow-Methods", r.join(","));
-      let s = c.allowHeaders;
-      if (!(s != null && s.length)) {
-        const t = n.req.header("Access-Control-Request-Headers");
-        t && (s = t.split(/\s*,\s*/));
+    if (d.credentials && p("Access-Control-Allow-Credentials", "true"), (x = d.exposeHeaders) != null && x.length && p("Access-Control-Expose-Headers", d.exposeHeaders.join(",")), n.req.method === "OPTIONS") {
+      d.maxAge != null && p("Access-Control-Max-Age", d.maxAge.toString());
+      const h = j(n.req.header("origin") || "", n);
+      h.length && p("Access-Control-Allow-Methods", h.join(","));
+      let f = d.allowHeaders;
+      if (!(f != null && f.length)) {
+        const e = n.req.header("Access-Control-Request-Headers");
+        e && (f = e.split(/\s*,\s*/));
       }
-      return s != null && s.length && (f("Access-Control-Allow-Headers", s.join(",")), n.res.headers.append("Vary", "Access-Control-Request-Headers")), n.res.headers.delete("Content-Length"), n.res.headers.delete("Content-Type"), new Response(null, {
+      return f != null && f.length && (p("Access-Control-Allow-Headers", f.join(",")), n.res.headers.append("Vary", "Access-Control-Request-Headers")), n.res.headers.delete("Content-Length"), n.res.headers.delete("Content-Type"), new Response(null, {
         headers: n.res.headers,
         status: 204,
         statusText: "No Content"
       });
     }
-    await d();
+    await m();
   };
 };
-function E(y) {
+function E(q) {
   const {
     semanticLayer: a,
-    drizzle: c,
-    schema: q,
-    getSecurityContext: g,
+    drizzle: d,
+    schema: A,
+    getSecurityContext: j,
     cors: u,
     basePath: n = "/cubejs-api/v1"
-  } = y, d = new v();
-  u && d.use("/*", A(u)), a.hasExecutor() || a.setDrizzle(c, q), d.post(`${n}/load`, async (e) => {
+  } = q, m = new D();
+  u && m.use("/*", S(u)), a.hasExecutor() || a.setDrizzle(d, A), m.post(`${n}/load`, async (e) => {
     try {
-      const r = await e.req.json(), s = r.query || r, t = await g(e), o = a.validateQuery(s);
+      const r = await e.req.json(), s = r.query || r, t = await j(e), o = a.validateQuery(s);
       if (!o.isValid)
         return e.json({
           error: `Query validation failed: ${o.errors.join(", ")}`
         }, 400);
-      const i = await a.executeMultiCubeQuery(s, t);
+      const i = await a.executeMultiCubeQuery(s, t), l = h(a), y = b(), g = (/* @__PURE__ */ new Date()).toISOString(), Q = x(s);
       return e.json({
-        data: i.data,
-        annotation: i.annotation,
-        query: s,
+        queryType: "regularQuery",
+        results: [{
+          query: s,
+          lastRefreshTime: g,
+          usedPreAggregations: {},
+          transformedQuery: Q,
+          requestId: y,
+          annotation: i.annotation,
+          dataSource: "default",
+          dbType: l,
+          extDbType: l,
+          external: !1,
+          slowQuery: !1,
+          data: i.data
+        }],
+        pivotQuery: {
+          ...s,
+          queryType: "regularQuery"
+        },
         slowQuery: !1
       });
     } catch (r) {
@@ -65,23 +81,39 @@ function E(y) {
         error: r instanceof Error ? r.message : "Query execution failed"
       }, 500);
     }
-  }), d.get(`${n}/load`, async (e) => {
+  }), m.get(`${n}/load`, async (e) => {
     try {
       const r = e.req.query("query");
       if (!r)
         return e.json({
           error: "Query parameter is required"
         }, 400);
-      const s = JSON.parse(r), t = await g(e), o = a.validateQuery(s);
+      const s = JSON.parse(r), t = await j(e), o = a.validateQuery(s);
       if (!o.isValid)
         return e.json({
           error: `Query validation failed: ${o.errors.join(", ")}`
         }, 400);
-      const i = await a.executeMultiCubeQuery(s, t);
+      const i = await a.executeMultiCubeQuery(s, t), l = h(a), y = b(), g = (/* @__PURE__ */ new Date()).toISOString(), Q = x(s);
       return e.json({
-        data: i.data,
-        annotation: i.annotation,
-        query: s,
+        queryType: "regularQuery",
+        results: [{
+          query: s,
+          lastRefreshTime: g,
+          usedPreAggregations: {},
+          transformedQuery: Q,
+          requestId: y,
+          annotation: i.annotation,
+          dataSource: "default",
+          dbType: l,
+          extDbType: l,
+          external: !1,
+          slowQuery: !1,
+          data: i.data
+        }],
+        pivotQuery: {
+          ...s,
+          queryType: "regularQuery"
+        },
         slowQuery: !1
       });
     } catch (r) {
@@ -89,7 +121,7 @@ function E(y) {
         error: r instanceof Error ? r.message : "Query execution failed"
       }, 500);
     }
-  }), d.get(`${n}/meta`, async (e) => {
+  }), m.get(`${n}/meta`, (e) => {
     try {
       const r = a.getMetadata();
       return e.json({
@@ -100,23 +132,23 @@ function E(y) {
         error: r instanceof Error ? r.message : "Failed to fetch metadata"
       }, 500);
     }
-  }), d.post(`${n}/sql`, async (e) => {
+  }), m.post(`${n}/sql`, async (e) => {
     var r, s;
     try {
-      const t = await e.req.json(), o = await g(e), i = a.validateQuery(t);
+      const t = await e.req.json(), o = await j(e), i = a.validateQuery(t);
       if (!i.isValid)
         return e.json({
           error: `Query validation failed: ${i.errors.join(", ")}`
         }, 400);
-      const p = ((r = t.measures) == null ? void 0 : r[0]) || ((s = t.dimensions) == null ? void 0 : s[0]);
-      if (!p)
+      const l = ((r = t.measures) == null ? void 0 : r[0]) || ((s = t.dimensions) == null ? void 0 : s[0]);
+      if (!l)
         return e.json({
           error: "No measures or dimensions specified"
         }, 400);
-      const h = p.split(".")[0], j = await a.generateSQL(h, t, o);
+      const y = l.split(".")[0], g = await a.generateSQL(y, t, o);
       return e.json({
-        sql: j.sql,
-        params: j.params || [],
+        sql: g.sql,
+        params: g.params || [],
         query: t
       });
     } catch (t) {
@@ -124,7 +156,7 @@ function E(y) {
         error: t instanceof Error ? t.message : "SQL generation failed"
       }, 500);
     }
-  }), d.get(`${n}/sql`, async (e) => {
+  }), m.get(`${n}/sql`, async (e) => {
     var r, s;
     try {
       const t = e.req.query("query");
@@ -132,17 +164,17 @@ function E(y) {
         return e.json({
           error: "Query parameter is required"
         }, 400);
-      const o = JSON.parse(t), i = await g(e), p = a.validateQuery(o);
-      if (!p.isValid)
+      const o = JSON.parse(t), i = await j(e), l = a.validateQuery(o);
+      if (!l.isValid)
         return e.json({
-          error: `Query validation failed: ${p.errors.join(", ")}`
+          error: `Query validation failed: ${l.errors.join(", ")}`
         }, 400);
-      const h = ((r = o.measures) == null ? void 0 : r[0]) || ((s = o.dimensions) == null ? void 0 : s[0]);
-      if (!h)
+      const y = ((r = o.measures) == null ? void 0 : r[0]) || ((s = o.dimensions) == null ? void 0 : s[0]);
+      if (!y)
         return e.json({
           error: "No measures or dimensions specified"
         }, 400);
-      const j = h.split(".")[0], Q = await a.generateSQL(j, o, i);
+      const g = y.split(".")[0], Q = await a.generateSQL(g, o, i);
       return e.json({
         sql: Q.sql,
         params: Q.params || [],
@@ -154,30 +186,67 @@ function E(y) {
       }, 500);
     }
   });
-  function f(e) {
+  function p(e) {
     var s, t, o, i;
     let r = 0;
     return r += (((s = e.measures) == null ? void 0 : s.length) || 0) * 1, r += (((t = e.dimensions) == null ? void 0 : t.length) || 0) * 1, r += (((o = e.filters) == null ? void 0 : o.length) || 0) * 2, r += (((i = e.timeDimensions) == null ? void 0 : i.length) || 0) * 3, r <= 5 ? "low" : r <= 15 ? "medium" : "high";
   }
-  async function w(e, r) {
-    var h, j, Q, b;
+  function b() {
+    const e = Date.now(), r = Math.random().toString(36).substring(2, 9);
+    return `${e}-${r}`;
+  }
+  function x(e) {
+    const r = e.dimensions || [], s = e.timeDimensions || [], t = e.measures || [];
+    return {
+      sortedDimensions: r,
+      sortedTimeDimensions: s,
+      timeDimensions: s,
+      measures: t,
+      leafMeasureAdditive: !0,
+      leafMeasures: t,
+      measureToLeafMeasures: {},
+      hasNoTimeDimensionsWithoutGranularity: !0,
+      allFiltersWithinSelectedDimensions: !0,
+      isAdditive: !0,
+      granularityHierarchies: {},
+      hasMultipliedMeasures: !1,
+      hasCumulativeMeasures: !1,
+      windowGranularity: null,
+      filterDimensionsSingleValueEqual: {},
+      ownedDimensions: r,
+      ownedTimeDimensionsWithRollupGranularity: [],
+      ownedTimeDimensionsAsIs: [],
+      allBackAliasMembers: {},
+      hasMultiStage: !1
+    };
+  }
+  function h(e) {
+    if (e.hasExecutor()) {
+      const r = e.databaseExecutor;
+      if (r != null && r.engineType)
+        return r.engineType;
+    }
+    return "postgres";
+  }
+  async function f(e, r) {
+    var y, g, Q, v;
     const s = a.validateQuery(e);
     if (!s.isValid)
       throw new Error(`Query validation failed: ${s.errors.join(", ")}`);
     const t = /* @__PURE__ */ new Set();
-    (h = e.measures) == null || h.forEach((l) => {
-      const m = l.split(".")[0];
-      t.add(m);
-    }), (j = e.dimensions) == null || j.forEach((l) => {
-      const m = l.split(".")[0];
-      t.add(m);
-    }), (Q = e.timeDimensions) == null || Q.forEach((l) => {
-      const m = l.dimension.split(".")[0];
-      t.add(m);
-    }), (b = e.filters) == null || b.forEach((l) => {
-      if ("member" in l) {
-        const m = l.member.split(".")[0];
-        t.add(m);
+    (y = e.measures) == null || y.forEach((c) => {
+      const w = c.split(".")[0];
+      t.add(w);
+    }), (g = e.dimensions) == null || g.forEach((c) => {
+      const w = c.split(".")[0];
+      t.add(w);
+    }), (Q = e.timeDimensions) == null || Q.forEach((c) => {
+      const w = c.dimension.split(".")[0];
+      t.add(w);
+    }), (v = e.filters) == null || v.forEach((c) => {
+      if ("member" in c) {
+        const w = c.member.split(".")[0];
+        t.add(w);
       }
     });
     const o = t.size > 1;
@@ -185,16 +254,16 @@ function E(y) {
     if (o)
       i = await a.generateMultiCubeSQL(e, r);
     else {
-      const l = Array.from(t)[0];
-      i = await a.generateSQL(l, e, r);
+      const c = Array.from(t)[0];
+      i = await a.generateSQL(c, e, r);
     }
-    const p = Array.from(t).map((l) => {
-      var m, x;
+    const l = Array.from(t).map((c) => {
+      var w, T;
       return {
-        cube: l,
+        cube: c,
         query: {
-          measures: ((m = e.measures) == null ? void 0 : m.filter((C) => C.startsWith(l + "."))) || [],
-          dimensions: ((x = e.dimensions) == null ? void 0 : x.filter((C) => C.startsWith(l + "."))) || [],
+          measures: ((w = e.measures) == null ? void 0 : w.filter((C) => C.startsWith(c + "."))) || [],
+          dimensions: ((T = e.dimensions) == null ? void 0 : T.filter((C) => C.startsWith(c + "."))) || [],
           filters: e.filters || [],
           timeDimensions: e.timeDimensions || [],
           order: e.order || {},
@@ -205,9 +274,9 @@ function E(y) {
     });
     return {
       queryType: "regularQuery",
-      normalizedQueries: p,
+      normalizedQueries: l,
       queryOrder: Array.from(t),
-      transformedQueries: p,
+      transformedQueries: l,
       pivotQuery: {
         query: e,
         cubes: Array.from(t)
@@ -216,16 +285,16 @@ function E(y) {
         sql: [i.sql],
         params: i.params || []
       },
-      complexity: f(e),
+      complexity: p(e),
       valid: !0,
       cubesUsed: Array.from(t),
       joinType: o ? "multi_cube_join" : "single_cube",
       query: e
     };
   }
-  return d.post(`${n}/dry-run`, async (e) => {
+  return m.post(`${n}/dry-run`, async (e) => {
     try {
-      const r = await e.req.json(), s = r.query || r, t = await g(e), o = await w(s, t);
+      const r = await e.req.json(), s = r.query || r, t = await j(e), o = await f(s, t);
       return e.json(o);
     } catch (r) {
       return console.error("Dry-run error:", r), e.json({
@@ -233,7 +302,7 @@ function E(y) {
         valid: !1
       }, 400);
     }
-  }), d.get(`${n}/dry-run`, async (e) => {
+  }), m.get(`${n}/dry-run`, async (e) => {
     try {
       const r = e.req.query("query");
       if (!r)
@@ -241,7 +310,7 @@ function E(y) {
           error: "Query parameter is required",
           valid: !1
         }, 400);
-      const s = JSON.parse(r), t = await g(e), o = await w(s, t);
+      const s = JSON.parse(r), t = await j(e), o = await f(s, t);
       return e.json(o);
     } catch (r) {
       return console.error("Dry-run error:", r), e.json({
@@ -249,18 +318,18 @@ function E(y) {
         valid: !1
       }, 400);
     }
-  }), d;
+  }), m;
 }
-function S(y, a) {
-  const c = E(a);
-  return y.route("/", c), y;
+function M(q, a) {
+  const d = E(a);
+  return q.route("/", d), q;
 }
-function D(y) {
-  const a = new v();
-  return S(a, y);
+function R(q) {
+  const a = new D();
+  return M(a, q);
 }
 export {
-  D as createCubeApp,
+  R as createCubeApp,
   E as createCubeRoutes,
-  S as mountCubeRoutes
+  M as mountCubeRoutes
 };

package/dist/client/client/CubeClient.d.ts

@@ -6,6 +6,7 @@ export declare class CubeClient {
     load(query: CubeQuery): Promise<CubeResultSet>;
     meta(): Promise<any>;
     sql(query: CubeQuery): Promise<any>;
+    dryRun(query: CubeQuery): Promise<any>;
 }
 /**
  * Factory function to create a cube client

package/dist/client/components/Modal.d.ts

@@ -3,13 +3,14 @@ export interface ModalProps {
     isOpen: boolean;
     onClose: () => void;
     title?: string;
-    size?: 'sm' | 'md' | 'lg' | 'xl' | 'full';
+    size?: 'sm' | 'md' | 'lg' | 'xl' | 'full' | 'fullscreen';
     closeOnBackdropClick?: boolean;
     closeOnEscape?: boolean;
     showCloseButton?: boolean;
     className?: string;
     children: React.ReactNode;
     footer?: React.ReactNode;
+    noPadding?: boolean;
 }
 declare const Modal: React.FC<ModalProps>;
 export default Modal;

package/dist/client/components/QueryBuilder/CubeMetaExplorer.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { CubeMetaExplorerProps } from './types';
+declare const CubeMetaExplorer: React.FC<CubeMetaExplorerProps>;
+export default CubeMetaExplorer;

package/dist/client/components/QueryBuilder/QueryPanel.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { QueryPanelProps } from './types';
+declare const QueryPanel: React.FC<QueryPanelProps>;
+export default QueryPanel;

package/dist/client/components/QueryBuilder/ResultsPanel.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { ResultsPanelProps } from './types';
+declare const ResultsPanel: React.FC<ResultsPanelProps>;
+export default ResultsPanel;

package/dist/client/components/QueryBuilder/SetupPanel.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { ApiConfig } from './types';
+interface SetupPanelProps {
+    isOpen: boolean;
+    onToggle: () => void;
+    config: ApiConfig;
+    onConfigChange: (config: ApiConfig) => void;
+    onReset: () => void;
+}
+declare const SetupPanel: React.FC<SetupPanelProps>;
+export default SetupPanel;

package/dist/client/components/QueryBuilder/index.d.ts

@@ -0,0 +1,3 @@
+import { QueryBuilderProps, QueryBuilderRef } from './types';
+declare const QueryBuilder: import('react').ForwardRefExoticComponent<QueryBuilderProps & import('react').RefAttributes<QueryBuilderRef>>;
+export default QueryBuilder;

package/dist/client/components/QueryBuilder/types.d.ts

@@ -0,0 +1,132 @@
+import { CubeQuery } from '../../types';
+export interface MetaField {
+    name: string;
+    title: string;
+    shortTitle: string;
+    type: string;
+    description?: string;
+}
+export interface MetaCube {
+    name: string;
+    title: string;
+    description: string;
+    measures: MetaField[];
+    dimensions: MetaField[];
+    segments: MetaField[];
+}
+export interface MetaResponse {
+    cubes: MetaCube[];
+}
+export type ValidationStatus = 'idle' | 'validating' | 'valid' | 'invalid';
+export type ExecutionStatus = 'idle' | 'loading' | 'success' | 'error';
+export type SchemaStatus = 'idle' | 'loading' | 'success' | 'error';
+export interface QueryBuilderState {
+    query: CubeQuery;
+    schema: MetaResponse | null;
+    schemaStatus: SchemaStatus;
+    schemaError: string | null;
+    validationStatus: ValidationStatus;
+    validationError: string | null;
+    validationSql: {
+        sql: string[];
+        params: any[];
+    } | null;
+    executionStatus: ExecutionStatus;
+    executionResults: any[] | null;
+    executionError: string | null;
+    totalRowCount: number | null;
+    totalRowCountStatus: 'idle' | 'loading' | 'success' | 'error';
+}
+export interface ValidationResult {
+    valid?: boolean;
+    error?: string;
+    query?: CubeQuery;
+    sql?: {
+        sql: string[];
+        params: any[];
+    };
+    queryType?: string;
+    normalizedQueries?: any[];
+    queryOrder?: string[];
+    transformedQueries?: any[];
+    pivotQuery?: any;
+    complexity?: string;
+    cubesUsed?: string[];
+    joinType?: string;
+}
+export interface ApiConfig {
+    baseApiUrl: string;
+    apiToken: string;
+}
+export interface QueryBuilderProps {
+    baseUrl: string;
+    className?: string;
+    initialQuery?: CubeQuery;
+    disableLocalStorage?: boolean;
+    hideSettings?: boolean;
+}
+export interface QueryBuilderRef {
+    getCurrentQuery: () => CubeQuery;
+    getValidationState: () => {
+        status: ValidationStatus;
+        result?: ValidationResult;
+    };
+    getValidationResult: () => ValidationResult | null;
+}
+export interface CubeMetaExplorerProps {
+    schema: MetaResponse | null;
+    schemaStatus: SchemaStatus;
+    schemaError: string | null;
+    selectedFields: {
+        measures: string[];
+        dimensions: string[];
+        timeDimensions: string[];
+    };
+    onFieldSelect: (fieldName: string, fieldType: 'measures' | 'dimensions' | 'timeDimensions') => void;
+    onFieldDeselect: (fieldName: string, fieldType: 'measures' | 'dimensions' | 'timeDimensions') => void;
+    onRetrySchema?: () => void;
+    onOpenSettings?: () => void;
+}
+export interface QueryPanelProps {
+    query: CubeQuery;
+    validationStatus: ValidationStatus;
+    validationError: string | null;
+    validationSql: {
+        sql: string[];
+        params: any[];
+    } | null;
+    onValidate: () => void;
+    onExecute: () => void;
+    onRemoveField: (fieldName: string, fieldType: 'measures' | 'dimensions' | 'timeDimensions') => void;
+    onTimeDimensionGranularityChange: (dimensionName: string, granularity: string) => void;
+    onClearQuery?: () => void;
+    showSettings?: boolean;
+    onSettingsClick?: () => void;
+}
+export interface ResultsPanelProps {
+    executionStatus: ExecutionStatus;
+    executionResults: any[] | null;
+    executionError: string | null;
+    query: CubeQuery;
+    displayLimit?: number;
+    onDisplayLimitChange?: (limit: number) => void;
+    totalRowCount?: number | null;
+    totalRowCountStatus?: 'idle' | 'loading' | 'success' | 'error';
+}
+export declare const TIME_GRANULARITIES: readonly [{
+    readonly value: "day";
+    readonly label: "Day";
+}, {
+    readonly value: "week";
+    readonly label: "Week";
+}, {
+    readonly value: "month";
+    readonly label: "Month";
+}, {
+    readonly value: "quarter";
+    readonly label: "Quarter";
+}, {
+    readonly value: "year";
+    readonly label: "Year";
+}];
+export type TimeGranularity = typeof TIME_GRANULARITIES[number]['value'];

package/dist/client/components/QueryBuilder/utils.d.ts

@@ -0,0 +1,42 @@
+import { CubeQuery } from '../../types';
+import { MetaField, MetaResponse } from './types';
+/**
+ * Check if a field is selected in the current query
+ */
+export declare function isFieldSelected(fieldName: string, fieldType: 'measures' | 'dimensions' | 'timeDimensions', query: CubeQuery): boolean;
+/**
+ * Get all time dimension fields from schema
+ */
+export declare function getTimeDimensionFields(schema: MetaResponse): MetaField[];
+/**
+ * Get all non-time dimension fields from schema
+ */
+export declare function getRegularDimensionFields(schema: MetaResponse): MetaField[];
+/**
+ * Get all measure fields from schema
+ */
+export declare function getMeasureFields(schema: MetaResponse): MetaField[];
+/**
+ * Check if query has any content (measures, dimensions, or timeDimensions)
+ */
+export declare function hasQueryContent(query: CubeQuery): boolean;
+/**
+ * Get count of selected fields across all types
+ */
+export declare function getSelectedFieldsCount(query: CubeQuery): number;
+/**
+ * Get cube name from field name (e.g., "Employees.count" -> "Employees")
+ */
+export declare function getCubeNameFromField(fieldName: string): string;
+/**
+ * Group fields by cube name
+ */
+export declare function groupFieldsByCube(fields: MetaField[]): Record<string, MetaField[]>;
+/**
+ * Clean query object by removing empty arrays
+ */
+export declare function cleanQuery(query: CubeQuery): CubeQuery;
+/**
+ * Create an empty query object
+ */
+export declare function createEmptyQuery(): CubeQuery;

package/dist/client/index.d.ts

@@ -7,6 +7,7 @@ export { default as PortletEditModal } from './components/PortletEditModal';
 export { default as DashboardEditModal } from './components/DashboardEditModal';
 export { default as Modal } from './components/Modal';
 export { default as ChartConfigEditor } from './components/ChartConfigEditor';
+export { default as QueryBuilder } from './components/QueryBuilder';
 export { CubeProvider } from './providers/CubeProvider';
 export { useCubeQuery } from './hooks/useCubeQuery';
 export { createCubeClient } from './client/CubeClient';