drizzle-cube 0.5.8 → 0.6.1

package/dist/server/{server/adapters → adapters}/base-adapter.d.ts

@@ -1,26 +1,16 @@
 import { SQL, AnyColumn } from 'drizzle-orm';
-import { TimeGranularity } from '../types';
+import { TimeGranularity } from '../types/index.js';
 /**
  * Database capabilities for feature detection
  * Used for graceful degradation when functions aren't supported
  */
 export interface DatabaseCapabilities {
-    /** Whether the database supports STDDEV_POP/STDDEV_SAMP */
-    supportsStddev: boolean;
-    /** Whether the database supports VAR_POP/VAR_SAMP */
-    supportsVariance: boolean;
     /** Whether the database supports PERCENTILE_CONT or similar */
     supportsPercentile: boolean;
-    /** Whether the database supports window functions (LAG, LEAD, RANK, etc.) */
-    supportsWindowFunctions: boolean;
-    /** Whether the database supports frame clauses (ROWS BETWEEN, RANGE BETWEEN) */
-    supportsFrameClause: boolean;
     /** Whether the database supports LATERAL joins (PostgreSQL 9.3+, MySQL 8.0.14+) */
     supportsLateralJoins: boolean;
     /** Whether percentile functions work in subqueries against CTEs (false for DuckDB) */
     supportsPercentileSubqueries: boolean;
-    /** Whether derived tables (subqueries) work in FROM clauses inside CTEs (false for Databend) */
-    supportsDerivedTablesInCTE: boolean;
     /** Whether correlated LATERAL subqueries can reference CTEs (false for Snowflake) */
     supportsLateralSubqueriesInCTE: boolean;
 }
