drizzle-cube 0.9.5 → 0.9.7

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

@@ -103,7 +103,7 @@ export interface DatabaseAdapter {
      * @param value - The value to match
      * @returns SQL expression for string matching
      */
-    buildStringCondition(fieldExpr: AnyColumn | SQL, operator: 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'like' | 'notLike' | 'ilike' | 'regex' | 'notRegex', value: string): SQL;
+    buildStringCondition(fieldExpr: AnyColumn | SQL, operator: 'contains' | 'notContains' | 'startsWith' | 'notStartsWith' | 'endsWith' | 'notEndsWith' | 'like' | 'notLike' | 'ilike' | 'regex' | 'notRegex', value: string): SQL;
     /**
      * Cast expression to specific database type
      * @param fieldExpr - The field expression to cast
@@ -241,7 +241,7 @@ export declare abstract class BaseDatabaseAdapter implements DatabaseAdapter {
      */
     protected nullToZero(expr: SQL): SQL;
     /**
-     * Case-insensitive LIKE matching for contains/startsWith/endsWith/ilike.
+     * Case-insensitive LIKE matching for (not)contains/(not)startsWith/(not)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)
@@ -257,7 +257,7 @@ export declare abstract class BaseDatabaseAdapter implements DatabaseAdapter {
      * 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;
+    buildStringCondition(fieldExpr: AnyColumn | SQL, operator: 'contains' | 'notContains' | 'startsWith' | 'notStartsWith' | 'endsWith' | 'notEndsWith' | '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.

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

@@ -45,7 +45,7 @@ export declare const QUERY_PARAMS_SCHEMA: {
                 readonly values: {
                     readonly type: "array";
                     readonly items: {};
-                    readonly description: "Filter values. Omit for set/notSet/isEmpty/isNotEmpty.";
+                    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 required: readonly ["member", "operator"];
@@ -64,10 +64,10 @@ export declare const QUERY_PARAMS_SCHEMA: {
                 readonly granularity: {
                     readonly type: "string";
                     readonly enum: readonly ["second", "minute", "hour", "day", "week", "month", "quarter", "year"];
-                    readonly description: "Time bucket size. REQUIRED for time series; omit only for date range filtering.";
+                    readonly description: "Time bucket size. REQUIRED for time series. Without it the time dimension is a date-range filter only (no time column, no grouping).";
                 };
                 readonly dateRange: {
-                    readonly description: "Relative string (\"last 7 days\", \"this month\", \"last quarter\") or absolute tuple [\"YYYY-MM-DD\", \"YYYY-MM-DD\"]";
+                    readonly description: "Relative string (\"today\", \"last 7 days\", \"this month\", \"last quarter\", \"next week\", \"last N days|weeks|months|quarters|years\"), a single \"YYYY-MM-DD\", or absolute tuple [\"YYYY-MM-DD\", \"YYYY-MM-DD\"]. Unrecognised strings are rejected.";
                 };
                 readonly fillMissingDates: {
                     readonly type: "boolean";

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

@@ -18,8 +18,7 @@ export declare class DateTimeBuilder {
     private buildArrayDateRangeCondition;
     private buildStringDateRangeCondition;
     /**
-     * Parse relative date range expressions like "today", "yesterday", "last 7 days", "this month", etc.
-     * Handles all 14 DATE_RANGE_OPTIONS from the client
+     * Parse relative date range expressions like "today", "yesterday", "last 7 days", "this month", "next week", etc.
      */
     parseRelativeDateRange(dateRange: string): {
         start: Date;

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

@@ -22,13 +22,26 @@ export declare function isDateOnlyString(value: unknown): value is string;
  * unparseable.
  */
 export declare function normalizeDateValue(databaseAdapter: DatabaseAdapter, value: any): string | number | null;
-type DateRange = {
+/**
+ * Parse relative date range expressions like "today", "yesterday",
+ * "last 7 days", "this month", "next week", etc. Delegates to the shared parser
+ * so the server, gap filler and client resolve the same strings identically.
+ */
+export declare function parseRelativeDateRangeValue(dateRange: string): {
     start: Date;
     end: Date;
-};
+} | null;
 /**
- * Parse relative date range expressions like "today", "yesterday",
- * "last 7 days", "this month", etc. Handles all 14 DATE_RANGE_OPTIONS.
+ * Whether a value parses as a single absolute date (string, number or Date) —
+ * the same test `normalizeDateValue` applies before building SQL.
+ */
+export declare function isValidDateValue(value: unknown): boolean;
+/**
+ * Whether a date-range expression resolves to concrete bounds exactly as
+ * `DateTimeBuilder.buildDateRangeCondition` would resolve it:
+ * - a relative string ('last 7 days', 'this month', 'next week', ...)
+ * - a single absolute date string (that whole day)
+ * - a one-element array holding either of the above
+ * - a `[start, end]` pair of absolute dates
  */
-export declare function parseRelativeDateRangeValue(dateRange: string): DateRange | null;
-export {};
+export declare function isResolvableDateRange(dateRange: unknown): boolean;

package/dist/server/builders/filter-operators.d.ts

@@ -16,8 +16,17 @@ export interface FilterOperatorContext {
     databaseAdapter: DatabaseAdapter;
     dateTimeBuilder: DateTimeBuilder;
 }
+/** Every operator the SQL layer can build, in declaration order. */
+export declare const SUPPORTED_FILTER_OPERATORS: FilterOperator[];
+/** Type guard: whether `operator` is a filter operator the SQL layer can build. */
+export declare function isSupportedFilterOperator(operator: unknown): operator is FilterOperator;
+/**
+ * Operators that test the field itself and take no values (`values` may be
+ * omitted or empty).
+ */
+export declare const NO_VALUE_FILTER_OPERATORS: ReadonlySet<FilterOperator>;
 /**
  * Dispatch a single filter operator to its handler. Returns null for any
- * unknown operator (matching the original `default` case).
+ * unknown operator (validation rejects those before SQL is built).
  */
 export declare function applyFilterOperator(operator: FilterOperator, ctx: FilterOperatorContext): SQL | null;

package/dist/server/execution/query-normalizer.d.ts

@@ -0,0 +1,9 @@
+import { SemanticQuery, TimeDimension } from '../types/index.js';
+/** Whether a timeDimension only restricts the date range (no granularity, no comparison). */
+export declare function isFilterOnlyTimeDimension(timeDimension: TimeDimension): boolean;
+/**
+ * Rewrite granularity-less timeDimensions into equivalent `inDateRange`
+ * filters, dropping them from the selection. Returns the query unchanged when
+ * there is nothing to rewrite.
+ */
+export declare function normalizeFilterOnlyTimeDimensions(query: SemanticQuery): SemanticQuery;