drizzle-cube 0.10.0 → 0.11.0

package/dist/adapters/utils.cjs

@@ -1 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./utils-Du_UZbn5.cjs");exports.buildTransformedQuery=e.t,exports.calculateQueryComplexity=e.n,exports.formatCubeResponse=e.r,exports.formatErrorResponse=e.i,exports.formatMetaResponse=e.a,exports.formatSqlResponse=e.o,exports.formatSqlString=e.x,exports.generateRequestId=e.s,exports.getDatabaseType=e.c,exports.handleBatchRequest=e.l,exports.handleDiscover=e.p,exports.handleDryRun=e.u,exports.handleLoad=e.m,exports.handleSuggest=e.d,exports.handleValidate=e.f,exports.normalizeQueryFields=e.h;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./utils-a2p2B6x8.cjs");exports.buildTransformedQuery=e.t,exports.calculateQueryComplexity=e.n,exports.formatCubeResponse=e.r,exports.formatErrorResponse=e.i,exports.formatMetaResponse=e.a,exports.formatSqlResponse=e.o,exports.formatSqlString=e.x,exports.generateRequestId=e.s,exports.getDatabaseType=e.c,exports.handleBatchRequest=e.l,exports.handleDiscover=e.p,exports.handleDryRun=e.u,exports.handleLoad=e.m,exports.handleSuggest=e.d,exports.handleValidate=e.f,exports.normalizeQueryFields=e.h;

package/dist/adapters/utils.js

@@ -1,2 +1,2 @@
-import { a as e, c as t, d as n, f as r, h as i, i as a, l as o, m as s, n as c, o as l, p as u, r as d, s as f, t as p, u as m, x as h } from "./utils-i2h5cwI3.js";
+import { a as e, c as t, d as n, f as r, h as i, i as a, l as o, m as s, n as c, o as l, p as u, r as d, s as f, t as p, u as m, x as h } from "./utils-BaxFceDq.js";
 export { p as buildTransformedQuery, c as calculateQueryComplexity, d as formatCubeResponse, a as formatErrorResponse, e as formatMetaResponse, l as formatSqlResponse, h as formatSqlString, f as generateRequestId, t as getDatabaseType, o as handleBatchRequest, u as handleDiscover, m as handleDryRun, s as handleLoad, n as handleSuggest, r as handleValidate, i as normalizeQueryFields };

package/dist/cjs/client/charts/chartConfigHelpers.d.ts

