drizzle-cube/dist/client/components/QueryBuilder/utils.d.ts

Drizzle ORM-first semantic layer with Cube.js compatibility. Type-safe analytics and dashboards with SQL injection protection.

import { CubeQuery, Filter, SimpleFilter, GroupFilter } 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;
/**
 * 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)
 * Returns ALL fields if no query provided, or only query fields if query provided
 */
export declare function getFilterableFields(schema: MetaResponse, query?: CubeQuery): MetaField[];
/**
 * Get ALL filterable fields from schema, regardless of query selection
 */
export declare function getAllFilterableFields(schema: MetaResponse): MetaField[];
/**
 * Get organized filter field options with query fields prioritized at top
 */
export declare function getOrganizedFilterFields(schema: MetaResponse, query?: CubeQuery): {
    queryFields: MetaField[];
    allFields: 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
 * @deprecated This function is no longer used as we now support filtering on any schema field
 */
export declare function cleanupFilters(filters: Filter[], _query?: CubeQuery): Filter[];
/**
 * Clean up filters by removing any that reference fields not in the current query (legacy)
 * Only used for backward compatibility - filters on non-query fields are now supported
 */
export declare function cleanupFiltersLegacy(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[];
/**
 * Date range utility functions
 */
/**
 * Convert DateRangeType to Cube.js compatible date range format
 */
export declare function convertDateRangeTypeToValue(rangeType: string, number?: number): string;
/**
 * Check if a date range type requires a number input
 */
export declare function requiresNumberInput(rangeType: string): boolean;
/**
 * Format date for Cube.js (YYYY-MM-DD)
 */
export declare function formatDateForCube(date: Date): string;
/**
 * Get the time dimensions that have date ranges applied
 */
export declare function getTimeDimensionsWithDateRanges(query: CubeQuery): Record<string, string | string[]>;
/**
 * Check if a query has any time dimensions
 */
export declare function hasTimeDimensions(query: CubeQuery): boolean;
/**
 * Transform a Cube.js query from external format to UI internal format
 * This handles format differences between server/API queries and QueryBuilder state
 */
export declare function transformQueryForUI(query: any): CubeQuery;
/**
 * Sorting utility functions
 */
/**
 * Get field title from schema metadata, falling back to field name
 */
export declare function getFieldTitle(fieldName: string, schema: MetaResponse | null): string;
/**
 * Clean up order object by removing fields that are no longer in the query
 */
export declare function cleanupOrder(order: Record<string, 'asc' | 'desc'> | undefined, query: CubeQuery): Record<string, 'asc' | 'desc'> | undefined;
/**
 * Get sort direction for a field from the order object
 */
export declare function getSortDirection(fieldName: string, order: Record<string, 'asc' | 'desc'> | undefined): 'asc' | 'desc' | null;
/**
 * Get tooltip text for sort button based on current direction
 */
export declare function getSortTooltip(direction: 'asc' | 'desc' | null): string;
/**
 * Get next sort direction in the cycle: null -> asc -> desc -> null
 */
export declare function getNextSortDirection(current: 'asc' | 'desc' | null): 'asc' | 'desc' | null;