drizzle-cube 0.1.8 → 0.1.9

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 {};