drizzle-cube 0.6.1 → 0.6.2

package/dist/cjs/client/stores/slices/funnelSlice.d.ts

@@ -0,0 +1,61 @@
+import { StateCreator } from 'zustand';
+import { AnalysisBuilderStore } from '../analysisBuilderStore.js';
+import { FunnelStepState, FunnelBindingKey, FunnelConfig } from '../../types.js';
+import { ServerFunnelQuery } from '../../types/funnel.js';
+/**
+ * Funnel slice state
+ */
+export interface FunnelSliceState {
+    /** Selected cube for funnel mode (all steps use this cube) */
+    funnelCube: string | null;
+    /** Dedicated funnel steps (separate from queryStates) */
+    funnelSteps: FunnelStepState[];
+    /** Index of currently active funnel step */
+    activeFunnelStepIndex: number;
+    /** Time dimension for funnel temporal ordering */
+    funnelTimeDimension: string | null;
+    /** Binding key dimension that links funnel steps together */
+    funnelBindingKey: FunnelBindingKey | null;
+    /** @deprecated Use funnelSteps[].timeToConvert instead - kept for backward compat */
+    stepTimeToConvert: (string | null)[];
+}
+/**
+ * Funnel slice actions
+ */
+export interface FunnelSliceActions {
+    /** Add a new funnel step */
+    addFunnelStep: () => void;
+    /** Remove a funnel step by index */
+    removeFunnelStep: (index: number) => void;
+    /** Update a funnel step by index */
+    updateFunnelStep: (index: number, updates: Partial<FunnelStepState>) => void;
+    /** Set the active funnel step index */
+    setActiveFunnelStepIndex: (index: number) => void;
+    /** Reorder funnel steps */
+    reorderFunnelSteps: (fromIndex: number, toIndex: number) => void;
+    /** Set the time dimension for funnel */
+    setFunnelTimeDimension: (dimension: string | null) => void;
+    /** Set the funnel binding key */
+    setFunnelBindingKey: (bindingKey: FunnelBindingKey | null) => void;
+    /** Set the funnel cube (clears binding key/time dimension, updates all steps) */
+    setFunnelCube: (cube: string | null) => void;
+    /** @deprecated No-op - use updateFunnelStep with timeToConvert instead */
+    setStepTimeToConvert: (stepIndex: number, duration: string | null) => void;
+    /** @deprecated Always returns null - use buildFunnelQueryFromSteps instead */
+    buildFunnelConfig: () => FunnelConfig | null;
+    /** Build ServerFunnelQuery from dedicated funnelSteps */
+    buildFunnelQueryFromSteps: () => ServerFunnelQuery | null;
+    /** Check if in funnel mode (analysisType === 'funnel') */
+    isFunnelMode: () => boolean;
+    /** Check if funnel mode is properly configured and ready for execution */
+    isFunnelModeEnabled: () => boolean;
+}
+export type FunnelSlice = FunnelSliceState & FunnelSliceActions;
+export declare const createInitialFunnelState: () => FunnelSliceState;
+/**
+ * Create the funnel slice.
+ * Uses StateCreator pattern for composability.
+ */
+export declare const createFunnelSlice: StateCreator<AnalysisBuilderStore, [
+], [
+], FunnelSlice>;

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

@@ -0,0 +1,13 @@
+/**
+ * Slices Barrel Export
+ *
+ * Exports all slice types, state creators, and action types for use in
+ * the main store composition.
+ */
+export { createCoreSlice, createInitialCoreState, type CoreSlice, type CoreSliceState, type CoreSliceActions, } from './coreSlice.js';
+export { createQuerySlice, createInitialQueryState, type QuerySlice, type QuerySliceState, type QuerySliceActions, } from './querySlice.js';
+export { createFunnelSlice, createInitialFunnelState, type FunnelSlice, type FunnelSliceState, type FunnelSliceActions, } from './funnelSlice.js';
+export { createFlowSlice, createInitialFlowState, type FlowSlice, type FlowSliceState, type FlowSliceActions, } from './flowSlice.js';
+export { createRetentionSlice, createInitialRetentionState, type RetentionSlice, type RetentionSliceActions, } from './retentionSlice.js';
+export type { RetentionSliceState } from '../../types/retention.js';
+export { createUISlice, createInitialUIState, type UISlice, type UISliceState, type UISliceActions, type FieldModalMode, } from './uiSlice.js';

package/dist/cjs/client/stores/slices/querySlice.d.ts

