drizzle-cube 0.2.26 → 0.2.27

package/dist/client/stores/analysisBuilderStore.d.ts

@@ -0,0 +1,271 @@
+import { ReactNode } from 'react';
+import { StoreApi } from 'zustand';
+import { Filter, ChartType, ChartAxisConfig, ChartDisplayConfig, CubeQuery, QueryMergeStrategy, MultiQueryConfig } from '../types';
+import { AnalysisBuilderState, MetricItem, BreakdownItem, QueryPanelTab, AIState } from '../components/AnalysisBuilder/types';
+/**
+ * Field modal mode for field search
+ */
+export type FieldModalMode = 'metrics' | 'breakdown';
+/**
+ * Complete store state interface
+ */
+export interface AnalysisBuilderStoreState {
+    /** Array of query states (one per tab) */
+    queryStates: AnalysisBuilderState[];
+    /** Index of the currently active query tab */
+    activeQueryIndex: number;
+    /** Strategy for merging multi-query results */
+    mergeStrategy: QueryMergeStrategy;
+    /** Current chart type */
+    chartType: ChartType;
+    /** Chart axis configuration */
+    chartConfig: ChartAxisConfig;
+    /** Chart display configuration */
+    displayConfig: ChartDisplayConfig;
+    /** Whether user manually selected chart type (disables auto-switch) */
+    userManuallySelectedChart: boolean;
+    /** Current color palette name */
+    localPaletteName: string;
+    /** Active tab in query panel */
+    activeTab: QueryPanelTab;
+    /** Active view (table or chart) */
+    activeView: 'table' | 'chart';
+    /** Display limit for table */
+    displayLimit: number;
+    /** Whether field search modal is open */
+    showFieldModal: boolean;
+    /** Current mode for field search modal */
+    fieldModalMode: FieldModalMode;
+    /** AI panel state */
+    aiState: AIState;
+}
+/**
+ * Store actions interface
+ */
+export interface AnalysisBuilderStoreActions {
+    /** Set all query states */
+    setQueryStates: (states: AnalysisBuilderState[]) => void;
+    /** Update a specific query state by index */
+    updateQueryState: (index: number, updater: (state: AnalysisBuilderState) => AnalysisBuilderState) => void;
+    /** Set active query index */
+    setActiveQueryIndex: (index: number) => void;
+    /** Set merge strategy */
+    setMergeStrategy: (strategy: QueryMergeStrategy) => void;
+    /** Open field modal in metrics mode */
+    openMetricsModal: () => void;
+    /** Add a metric to current query */
+    addMetric: (field: string, label?: string) => void;
+    /** Remove a metric from current query */
+    removeMetric: (id: string) => void;
+    /** Toggle a metric (add if not present, remove if present) */
+    toggleMetric: (fieldName: string) => void;
+    /** Reorder metrics */
+    reorderMetrics: (fromIndex: number, toIndex: number) => void;
+    /** Open field modal in breakdown mode */
+    openBreakdownsModal: () => void;
+    /** Add a breakdown to current query */
+    addBreakdown: (field: string, isTimeDimension: boolean, granularity?: string) => void;
+    /** Remove a breakdown from current query */
+    removeBreakdown: (id: string) => void;
+    /** Toggle a breakdown (add if not present, remove if present) */
+    toggleBreakdown: (fieldName: string, isTimeDimension: boolean, granularity?: string) => void;
+    /** Change granularity for a time dimension breakdown */
+    setBreakdownGranularity: (id: string, granularity: string) => void;
+    /** Toggle comparison mode for a time dimension breakdown */
+    toggleBreakdownComparison: (id: string) => void;
+    /** Reorder breakdowns */
+    reorderBreakdowns: (fromIndex: number, toIndex: number) => void;
+    /** Set filters for current query */
+    setFilters: (filters: Filter[]) => void;
+    /** Drop a field to create a filter */
+    dropFieldToFilter: (field: string) => void;
+    /** Set sort order for a field */
+    setOrder: (fieldName: string, direction: 'asc' | 'desc' | null) => void;
+    /** Add a new query tab */
+    addQuery: () => void;
+    /** Remove a query tab */
+    removeQuery: (index: number) => void;
+    /** Set chart type */
+    setChartType: (type: ChartType) => void;
+    /** Set chart type with manual selection flag */
+    setChartTypeManual: (type: ChartType) => void;
+    /** Set chart config */
+    setChartConfig: (config: ChartAxisConfig) => void;
+    /** Set display config */
+    setDisplayConfig: (config: ChartDisplayConfig) => void;
+    /** Set color palette name */
+    setLocalPaletteName: (name: string) => void;
+    /** Set user manually selected chart flag */
+    setUserManuallySelectedChart: (value: boolean) => void;
+    /** Set active tab */
+    setActiveTab: (tab: QueryPanelTab) => void;
+    /** Set active view */
+    setActiveView: (view: 'table' | 'chart') => void;
+    /** Set display limit */
+    setDisplayLimit: (limit: number) => void;
+    /** Close field modal */
+    closeFieldModal: () => void;
+    /** Open AI panel */
+    openAI: () => void;
+    /** Close AI panel */
+    closeAI: () => void;
+    /** Set AI prompt */
+    setAIPrompt: (prompt: string) => void;
+    /** Set AI generating state */
+    setAIGenerating: (generating: boolean) => void;
+    /** Set AI error */
+    setAIError: (error: string | null) => void;
+    /** Set AI has generated query */
+    setAIHasGeneratedQuery: (hasQuery: boolean) => void;
+    /** Save previous state for AI undo */
+    saveAIPreviousState: () => void;
+    /** Restore previous state (AI cancel/undo) */
+    restoreAIPreviousState: () => void;
+    /** Clear the current query */
+    clearQuery: () => void;
+    /** Load state from URL share */
+    loadFromShare: (sharedState: SharedState) => void;
+    /** Get current state (helper accessor) */
+    getCurrentState: () => AnalysisBuilderState;
+    /** Get merge keys (computed from Q1 breakdowns) */
+    getMergeKeys: () => string[] | undefined;
+    /** Check if in multi-query mode */
+    isMultiQueryMode: () => boolean;
+    /** Build current CubeQuery */
+    buildCurrentQuery: () => CubeQuery;
+    /** Build all queries */
+    buildAllQueries: () => CubeQuery[];
+    /** Build MultiQueryConfig */
+    buildMultiQueryConfig: () => MultiQueryConfig | null;
+    /** Reset store to initial state */
+    reset: () => void;
+}
+/**
+ * Shared state from URL
+ */
+export interface SharedState {
+    query: CubeQuery | MultiQueryConfig;
+    chartType?: ChartType;
+    chartConfig?: ChartAxisConfig;
+    displayConfig?: ChartDisplayConfig;
+    activeView?: 'table' | 'chart';
+}
+/**
+ * Combined store type
+ */
+export type AnalysisBuilderStore = AnalysisBuilderStoreState & AnalysisBuilderStoreActions;
+/**
+ * Options for creating a store instance
+ */
+export interface CreateStoreOptions {
+    /** Initial query configuration */
+    initialQuery?: CubeQuery | MultiQueryConfig;
+    /** Initial chart configuration */
+    initialChartConfig?: {
+        chartType?: ChartType;
+        chartConfig?: ChartAxisConfig;
+        displayConfig?: ChartDisplayConfig;
+    };
+    /** Disable localStorage persistence */
+    disableLocalStorage?: boolean;
+}
+/**
+ * Create a new store instance with optional persistence
+ */
+export declare function createAnalysisBuilderStore(options?: CreateStoreOptions): Omit<Omit<StoreApi<AnalysisBuilderStore>, "setState" | "devtools"> & {
+    setState(partial: AnalysisBuilderStore | Partial<AnalysisBuilderStore> | ((state: AnalysisBuilderStore) => AnalysisBuilderStore | Partial<AnalysisBuilderStore>), replace?: false | undefined, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    setState(state: AnalysisBuilderStore | ((state: AnalysisBuilderStore) => AnalysisBuilderStore), replace: true, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    devtools: {
+        cleanup: () => void;
+    };
+}, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: AnalysisBuilderStore, previousSelectedState: AnalysisBuilderStore) => void): () => void;
+        <U>(selector: (state: AnalysisBuilderStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+};
+/**
+ * Provider props
+ */
+export interface AnalysisBuilderStoreProviderProps {
+    children: ReactNode;
+    /** Initial query configuration */
+    initialQuery?: CubeQuery | MultiQueryConfig;
+    /** Initial chart configuration */
+    initialChartConfig?: {
+        chartType?: ChartType;
+        chartConfig?: ChartAxisConfig;
+        displayConfig?: ChartDisplayConfig;
+    };
+    /** Disable localStorage persistence */
+    disableLocalStorage?: boolean;
+}
+/**
+ * Provider component that creates a store instance per AnalysisBuilder
+ */
+export declare function AnalysisBuilderStoreProvider({ children, initialQuery, initialChartConfig, disableLocalStorage, }: AnalysisBuilderStoreProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to access the store from context
+ * @throws Error if used outside of provider
+ */
+export declare function useAnalysisBuilderStore<T>(selector: (state: AnalysisBuilderStore) => T): T;
+/**
+ * Hook to get the raw store API (for actions that need direct access)
+ */
+export declare function useAnalysisBuilderStoreApi(): StoreApi<AnalysisBuilderStore>;
+/**
+ * Select current query state
+ */
+export declare const selectCurrentState: (state: AnalysisBuilderStore) => AnalysisBuilderState;
+/**
+ * Select current metrics
+ */
+export declare const selectMetrics: (state: AnalysisBuilderStore) => MetricItem[];
+/**
+ * Select current breakdowns
+ */
+export declare const selectBreakdowns: (state: AnalysisBuilderStore) => BreakdownItem[];
+/**
+ * Select current filters
+ */
+export declare const selectFilters: (state: AnalysisBuilderStore) => Filter[];
+/**
+ * Select chart configuration
+ */
+export declare const selectChartConfig: (state: AnalysisBuilderStore) => {
+    chartType: ChartType;
+    chartConfig: ChartAxisConfig;
+    displayConfig: ChartDisplayConfig;
+};
+/**
+ * Select UI state
+ */
+export declare const selectUIState: (state: AnalysisBuilderStore) => {
+    activeTab: QueryPanelTab;
+    activeView: "table" | "chart";
+    displayLimit: number;
+    showFieldModal: boolean;
+    fieldModalMode: FieldModalMode;
+};
+/**
+ * Select multi-query state
+ */
+export declare const selectMultiQueryState: (state: AnalysisBuilderStore) => {
+    queryStates: AnalysisBuilderState[];
+    activeQueryIndex: number;
+    mergeStrategy: QueryMergeStrategy;
+    isMultiQueryMode: boolean;
+};

package/dist/client/stores/dashboardStore.d.ts

@@ -0,0 +1,267 @@
+import { ReactNode } from 'react';
+import { StoreApi } from 'zustand';
+import { LayoutItem } from 'react-grid-layout';
+import { PortletConfig, RowLayout, ChartType, ChartAxisConfig, ChartDisplayConfig, CubeQuery } from '../types';
+/**
+ * Debug data entry for a portlet (used by chart inspector)
+ */
+export interface PortletDebugDataEntry {
+    chartConfig: ChartAxisConfig;
+    displayConfig: ChartDisplayConfig;
+    queryObject: CubeQuery | null;
+    data: unknown[];
+    chartType: ChartType;
+    cacheInfo?: {
+        hit: boolean;
+        cachedAt: string;
+        ttlMs: number;
+        ttlRemainingMs: number;
+    };
+}
+/**
+ * @deprecated Use PortletDebugDataEntry instead. Kept for backward compatibility.
+ */
+export type DebugDataEntry = PortletDebugDataEntry;
+/**
+ * Drag state for row-based layout
+ */
+export interface DragState {
+    rowIndex: number;
+    colIndex: number;
+    portletId: string;
+}
+/**
+ * Complete store state interface
+ */
+export interface DashboardStoreState {
+    /** Whether dashboard is in edit mode */
+    isEditMode: boolean;
+    /** Currently selected filter ID for filter-assignment mode */
+    selectedFilterId: string | null;
+    /** Whether portlet edit modal is open */
+    isPortletModalOpen: boolean;
+    /** Portlet being edited (null = adding new) */
+    editingPortlet: PortletConfig | null;
+    /** Whether filter config modal is open */
+    isFilterConfigModalOpen: boolean;
+    /** Portlet for filter configuration */
+    filterConfigPortlet: PortletConfig | null;
+    /** Portlet ID pending delete confirmation (null = no confirmation active) */
+    deleteConfirmPortletId: string | null;
+    /** Draft row layout during drag operations (rows mode) */
+    draftRows: RowLayout[] | null;
+    /** Whether a portlet is currently being dragged */
+    isDraggingPortlet: boolean;
+    /** Last known layout for change detection */
+    lastKnownLayout: LayoutItem[];
+    /** Whether component has been initialized (prevents saves during load) */
+    isInitialized: boolean;
+    /** Current drag state for row-based layout */
+    dragState: DragState | null;
+    /** Debug data keyed by portlet ID (for chart inspector) */
+    debugData: Record<string, DebugDataEntry>;
+}
+/**
+ * Store actions interface
+ */
+export interface DashboardStoreActions {
+    /** Set edit mode */
+    setEditMode: (isEdit: boolean) => void;
+    /** Toggle edit mode */
+    toggleEditMode: () => void;
+    /** Set selected filter ID for filter selection mode */
+    setSelectedFilterId: (filterId: string | null) => void;
+    /** Exit filter selection mode */
+    exitFilterSelectionMode: () => void;
+    /** Open portlet modal (optionally with a portlet to edit) */
+    openPortletModal: (portlet?: PortletConfig | null) => void;
+    /** Close portlet modal */
+    closePortletModal: () => void;
+    /** Open filter config modal for a portlet */
+    openFilterConfigModal: (portlet: PortletConfig) => void;
+    /** Close filter config modal */
+    closeFilterConfigModal: () => void;
+    /** Open delete confirmation for a portlet */
+    openDeleteConfirm: (portletId: string) => void;
+    /** Close delete confirmation */
+    closeDeleteConfirm: () => void;
+    /** Set draft rows during drag operations */
+    setDraftRows: (rows: RowLayout[] | null) => void;
+    /** Set whether a portlet is being dragged */
+    setIsDraggingPortlet: (isDragging: boolean) => void;
+    /** Set last known layout for change detection */
+    setLastKnownLayout: (layout: LayoutItem[]) => void;
+    /** Set whether component is initialized */
+    setIsInitialized: (initialized: boolean) => void;
+    /** Set drag state */
+    setDragState: (state: DragState | null) => void;
+    /** Clear drag state */
+    clearDragState: () => void;
+    /** Set debug data for a portlet */
+    setDebugData: (portletId: string, data: DebugDataEntry) => void;
+    /** Clear debug data for a portlet (or all if no portletId) */
+    clearDebugData: (portletId?: string) => void;
+    /** Reset store to initial state */
+    reset: () => void;
+}
+/**
+ * Combined store type
+ */
+export type DashboardStore = DashboardStoreState & DashboardStoreActions;
+/**
+ * Options for creating a store instance
+ */
+export interface CreateDashboardStoreOptions {
+    /** Initial edit mode state */
+    initialEditMode?: boolean;
+}
+/**
+ * Create a new dashboard store instance
+ */
+export declare function createDashboardStore(options?: CreateDashboardStoreOptions): Omit<Omit<StoreApi<DashboardStore>, "setState" | "devtools"> & {
+    setState(partial: DashboardStore | Partial<DashboardStore> | ((state: DashboardStore) => DashboardStore | Partial<DashboardStore>), replace?: false | undefined, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    setState(state: DashboardStore | ((state: DashboardStore) => DashboardStore), replace: true, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    devtools: {
+        cleanup: () => void;
+    };
+}, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: DashboardStore, previousSelectedState: DashboardStore) => void): () => void;
+        <U>(selector: (state: DashboardStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+};
+/**
+ * Provider props
+ */
+export interface DashboardStoreProviderProps {
+    children: ReactNode;
+    /** Initial edit mode state */
+    initialEditMode?: boolean;
+}
+/**
+ * Provider component that creates a store instance per Dashboard
+ */
+export declare function DashboardStoreProvider({ children, initialEditMode, }: DashboardStoreProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to access the store from context
+ * @throws Error if used outside of provider
+ */
+export declare function useDashboardStore<T>(selector: (state: DashboardStore) => T): T;
+/**
+ * Hook to get the raw store API (for actions that need direct access)
+ */
+export declare function useDashboardStoreApi(): StoreApi<DashboardStore>;
+/**
+ * Optional hook that returns null if used outside provider (for optional store access)
+ * Uses a fallback store to ensure useStore is always called (React hooks rules compliance)
+ */
+export declare function useDashboardStoreOptional<T>(selector: (state: DashboardStore) => T): T | null;
+/**
+ * Select edit mode state
+ */
+export declare const selectEditModeState: (state: DashboardStore) => {
+    isEditMode: boolean;
+    selectedFilterId: string | null;
+};
+/**
+ * Select modal state
+ */
+export declare const selectModalState: (state: DashboardStore) => {
+    isPortletModalOpen: boolean;
+    editingPortlet: PortletConfig | null;
+    isFilterConfigModalOpen: boolean;
+    filterConfigPortlet: PortletConfig | null;
+};
+/**
+ * Select layout state
+ */
+export declare const selectLayoutState: (state: DashboardStore) => {
+    draftRows: RowLayout[] | null;
+    isDraggingPortlet: boolean;
+    lastKnownLayout: LayoutItem[];
+    isInitialized: boolean;
+    dragState: DragState | null;
+};
+/**
+ * Select debug data
+ */
+export declare const selectDebugData: (state: DashboardStore) => Record<string, PortletDebugDataEntry>;
+/**
+ * Select debug data for a specific portlet
+ */
+export declare const selectPortletDebugData: (portletId: string) => (state: DashboardStore) => PortletDebugDataEntry;
+/**
+ * Select all edit mode actions
+ */
+export declare const selectEditModeActions: (state: DashboardStore) => {
+    setEditMode: (isEdit: boolean) => void;
+    toggleEditMode: () => void;
+    setSelectedFilterId: (filterId: string | null) => void;
+    exitFilterSelectionMode: () => void;
+};
+/**
+ * Select all modal actions
+ */
+export declare const selectModalActions: (state: DashboardStore) => {
+    openPortletModal: (portlet?: PortletConfig | null) => void;
+    closePortletModal: () => void;
+    openFilterConfigModal: (portlet: PortletConfig) => void;
+    closeFilterConfigModal: () => void;
+    openDeleteConfirm: (portletId: string) => void;
+    closeDeleteConfirm: () => void;
+};
+/**
+ * Select all layout actions
+ */
+export declare const selectLayoutActions: (state: DashboardStore) => {
+    setDraftRows: (rows: RowLayout[] | null) => void;
+    setIsDraggingPortlet: (isDragging: boolean) => void;
+    setLastKnownLayout: (layout: LayoutItem[]) => void;
+    setIsInitialized: (initialized: boolean) => void;
+    setDragState: (state: DragState | null) => void;
+    clearDragState: () => void;
+};
+/**
+ * Select all debug data actions
+ */
+export declare const selectDebugDataActions: (state: DashboardStore) => {
+    setDebugData: (portletId: string, data: DebugDataEntry) => void;
+    clearDebugData: (portletId?: string) => void;
+};
+/**
+ * Select all actions
+ */
+export declare const selectAllActions: (state: DashboardStore) => {
+    setEditMode: (isEdit: boolean) => void;
+    toggleEditMode: () => void;
+    setSelectedFilterId: (filterId: string | null) => void;
+    exitFilterSelectionMode: () => void;
+    openPortletModal: (portlet?: PortletConfig | null) => void;
+    closePortletModal: () => void;
+    openFilterConfigModal: (portlet: PortletConfig) => void;
+    closeFilterConfigModal: () => void;
+    openDeleteConfirm: (portletId: string) => void;
+    closeDeleteConfirm: () => void;
+    setDraftRows: (rows: RowLayout[] | null) => void;
+    setIsDraggingPortlet: (isDragging: boolean) => void;
+    setLastKnownLayout: (layout: LayoutItem[]) => void;
+    setIsInitialized: (initialized: boolean) => void;
+    setDragState: (state: DragState | null) => void;
+    clearDragState: () => void;
+    setDebugData: (portletId: string, data: DebugDataEntry) => void;
+    clearDebugData: (portletId?: string) => void;
+    reset: () => void;
+};

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

@@ -0,0 +1,13 @@
+/**
+ * Zustand Stores - Barrel Export
+ *
+ * Centralized state management stores for the drizzle-cube client.
+ *
+ * ARCHITECTURE: Instance-based stores
+ * - Each AnalysisBuilder/Dashboard gets its own Zustand store instance via Context
+ * - Use `*StoreProvider` to wrap components that need store access
+ * - Use `use*Store` hook to access state (must be inside provider)
+ */
+export { AnalysisBuilderStoreProvider, useAnalysisBuilderStore, useAnalysisBuilderStoreApi, createAnalysisBuilderStore, selectCurrentState, selectMetrics, selectBreakdowns, selectFilters, selectChartConfig, selectUIState, selectMultiQueryState, type AnalysisBuilderStore, type AnalysisBuilderStoreState, type AnalysisBuilderStoreActions, type FieldModalMode, type SharedState, type CreateStoreOptions, type AnalysisBuilderStoreProviderProps, } from './analysisBuilderStore.js';
+export { DashboardStoreProvider, useDashboardStore, useDashboardStoreApi, useDashboardStoreOptional, createDashboardStore, selectEditModeState, selectModalState, selectLayoutState, selectDebugData, selectPortletDebugData, selectEditModeActions, selectModalActions, selectLayoutActions, selectDebugDataActions, selectAllActions, type DashboardStore, type DashboardStoreState, type DashboardStoreActions, type PortletDebugDataEntry, type DebugDataEntry as DashboardDebugDataEntry, // Alias to avoid conflict with hooks/queries
+type DragState, type CreateDashboardStoreOptions, type DashboardStoreProviderProps, } from './dashboardStore.js';