@@ -21,6 +21,11 @@ export declare function requiresMeasure({ measureCount }: ChartAvailabilityConte
 export declare const targetDisplayOption: DisplayOptionConfig;
 /** Connect-nulls toggle for line/area charts. */
 export declare const connectNullsDisplayOption: DisplayOptionConfig;
+/**
+ * Gap-filling control for time-series charts (issue #1368). `auto` follows the
+ * query, then the cube time dimension's `fillMissingDates`, then fills.
+ */
+export declare const fillMissingDatesDisplayOption: DisplayOptionConfig;
 /** Left Y-axis numeric format control (dual-axis charts). */
 export declare const leftYAxisFormatDisplayOption: DisplayOptionConfig;
 /** Right Y-axis numeric format control (dual-axis charts). */

package/dist/cjs/client/components/DashboardFilters/useCompactFilterBar.d.ts

@@ -1,4 +1,9 @@
 import { DashboardFilter } from '../../types.js';
+/**
+ * Find the dashboard filter the date control is bound to: the universal time
+ * filter when present, otherwise the first simple `inDateRange` filter.
+ */
+export declare function findDateControlFilter(filters: DashboardFilter[]): DashboardFilter | undefined;
 export declare function useCompactFilterBar(dashboardFilters: DashboardFilter[], onDashboardFiltersChange: (filters: DashboardFilter[]) => void): {
     localFilters: DashboardFilter[];
     showCustomDropdown: boolean;

package/dist/cjs/client/components/analyticsPortlet/usePortletQueryResults.d.ts

@@ -1,5 +1,5 @@
 import { useCubeLoadQuery, useFunnelQuery, useFlowQuery, useRetentionQuery } from '../../hooks/queries/index.js';
-import { CubeQuery, MultiQueryConfig, ServerFunnelQuery } from '../../types.js';
+import { ChartDisplayConfig, CubeQuery, MultiQueryConfig, ServerFunnelQuery } from '../../types.js';
 import { FlowChartData, ServerFlowQuery } from '../../types/flow.js';
 import { RetentionChartData, ServerRetentionQuery } from '../../types/retention.js';
 interface RefreshOptions {
@@ -18,6 +18,8 @@ export interface UsePortletQueryResultsParams {
     shouldSkipQuery: boolean;
     eagerLoad: boolean;
     isVisible: boolean;
+    /** Chart display config — its `fillMissingDates` drives client-side gap filling */
+    displayConfig?: ChartDisplayConfig;
 }
 export interface PortletQueryResults {
     resultSet: ReturnType<typeof useCubeLoadQuery>['resultSet'];

package/dist/cjs/client/components/dashboardPortletCard/PortletCardHeader.d.ts

@@ -17,6 +17,8 @@ interface PortletCardHeaderProps {
     xlsExportAvailable: boolean;
     exportInProgress: boolean;
     showCacheBustIndicator: boolean;
+    /** Labels of mapped dashboard date filters that cannot narrow this portlet */
+    unreachableDateFilterLabels?: string[];
     icons: CardIcons;
     onRefresh: (options?: {
         bustCache?: boolean;

package/dist/cjs/client/hooks/queries/useCubeLoadQuery.d.ts

@@ -1,5 +1,6 @@
 import { CubeQuery, CubeResultSet } from '../../types.js';
 import { QueryWarning } from '../../shared/types.js';
+import { ChartGapFillOptions } from '../../utils/gapFilling.js';
 /**
  * Create a stable query key from a CubeQuery
  * The key includes all query parameters to ensure proper caching
@@ -31,6 +32,12 @@ export interface UseCubeLoadQueryOptions {
      * @default true
      */
     keepPreviousData?: boolean;
+    /**
+     * Fill missing time buckets for a chart (Cube.js-style, client-side). The
+     * server returns observed rows only; when set, the returned result set's rows
+     * are gap-filled per `ChartGapFillOptions`. Omit for raw rows.
+     */
+    gapFill?: ChartGapFillOptions;
 }
 /** Options for the refetch function */
 export interface RefetchOptions {

package/dist/cjs/client/hooks/queries/useMultiCubeLoadQuery.d.ts

@@ -1,4 +1,5 @@
 import { MultiQueryConfig, CubeResultSet } from '../../types.js';
+import { ChartGapFillOptions } from '../../utils/gapFilling.js';
 /**
  * Create a stable query key for multi-query
  */
@@ -29,6 +30,12 @@ export interface UseMultiCubeLoadQueryOptions {
      * @default true
      */
     keepPreviousData?: boolean;
+    /**
+     * Fill missing time buckets for a chart (Cube.js-style, client-side). When
+     * set, each query's rows are gap-filled per `ChartGapFillOptions` before
+     * merging. Omit for raw rows.
+     */
+    gapFill?: ChartGapFillOptions;
 }
 export interface UseMultiCubeLoadQueryResult {
     /** Merged data from all queries */

package/dist/cjs/client/hooks/useAnalysisQuery.d.ts

@@ -1,5 +1,5 @@
 import { DebugDataEntry } from './queries/index.js';
-import { CubeQuery, MultiQueryConfig, FunnelBindingKey, QueryMergeStrategy, AnalysisType } from '../types.js';
+import { CubeQuery, MultiQueryConfig, FunnelBindingKey, QueryMergeStrategy, AnalysisType, ChartDisplayConfig } from '../types.js';
 import { ExecutionStatus } from '../components/AnalysisBuilder/types.js';
 import { ServerFunnelQuery } from '../types/funnel.js';
 import { ServerFlowQuery, FlowChartData } from '../types/flow.js';
@@ -56,6 +56,11 @@ export interface UseAnalysisQueryOptions {
         errors: string[];
         warnings: string[];
     } | null;
+    /**
+     * The chart's gap-filling setting (`displayConfig.fillMissingDates`). Results
+     * are gap-filled client-side per this setting, the query and the cube.
+     */
+    fillMissingDates?: ChartDisplayConfig['fillMissingDates'];
 }
 export interface UseAnalysisQueryResult {
     /** Query execution status */

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

@@ -71,6 +71,8 @@ export type { DashboardExportFile, DashboardImportResult, DashboardImportError,
 export type { DashboardImportExportState, PendingDashboardImport, FailedDashboardImport, } from './hooks/dashboard/useDashboardImportExport.js';
 export { compressAndEncode, decodeAndDecompress, generateShareUrl, parseShareUrl, isShareableSize } from './utils/shareUtils.js';
 export { isMultiQueryData, mergeQueryResults, mergeResultsConcat, mergeResultsByKey, getCombinedFields, getQueryLabels, getQueryIndices, generateQueryLabel, validateMergeKey } from './utils/multiQueryUtils.js';
+export { fillChartRows, withChartGapFilling } from './utils/gapFilling.js';
+export type { ChartGapFillOptions } from './utils/gapFilling.js';
 export { validateFunnelConfig, validateBindingKeyExists, validateStepQueries, validateBindingKeyForSteps, isMinimumFunnelConfigValid, getAvailableBindingKeyDimensions, getBindingKeyLabel, } from './utils/funnelValidation.js';
 export { getBindingKeyField, getCubeNameFromQuery, formatDuration, transformServerFunnelResult, buildServerFunnelQuery, isFunnelData, buildFunnelConfigFromQueries, } from './utils/funnelExecution.js';
 export { getThemeVariable, setThemeVariable, applyTheme, resetTheme, getTheme, setTheme, isDarkMode, watchThemeChanges, THEME_PRESETS } from './theme/index.js';

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

@@ -19,6 +19,8 @@ export interface CubeMetaDimension {
     type: string;
     /** Supported granularities for time dimensions (for time-based drill-down) */
     granularities?: TimeGranularity[];
+    /** The cube time dimension's gap-filling default, when it declares one */
+    fillMissingDates?: boolean;
 }
 export interface CubeMetaField {
     name: string;
@@ -146,6 +148,7 @@ export interface ChartDisplayConfig {
     stacked?: boolean;
     stackType?: 'none' | 'normal' | 'percent';
     connectNulls?: boolean;
+    fillMissingDates?: boolean | 'auto';
     showSummary?: boolean;
     showPoints?: boolean;
     showAllXLabels?: boolean;

package/dist/cjs/client/utils/filterUtils.d.ts

@@ -43,6 +43,21 @@ export declare function shouldIncludeFilter(filter: Filter): boolean;
  * @returns Array of filters that should be applied to the portlet
  */
 export declare function getApplicableDashboardFilters(dashboardFilters: DashboardFilter[] | undefined, filterMapping: DashboardFilterMapping | undefined): Filter[];
+/**
+ * Whether a dashboard filter is applied to a portlet as a regular filter.
+ *
+ * Non-universal filters always are. A universal time filter normally reaches a
+ * portlet through its timeDimensions, but when the portlet's mapping pins it to
+ * a field (a member override) it becomes a plain inDateRange filter on that
+ * field - which is how a KPI or breakdown without time dimensions is narrowed
+ * by the dashboard date control.
+ */
+export declare function isAppliedAsRegularFilter(dashboardFilter: DashboardFilter, filterMapping: DashboardFilterMapping | undefined): boolean;
+/**
+ * Dashboard filters that reach a portlet through its `filters` (as opposed to
+ * universal time filters applied to its timeDimensions).
+ */
+export declare function getRegularDashboardFilters(dashboardFilters: DashboardFilter[] | undefined, filterMapping: DashboardFilterMapping | undefined): DashboardFilter[] | undefined;
 /**
  * Filter format for merge operation:
  * - 'server': Returns {and: [...]} or {or: [...]} format (for API queries)
@@ -94,6 +109,21 @@ type TimeDimension = {
     granularity?: string;
     dateRange?: string[] | string;
 };
+/**
+ * Universal time filters mapped to a portlet that apply through its
+ * timeDimensions - i.e. mapped without a member override.
+ */
+export declare function getTimeDimensionUniversalFilters(dashboardFilters: DashboardFilter[] | undefined, filterMapping: DashboardFilterMapping | undefined): DashboardFilter[];
+/**
+ * Universal time filters mapped to a portlet that cannot narrow it: they apply
+ * only through timeDimensions, but some query in the portlet has none. Such a
+ * portlet would otherwise silently render all-time values while the dashboard
+ * date control shows a narrower range.
+ *
+ * Only plain and multi-query portlets are checked; funnel, flow and retention
+ * queries handle dashboard time filters separately.
+ */
+export declare function getUnreachableUniversalTimeFilters(query: string, dashboardFilters: DashboardFilter[] | undefined, filterMapping: DashboardFilterMapping | undefined): DashboardFilter[];
 /**
  * Apply universal time filters to a portlet's timeDimensions
  * Universal time filters apply their dateRange to ALL time dimensions in the portlet

package/dist/cjs/client/utils/gapFilling.d.ts

@@ -0,0 +1,52 @@
+import { CubeResultSet } from '../types.js';
+/** A chart's gap-filling preference. */
+export interface ChartGapFillOptions {
+    /** `true`/`false` force filling on/off; `'auto'` or unset defers to the query and cube. */
+    fillMissingDates?: boolean | 'auto';
+}
+/** A time dimension of the query a result came from. */
+export interface ChartGapFillTimeDimension {
+    dimension: string;
+    granularity?: string;
+    dateRange?: string | string[];
+    fillMissingDates?: boolean;
+    compareDateRange?: readonly unknown[];
+}
+/** The parts of a query chart gap filling reads. */
+export interface ChartGapFillQuery {
+    measures?: readonly string[];
+    dimensions?: readonly string[];
+    timeDimensions?: readonly ChartGapFillTimeDimension[];
+    filters?: readonly ChartGapFillFilter[];
+    fillMissingDatesValue?: number | null;
+    ungrouped?: boolean;
+}
+interface ChartGapFillFilter {
+    member?: string;
+    operator?: string;
+    values?: readonly unknown[];
+    dateRange?: string | string[];
+    and?: readonly ChartGapFillFilter[];
+    or?: readonly ChartGapFillFilter[];
+}
+interface TimeDimensionAnnotation {
+    fillMissingDates?: boolean;
+}
+/**
+ * Fill missing time buckets in result rows for a chart.
+ *
+ * Comparison (`compareDateRange`) dimensions are left alone — the server fills
+ * each period already and the rows carry period metadata. Ungrouped queries are
+ * never filled.
+ */
+export declare function fillChartRows(rows: Record<string, unknown>[], query: ChartGapFillQuery, annotation: {
+    timeDimensions?: Record<string, TimeDimensionAnnotation>;
+} | undefined, options?: ChartGapFillOptions): Record<string, unknown>[];
+/**
+ * Wrap a result set so its rows are gap-filled for a chart. The underlying
+ * result set (and the query cache holding it) stays raw, so changing the chart
+ * setting never refetches. Returns the result set unchanged when it does not
+ * carry the query it came from.
+ */
+export declare function withChartGapFilling(resultSet: CubeResultSet, options?: ChartGapFillOptions): CubeResultSet;
+export {};

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

@@ -6,6 +6,7 @@ export * from './periodUtils.js';
 export * from './pivotUtils.js';
 export * from './syntaxHighlighting.js';
 export * from './comparisonUtils.js';
+export * from './gapFilling.js';
 export { captureThumbnail, isThumbnailCaptureAvailable } from './thumbnail.js';
 export { exportPortletToXlsx, isExportAvailable } from './exportXlsx.js';
 export { createDashboardExport, serializeDashboardExport, parseDashboardExport, readDashboardExportFile, downloadDashboardExport, dashboardExportFilename, normalizeDashboardConfigForExport, } from './dashboardExport.js';

package/dist/cjs/client/utils/joinReachability.d.ts

@@ -24,4 +24,5 @@ export interface ReachableDimensionGroup {
  */
 export declare function getReachableDimensionOptions(meta: CubeMeta | null, portlet: PortletConfig, options?: {
     sameTypeAs?: string;
+    type?: string;
 }): ReachableDimensionGroup[];

package/dist/cjs/server/ai/query-schema.d.ts

@@ -44,8 +44,13 @@ export declare const QUERY_PARAMS_SCHEMA: {
                 };
                 readonly values: {
                     readonly type: "array";
-                    readonly items: {};
-                    readonly description: "Filter values. Omit for set/notSet/isEmpty/isNotEmpty. inDateRange: [\"last 3 months\"] (one relative string) or [\"YYYY-MM-DD\", \"YYYY-MM-DD\"].";
+                    readonly items: {
+                        readonly type: readonly ["string", "number", "boolean"];
+                    };
+                    readonly description: "Filter values. Omit for set/notSet/isEmpty/isNotEmpty. inDateRange accepts ONLY a flat two-date array (strings or finite numeric timestamps): [\"2024-01-01\", \"2024-03-31\"], or a one-item array holding one relative expression or one date (that whole day): [\"last 3 months\"], [\"2024-01-15\"]. Never nest the two-date array.";
+                };
+                readonly dateRange: {
+                    readonly description: "inDateRange only: alternative to values. A supported relative string, one absolute date string, or flat two-date array. Prefer values: [] when using dateRange; if values are also given they must hold the same range.";
                 };
             };
             readonly required: readonly ["member", "operator"];
@@ -71,7 +76,7 @@ export declare const QUERY_PARAMS_SCHEMA: {
                 };
                 readonly fillMissingDates: {
                     readonly type: "boolean";
-                    readonly description: "Fill gaps in time series with fillMissingDatesValue (default: true). Requires granularity + dateRange.";
+                    readonly description: "Fill gaps in time series with fillMissingDatesValue. Default: off (observed rows only) unless the cube time dimension enables it. Requires granularity + dateRange.";
                 };
                 readonly compareDateRange: {
                     readonly type: "array";

package/dist/cjs/server/builders/date-time-builder.d.ts

@@ -11,7 +11,7 @@ export declare class DateTimeBuilder {
     /**
      * Build date range condition for time dimensions
      */
-    buildDateRangeCondition(fieldExpr: AnyColumn | SQL, dateRange: string | string[]): SQL | null;
+    buildDateRangeCondition(fieldExpr: AnyColumn | SQL, dateRange: unknown): SQL | null;
     private rangeBetween;
     /** Shift a normalized end value to end-of-day when its source was a date-only string. */
     private endOfDayValue;

package/dist/cjs/server/builders/date-time-helpers.d.ts

@@ -17,6 +17,8 @@ export declare function dateToEngineValue(databaseAdapter: DatabaseAdapter, date
 export declare function engineValueToDate(databaseAdapter: DatabaseAdapter, value: string | number): Date;
 /** Detect a date-only string (YYYY-MM-DD). */
 export declare function isDateOnlyString(value: unknown): value is string;
+/** Parse a string/number/Date into a validated Date, or null if invalid. */
+export declare function toValidDate(value: unknown): Date | null;
 /**
  * Normalize a date value to the engine's wire format, or null when falsy or
  * unparseable.

package/dist/cjs/server/builders/filter-builder.d.ts

@@ -9,7 +9,7 @@ export declare class FilterBuilder {
     /**
      * Build filter condition using Drizzle operators
      */
-    buildFilterCondition(fieldExpr: AnyColumn | SQL, operator: FilterOperator, values: any[], field?: any, dateRange?: string | string[]): SQL | null;
+    buildFilterCondition(fieldExpr: AnyColumn | SQL, operator: FilterOperator, values: any[], field?: any, dateRangeInput?: string | string[] | null): SQL | null;
     /**
      * Build a logical filter (AND/OR) - used by executor for cache preloading
      * This handles nested filter structures and builds combined SQL

package/dist/cjs/server/builders/in-date-range-validation.d.ts

@@ -0,0 +1,25 @@
+export type DateRangeReason = 'missing' | 'shape' | 'invalidDate' | 'invalidRelative' | 'reverseOrder' | 'conflict';
+export type DateRangeValidation = {
+    valid: true;
+} | {
+    valid: false;
+    reason: DateRangeReason;
+    input: 'values' | 'dateRange';
+    value?: string;
+};
+/** Validate an exact absolute tuple without accepting JS Date rollover or nested arrays. */
+export declare function validateDateTuple(value: unknown): DateRangeReason | null;
+/**
+ * Validate a standalone date range (`filter.dateRange` or `timeDimensions[].dateRange`):
+ * a relative expression, one absolute day, or a flat `[start, end]` pair.
+ */
+export declare function validateDateRangeInput(dateRange: unknown): DateRangeValidation;
+export declare function validateInDateRange(values: unknown, dateRange?: unknown): DateRangeValidation;
+/**
+ * Diagnostic for SQL builders, which only see a field expression. Queries are
+ * validated before they reach the builders, so this only surfaces for callers
+ * that bypass validation.
+ */
+export declare function dateRangeInputDiagnostic(result: DateRangeValidation): string;
+export declare function timeDimensionDateRangeDiagnostic(member: string, result: DateRangeValidation): string;
+export declare function inDateRangeDiagnostic(member: string, result: DateRangeValidation): string;

package/dist/cjs/server/execution/result-post-processor.d.ts

@@ -1,4 +1,4 @@
-import { SemanticQuery } from '../types/index.js';
+import { Cube, SemanticQuery } from '../types/index.js';
 import { DatabaseAdapter } from '../adapters/base-adapter.js';
 /**
  * Normalise time-dimension values in result rows and apply gap filling.
@@ -6,5 +6,7 @@ import { DatabaseAdapter } from '../adapters/base-adapter.js';
  * @param data Raw rows from the database executor
  * @param query The semantic query (for timeDimensions + measures)
  * @param databaseAdapter Adapter used to convert engine-specific date results
+ * @param cubes Cube definitions, for each time dimension's `fillMissingDates`
+ * @param fillByDefault Gap-fill time dimensions neither the query nor the cube configures
  */
-export declare function postProcessResultRows(data: unknown, query: SemanticQuery, databaseAdapter: DatabaseAdapter): Record<string, unknown>[];
+export declare function postProcessResultRows(data: unknown, query: SemanticQuery, databaseAdapter: DatabaseAdapter, cubes?: Map<string, Cube>, fillByDefault?: boolean): Record<string, unknown>[];

package/dist/cjs/server/executor.d.ts

@@ -93,6 +93,8 @@ export declare class QueryExecutor {
      * @param cacheKey - When provided (and a cache provider is configured), the
      *   fresh result is written to the cache. Pass `undefined` to skip caching
      *   (e.g. comparison period sub-queries cache at the comparison level).
+     * @param fillByDefault - Gap-fill time dimensions that neither the query nor
+     *   the cube configures. Only comparison period sub-queries pass `true`.
      */
     private executeStandardQuery;
     /**

package/dist/cjs/server/gap-filler.d.ts

@@ -1,48 +1,13 @@
+import { Cube } from './types/cube.js';
 import { SemanticQuery } from './types/query.js';
-import { TimeGranularity } from './types/core.js';
+export { generateTimeBuckets, fillTimeSeriesGaps, parseDateRange, MAX_GAP_FILL_BUCKETS, type GapFillerConfig } from '../shared/gap-filler.js';
 /**
- * Maximum number of time buckets gap filling will generate. Beyond this, gap
- * filling is skipped entirely (data is returned unmodified) to avoid both
- * runaway memory use and silent truncation of real rows.
- */
-export declare const MAX_GAP_FILL_BUCKETS = 10000;
-export interface GapFillerConfig {
-    /** The time dimension key (e.g., 'Sales.date') */
-    timeDimensionKey: string;
-    /** Time granularity for bucket generation */
-    granularity: TimeGranularity;
-    /** Date range [start, end] */
-    dateRange: [Date, Date];
-    /** Value to fill for missing measures (default: 0) */
-    fillValue: number | null;
-    /** List of measure keys in the data */
-    measures: string[];
-    /** List of dimension keys in the data (excluding time dimensions) */
-    dimensions: string[];
-}
-/**
- * Generate all time buckets for a given date range and granularity
- */
-export declare function generateTimeBuckets(startDate: Date, endDate: Date, granularity: TimeGranularity): Date[];
-/**
- * Fill time series gaps in query result data
+ * Apply server-side gap filling to query result rows.
  *
- * @param data - Original query result data
- * @param config - Gap filling configuration
- * @returns Data with gaps filled
- */
-export declare function fillTimeSeriesGaps(data: Record<string, unknown>[], config: GapFillerConfig): Record<string, unknown>[];
-/**
- * Parse date range from query time dimension
- * Handles both array format ['2024-01-01', '2024-01-31'] and string format
- */
-export declare function parseDateRange(dateRange: string | string[] | undefined): [Date, Date] | null;
-/**
- * Apply gap filling to query result data based on query configuration
+ * Precedence per time dimension: the query's `fillMissingDates`, then the cube
+ * dimension's, then `fillByDefault`. Ungrouped queries are never filled.
  *
- * @param data - Original query result data
- * @param query - The semantic query
- * @param measures - List of measure names in the result
- * @returns Data with gaps filled (if applicable)
+ * @param fillByDefault - Fill when neither the query nor the cube says. Only
+ *   comparison-period sub-queries pass `true`, to keep periods aligned.
  */
-export declare function applyGapFilling(data: Record<string, unknown>[], query: SemanticQuery, measures: string[]): Record<string, unknown>[];
+export declare function applyServerGapFilling(data: Record<string, unknown>[], query: SemanticQuery, cubes?: Map<string, Cube>, fillByDefault?: boolean): Record<string, unknown>[];

package/dist/cjs/server/types/core.d.ts

@@ -165,6 +165,8 @@ export interface TimeDimensionAnnotation {
     shortTitle: string;
     type: string;
     granularity?: TimeGranularity;
+    /** The cube time dimension's `fillMissingDates`, when it declares one */
+    fillMissingDates?: boolean;
 }
 /**
  * Type enums and constants

package/dist/cjs/server/types/cube.d.ts

@@ -191,6 +191,18 @@ export interface Dimension {
      * @example ['year', 'quarter', 'month', 'day'] for a custom subset
      */
     granularities?: TimeGranularity[];
+    /**
+     * Whether missing time buckets are filled for this time dimension when a
+     * query or chart does not say. Only applies when type is 'time'.
+     *
+     * - Server: a query that omits `fillMissingDates` is filled only when this is
+     *   `true`. Unset means observed rows only (the Cube.js default).
+     * - Charts: fill gaps by default, like Cube.js. Set `false` where a missing
+     *   bucket means "no data" rather than zero, e.g. daily snapshot tables.
+     *
+     * A query's or chart's own `fillMissingDates` always wins.
+     */
+    fillMissingDates?: boolean;
 }
 /**
  * Measure definition

package/dist/cjs/server/types/metadata.d.ts

@@ -77,6 +77,11 @@ export interface DimensionMetadata {
      * Used for time-based drill-down (year -> quarter -> month -> week -> day)
      */
     granularities?: TimeGranularity[];
+    /**
+     * The time dimension's `fillMissingDates` default, when the cube declares one.
+     * Charts use it to decide whether to fill missing buckets.
+     */
+    fillMissingDates?: boolean;
 }
 /**
  * Hierarchy metadata for structured drill-down paths

package/dist/cjs/server/types/query.d.ts

@@ -135,7 +135,8 @@ export interface TimeDimension {
     /**
      * Fill missing dates in time series with the fill value.
      * Requires both granularity and dateRange to be set.
-     * Default: true (enabled)
+     * Default: the cube time dimension's `fillMissingDates`, else false — the
+     * server returns observed rows only and charts fill gaps client-side.
      */
     fillMissingDates?: boolean;
     /**

package/dist/client/charts/chartConfigHelpers.d.ts

@@ -21,6 +21,11 @@ export declare function requiresMeasure({ measureCount }: ChartAvailabilityConte
 export declare const targetDisplayOption: DisplayOptionConfig;
 /** Connect-nulls toggle for line/area charts. */
 export declare const connectNullsDisplayOption: DisplayOptionConfig;
+/**
+ * Gap-filling control for time-series charts (issue #1368). `auto` follows the
+ * query, then the cube time dimension's `fillMissingDates`, then fills.
+ */
+export declare const fillMissingDatesDisplayOption: DisplayOptionConfig;
 /** Left Y-axis numeric format control (dual-axis charts). */
 export declare const leftYAxisFormatDisplayOption: DisplayOptionConfig;
 /** Right Y-axis numeric format control (dual-axis charts). */

package/dist/client/charts.js

@@ -1,14 +1,14 @@
-import { dt as e, ft as t, gt as n, ht as r, lt as i, mt as a, pt as o, t as s, ut as c } from "./chunks/chart-data-table-BdMo3zVh.js";
-import { d as l, l as u, s as d, u as f } from "./chunks/chart-activity-grid-DGazwi4C.js";
-import { t as p } from "./chunks/chart-funnel-BRyZS6ie.js";
-import { a as m, i as h, n as g, o as _, r as v, s as y, t as b } from "./chunks/charts-loader-BTI0UPK4.js";
-import { t as x } from "./chunks/chart-area-zyLGD-ym.js";
+import { dt as e, ft as t, gt as n, ht as r, lt as i, mt as a, pt as o, t as s, ut as c } from "./chunks/chart-data-table-Cxd0cdAl.js";
+import { d as l, l as u, s as d, u as f } from "./chunks/chart-activity-grid-Ly_-2B-f.js";
+import { t as p } from "./chunks/chart-funnel-71Kn4eeF.js";
+import { a as m, i as h, n as g, o as _, r as v, s as y, t as b } from "./chunks/charts-loader-DoLQqFXg.js";
+import { t as x } from "./chunks/chart-area-D3l-71Wy.js";
 import { i as S } from "./chunks/utils-CToHkuhU.js";
-import { t as C } from "./chunks/chart-bar-DMCBq8qJ.js";
-import { t as w } from "./chunks/chart-line-IEgiF8Nv.js";
-import { t as T } from "./chunks/chart-pie-BEB2sCXF.js";
-import { t as E } from "./chunks/chart-scatter-CSWF6-lx.js";
-import { t as D } from "./chunks/chart-radar-BbSbXKbP.js";
-import { t as O } from "./chunks/chart-radial-bar-CNYD7tkM.js";
-import { t as k } from "./chunks/chart-tree-map-BiXB7EiM.js";
+import { t as C } from "./chunks/chart-bar-BaTyQOqs.js";
+import { t as w } from "./chunks/chart-line-BNqjUowg.js";
+import { t as T } from "./chunks/chart-pie-D8r9HCZ4.js";
+import { t as E } from "./chunks/chart-scatter-CH82md0L.js";
+import { t as D } from "./chunks/chart-radar-R4PuCIWp.js";
+import { t as O } from "./chunks/chart-radial-bar-hmrSFa6O.js";
+import { t as k } from "./chunks/chart-tree-map-CmysE4bF.js";
 export { d as CHART_COLORS, u as CHART_MARGINS, s as DataTable, p as FunnelChart, b as LazyChart, f as NEGATIVE_COLOR, l as POSITIVE_COLOR, x as RechartsAreaChart, C as RechartsBarChart, w as RechartsLineChart, T as RechartsPieChart, D as RechartsRadarChart, O as RechartsRadialBarChart, E as RechartsScatterChart, k as RechartsTreeMapChart, i as clearChartConfigCache, S as formatChartData, g as getAvailableChartTypes, c as getChartConfigAsync, e as getChartConfigSync, v as getUnavailableChartTypes, t as isChartConfigLoaded, h as isChartTypeAvailable, m as isValidChartType, o as loadAllChartConfigs, _ as preloadChart, a as preloadChartConfig, r as preloadChartConfigs, y as preloadCharts, n as useChartConfig };