@@ -0,0 +1,55 @@
+import { StateCreator } from 'zustand';
+import { AnalysisBuilderStore } from '../analysisBuilderStore.js';
+import { Filter, QueryMergeStrategy, CubeQuery, MultiQueryConfig } from '../../types.js';
+import { AnalysisBuilderState } from '../../components/AnalysisBuilder/types.js';
+/**
+ * Query slice state
+ */
+export interface QuerySliceState {
+    /** 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;
+}
+/**
+ * Query slice actions
+ */
+export interface QuerySliceActions {
+    setQueryStates: (states: AnalysisBuilderState[]) => void;
+    updateQueryState: (index: number, updater: (state: AnalysisBuilderState) => AnalysisBuilderState) => void;
+    setActiveQueryIndex: (index: number) => void;
+    setMergeStrategy: (strategy: QueryMergeStrategy) => void;
+    addQuery: () => void;
+    removeQuery: (index: number) => void;
+    addMetric: (field: string, label?: string) => void;
+    removeMetric: (id: string) => void;
+    toggleMetric: (fieldName: string) => void;
+    reorderMetrics: (fromIndex: number, toIndex: number) => void;
+    addBreakdown: (field: string, isTimeDimension: boolean, granularity?: string) => void;
+    removeBreakdown: (id: string) => void;
+    toggleBreakdown: (fieldName: string, isTimeDimension: boolean, granularity?: string) => void;
+    setBreakdownGranularity: (id: string, granularity: string) => void;
+    toggleBreakdownComparison: (id: string) => void;
+    reorderBreakdowns: (fromIndex: number, toIndex: number) => void;
+    setFilters: (filters: Filter[]) => void;
+    dropFieldToFilter: (field: string) => void;
+    setOrder: (fieldName: string, direction: 'asc' | 'desc' | null) => void;
+    setLimit: (limit: number | undefined) => void;
+    getCurrentState: () => AnalysisBuilderState;
+    getMergeKeys: () => string[] | undefined;
+    isMultiQueryMode: () => boolean;
+    buildCurrentQuery: () => CubeQuery;
+    buildAllQueries: () => CubeQuery[];
+    buildMultiQueryConfig: () => MultiQueryConfig | null;
+}
+export type QuerySlice = QuerySliceState & QuerySliceActions;
+export declare const createInitialQueryState: () => QuerySliceState;
+/**
+ * Create the query slice.
+ * Uses StateCreator pattern for composability.
+ */
+export declare const createQuerySlice: StateCreator<AnalysisBuilderStore, [
+], [
+], QuerySlice>;

package/dist/cjs/client/stores/slices/retentionSlice.d.ts

@@ -0,0 +1,66 @@
+import { StateCreator } from 'zustand';
+import { AnalysisBuilderStore } from '../analysisBuilderStore.js';
+import { Filter, FunnelBindingKey } from '../../types.js';
+import { ServerRetentionQuery, RetentionSliceState, RetentionGranularity, RetentionType, DateRange, RetentionBreakdownItem } from '../../types/retention.js';
+/**
+ * Retention slice actions
+ */
+export interface RetentionSliceActions {
+    /** Set the single cube for retention analysis (clears related fields) */
+    setRetentionCube: (cube: string | null) => void;
+    /** Set the retention binding key */
+    setRetentionBindingKey: (key: FunnelBindingKey | null) => void;
+    /** Set the single timestamp dimension */
+    setRetentionTimeDimension: (dim: string | null) => void;
+    /** Set the date range (REQUIRED) */
+    setRetentionDateRange: (range: DateRange) => void;
+    /** Set all cohort filters at once */
+    setRetentionCohortFilters: (filters: Filter[]) => void;
+    /** Add a cohort filter */
+    addRetentionCohortFilter: (filter: Filter) => void;
+    /** Remove a cohort filter by index */
+    removeRetentionCohortFilter: (index: number) => void;
+    /** Update a cohort filter by index */
+    updateRetentionCohortFilter: (index: number, filter: Filter) => void;
+    /** Set all activity filters at once */
+    setRetentionActivityFilters: (filters: Filter[]) => void;
+    /** Add an activity filter */
+    addRetentionActivityFilter: (filter: Filter) => void;
+    /** Remove an activity filter by index */
+    removeRetentionActivityFilter: (index: number) => void;
+    /** Update an activity filter by index */
+    updateRetentionActivityFilter: (index: number, filter: Filter) => void;
+    /** Set all breakdown dimensions */
+    setRetentionBreakdowns: (breakdowns: RetentionBreakdownItem[]) => void;
+    /** Add a breakdown dimension */
+    addRetentionBreakdown: (breakdown: RetentionBreakdownItem) => void;
+    /** Remove a breakdown dimension by field */
+    removeRetentionBreakdown: (field: string) => void;
+    /** Set the view granularity */
+    setRetentionViewGranularity: (granularity: RetentionGranularity) => void;
+    /** Set the number of periods */
+    setRetentionPeriods: (periods: number) => void;
+    /** Set the retention type */
+    setRetentionType: (type: RetentionType) => void;
+    /** Check if in retention mode (analysisType === 'retention') */
+    isRetentionMode: () => boolean;
+    /** Check if retention mode is properly configured and ready for execution */
+    isRetentionModeEnabled: () => boolean;
+    /** Build ServerRetentionQuery from retention state */
+    buildRetentionQuery: () => ServerRetentionQuery | null;
+    /** Get validation errors explaining why retention query cannot be built */
+    getRetentionValidation: () => {
+        isValid: boolean;
+        errors: string[];
+        warnings: string[];
+    };
+}
+export type RetentionSlice = RetentionSliceState & RetentionSliceActions;
+export declare const createInitialRetentionState: () => RetentionSliceState;
+/**
+ * Create the retention slice.
+ * Uses StateCreator pattern for composability.
+ */
+export declare const createRetentionSlice: StateCreator<AnalysisBuilderStore, [
+], [
+], RetentionSlice>;

package/dist/cjs/client/stores/slices/uiSlice.d.ts

@@ -0,0 +1,52 @@
+import { StateCreator } from 'zustand';
+import { AnalysisBuilderStore } from '../analysisBuilderStore.js';
+import { QueryPanelTab, AIState } from '../../components/AnalysisBuilder/types.js';
+/**
+ * Field modal mode for field search
+ */
+export type FieldModalMode = 'metrics' | 'breakdown';
+/**
+ * UI slice state
+ */
+export interface UISliceState {
+    /** 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;
+}
+/**
+ * UI slice actions
+ */
+export interface UISliceActions {
+    setActiveTab: (tab: QueryPanelTab) => void;
+    setActiveView: (view: 'table' | 'chart') => void;
+    setDisplayLimit: (limit: number) => void;
+    openMetricsModal: () => void;
+    openBreakdownsModal: () => void;
+    closeFieldModal: () => void;
+    openAI: () => void;
+    closeAI: () => void;
+    setAIPrompt: (prompt: string) => void;
+    setAIGenerating: (generating: boolean) => void;
+    setAIError: (error: string | null) => void;
+    setAIHasGeneratedQuery: (hasQuery: boolean) => void;
+    saveAIPreviousState: () => void;
+    restoreAIPreviousState: () => void;
+}
+export type UISlice = UISliceState & UISliceActions;
+export declare const createInitialUIState: () => UISliceState;
+/**
+ * Create the UI slice.
+ * Uses StateCreator pattern for composability.
+ */
+export declare const createUISlice: StateCreator<AnalysisBuilderStore, [
+], [
+], UISlice>;

package/dist/cjs/client/theme/index.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Theme utilities and TypeScript types for drizzle-cube theming system
+ */
+/**
+ * Semantic color tokens used throughout drizzle-cube components
+ */
+export interface ThemeColorTokens {
+    surface: string;
+    surfaceSecondary: string;
+    surfaceTertiary: string;
+    surfaceHover: string;
+    text: string;
+    textSecondary: string;
+    textMuted: string;
+    textDisabled: string;
+    border: string;
+    borderSecondary: string;
+    borderHover: string;
+    primary: string;
+    primaryHover: string;
+    primaryContent: string;
+    success: string;
+    successBg: string;
+    successBorder: string;
+    warning: string;
+    warningBg: string;
+    warningBorder: string;
+    error: string;
+    errorBg: string;
+    errorBorder: string;
+    info: string;
+    infoBg: string;
+    infoBorder: string;
+    danger: string;
+    dangerHover: string;
+    dangerBg: string;
+    overlay: string;
+    overlayLight: string;
+}
+/**
+ * Theme configuration interface
+ */
+export interface ThemeConfig {
+    name: string;
+    colors: Partial<ThemeColorTokens>;
+}
+/**
+ * Get the current value of a theme CSS variable
+ */
+export declare function getThemeVariable(variableName: string): string;
+/**
+ * Set a theme CSS variable
+ */
+export declare function setThemeVariable(variableName: string, value: string): void;
+/**
+ * Apply a complete theme configuration
+ */
+export declare function applyTheme(theme: ThemeConfig): void;
+/**
+ * Reset theme to defaults by removing custom properties
+ */
+export declare function resetTheme(): void;
+/**
+ * Theme type definition
+ */
+export type Theme = 'light' | 'dark' | 'neon';
+/**
+ * Get the current theme
+ */
+export declare function getTheme(): Theme;
+/**
+ * Set the theme
+ */
+export declare function setTheme(theme: Theme): void;
+/**
+ * Detect if dark mode is currently active (backwards compatibility)
+ * @deprecated Use getTheme() instead
+ */
+export declare function isDarkMode(): boolean;
+/**
+ * Watch for theme changes
+ */
+export declare function watchThemeChanges(callback: (theme: Theme) => void): () => void;
+/**
+ * Example theme configurations
+ */
+export declare const THEME_PRESETS: {
+    readonly light: {
+        readonly name: "light";
+        readonly colors: {
+            readonly surface: "#ffffff";
+            readonly surfaceSecondary: "#f9fafb";
+            readonly text: "#111827";
+            readonly textSecondary: "#374151";
+            readonly textMuted: "#6b7280";
+            readonly border: "#e5e7eb";
+            readonly primary: "#3b82f6";
+            readonly primaryHover: "#2563eb";
+        };
+    };
+    readonly dark: {
+        readonly name: "dark";
+        readonly colors: {
+            readonly surface: "#1e293b";
+            readonly surfaceSecondary: "#334155";
+            readonly text: "#f1f5f9";
+            readonly textSecondary: "#e2e8f0";
+            readonly textMuted: "#cbd5e1";
+            readonly border: "#475569";
+            readonly primary: "#60a5fa";
+            readonly primaryHover: "#3b82f6";
+        };
+    };
+    readonly neon: {
+        readonly name: "neon";
+        readonly colors: {
+            readonly surface: "#0a0118";
+            readonly surfaceSecondary: "#1a0f2e";
+            readonly surfaceTertiary: "#2a1f3e";
+            readonly text: "#ffffff";
+            readonly textSecondary: "#e0e0ff";
+            readonly textMuted: "#b0b0d0";
+            readonly border: "#ff00ff";
+            readonly borderSecondary: "#00ffff";
+            readonly primary: "#00ffff";
+            readonly primaryHover: "#00cccc";
+            readonly primaryContent: "#000000";
+            readonly success: "#00ff00";
+            readonly warning: "#ffff00";
+            readonly error: "#ff0066";
+            readonly info: "#00ffff";
+            readonly danger: "#ff1493";
+        };
+    };
+};

package/dist/cjs/client/types/analysisConfig.d.ts

@@ -0,0 +1,185 @@
+import { ChartType, ChartAxisConfig, ChartDisplayConfig, CubeQuery, MultiQueryConfig } from '../types.js';
+import { ServerFunnelQuery } from './funnel.js';
+import { ServerFlowQuery } from './flow.js';
+import { ServerRetentionQuery } from './retention.js';
+/**
+ * Chart configuration - shared across all analysis types
+ */
+export interface ChartConfig {
+    chartType: ChartType;
+    chartConfig: ChartAxisConfig;
+    displayConfig: ChartDisplayConfig;
+}
+/**
+ * Analysis type discriminator
+ * Future modes: 'cohort'
+ */
+export type AnalysisType = 'query' | 'funnel' | 'flow' | 'retention';
+/**
+ * Base config - common to all analysis types
+ */
+interface AnalysisConfigBase {
+    /** Version number for migration support */
+    version: 1;
+    /** Which analysis mode this config represents */
+    analysisType: AnalysisType;
+    /** Whether to show table or chart view */
+    activeView: 'table' | 'chart';
+    /**
+     * Per-mode chart configuration map.
+     * Each mode owns its own chart settings, allowing users to configure
+     * different chart types for query mode vs funnel mode.
+     */
+    charts: {
+        [K in AnalysisType]?: ChartConfig;
+    };
+}
+/**
+ * Query mode config - for single queries and multi-query analysis
+ *
+ * The `query` field is the actual executable query:
+ * - Single query: CubeQuery object
+ * - Multi-query: MultiQueryConfig with queries array and merge strategy
+ */
+export interface QueryAnalysisConfig extends AnalysisConfigBase {
+    analysisType: 'query';
+    /**
+     * The executable query.
+     * - CubeQuery: Single query with measures, dimensions, filters
+     * - MultiQueryConfig: Multiple queries with merge strategy
+     */
+    query: CubeQuery | MultiQueryConfig;
+}
+/**
+ * Funnel mode config - for funnel analysis
+ *
+ * The `query` field is the ServerFunnelQuery which can be sent
+ * directly to the server for execution.
+ */
+export interface FunnelAnalysisConfig extends AnalysisConfigBase {
+    analysisType: 'funnel';
+    /**
+     * Server funnel query - executable as-is.
+     * Contains bindingKey, timeDimension, steps[], and options.
+     */
+    query: ServerFunnelQuery;
+}
+/**
+ * Flow mode config - for bidirectional flow analysis
+ *
+ * The `query` field is the ServerFlowQuery which can be sent
+ * directly to the server for execution.
+ */
+export interface FlowAnalysisConfig extends AnalysisConfigBase {
+    analysisType: 'flow';
+    /**
+     * Server flow query - executable as-is.
+     * Contains bindingKey, timeDimension, eventDimension, startingStep, and depth config.
+     */
+    query: ServerFlowQuery;
+}
+/**
+ * Retention mode config - for cohort-based retention analysis
+ *
+ * The `query` field is the ServerRetentionQuery which can be sent
+ * directly to the server for execution.
+ */
+export interface RetentionAnalysisConfig extends AnalysisConfigBase {
+    analysisType: 'retention';
+    /**
+     * Server retention query - executable as-is.
+     * Contains cohortTimeDimension, activityTimeDimension, bindingKey,
+     * granularity settings, and period configuration.
+     */
+    query: ServerRetentionQuery;
+}
+/**
+ * AnalysisConfig - union of all analysis mode configurations
+ */
+export type AnalysisConfig = QueryAnalysisConfig | FunnelAnalysisConfig | FlowAnalysisConfig | RetentionAnalysisConfig;
+/**
+ * Check if config is for query mode
+ */
+export declare const isQueryConfig: (c: AnalysisConfig) => c is QueryAnalysisConfig;
+/**
+ * Check if config is for funnel mode
+ */
+export declare const isFunnelConfig: (c: AnalysisConfig) => c is FunnelAnalysisConfig;
+/**
+ * Check if config is for flow mode
+ */
+export declare const isFlowConfig: (c: AnalysisConfig) => c is FlowAnalysisConfig;
+/**
+ * Check if config is for retention mode
+ */
+export declare const isRetentionConfig: (c: AnalysisConfig) => c is RetentionAnalysisConfig;
+/**
+ * Check if a query config contains multiple queries
+ */
+export declare const isMultiQuery: (config: QueryAnalysisConfig) => boolean;
+/**
+ * Check if a query config contains a single query
+ */
+export declare const isSingleQuery: (config: QueryAnalysisConfig) => boolean;
+/**
+ * Type guard to validate if an unknown value is a valid AnalysisConfig
+ */
+export declare const isValidAnalysisConfig: (config: unknown) => config is AnalysisConfig;
+/**
+ * Create a default empty query analysis config
+ */
+export declare const createDefaultQueryConfig: () => QueryAnalysisConfig;
+/**
+ * Create a default empty funnel analysis config
+ */
+export declare const createDefaultFunnelConfig: () => FunnelAnalysisConfig;
+/**
+ * Create a default empty flow analysis config
+ */
+export declare const createDefaultFlowConfig: () => FlowAnalysisConfig;
+/**
+ * Create a default empty retention analysis config
+ */
+export declare const createDefaultRetentionConfig: () => RetentionAnalysisConfig;
+/**
+ * Create a default config for the given analysis type
+ */
+export declare const createDefaultConfig: (type?: AnalysisType) => AnalysisConfig;
+/**
+ * AnalysisWorkspace - Multi-mode persistence format for localStorage
+ *
+ * Unlike AnalysisConfig (which represents a single analysis mode),
+ * AnalysisWorkspace preserves state for ALL modes. This prevents state
+ * loss when switching between query, funnel, flow, and retention modes.
+ *
+ * Usage:
+ * - localStorage persistence → AnalysisWorkspace (preserves all modes)
+ * - Share URLs → AnalysisConfig (shares one specific analysis)
+ * - Dashboard portlets → AnalysisConfig (embeds one specific analysis)
+ */
+export interface AnalysisWorkspace {
+    /** Version number for migration support */
+    version: 1;
+    /** Currently active analysis type */
+    activeType: AnalysisType;
+    /**
+     * Per-mode configurations.
+     * Each mode stores its complete AnalysisConfig independently.
+     * Charts are duplicated per-mode but merged on load.
+     */
+    modes: {
+        query?: QueryAnalysisConfig;
+        funnel?: FunnelAnalysisConfig;
+        flow?: FlowAnalysisConfig;
+        retention?: RetentionAnalysisConfig;
+    };
+}
+/**
+ * Type guard to validate if an unknown value is a valid AnalysisWorkspace
+ */
+export declare const isValidAnalysisWorkspace: (data: unknown) => data is AnalysisWorkspace;
+/**
+ * Create a default empty workspace with all modes initialized
+ */
+export declare const createDefaultWorkspace: () => AnalysisWorkspace;
+export {};