drizzle-cube 0.1.8 → 0.1.10

package/dist/adapters/hono/index.js

@@ -1,6 +1,6 @@
 import { Hono as D } from "hono";
 var S = (q) => {
-  const d = {
+  const c = {
     ...{
       origin: "*",
       allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"],
@@ -8,22 +8,22 @@ var S = (q) => {
       exposeHeaders: []
     },
     ...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);
+  }, v = /* @__PURE__ */ ((u) => typeof u == "string" ? u === "*" ? () => u : (n) => u === n ? n : null : typeof u == "function" ? u : (n) => u.includes(n) ? n : null)(c.origin), j = ((u) => typeof u == "function" ? u : Array.isArray(u) ? () => u : () => [])(c.allowMethods);
   return async function(n, m) {
     var x;
     function p(h, f) {
       n.res.headers.set(h, f);
     }
-    const b = A(n.req.header("origin") || "", n);
-    if (b && p("Access-Control-Allow-Origin", b), d.origin !== "*") {
+    const b = v(n.req.header("origin") || "", n);
+    if (b && p("Access-Control-Allow-Origin", b), c.origin !== "*") {
       const h = n.req.header("Vary");
       h ? p("Vary", h) : p("Vary", "Origin");
     }
-    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());
+    if (c.credentials && p("Access-Control-Allow-Credentials", "true"), (x = c.exposeHeaders) != null && x.length && p("Access-Control-Expose-Headers", c.exposeHeaders.join(",")), n.req.method === "OPTIONS") {
+      c.maxAge != null && p("Access-Control-Max-Age", c.maxAge.toString());
       const h = j(n.req.header("origin") || "", n);
       h.length && p("Access-Control-Allow-Methods", h.join(","));
-      let f = d.allowHeaders;
+      let f = c.allowHeaders;
       if (!(f != null && f.length)) {
         const e = n.req.header("Access-Control-Request-Headers");
         e && (f = e.split(/\s*,\s*/));
@@ -40,13 +40,13 @@ var S = (q) => {
 function E(q) {
   const {
     semanticLayer: a,
-    drizzle: d,
-    schema: A,
+    drizzle: c,
+    schema: v,
     getSecurityContext: j,
     cors: u,
     basePath: n = "/cubejs-api/v1"
   } = q, m = new D();
-  u && m.use("/*", S(u)), a.hasExecutor() || a.setDrizzle(d, A), m.post(`${n}/load`, async (e) => {
+  u && m.use("/*", S(u)), a.hasExecutor() || a.setDrizzle(c, v), m.post(`${n}/load`, async (e) => {
     try {
       const r = await e.req.json(), s = r.query || r, t = await j(e), o = a.validateQuery(s);
       if (!o.isValid)
@@ -88,7 +88,15 @@ function E(q) {
         return e.json({
           error: "Query parameter is required"
         }, 400);
-      const s = JSON.parse(r), t = await j(e), o = a.validateQuery(s);
+      let s;
+      try {
+        s = JSON.parse(r);
+      } catch {
+        return e.json({
+          error: "Invalid JSON in query parameter"
+        }, 400);
+      }
+      const t = await j(e), o = a.validateQuery(s);
       if (!o.isValid)
         return e.json({
           error: `Query validation failed: ${o.errors.join(", ")}`
@@ -229,23 +237,23 @@ function E(q) {
     return "postgres";
   }
   async function f(e, r) {
-    var y, g, Q, v;
+    var y, g, Q, A;
     const s = a.validateQuery(e);
     if (!s.isValid)
       throw new Error(`Query validation failed: ${s.errors.join(", ")}`);
     const t = /* @__PURE__ */ new Set();
-    (y = e.measures) == null || y.forEach((c) => {
-      const w = c.split(".")[0];
+    (y = e.measures) == null || y.forEach((d) => {
+      const w = d.split(".")[0];
       t.add(w);
-    }), (g = e.dimensions) == null || g.forEach((c) => {
-      const w = c.split(".")[0];
+    }), (g = e.dimensions) == null || g.forEach((d) => {
+      const w = d.split(".")[0];
       t.add(w);
-    }), (Q = e.timeDimensions) == null || Q.forEach((c) => {
-      const w = c.dimension.split(".")[0];
+    }), (Q = e.timeDimensions) == null || Q.forEach((d) => {
+      const w = d.dimension.split(".")[0];
       t.add(w);
-    }), (v = e.filters) == null || v.forEach((c) => {
-      if ("member" in c) {
-        const w = c.member.split(".")[0];
+    }), (A = e.filters) == null || A.forEach((d) => {
+      if ("member" in d) {
+        const w = d.member.split(".")[0];
         t.add(w);
       }
     });
@@ -254,16 +262,16 @@ function E(q) {
     if (o)
       i = await a.generateMultiCubeSQL(e, r);
     else {
-      const c = Array.from(t)[0];
-      i = await a.generateSQL(c, e, r);
+      const d = Array.from(t)[0];
+      i = await a.generateSQL(d, e, r);
     }
-    const l = Array.from(t).map((c) => {
+    const l = Array.from(t).map((d) => {
       var w, T;
       return {
-        cube: c,
+        cube: d,
         query: {
-          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 + "."))) || [],
+          measures: ((w = e.measures) == null ? void 0 : w.filter((C) => C.startsWith(d + "."))) || [],
+          dimensions: ((T = e.dimensions) == null ? void 0 : T.filter((C) => C.startsWith(d + "."))) || [],
           filters: e.filters || [],
           timeDimensions: e.timeDimensions || [],
           order: e.order || {},
@@ -321,15 +329,15 @@ function E(q) {
   }), m;
 }
 function M(q, a) {
-  const d = E(a);
-  return q.route("/", d), q;
+  const c = E(a);
+  return q.route("/", c), q;
 }
-function R(q) {
+function N(q) {
   const a = new D();
   return M(a, q);
 }
 export {
-  R as createCubeApp,
+  N as createCubeApp,
   E as createCubeRoutes,
   M as mountCubeRoutes
 };

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

@@ -3,7 +3,7 @@ export interface ModalProps {
     isOpen: boolean;
     onClose: () => void;
     title?: string;
-    size?: 'sm' | 'md' | 'lg' | 'xl' | 'full' | 'fullscreen';
+    size?: 'sm' | 'md' | 'lg' | 'xl' | 'full' | 'fullscreen' | 'fullscreen-mobile';
     closeOnBackdropClick?: boolean;
     closeOnEscape?: boolean;
     showCloseButton?: boolean;

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

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

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { CubeQuery } from '../../types';
+import { CubeQuery, FilterOperator, Filter, SimpleFilter, GroupFilter } from '../../types';
 export interface MetaField {
     name: string;
     title: string;
@@ -89,6 +89,7 @@ export interface CubeMetaExplorerProps {
 }
 export interface QueryPanelProps {
     query: CubeQuery;
+    schema: MetaResponse | null;
     validationStatus: ValidationStatus;
     validationError: string | null;
     validationSql: {
@@ -99,6 +100,7 @@ export interface QueryPanelProps {
     onExecute: () => void;
     onRemoveField: (fieldName: string, fieldType: 'measures' | 'dimensions' | 'timeDimensions') => void;
     onTimeDimensionGranularityChange: (dimensionName: string, granularity: string) => void;
+    onFiltersChange: (filters: Filter[]) => void;
     onClearQuery?: () => void;
     showSettings?: boolean;
     onSettingsClick?: () => void;
@@ -130,3 +132,43 @@ export declare const TIME_GRANULARITIES: readonly [{
     readonly label: "Year";
 }];
 export type TimeGranularity = typeof TIME_GRANULARITIES[number]['value'];
+export interface FilterOperatorMeta {
+    label: string;
+    description: string;
+    requiresValues: boolean;
+    supportsMultipleValues: boolean;
+    valueType: 'string' | 'number' | 'date' | 'boolean' | 'any';
+    fieldTypes: string[];
+}
+export declare const FILTER_OPERATORS: Record<FilterOperator, FilterOperatorMeta>;
+export interface FilterBuilderProps {
+    filters: Filter[];
+    schema: MetaResponse | null;
+    query: CubeQuery;
+    onFiltersChange: (filters: Filter[]) => void;
+}
+export interface FilterItemProps {
+    filter: SimpleFilter;
+    index: number;
+    onFilterChange: (index: number, filter: SimpleFilter) => void;
+    onFilterRemove: (index: number) => void;
+    schema: MetaResponse | null;
+    query: CubeQuery;
+}
+export interface FilterGroupProps {
+    group: GroupFilter;
+    index: number;
+    onGroupChange: (index: number, group: GroupFilter) => void;
+    onGroupChangeWithUnwrap?: (index: number, group: GroupFilter) => void;
+    onGroupRemove: (index: number) => void;
+    schema: MetaResponse | null;
+    query: CubeQuery;
+    depth: number;
+}
+export interface FilterValueSelectorProps {
+    fieldName: string;
+    operator: FilterOperator;
+    values: any[];
+    onValuesChange: (values: any[]) => void;
+    schema: MetaResponse | null;
+}

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

@@ -1,4 +1,4 @@
-import { CubeQuery } from '../../types';
+import { CubeQuery, Filter, SimpleFilter, GroupFilter } from '../../types';
 import { MetaField, MetaResponse } from './types';
 /**
  * Check if a field is selected in the current query
@@ -36,7 +36,82 @@ export declare function groupFieldsByCube(fields: MetaField[]): Record<string, M
  * Clean query object by removing empty arrays
  */
 export declare function cleanQuery(query: CubeQuery): CubeQuery;
+/**
+ * Clean a query and transform filters for server compatibility
+ * This version transforms GroupFilter to legacy and/or format
+ */
+export declare function cleanQueryForServer(query: CubeQuery): CubeQuery;
 /**
  * Create an empty query object
  */
 export declare function createEmptyQuery(): CubeQuery;
+/**
+ * Filter utility functions
+ */
+/**
+ * Check if a filter is a simple filter
+ */
+export declare function isSimpleFilter(filter: Filter): filter is SimpleFilter;
+/**
+ * Check if a filter is a group filter
+ */
+export declare function isGroupFilter(filter: Filter): filter is GroupFilter;
+/**
+ * Check if a filter is an AND filter
+ */
+export declare function isAndFilter(filter: Filter): filter is GroupFilter;
+/**
+ * Check if a filter is an OR filter
+ */
+export declare function isOrFilter(filter: Filter): filter is GroupFilter;
+/**
+ * Flatten all simple filters from a hierarchical filter structure
+ */
+export declare function flattenFilters(filters: Filter[]): SimpleFilter[];
+/**
+ * Get all filterable fields from schema (measures, dimensions, and time dimensions)
+ */
+export declare function getFilterableFields(schema: MetaResponse, query?: CubeQuery): MetaField[];
+/**
+ * Get available operators for a field type
+ */
+export declare function getAvailableOperators(fieldType: string): Array<{
+    operator: string;
+    label: string;
+}>;
+/**
+ * Get field type from schema
+ */
+export declare function getFieldType(fieldName: string, schema: MetaResponse): string;
+/**
+ * Validate a filter
+ */
+export declare function validateFilter(filter: SimpleFilter, schema: MetaResponse): {
+    isValid: boolean;
+    errors: string[];
+};
+/**
+ * Count total filters in hierarchical structure
+ */
+export declare function countFilters(filters: Filter[]): number;
+/**
+ * Create a new simple filter
+ */
+export declare function createSimpleFilter(member: string, operator?: string, values?: any[]): SimpleFilter;
+/**
+ * Create a new AND filter group
+ */
+export declare function createAndFilter(filters?: Filter[]): GroupFilter;
+/**
+ * Create a new OR filter group
+ */
+export declare function createOrFilter(filters?: Filter[]): GroupFilter;
+/**
+ * Clean up filters by removing any that reference fields not in the current query
+ */
+export declare function cleanupFilters(filters: Filter[], query: CubeQuery): Filter[];
+/**
+ * Transform filters from new GroupFilter format to legacy server format
+ * Server expects { and: [...] } and { or: [...] } instead of { type: 'and', filters: [...] }
+ */
+export declare function transformFiltersForServer(filters: Filter[]): any[];

package/dist/client/hooks/useCubeQuery.d.ts

@@ -3,6 +3,7 @@ interface UseCubeQueryResult {
     resultSet: CubeResultSet | null;
     isLoading: boolean;
     error: Error | null;
+    queryId: string | null;
 }
 export declare function useCubeQuery(query: CubeQuery | null, options?: CubeQueryOptions): UseCubeQueryResult;
 export {};

package/dist/client/hooks/useDebounce.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Custom hook for debouncing values
+ * Delays updating the value until after the specified delay has passed
+ * since the last change
+ */
+/**
+ * Debounces a value by the specified delay
+ * @param value The value to debounce
+ * @param delay The delay in milliseconds
+ * @returns The debounced value
+ */
+export declare function useDebounce<T>(value: T, delay: number): T;

package/dist/client/hooks/useFilterValues.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Hook for fetching distinct field values for filter dropdowns
+ * Uses the /load API to get actual data values
+ */
+interface UseFilterValuesResult {
+    values: any[];
+    loading: boolean;
+    error: string | null;
+    refetch: () => void;
+    searchValues: (searchTerm: string, force?: boolean) => void;
+}
+/**
+ * Custom hook to fetch distinct values for a field
+ */
+export declare function useFilterValues(fieldName: string | null, enabled?: boolean): UseFilterValuesResult;
+export {};