drizzle-cube 0.2.5 → 0.2.8

package/dist/client/providers/CubeProvider.d.ts

@@ -1,6 +1,6 @@
 import { default as React } from 'react';
 import { CubeClient } from '../client/CubeClient';
-import { CubeQueryOptions, CubeApiOptions, FeaturesConfig } from '../types';
+import { CubeQueryOptions, CubeApiOptions, FeaturesConfig, DashboardLayoutMode } from '../types';
 import { CubeMeta, FieldLabelMap } from '../hooks/useCubeMeta';
 import { BatchCoordinator } from '../client/BatchCoordinator';
 interface CubeContextValue {
@@ -16,6 +16,7 @@ interface CubeContextValue {
     features: FeaturesConfig;
     batchCoordinator: BatchCoordinator | null;
     enableBatching: boolean;
+    dashboardModes: DashboardLayoutMode[];
 }
 interface CubeProviderProps {
     cubeApi?: CubeClient;
@@ -23,12 +24,13 @@ interface CubeProviderProps {
     token?: string;
     options?: CubeQueryOptions;
     features?: FeaturesConfig;
+    dashboardModes?: DashboardLayoutMode[];
     enableBatching?: boolean;
     batchDelayMs?: number;
     children: React.ReactNode;
 }
 export declare function CubeProvider({ cubeApi: initialCubeApi, apiOptions: initialApiOptions, token: initialToken, options, features, // Default to AI enabled, schema diagram disabled
-enableBatching, // Default to batching enabled
+dashboardModes, enableBatching, // Default to batching enabled
 batchDelayMs, // Default 100ms batch window
 children }: CubeProviderProps): import("react/jsx-runtime").JSX.Element;
 export declare function useCubeContext(): CubeContextValue;

package/dist/client/providers.js

@@ -1,4 +1,4 @@
-import { n as a, r as c, u as i } from "./chunks/chart-activitygridchart-BzL97Vnm.js";
+import { n as a, r as c, u as i } from "./chunks/chart-activitygridchart-Cz4bEf3V.js";
 import { createContext as o, useContext as r } from "react";
 const e = o(null), n = e.Provider, C = () => r(e);
 export {

package/dist/client/shared/chartDefaults.d.ts

@@ -0,0 +1,64 @@
+import { ChartType, ChartAxisConfig } from '../types';
+import { MetricItem, BreakdownItem } from '../components/AnalysisBuilder/types';
+/**
+ * Result of smart chart defaults calculation
+ */
+export interface SmartChartDefaults {
+    /** The recommended chart type */
+    chartType: ChartType;
+    /** The auto-configured chart axis settings */
+    chartConfig: ChartAxisConfig;
+}
+/**
+ * Availability status for a chart type
+ */
+export interface ChartAvailability {
+    /** Whether the chart type can be used with current selections */
+    available: boolean;
+    /** Reason why the chart is unavailable (for tooltip) */
+    reason?: string;
+}
+/**
+ * Map of chart type availability statuses
+ */
+export type ChartAvailabilityMap = Record<ChartType, ChartAvailability>;
+/**
+ * Check if a specific chart type is available given current selections
+ */
+export declare function getChartAvailability(chartType: ChartType, metrics: MetricItem[], breakdowns: BreakdownItem[]): ChartAvailability;
+/**
+ * Get availability for all chart types
+ */
+export declare function getAllChartAvailability(metrics: MetricItem[], breakdowns: BreakdownItem[]): ChartAvailabilityMap;
+/**
+ * Select the best chart type based on current metrics and breakdowns
+ *
+ * Priority order:
+ * 1. If current chart type is still valid, keep it (preserve user intent)
+ * 2. If current chart becomes invalid, switch to best alternative:
+ *    - Has time dimension → line
+ *    - Has dimension + measure → bar
+ *    - Has measures only → bar (or kpiNumber if single measure + no breakdowns)
+ *    - No fields → keep current
+ */
+export declare function selectBestChartType(metrics: MetricItem[], breakdowns: BreakdownItem[], currentChartType: ChartType): ChartType;
+/**
+ * Get smart default chart configuration based on chart type and selections
+ */
+export declare function getSmartChartDefaults(metrics: MetricItem[], breakdowns: BreakdownItem[], currentChartType: ChartType): SmartChartDefaults;
+/**
+ * Determine if chart type should be auto-switched based on selections change
+ *
+ * Returns the new chart type if a switch is recommended, or null if no change needed.
+ *
+ * @param metrics - Current metrics selection
+ * @param breakdowns - Current breakdowns selection
+ * @param currentChartType - Current chart type
+ * @param userManuallySelected - Whether user manually selected the current chart type
+ */
+export declare function shouldAutoSwitchChartType(metrics: MetricItem[], breakdowns: BreakdownItem[], currentChartType: ChartType, userManuallySelected: boolean): ChartType | null;
+/**
+ * Merge existing chart config with smart defaults
+ * Only fills in missing or invalid fields, preserves valid existing config
+ */
+export declare function mergeChartConfigWithDefaults(existingConfig: ChartAxisConfig, smartDefaults: ChartAxisConfig, metrics: MetricItem[], breakdowns: BreakdownItem[]): ChartAxisConfig;

package/dist/client/shared/components/QueryAnalysisPanel.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+import { QueryAnalysis } from '../types';
+interface QueryAnalysisPanelProps {
+    analysis: QueryAnalysis;
+}
+declare const QueryAnalysisPanel: React.FC<QueryAnalysisPanelProps>;
+export default QueryAnalysisPanel;

package/dist/client/shared/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared module exports
+ * Common types, utilities, and components used across QueryBuilder and AnalysisBuilder
+ */
+export type { MetaField, MetaCube, MetaResponse, QueryAnalysis, PrimaryCubeSelectionReason, PrimaryCubeCandidate, PrimaryCubeAnalysis, JoinPathStep, JoinPathAnalysis, PreAggregationAnalysis, QuerySummary, ValidationResult, FilterOperatorMeta, DateRangeType, DateRangeOption, TimeGranularity } from './types';
+export { FILTER_OPERATORS, DATE_RANGE_OPTIONS, TIME_GRANULARITIES } from './types';
+export { isSimpleFilter, isGroupFilter, isAndFilter, isOrFilter, flattenFilters, countFilters, createSimpleFilter, createAndFilter, createOrFilter, transformFiltersForServer, transformFiltersFromServer, hasQueryContent, cleanQuery, cleanQueryForServer, transformQueryForUI, getCubeNameFromField, getFieldType, getFieldTitle, getAvailableOperators, getAllFilterableFields, convertDateRangeTypeToValue, requiresNumberInput, formatDateForCube } from './utils';
+export { default as QueryAnalysisPanel } from './components/QueryAnalysisPanel';
+export { getChartAvailability, getAllChartAvailability, selectBestChartType, getSmartChartDefaults, shouldAutoSwitchChartType, mergeChartConfigWithDefaults } from './chartDefaults';
+export type { SmartChartDefaults, ChartAvailability, ChartAvailabilityMap } from './chartDefaults';

package/dist/client/shared/types.d.ts

@@ -0,0 +1,134 @@
+import { CubeQuery, FilterOperator } 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 PrimaryCubeSelectionReason = 'most_dimensions' | 'most_connected' | 'alphabetical_fallback' | 'single_cube';
+export interface PrimaryCubeCandidate {
+    cubeName: string;
+    dimensionCount: number;
+    joinCount: number;
+    canReachAll: boolean;
+}
+export interface PrimaryCubeAnalysis {
+    selectedCube: string;
+    reason: PrimaryCubeSelectionReason;
+    explanation: string;
+    candidates?: PrimaryCubeCandidate[];
+}
+export interface JoinPathStep {
+    fromCube: string;
+    toCube: string;
+    relationship: 'belongsTo' | 'hasOne' | 'hasMany' | 'belongsToMany';
+    joinType: 'inner' | 'left' | 'right' | 'full';
+    joinColumns: Array<{
+        sourceColumn: string;
+        targetColumn: string;
+    }>;
+    junctionTable?: {
+        tableName: string;
+        sourceColumns: string[];
+        targetColumns: string[];
+    };
+}
+export interface JoinPathAnalysis {
+    targetCube: string;
+    pathFound: boolean;
+    path?: JoinPathStep[];
+    pathLength?: number;
+    error?: string;
+    visitedCubes?: string[];
+}
+export interface PreAggregationAnalysis {
+    cubeName: string;
+    cteAlias: string;
+    reason: string;
+    measures: string[];
+    joinKeys: Array<{
+        sourceColumn: string;
+        targetColumn: string;
+    }>;
+}
+export interface QuerySummary {
+    queryType: 'single_cube' | 'multi_cube_join' | 'multi_cube_cte';
+    joinCount: number;
+    cteCount: number;
+    hasPreAggregation: boolean;
+}
+export interface QueryAnalysis {
+    timestamp: string;
+    cubeCount: number;
+    cubesInvolved: string[];
+    primaryCube: PrimaryCubeAnalysis;
+    joinPaths: JoinPathAnalysis[];
+    preAggregations: PreAggregationAnalysis[];
+    querySummary: QuerySummary;
+    warnings?: string[];
+}
+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;
+    analysis?: QueryAnalysis;
+}
+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 type DateRangeType = 'custom' | 'today' | 'yesterday' | 'this_week' | 'this_month' | 'this_quarter' | 'this_year' | 'last_7_days' | 'last_30_days' | 'last_week' | 'last_month' | 'last_quarter' | 'last_year' | 'last_12_months' | 'last_n_days' | 'last_n_weeks' | 'last_n_months' | 'last_n_quarters' | 'last_n_years';
+export interface DateRangeOption {
+    value: DateRangeType;
+    label: string;
+}
+export declare const DATE_RANGE_OPTIONS: DateRangeOption[];
+export declare const TIME_GRANULARITIES: readonly [{
+    readonly value: "hour";
+    readonly label: "Hour";
+}, {
+    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/shared/utils.d.ts

@@ -0,0 +1,101 @@
+import { CubeQuery, Filter, SimpleFilter, GroupFilter } from '../types';
+import { MetaField, MetaResponse } from './types';
+/**
+ * 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[];
+/**
+ * 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;
+/**
+ * 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[];
+/**
+ * Transform filters from server/API format to UI format
+ * Converts {and: [...]} and {or: [...]} to {type: 'and', filters: [...]} format
+ */
+export declare function transformFiltersFromServer(filters: any[]): Filter[];
+/**
+ * Check if query has any content (measures, dimensions, or timeDimensions)
+ */
+export declare function hasQueryContent(query: CubeQuery): boolean;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * Get cube name from field name (e.g., "Employees.count" -> "Employees")
+ */
+export declare function getCubeNameFromField(fieldName: string): string;
+/**
+ * Get field type from schema
+ */
+export declare function getFieldType(fieldName: string, schema: MetaResponse): string;
+/**
+ * Get field title from schema metadata, falling back to field name
+ */
+export declare function getFieldTitle(fieldName: string, schema: MetaResponse | null): string;
+/**
+ * Get available operators for a field type
+ */
+export declare function getAvailableOperators(fieldType: string): Array<{
+    operator: string;
+    label: string;
+}>;
+/**
+ * Get ALL filterable fields from schema
+ */
+export declare function getAllFilterableFields(schema: MetaResponse): MetaField[];
+/**
+ * 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;