@@ -50,12 +40,6 @@ export interface DatabaseAdapter {
      * Get the database engine type this adapter supports
      */
     getEngineType(): 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb' | 'databend' | 'snowflake';
-    /**
-     * Check if the database supports LATERAL joins
-     * Required for optimized flow queries with index-backed seeks
-     * @returns true for PostgreSQL 9.3+, MySQL 8.0.14+, SingleStore; false for SQLite
-     */
-    supportsLateralJoins(): boolean;
     /**
      * Build SQL INTERVAL from ISO 8601 duration string
      * Used for time window constraints in funnel analysis
@@ -225,39 +209,100 @@ export interface DatabaseAdapter {
  */
 export declare abstract class BaseDatabaseAdapter implements DatabaseAdapter {
     abstract getEngineType(): 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb' | 'databend' | 'snowflake';
-    abstract supportsLateralJoins(): boolean;
     abstract buildIntervalFromISO(duration: string): SQL;
     abstract buildTimeDifferenceSeconds(end: SQL, start: SQL): SQL;
     abstract buildDateAddInterval(timestamp: SQL, duration: string): SQL;
-    abstract buildConditionalAggregation(aggFn: 'count' | 'avg' | 'min' | 'max' | 'sum', expr: SQL | null, condition: SQL): SQL;
     abstract buildDateDiffPeriods(startDate: SQL, endDate: SQL, unit: 'day' | 'week' | 'month'): SQL;
     abstract buildPeriodSeriesSubquery(maxPeriod: number): SQL;
     abstract buildTimeDimension(granularity: TimeGranularity, fieldExpr: AnyColumn | SQL): SQL;
-    abstract buildStringCondition(fieldExpr: AnyColumn | SQL, operator: 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'like' | 'notLike' | 'ilike' | 'regex' | 'notRegex', value: string): SQL;
     abstract castToType(fieldExpr: AnyColumn | SQL, targetType: 'timestamp' | 'decimal' | 'integer'): SQL;
-    abstract buildAvg(fieldExpr: AnyColumn | SQL): SQL;
-    abstract buildCaseWhen(conditions: Array<{
-        when: SQL;
-        then: any;
-    }>, elseValue?: any): SQL;
-    abstract buildBooleanLiteral(value: boolean): SQL;
-    abstract convertFilterValue(value: any): any;
-    abstract prepareDateValue(date: Date): any;
-    abstract isTimestampInteger(): boolean;
-    abstract convertTimeDimensionResult(value: any): any;
     abstract getCapabilities(): DatabaseCapabilities;
-    abstract buildStddev(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL | null;
-    abstract buildVariance(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL | null;
     abstract buildPercentile(fieldExpr: AnyColumn | SQL, percentile: number): SQL | null;
-    abstract buildWindowFunction(type: WindowFunctionType, fieldExpr: AnyColumn | SQL | null, partitionBy?: (AnyColumn | SQL)[], orderBy?: Array<{
-        field: AnyColumn | SQL;
-        direction: 'asc' | 'desc';
-    }>, config?: WindowFunctionConfig): SQL | null;
     /**
      * Default implementation returns template unchanged
      * Override in specific adapters for database-specific preprocessing
      */
     preprocessCalculatedTemplate(calculatedSql: string): string;
+    /**
+     * Wrap an aggregate so NULL (empty set) becomes 0.
+     * Default uses COALESCE; engines without COALESCE (MySQL/SQLite) override with IFNULL.
+     */
+    protected nullToZero(expr: SQL): SQL;
+    /**
+     * Case-insensitive LIKE matching for contains/startsWith/endsWith/ilike.
+     * Default uses native ILIKE (PostgreSQL/DuckDB/Snowflake); engines without ILIKE
+     * (MySQL/SQLite/Databend) override with LOWER()+LIKE.
+     * @param pattern - the LIKE pattern in its original case (already wrapped with % as needed)
+     */
+    protected caseInsensitiveLike(fieldExpr: AnyColumn | SQL, pattern: string, negated: boolean): SQL;
+    /**
+     * Regular-expression matching. Default uses PostgreSQL's ~* / !~* operators;
+     * each other engine overrides with its own regex syntax (REGEXP, GLOB, regexp_matches, REGEXP_LIKE).
+     */
+    protected regexCondition(fieldExpr: AnyColumn | SQL, value: string, negated: boolean): SQL;
+    /**
+     * Build a string matching condition. The case-insensitive and regex families are
+     * delegated to the caseInsensitiveLike()/regexCondition() hooks; plain LIKE/NOT LIKE
+     * are identical across all engines.
+     */
+    buildStringCondition(fieldExpr: AnyColumn | SQL, operator: 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'like' | 'notLike' | 'ilike' | 'regex' | 'notRegex', value: string): SQL;
+    /**
+     * Build conditional aggregation. Default uses portable CASE WHEN
+     * (MySQL/SQLite/Databend/Snowflake); PostgreSQL/DuckDB override with the FILTER clause.
+     */
+    buildConditionalAggregation(aggFn: 'count' | 'avg' | 'min' | 'max' | 'sum', expr: SQL | null, condition: SQL): SQL;
+    /**
+     * Build AVG with null-to-zero handling (COALESCE/IFNULL via nullToZero()).
+     */
+    buildAvg(fieldExpr: AnyColumn | SQL): SQL;
+    /**
+     * Build CASE WHEN conditional expression.
+     * SQLite overrides this to handle embedded SQL objects in THEN/ELSE.
+     */
+    buildCaseWhen(conditions: Array<{
+        when: SQL;
+        then: any;
+    }>, elseValue?: any): SQL;
+    /**
+     * Build boolean literal. Default uses TRUE/FALSE keywords; SQLite overrides with 1/0.
+     */
+    buildBooleanLiteral(value: boolean): SQL;
+    /**
+     * Convert filter values to database-compatible types.
+     * Default is a pass-through; SQLite overrides to handle booleans/dates as integers.
+     */
+    convertFilterValue(value: any): any;
+    /**
+     * Prepare a Date for storage. Default passes the Date through (native timestamps);
+     * SQLite overrides to convert to integer milliseconds.
+     */
+    prepareDateValue(date: Date): any;
+    /**
+     * Whether timestamps are stored as integers. Default false; SQLite overrides to true.
+     */
+    isTimestampInteger(): boolean;
+    /**
+     * Convert a time-dimension result value. Default is a pass-through.
+     */
+    convertTimeDimensionResult(value: any): any;
+    /**
+     * Build STDDEV aggregation. Default uses STDDEV_POP/STDDEV_SAMP with null-to-zero.
+     * Engines without native STDDEV (SQLite) override to return null.
+     */
+    buildStddev(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL | null;
+    /**
+     * Build VARIANCE aggregation. Default uses VAR_POP/VAR_SAMP with null-to-zero.
+     * SQLite overrides to null; Databend overrides to a COVAR-based workaround.
+     */
+    buildVariance(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL | null;
+    /**
+     * Build a window function expression. Identical across all supported engines
+     * (standard SQL:2003 window syntax), so it lives here as a shared default.
+     */
+    buildWindowFunction(type: WindowFunctionType, fieldExpr: AnyColumn | SQL | null, partitionBy?: (AnyColumn | SQL)[], orderBy?: Array<{
+        field: AnyColumn | SQL;
+        direction: 'asc' | 'desc';
+    }>, config?: WindowFunctionConfig): SQL | null;
     /**
      * Helper method to build pattern for string matching
      * Can be overridden by specific adapters if needed

package/dist/server/adapters/databend-adapter.d.ts

@@ -0,0 +1,63 @@
+import { SQL, AnyColumn } from 'drizzle-orm';
+import { TimeGranularity } from '../types/index.js';
+import { BaseDatabaseAdapter, DatabaseCapabilities } from './base-adapter.js';
+export declare class DatabendAdapter extends BaseDatabaseAdapter {
+    getEngineType(): 'databend';
+    /**
+     * Build Databend INTERVAL from ISO 8601 duration
+     * Databend supports INTERVAL n UNIT syntax (e.g., INTERVAL 7 DAY)
+     */
+    buildIntervalFromISO(duration: string): SQL;
+    /**
+     * Build Databend time difference in seconds
+     * Uses TIMESTAMPDIFF(SECOND, start, end)
+     */
+    buildTimeDifferenceSeconds(end: SQL, start: SQL): SQL;
+    /**
+     * Build Databend timestamp + interval expression
+     * Uses timestamp + INTERVAL n UNIT syntax (Databend doesn't support DATE_ADD function)
+     */
+    buildDateAddInterval(timestamp: SQL, duration: string): SQL;
+    /**
+     * Build Databend date difference in periods using DATE_DIFF
+     */
+    buildDateDiffPeriods(startDate: SQL, endDate: SQL, unit: 'day' | 'week' | 'month'): SQL;
+    /**
+     * Build Databend period series using generate_series via numbers table
+     * Databend has a numbers() table function that can be used similarly
+     */
+    buildPeriodSeriesSubquery(maxPeriod: number): SQL;
+    /**
+     * Build Databend time dimension using DATE_TRUNC function
+     * Databend supports DATE_TRUNC with unquoted granularity keywords
+     */
+    buildTimeDimension(granularity: TimeGranularity, fieldExpr: AnyColumn | SQL): SQL;
+    /**
+     * Databend has no ILIKE — use LOWER()+LIKE with SQL-side LOWER() on the pattern.
+     */
+    protected caseInsensitiveLike(fieldExpr: AnyColumn | SQL, pattern: string, negated: boolean): SQL;
+    /**
+     * Databend regex matching uses the REGEXP operator
+     */
+    protected regexCondition(fieldExpr: AnyColumn | SQL, value: string, negated: boolean): SQL;
+    /**
+     * Build Databend type casting
+     * Databend supports both :: syntax and CAST() function
+     */
+    castToType(fieldExpr: AnyColumn | SQL, targetType: 'timestamp' | 'decimal' | 'integer'): SQL;
+    /**
+     * Databend capabilities - start conservative
+     */
+    getCapabilities(): DatabaseCapabilities;
+    /**
+     * Build Databend VARIANCE aggregation
+     * Databend doesn't have VAR_POP/VAR_SAMP, but COVAR_POP(x,x) = VAR_POP(x)
+     * and COVAR_SAMP(x,x) = VAR_SAMP(x) mathematically
+     */
+    buildVariance(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL;
+    /**
+     * Build Databend PERCENTILE aggregation
+     * Databend may support QUANTILE or PERCENTILE_CONT - start with unsupported
+     */
+    buildPercentile(_fieldExpr: AnyColumn | SQL, _percentile: number): SQL;
+}

package/dist/server/{server/adapters → adapters}/duckdb-adapter.d.ts

@@ -1,6 +1,6 @@
 import { SQL, AnyColumn } from 'drizzle-orm';
-import { TimeGranularity } from '../types';
-import { BaseDatabaseAdapter, DatabaseCapabilities, WindowFunctionType, WindowFunctionConfig } from './base-adapter';
+import { TimeGranularity } from '../types/index.js';
+import { BaseDatabaseAdapter, DatabaseCapabilities } from './base-adapter.js';
 export declare class DuckDBAdapter extends BaseDatabaseAdapter {
     getEngineType(): 'duckdb';
     /**
@@ -8,7 +8,6 @@ export declare class DuckDBAdapter extends BaseDatabaseAdapter {
      * which is required for the LATERAL join strategy in flow queries.
      * Use window function strategy instead.
      */
-    supportsLateralJoins(): boolean;
     /**
      * Build DuckDB INTERVAL from ISO 8601 duration
      * DuckDB supports PostgreSQL-style INTERVAL literal syntax: INTERVAL '7 days'
@@ -25,9 +24,8 @@ export declare class DuckDBAdapter extends BaseDatabaseAdapter {
      */
     buildDateAddInterval(timestamp: SQL, duration: string): SQL;
     /**
-     * Build DuckDB conditional aggregation using CASE WHEN
-     * DuckDB supports FILTER clause, but CASE WHEN provides broader compatibility
-     * Using FILTER clause as DuckDB does support it
+     * Build DuckDB conditional aggregation using the FILTER clause
+     * DuckDB supports the standard SQL FILTER clause like PostgreSQL
      */
     buildConditionalAggregation(aggFn: 'count' | 'avg' | 'min' | 'max' | 'sum', expr: SQL | null, condition: SQL): SQL;
     /**
@@ -46,48 +44,14 @@ export declare class DuckDBAdapter extends BaseDatabaseAdapter {
      */
     buildTimeDimension(granularity: TimeGranularity, fieldExpr: AnyColumn | SQL): SQL;
     /**
-     * Build DuckDB string matching conditions using ILIKE (case-insensitive)
-     * DuckDB supports ILIKE like PostgreSQL
+     * DuckDB uses function-style regex matching: regexp_matches(field, pattern)
      */
-    buildStringCondition(fieldExpr: AnyColumn | SQL, operator: 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'like' | 'notLike' | 'ilike' | 'regex' | 'notRegex', value: string): SQL;
+    protected regexCondition(fieldExpr: AnyColumn | SQL, value: string, negated: boolean): SQL;
     /**
      * Build DuckDB type casting
      * DuckDB supports both :: syntax and CAST() function
      */
     castToType(fieldExpr: AnyColumn | SQL, targetType: 'timestamp' | 'decimal' | 'integer'): SQL;
-    /**
-     * Build DuckDB AVG aggregation with COALESCE for NULL handling
-     */
-    buildAvg(fieldExpr: AnyColumn | SQL): SQL;
-    /**
-     * Build DuckDB CASE WHEN conditional expression
-     */
-    buildCaseWhen(conditions: Array<{
-        when: SQL;
-        then: any;
-    }>, elseValue?: any): SQL;
-    /**
-     * Build DuckDB boolean literal
-     * DuckDB uses TRUE/FALSE keywords
-     */
-    buildBooleanLiteral(value: boolean): SQL;
-    /**
-     * Convert filter values - DuckDB uses native types
-     */
-    convertFilterValue(value: any): any;
-    /**
-     * Prepare date value for DuckDB
-     * DuckDB accepts Date objects directly
-     */
-    prepareDateValue(date: Date): any;
-    /**
-     * DuckDB stores timestamps as native timestamp types
-     */
-    isTimestampInteger(): boolean;
-    /**
-     * DuckDB time dimensions already return proper values
-     */
-    convertTimeDimensionResult(value: any): any;
     /**
      * DuckDB has full support for statistical and window functions
      * Note: supportsPercentileSubqueries is false because DuckDB's QUANTILE_CONT
@@ -96,27 +60,9 @@ export declare class DuckDBAdapter extends BaseDatabaseAdapter {
      * LIMIT in correlated subqueries, which is required for flow query LATERAL joins
      */
     getCapabilities(): DatabaseCapabilities;
-    /**
-     * Build DuckDB STDDEV aggregation
-     * Uses STDDEV_POP for population, STDDEV_SAMP for sample
-     */
-    buildStddev(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL;
-    /**
-     * Build DuckDB VARIANCE aggregation
-     * Uses VAR_POP for population, VAR_SAMP for sample
-     */
-    buildVariance(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL;
     /**
      * Build DuckDB PERCENTILE aggregation
      * DuckDB uses QUANTILE_CONT instead of PERCENTILE_CONT
      */
     buildPercentile(fieldExpr: AnyColumn | SQL, percentile: number): SQL;
-    /**
-     * Build DuckDB window function expression
-     * DuckDB has full window function support
-     */
-    buildWindowFunction(type: WindowFunctionType, fieldExpr: AnyColumn | SQL | null, partitionBy?: (AnyColumn | SQL)[], orderBy?: Array<{
-        field: AnyColumn | SQL;
-        direction: 'asc' | 'desc';
-    }>, config?: WindowFunctionConfig): SQL;
 }

package/dist/server/adapters/mysql-adapter.d.ts

@@ -0,0 +1,65 @@
+import { SQL, AnyColumn } from 'drizzle-orm';
+import { TimeGranularity } from '../types/index.js';
+import { BaseDatabaseAdapter, DatabaseCapabilities } from './base-adapter.js';
+export declare class MySQLAdapter extends BaseDatabaseAdapter {
+    getEngineType(): 'mysql' | 'singlestore';
+    /**
+     * Build MySQL INTERVAL from ISO 8601 duration
+     * MySQL has no standalone interval literal usable in arithmetic, so we convert
+     * to total seconds for consistent handling.
+     */
+    buildIntervalFromISO(duration: string): SQL;
+    /**
+     * Build MySQL time difference in seconds using TIMESTAMPDIFF
+     * Returns (end - start) as seconds
+     */
+    buildTimeDifferenceSeconds(end: SQL, start: SQL): SQL;
+    /**
+     * Build MySQL timestamp + interval expression
+     * Uses a chain of DATE_ADD calls, one per duration component
+     */
+    buildDateAddInterval(timestamp: SQL, duration: string): SQL;
+    /**
+     * Build MySQL date difference in periods using TIMESTAMPDIFF
+     * For retention analysis period calculations
+     */
+    buildDateDiffPeriods(startDate: SQL, endDate: SQL, unit: 'day' | 'week' | 'month'): SQL;
+    /**
+     * Build MySQL period series using recursive CTE
+     * MySQL 8.0+ supports recursive CTEs for generating sequences
+     */
+    buildPeriodSeriesSubquery(maxPeriod: number): SQL;
+    /**
+     * Build MySQL time dimension using DATE_FORMAT function
+     * MySQL equivalent to PostgreSQL's DATE_TRUNC
+     */
+    buildTimeDimension(granularity: TimeGranularity, fieldExpr: AnyColumn | SQL): SQL;
+    /**
+     * MySQL has no ILIKE — use LOWER()+LIKE with the pattern lowercased in JS.
+     */
+    protected caseInsensitiveLike(fieldExpr: AnyColumn | SQL, pattern: string, negated: boolean): SQL;
+    /**
+     * MySQL regex matching uses the REGEXP operator
+     */
+    protected regexCondition(fieldExpr: AnyColumn | SQL, value: string, negated: boolean): SQL;
+    /**
+     * Build MySQL type casting using CAST() function
+     * MySQL equivalent to PostgreSQL's :: casting syntax
+     */
+    castToType(fieldExpr: AnyColumn | SQL, targetType: 'timestamp' | 'decimal' | 'integer'): SQL;
+    /**
+     * MySQL AVG/STDDEV/VARIANCE use IFNULL (no COALESCE-for-zero idiom mismatch,
+     * but IFNULL is the MySQL-idiomatic null guard).
+     */
+    protected nullToZero(expr: SQL): SQL;
+    /**
+     * MySQL 8.0+ has support for statistical and window functions
+     * but not PERCENTILE_CONT
+     */
+    getCapabilities(): DatabaseCapabilities;
+    /**
+     * MySQL does not support PERCENTILE_CONT
+     * Returns null for graceful degradation
+     */
+    buildPercentile(_fieldExpr: AnyColumn | SQL, _percentile: number): SQL | null;
+}

package/dist/server/adapters/postgres-adapter.d.ts

@@ -0,0 +1,55 @@
+import { SQL, AnyColumn } from 'drizzle-orm';
+import { TimeGranularity } from '../types/index.js';
+import { BaseDatabaseAdapter, DatabaseCapabilities } from './base-adapter.js';
+export declare class PostgresAdapter extends BaseDatabaseAdapter {
+    getEngineType(): 'postgres';
+    /**
+     * Build PostgreSQL INTERVAL from ISO 8601 duration
+     * PostgreSQL supports INTERVAL literal syntax: INTERVAL '7 days'
+     */
+    buildIntervalFromISO(duration: string): SQL;
+    /**
+     * Build PostgreSQL time difference in seconds using EXTRACT(EPOCH FROM ...)
+     * Returns (end - start) as seconds
+     */
+    buildTimeDifferenceSeconds(end: SQL, start: SQL): SQL;
+    /**
+     * Build PostgreSQL timestamp + interval expression
+     */
+    buildDateAddInterval(timestamp: SQL, duration: string): SQL;
+    /**
+     * Build PostgreSQL conditional aggregation using FILTER clause
+     * PostgreSQL supports the standard SQL FILTER clause for efficient conditional aggregation
+     * Example: AVG(time_diff) FILTER (WHERE step_1_time IS NOT NULL)
+     */
+    buildConditionalAggregation(aggFn: 'count' | 'avg' | 'min' | 'max' | 'sum', expr: SQL | null, condition: SQL): SQL;
+    /**
+     * Build PostgreSQL date difference in periods using AGE and EXTRACT
+     * For retention analysis period calculations
+     */
+    buildDateDiffPeriods(startDate: SQL, endDate: SQL, unit: 'day' | 'week' | 'month'): SQL;
+    /**
+     * Build PostgreSQL period series using generate_series
+     * PostgreSQL's generate_series returns a set directly usable as a table
+     */
+    buildPeriodSeriesSubquery(maxPeriod: number): SQL;
+    /**
+     * Build PostgreSQL time dimension using DATE_TRUNC function
+     * Extracted from executor.ts:649-670 and multi-cube-builder.ts:306-320
+     */
+    buildTimeDimension(granularity: TimeGranularity, fieldExpr: AnyColumn | SQL): SQL;
+    /**
+     * Build PostgreSQL type casting using :: syntax
+     * Extracted from various locations where ::timestamp was used
+     */
+    castToType(fieldExpr: AnyColumn | SQL, targetType: 'timestamp' | 'decimal' | 'integer'): SQL;
+    /**
+     * PostgreSQL has full support for statistical and window functions
+     */
+    getCapabilities(): DatabaseCapabilities;
+    /**
+     * Build PostgreSQL PERCENTILE_CONT aggregation
+     * Uses ordered-set aggregate function
+     */
+    buildPercentile(fieldExpr: AnyColumn | SQL, percentile: number): SQL;
+}

package/dist/server/{server/adapters → adapters}/singlestore-adapter.d.ts

@@ -1,4 +1,4 @@
-import { MySQLAdapter } from './mysql-adapter';
+import { MySQLAdapter } from './mysql-adapter.js';
 export declare class SingleStoreAdapter extends MySQLAdapter {
     getEngineType(): 'singlestore';
 }

package/dist/server/adapters/snowflake-adapter.d.ts

@@ -0,0 +1,53 @@
+import { SQL, AnyColumn } from 'drizzle-orm';
+import { TimeGranularity } from '../types/index.js';
+import { BaseDatabaseAdapter, DatabaseCapabilities } from './base-adapter.js';
+export declare class SnowflakeAdapter extends BaseDatabaseAdapter {
+    getEngineType(): 'snowflake';
+    /**
+     * Build Snowflake INTERVAL from ISO 8601 duration
+     * Snowflake doesn't have a standalone INTERVAL type like PostgreSQL.
+     * We convert to total seconds for use in DATEADD; callers should prefer buildDateAddInterval.
+     */
+    buildIntervalFromISO(duration: string): SQL;
+    /**
+     * Build Snowflake time difference in seconds
+     * Uses DATEDIFF('SECOND', start, end)
+     */
+    buildTimeDifferenceSeconds(end: SQL, start: SQL): SQL;
+    /**
+     * Build Snowflake timestamp + interval expression
+     * Uses chained DATEADD(unit, amount, timestamp) calls
+     */
+    buildDateAddInterval(timestamp: SQL, duration: string): SQL;
+    /**
+     * Build Snowflake date difference in periods using DATEDIFF
+     */
+    buildDateDiffPeriods(startDate: SQL, endDate: SQL, unit: 'day' | 'week' | 'month'): SQL;
+    /**
+     * Build Snowflake period series using TABLE(GENERATOR(ROWCOUNT => n)) + ROW_NUMBER()
+     */
+    buildPeriodSeriesSubquery(maxPeriod: number): SQL;
+    /**
+     * Build Snowflake time dimension using DATE_TRUNC function
+     * Snowflake supports DATE_TRUNC with quoted granularity like PostgreSQL
+     */
+    buildTimeDimension(granularity: TimeGranularity, fieldExpr: AnyColumn | SQL): SQL;
+    /**
+     * Snowflake uses function-style regex matching: REGEXP_LIKE(field, pattern)
+     */
+    protected regexCondition(fieldExpr: AnyColumn | SQL, value: string, negated: boolean): SQL;
+    /**
+     * Build Snowflake type casting using :: syntax
+     * Snowflake supports both :: syntax and CAST() function
+     */
+    castToType(fieldExpr: AnyColumn | SQL, targetType: 'timestamp' | 'decimal' | 'integer'): SQL;
+    /**
+     * Snowflake capabilities - full SQL support
+     */
+    getCapabilities(): DatabaseCapabilities;
+    /**
+     * Build Snowflake PERCENTILE_CONT aggregation
+     * Uses ordered-set aggregate function
+     */
+    buildPercentile(fieldExpr: AnyColumn | SQL, percentile: number): SQL;
+}

package/dist/server/{server/adapters → adapters}/sqlite-adapter.d.ts

@@ -1,13 +1,8 @@
 import { SQL, AnyColumn } from 'drizzle-orm';
-import { TimeGranularity } from '../types';
-import { BaseDatabaseAdapter, DatabaseCapabilities, WindowFunctionType, WindowFunctionConfig } from './base-adapter';
+import { TimeGranularity } from '../types/index.js';
+import { BaseDatabaseAdapter, DatabaseCapabilities } from './base-adapter.js';
 export declare class SQLiteAdapter extends BaseDatabaseAdapter {
     getEngineType(): 'sqlite';
-    /**
-     * SQLite does not support LATERAL joins
-     * Flow queries require LATERAL for efficient execution and are not supported on SQLite
-     */
-    supportsLateralJoins(): boolean;
     /**
      * Build SQLite INTERVAL from ISO 8601 duration
      * SQLite doesn't have native interval types, so we convert to seconds
@@ -25,12 +20,6 @@ export declare class SQLiteAdapter extends BaseDatabaseAdapter {
      * Since SQLite stores timestamps as Unix seconds, just add the seconds
      */
     buildDateAddInterval(timestamp: SQL, duration: string): SQL;
-    /**
-     * Build SQLite conditional aggregation using CASE WHEN
-     * SQLite doesn't support FILTER clause, so we use CASE WHEN pattern
-     * Example: AVG(CASE WHEN step_1_time IS NOT NULL THEN time_diff END)
-     */
-    buildConditionalAggregation(aggFn: 'count' | 'avg' | 'min' | 'max' | 'sum', expr: SQL | null, condition: SQL): SQL;
     /**
      * Build SQLite date difference in periods
      * SQLite uses Julian day calculations for date arithmetic
@@ -50,22 +39,26 @@ export declare class SQLiteAdapter extends BaseDatabaseAdapter {
      */
     buildTimeDimension(granularity: TimeGranularity, fieldExpr: AnyColumn | SQL): SQL;
     /**
-     * Build SQLite string matching conditions using LOWER() + LIKE for case-insensitive matching
-     * SQLite LIKE is case-insensitive by default, but LOWER() ensures consistency
+     * SQLite has no ILIKE — use LOWER()+LIKE with the pattern lowercased in JS.
+     */
+    protected caseInsensitiveLike(fieldExpr: AnyColumn | SQL, pattern: string, negated: boolean): SQL;
+    /**
+     * SQLite regex requires loading an extension, so GLOB is used as a fallback.
      */
-    buildStringCondition(fieldExpr: AnyColumn | SQL, operator: 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'like' | 'notLike' | 'ilike' | 'regex' | 'notRegex', value: string): SQL;
+    protected regexCondition(fieldExpr: AnyColumn | SQL, value: string, negated: boolean): SQL;
     /**
      * Build SQLite type casting using CAST() function
      * SQLite has dynamic typing but supports CAST for consistency
      */
     castToType(fieldExpr: AnyColumn | SQL, targetType: 'timestamp' | 'decimal' | 'integer'): SQL;
     /**
-     * Build SQLite AVG aggregation with IFNULL for NULL handling
-     * SQLite AVG returns NULL for empty sets, using IFNULL for consistency
+     * SQLite AVG uses IFNULL rather than COALESCE for null-to-zero handling.
      */
-    buildAvg(fieldExpr: AnyColumn | SQL): SQL;
+    protected nullToZero(expr: SQL): SQL;
     /**
-     * Build SQLite CASE WHEN conditional expression
+     * Build SQLite CASE WHEN conditional expression.
+     * Unlike the base implementation, SQLite must detect embedded SQL objects in THEN/ELSE
+     * and inline them rather than binding them as parameters.
      */
     buildCaseWhen(conditions: Array<{
         when: SQL;
@@ -104,11 +97,6 @@ export declare class SQLiteAdapter extends BaseDatabaseAdapter {
      * SQLite stores timestamps as integers (milliseconds)
      */
     isTimestampInteger(): boolean;
-    /**
-     * Convert SQLite time dimension results back to Date objects
-     * SQLite time dimensions return datetime strings, but clients expect Date objects
-     */
-    convertTimeDimensionResult(value: any): any;
     /**
      * SQLite has limited statistical support (no native STDDEV/VARIANCE/PERCENTILE)
      * but supports window functions since SQLite 3.25
@@ -129,12 +117,4 @@ export declare class SQLiteAdapter extends BaseDatabaseAdapter {
      * Returns null for graceful degradation
      */
     buildPercentile(_fieldExpr: AnyColumn | SQL, _percentile: number): SQL | null;
-    /**
-     * Build SQLite window function expression
-     * SQLite 3.25+ supports window functions
-     */
-    buildWindowFunction(type: WindowFunctionType, fieldExpr: AnyColumn | SQL | null, partitionBy?: (AnyColumn | SQL)[], orderBy?: Array<{
-        field: AnyColumn | SQL;
-        direction: 'asc' | 'desc';
-    }>, config?: WindowFunctionConfig): SQL;
 }

package/dist/server/adapters/window-function-builder.d.ts

@@ -0,0 +1,11 @@
+import { SQL, AnyColumn } from 'drizzle-orm';
+import { WindowFunctionType, WindowFunctionConfig } from './base-adapter.js';
+type FieldExpr = AnyColumn | SQL | null;
+/** Build the full `OVER (...)` clause from partition/order/frame components. */
+export declare function buildWindowOverClause(partitionBy?: (AnyColumn | SQL)[], orderBy?: Array<{
+    field: AnyColumn | SQL;
+    direction: 'asc' | 'desc';
+}>, config?: WindowFunctionConfig): SQL;
+/** Build the window function expression for a given type and pre-built OVER clause. */
+export declare function buildWindowExpression(type: WindowFunctionType, fieldExpr: FieldExpr, over: SQL, config?: WindowFunctionConfig): SQL;
+export {};

package/dist/server/{server/agent → agent}/chart-validation.d.ts

@@ -13,11 +13,6 @@ interface ValidationResult {
  * Validate chartConfig against the chart type's drop zone requirements.
  */
 export declare function validateChartConfig(chartType: string, chartConfig: Record<string, unknown> | undefined, _query: Record<string, unknown>): ValidationResult;
-/**
- * Auto-infer missing chartConfig fields from the query structure.
- * Fills in xAxis, yAxis, series, sizeField, etc. based on query measures/dimensions
- * and the chart type's drop zone acceptTypes.
- */
 export declare function inferChartConfig(chartType: string, chartConfig: Record<string, unknown> | undefined, query: Record<string, unknown>): Record<string, unknown>;
 /**
  * Build per-chart-type requirements text for the agent tool description.

package/dist/server/agent/handler-steps.d.ts

@@ -0,0 +1,37 @@
+import { AgentSSEEvent, AgentHistoryMessage, AgentConfig } from './types.js';
+import { ContentBlock, InternalMessage, ToolResult, LLMProvider } from './providers/types.js';
+import { ToolExecutionResult } from './tools.js';
+type AgentObservability = AgentConfig['observability'];
+type ToolExecutorMap = Map<string, (input: Record<string, unknown>) => Promise<ToolExecutionResult>>;
+/** Push provider-formatted tool results onto the message list (array or single). */
+export declare function pushFormattedResults(messages: InternalMessage[], formatted: unknown): void;
+/** Run an observability callback, swallowing any error (must never break the agent). */
+export declare function safeObserve(fn: (() => void) | undefined): void;
+/** Rebuild conversation messages from stored history (e.g. after notebook reload). */
+export declare function rebuildMessagesFromHistory(history: AgentHistoryMessage[] | undefined, provider: LLMProvider): InternalMessage[];
+/** Accumulated result of consuming one assistant generation stream. */
+export interface ConsumedStream {
+    contentBlocks: ContentBlock[];
+    stopReason: string;
+    inputTokens?: number;
+    outputTokens?: number;
+}
+/**
+ * Consume a provider's normalized stream, accumulating the assistant's content
+ * blocks and yielding text/tool SSE events. Returns the accumulated blocks,
+ * stop reason and token usage.
+ */
+export declare function consumeAssistantStream(provider: LLMProvider, stream: AsyncIterable<unknown>): AsyncGenerator<AgentSSEEvent, ConsumedStream>;
+/** Context shared across tool executions within a single turn. */
+export interface ToolExecContext {
+    executor: ToolExecutorMap;
+    observability: AgentObservability;
+    traceId: string;
+    turn: number;
+}
+/**
+ * Execute all tool-use blocks in the assistant's response, yielding their SSE
+ * events and returning the collected ToolResults.
+ */
+export declare function executeToolCalls(contentBlocks: ContentBlock[], ctx: ToolExecContext): AsyncGenerator<AgentSSEEvent, ToolResult[]>;
+export {};