@effectuate/cubejs-mongosql-driver 1.0.0

package/dist/MongoSqlQuery.js

@@ -0,0 +1,551 @@
+"use strict";
+/**
+ * MongoSqlQuery — Cube SQL dialect for MongoSQL.
+ *
+ * See SPEC.md FR-2 and ARCHITECTURE.md §4.1. Reference:
+ * https://www.mongodb.com/docs/sql-interface/language-reference/
+ *
+ * T12a scope: STATIC SYNTAX — identifier quoting, type names, timestamp
+ * casts, timezone passthrough, NULL/param tokens.
+ * T12b scope: DATE ARITHMETIC, INTERVALS, time-series generation,
+ * date-truncation, dateBin, unixTimestampSql.
+ *
+ * MongoSQL date-function audit (verified against mongosql v1.8.5 source —
+ * `mongosql/src/ast/definitions.rs` `FunctionName::try_from` and
+ * `algebrize_date_function`, plus `ast/rewrites/test.rs`):
+ *
+ * | Function       | Signature                                              | Notes                                                              |
+ * |----------------|--------------------------------------------------------|--------------------------------------------------------------------|
+ * | DATEADD        | DATEADD(<date_part>, <numeric>, <date>)                | TIMESTAMPADD is an alias.                                          |
+ * | DATEDIFF       | DATEDIFF(<date_part>, <start>, <end>[, <start_of_week>]) | Returns LONG. TIMESTAMPDIFF is an alias.                         |
+ * | DATETRUNC      | DATETRUNC(<date_part>, <date>[, <start_of_week>])      | TIMESTAMPTRUNC is an alias.                                        |
+ * | EXTRACT        | EXTRACT(<date_part> FROM <date>)                       | Supports YEAR/MONTH/WEEK/DAY/HOUR/MINUTE/SECOND/MILLISECOND/...    |
+ * | YEAR/MONTH/... | YEAR(d), MONTH(d), ... — rewritten to EXTRACT          | All datepart helpers map to EXTRACT.                               |
+ * | CURRENT_TIMESTAMP | CURRENT_TIMESTAMP[(<precision>)]                    | SQL-92 keyword. Replaces NOW().                                    |
+ *
+ * <date_part> for DATEADD / DATEDIFF / DATETRUNC must be one of:
+ *   YEAR | QUARTER | MONTH | WEEK | DAY | HOUR | MINUTE | SECOND | MILLISECOND
+ * (mongosql `DatePart` enum; `IsoWeek`/`DayOfYear` are EXTRACT-only and
+ * panic for date-functions per `algebrize_date_function`.)
+ *
+ * NOT available in MongoSQL (called out so future maintainers don't try):
+ *   - `INTERVAL '1 day'` literals — REJECTED by parser.
+ *   - `EXTRACT(EPOCH FROM ...)` — EPOCH is not a `DatePart`.
+ *   - `AT TIME ZONE` / `CONVERT_TZ` — no SQL-level timezone function.
+ *   - `VALUES (...)` table constructors — no parser support.
+ *   - `WITH RECURSIVE` / `generate_series` — no recursive CTEs.
+ * For each gap, see the override below for the closest viable substitute.
+ *
+ * BaseQuery method-list audit (against
+ * `node_modules/@cubejs-backend/schema-compiler/dist/src/adapter/BaseQuery.js`,
+ * cross-checked against `MysqlQuery.js` and `PostgresQuery.js`):
+ *
+ * | BaseQuery method                          | T12a/b action     | Why                                                                 |
+ * |-------------------------------------------|-------------------|---------------------------------------------------------------------|
+ * | escapeColumnName(name)                    | OVERRIDE (T12a)   | Default emits double-quoted ident; MongoSQL uses backticks.         |
+ * | quoteIdentifier(name)                     | ADD (alias) (T12a)| Not on BaseQuery, but task spec + driver doc-comment expect it.     |
+ * | autoPrefixWithCubeName(c, sql, isExpr)    | OVERRIDE (T19a)   | mongosql v1.8.5 rejects `<alias>.<col>` outside JOIN scope (3008).  |
+ * | timeStampCast(value)                      | OVERRIDE (T12a)   | Base emits `value::timestamptz` (Postgres). Mongosql has no `::`.   |
+ * | dateTimeCast(value)                       | OVERRIDE (T12a)   | Base emits `value::timestamp` (Postgres) — invalid in MongoSQL.     |
+ * | timeStampParam(td)                        | INHERIT           | Default delegates to timeStampCast — fine once we override that.    |
+ * | timestampFormat()                         | INHERIT           | ISO-8601 default matches mongosql's accepted CAST literal form.     |
+ * | castToString(sql)                         | OVERRIDE (T12a)   | Base emits `CAST(.. as TEXT)`; MongoSQL spells it `STRING`.         |
+ * | convertTz(field)                          | OVERRIDE (T12a)   | MongoSQL has no AT TIME ZONE / CONVERT_TZ. UTC-only passthrough.    |
+ * | inDbTimeZone(date)                        | INHERIT           | Pure JS — converts JS-side; no SQL emitted.                         |
+ * | nowTimestampSql()                         | OVERRIDE (T12a)   | Base emits `NOW()`; MongoSQL spells it `CURRENT_TIMESTAMP`.         |
+ * | unixTimestampSql()                        | OVERRIDE (T12b)   | Base uses EXTRACT(EPOCH ...) — not in MongoSQL. Use DATEDIFF.       |
+ * | concatStringsSql(strings)                 | INHERIT           | Default uses `||` template; MongoSQL accepts `||` for concat.       |
+ * | sqlTemplates()                            | OVERRIDE (T12a)   | Patch quotes/identifiers + types.* to MongoSQL spellings.           |
+ * | timeGroupedColumn(g, dim)                 | OVERRIDE (T12b)   | Use DATETRUNC. Week pinned to 'sunday' for determinism.             |
+ * | dateBin(interval, source, origin)         | OVERRIDE (T12b)   | DATEADD(unit, FLOOR(DATEDIFF/N)*N, origin) — no INTERVAL literals.  |
+ * | subtractInterval / addInterval            | OVERRIDE (T12b)   | DATEADD with positive/negative numeric. Compound = chained calls.   |
+ * | intervalString(interval)                  | OVERRIDE (T12b)   | Quote-and-pass; no INTERVAL keyword. Used only in error/diag paths. |
+ * | seriesSql(td)                             | OVERRIDE (T12b)   | UNION ALL of literal rows (MysqlQuery pattern, CAST not TIMESTAMP). |
+ * | newFilter(f)                              | OVERRIDE (Gap 4)  | Return MongoSqlFilter — rewrites ILIKE (unsupported) to LOWER+LIKE. |
+ * | newParamAllocator(p)                      | INHERIT           | Default `?` placeholder works for MongoSQL.                         |
+ * | escapeColumnName-driven preAggTableName   | INHERIT           | Inherited tableName logic produces backtick-safe identifiers.       |
+ *
+ * Anything not in this table is BaseQuery default behaviour and is either
+ * (a) provably valid MongoSQL or (b) routed through the overrides above.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoSqlFilter = exports.MongoSqlQuery = void 0;
+const schema_compiler_1 = require("@cubejs-backend/schema-compiler");
+/**
+ * Inlined re-implementation of `@cubejs-backend/shared`'s `parseSqlInterval`.
+ * The shared package isn't a direct dep (only transitive via schema-compiler),
+ * and the function is a 10-line string-split — inlining avoids pulling in
+ * the entire shared package and keeps the dialect's resolver-friendly.
+ *
+ * Source pattern (matches shared@1.6.44 `dist/src/time.js::parseSqlInterval`):
+ *   "1 year 6 months" -> { year: 1, month: 6 }
+ *   Negative values are supported.
+ */
+function parseSqlInterval(intervalStr) {
+    const out = {};
+    const parts = intervalStr.trim().split(/\s+/);
+    for (let i = 0; i < parts.length; i += 2) {
+        const value = parseInt(parts[i], 10);
+        const unit = (parts[i + 1] ?? '').toLowerCase();
+        if (!unit || Number.isNaN(value)) {
+            throw new Error(`Cannot parse interval segment "${parts[i]} ${parts[i + 1] ?? ''}" in "${intervalStr}"`);
+        }
+        const singular = unit.endsWith('s') ? unit.slice(0, -1) : unit;
+        out[singular] = value;
+    }
+    return out;
+}
+/**
+ * Map from Cube's lowercase granularity names to MongoSQL's documented
+ * `DatePart` tokens (uppercase). Matches PostgresQuery's `GRANULARITY_TO_INTERVAL`
+ * spirit but uses MongoSQL's spellings.
+ */
+const GRANULARITY_TO_DATE_PART = Object.freeze({
+    second: 'SECOND',
+    minute: 'MINUTE',
+    hour: 'HOUR',
+    day: 'DAY',
+    week: 'WEEK',
+    month: 'MONTH',
+    quarter: 'QUARTER',
+    year: 'YEAR',
+});
+/**
+ * Map from `parseSqlInterval` keys (singular, lowercase) to MongoSQL DATEADD
+ * date-part tokens. Includes `millisecond` because mongosql DATEADD supports
+ * MILLISECOND (per `DatePart` enum).
+ */
+const INTERVAL_UNIT_TO_DATE_PART = Object.freeze({
+    millisecond: 'MILLISECOND',
+    second: 'SECOND',
+    minute: 'MINUTE',
+    hour: 'HOUR',
+    day: 'DAY',
+    week: 'WEEK',
+    month: 'MONTH',
+    quarter: 'QUARTER',
+    year: 'YEAR',
+});
+/**
+ * Cube SQL-dialect adapter that emits MongoSQL-compatible SQL.
+ *
+ * Instantiated by `MongoSqlDriver.dialectClass()`. Cube calls into this for
+ * every measure/dimension/timeDimension SQL fragment.
+ */
+class MongoSqlQuery extends schema_compiler_1.BaseQuery {
+    /**
+     * Identifier quoting — MongoSQL uses backticks.
+     * Reference: https://www.mongodb.com/docs/sql-interface/language-reference/identifiers/
+     *
+     * BaseQuery's actual identifier-quoting hook is `escapeColumnName`; we
+     * also expose `quoteIdentifier` as an alias because it's the conventional
+     * name and the driver's audit comment refers to it.
+     */
+    escapeColumnName(name) {
+        return `\`${name.replace(/`/g, '``')}\``;
+    }
+    quoteIdentifier(identifier) {
+        return this.escapeColumnName(identifier);
+    }
+    /**
+     * Suppress the cube-alias prefix on bare column references when the query
+     * has only one cube in scope.
+     *
+     * Background (T19 discovery): mongosql v1.8.5's algebrizer rejects qualified
+     * `<table_alias>.<col>` references in projections when only one collection
+     * is in scope — Error 3008 "Field `orders` in the `SELECT` clause at the 0
+     * scope level not found". Cube's BaseQuery emits `${cubeAlias}.${sql}` for
+     * every dimension that is a bare identifier (see BaseQuery.js:2508
+     * `autoPrefixWithCubeName`), which makes every realistic Cube query against
+     * a single cube fail translation.
+     *
+     * Strategy:
+     *   - Single-cube query (`this.join.joins.length === 0`): drop the prefix
+     *     — emit a bare column reference (`SELECT email FROM users`).
+     *   - Multi-cube / JOIN: keep the prefix (`SELECT users.email`) — mongosql
+     *     accepts qualified refs in JOIN scope (verified end-to-end in
+     *     tests/integration/basic-queries.test.ts).
+     *   - `this.join` may be `null` during pre-build / collect-cube-names paths
+     *     before `prebuildJoin` runs; treat that as "not enough info, keep
+     *     BaseQuery's behaviour" so we don't drop a prefix Cube actually needed.
+     *   - `isMemberExpr` (member-expression SQL) bypasses the prefix entirely
+     *     in BaseQuery; keep that semantics for forward compat.
+     *
+     * The conditional fall-through to `super` keeps every other code path
+     * (non-bare expressions like `LOWER(email)` already escape the regex match
+     * and are returned verbatim by the base implementation) unchanged.
+     */
+    autoPrefixWithCubeName(cubeName, sql, isMemberExpr = false) {
+        // Single-cube projection: mongosql rejects `<alias>.<col>`. Strip the
+        // alias prefix only when (a) we'd otherwise emit it (bare identifier,
+        // not a member-expression) and (b) the query truly has no joins.
+        const join = this
+            .join;
+        if (join &&
+            Array.isArray(join.joins) &&
+            join.joins.length === 0 &&
+            !isMemberExpr &&
+            /^[_a-zA-Z][_a-zA-Z0-9]*$/.test(sql)) {
+            return sql;
+        }
+        return super.autoPrefixWithCubeName(cubeName, sql, isMemberExpr);
+    }
+    /**
+     * GROUP BY by column alias instead of positional `1, 2, ...`.
+     * mongosql v1.8.5's algebrizer rejects positional refs in GROUP BY
+     * (and the failure mode misreports as Error 3008 "Field <col> in the
+     * SELECT clause not found"). Mirrors the ClickHouseQuery pattern.
+     */
+    groupByClause() {
+        if (this.ungrouped) {
+            return '';
+        }
+        const aliases = this.dimensionAliasNames();
+        return aliases.length ? ` GROUP BY ${aliases.join(', ')}` : '';
+    }
+    /**
+     * ORDER BY by column alias instead of positional `1, 2, ...`.
+     * Same constraint as `groupByClause` — mongosql requires named refs.
+     */
+    orderHashToString(hash) {
+        if (!hash?.id) {
+            return null;
+        }
+        const fieldAlias = this.getFieldAlias(hash.id);
+        if (fieldAlias === null) {
+            return null;
+        }
+        const direction = hash.desc ? 'DESC' : 'ASC';
+        return `${fieldAlias} ${direction}`;
+    }
+    /**
+     * Timestamp literal cast — CRITICAL DISCOVERY (T07): MongoSQL does NOT
+     * accept the SQL-92 `TIMESTAMP 'literal'` form. Use `CAST('...' AS TIMESTAMP)`.
+     * Reference: https://www.mongodb.com/docs/sql-interface/language-reference/data-types/
+     * (and crates/native/src/translate.rs::date_filter_emits_match_referencing_created_at)
+     */
+    timeStampCast(value) {
+        return `CAST(${value} AS TIMESTAMP)`;
+    }
+    /**
+     * datetime cast — MongoSQL has only `TIMESTAMP` (no separate `DATETIME` /
+     * `DATE` types), so `dateTimeCast` and `timeStampCast` produce the same SQL.
+     * SPEC FR-2 explicitly substitutes `TIMESTAMP` for `DATE`.
+     */
+    dateTimeCast(value) {
+        return `CAST(${value} AS TIMESTAMP)`;
+    }
+    /**
+     * String cast — MongoSQL's string type is spelt `STRING`, not the SQL-92
+     * `TEXT` (BaseQuery's default) or MySQL's `CHAR`.
+     * Reference: https://www.mongodb.com/docs/sql-interface/language-reference/data-types/
+     */
+    castToString(sql) {
+        return `CAST(${sql} AS STRING)`;
+    }
+    /**
+     * Generic typed cast helper. MongoSQL accepts the standard CAST grammar;
+     * the *type name* must be one of MongoSQL's documented type tokens
+     * (BOOL, INT, LONG, DOUBLE, DECIMAL, STRING, TIMESTAMP, ARRAY, DOCUMENT).
+     */
+    castSqlType(value, type) {
+        return `CAST(${value} AS ${type})`;
+    }
+    /**
+     * Timezone conversion — MongoSQL has no `AT TIME ZONE` or `CONVERT_TZ`
+     * function (verified against the v1.8.5 grammar). Data is stored in UTC
+     * (BSON DateTime), and `inDbTimeZone()` (inherited) shifts JS-side
+     * timestamp parameters. For SQL-emitted field references we passthrough —
+     * correct for UTC data and matching "no conversion" semantics.
+     *
+     * Revisit if MongoSQL adds a timezone-aware function form, or if T14
+     * integration shows non-UTC dimensions break.
+     */
+    convertTz(field) {
+        return field;
+    }
+    /**
+     * NOW() equivalent. MongoSQL's documented form for the current time is
+     * `CURRENT_TIMESTAMP` (SQL-92 keyword), not MySQL/Postgres `NOW()`.
+     */
+    nowTimestampSql() {
+        return 'CURRENT_TIMESTAMP';
+    }
+    /**
+     * Seconds since the Unix epoch. BaseQuery default uses
+     * `EXTRACT(EPOCH FROM NOW())`, but MongoSQL's `EXTRACT` does NOT support
+     * the `EPOCH` date-part (only YEAR/MONTH/WEEK/DAY/HOUR/MINUTE/SECOND/
+     * MILLISECOND/DAYOFYEAR/DAYOFWEEK/ISOWEEK/ISOWEEKDAY — see
+     * `algebrize_extract` in mongosql/src/algebrizer/definitions.rs).
+     *
+     * Use `DATEDIFF(SECOND, '1970-01-01T00:00:00Z', CURRENT_TIMESTAMP)`
+     * instead. Returns LONG (mongosql `$dateDiff`).
+     */
+    unixTimestampSql() {
+        return `DATEDIFF(SECOND, ${this.timeStampCast("'1970-01-01T00:00:00Z'")}, ${this.nowTimestampSql()})`;
+    }
+    /**
+     * Parse a Cube/Postgres-style interval string ("1 day", "2 weeks",
+     * "1 year 6 months") into an ordered list of MongoSQL DATEADD components.
+     *
+     * Cube emits compound intervals for partition ranges and granularity
+     * offsets. MongoSQL's DATEADD takes a single `<date_part>`, so we apply
+     * each component as a chained DATEADD call (see `addInterval` /
+     * `subtractInterval`). Order is preserved from `parseSqlInterval` so the
+     * outermost DATEADD is the *last* component (matches semantics: applying
+     * `(YEAR, 1)` then `(MONTH, 6)` is equivalent to "1 year 6 months").
+     *
+     * Public for unit-testing the bridge in isolation; not on BaseQuery.
+     */
+    intervalUnitsForMongo(interval) {
+        const parsed = parseSqlInterval(interval);
+        const components = [];
+        for (const [unit, value] of Object.entries(parsed)) {
+            const datePart = INTERVAL_UNIT_TO_DATE_PART[unit];
+            if (!datePart) {
+                throw new Error(`MongoSQL DATEADD does not support interval unit "${unit}" (from "${interval}")`);
+            }
+            components.push({ value, unit: datePart });
+        }
+        if (components.length === 0) {
+            throw new Error(`Cannot parse interval "${interval}" — produced no components`);
+        }
+        return components;
+    }
+    /**
+     * Add a Cube interval to a date expression. Compound intervals
+     * ("1 year 6 months") are emitted as chained DATEADD calls.
+     *
+     * MongoSQL has no `INTERVAL '...'` literal. The base implementation emits
+     * `${date} + interval '...'` which the parser rejects.
+     */
+    addInterval(date, interval) {
+        return this.applyIntervalChain(date, this.intervalUnitsForMongo(interval), 1);
+    }
+    /**
+     * Subtract a Cube interval from a date expression. Implemented as DATEADD
+     * with negated values (so `subtractInterval('d', '1 month')` becomes
+     * `DATEADD(MONTH, -1, d)`). Compound intervals chain the same way as
+     * `addInterval`.
+     */
+    subtractInterval(date, interval) {
+        return this.applyIntervalChain(date, this.intervalUnitsForMongo(interval), -1);
+    }
+    applyIntervalChain(date, components, sign) {
+        return components.reduce((acc, { value, unit }) => `DATEADD(${unit}, ${sign * value}, ${acc})`, date);
+    }
+    /**
+     * Printable interval string. MongoSQL has no INTERVAL literal so this is
+     * not safe to splice into emitted SQL — kept for diagnostic / error
+     * messages and for any BaseQuery code path we haven't audited yet (a
+     * future grep for `'1 day'` in SQL output would surface a regression).
+     */
+    intervalString(interval) {
+        return `'${interval}'`;
+    }
+    /**
+     * Truncate a timestamp to a granularity boundary. MongoSQL's documented
+     * form is `DATETRUNC(<unit>, <date>[, <start_of_week>])`. For week we pin
+     * `'sunday'` explicitly: mongosql's `ScalarFunctionsRewritePass` defaults
+     * a missing third arg to `'sunday'` (per ast/rewrites/test.rs::
+     * `timestamp_trunc`), but Cube's tests should not depend on that
+     * implicit default — a future mongosql release could change it.
+     */
+    timeGroupedColumn(granularity, dimension) {
+        const datePart = GRANULARITY_TO_DATE_PART[granularity];
+        if (!datePart) {
+            throw new Error(`MongoSQL dialect does not support granularity "${granularity}"`);
+        }
+        if (granularity === 'week') {
+            return `DATETRUNC(${datePart}, ${dimension}, 'sunday')`;
+        }
+        return `DATETRUNC(${datePart}, ${dimension})`;
+    }
+    /**
+     * Bucket `source` into intervals starting from `origin`. Cube uses this
+     * for custom (non-natural) granularities like "5 minutes" or "10 days".
+     *
+     * MongoSQL has no INTERVAL literal, so PostgresQuery's
+     * `'origin'::ts + INTERVAL N * FLOOR(EXTRACT(EPOCH ...))` form doesn't
+     * port. Instead we use the DATEADD/DATEDIFF identity:
+     *
+     *   floor((source - origin) / interval) * interval + origin
+     *
+     * which becomes:
+     *
+     *   DATEADD(unit, FLOOR(DATEDIFF(unit, origin, source) / N) * N, origin)
+     *
+     * Year and quarter intervals are normalised to MONTH (1 year = 12 months,
+     * 1 quarter = 3 months) so arithmetic doesn't depend on leap-day-aware
+     * second math. Every other unit (week / day / hour / minute / second /
+     * millisecond) is used as-is — DATEDIFF/DATEADD operate in the unit's
+     * native granularity which is the most precise viable choice.
+     *
+     * NOTE: only single-component intervals are supported here (matches
+     * Cube's custom-granularity inputs which are always one unit). Compound
+     * dateBin intervals would need a different strategy.
+     */
+    dateBin(interval, source, origin) {
+        const components = this.intervalUnitsForMongo(interval);
+        if (components.length !== 1) {
+            throw new Error(`MongoSQL dateBin requires a single-unit interval; got "${interval}"`);
+        }
+        const [{ value, unit }] = components;
+        // Normalise year/quarter to MONTH so the unit aligns with calendar
+        // boundaries; everything else uses its native unit for max precision.
+        const usedUnit = unit === 'YEAR' || unit === 'QUARTER' ? 'MONTH' : unit;
+        const stride = unit === 'YEAR' ? value * 12 : unit === 'QUARTER' ? value * 3 : value;
+        const originExpr = this.dateTimeCast(`'${origin}'`);
+        return `DATEADD(${usedUnit}, FLOOR(DATEDIFF(${usedUnit}, ${originExpr}, ${source}) / ${stride}) * ${stride}, ${originExpr})`;
+    }
+    /**
+     * Generate the date-series SQL Cube uses for time-bucketed pre-aggregations.
+     * MongoSQL has no `VALUES (...)`, no recursive CTE, and no `generate_series`,
+     * so we emit a UNION ALL of literal-row SELECTs (MysqlQuery's strategy)
+     * and CAST in the outer projection. Identical row count to MysqlQuery's
+     * version; the difference is `CAST(... AS TIMESTAMP)` instead of
+     * MySQL-specific `TIMESTAMP(...)`.
+     *
+     * NOTE: emits N rows for an N-row series. For very large partition ranges
+     * Cube can pre-compute the row set in JS — there's no in-DB way to grow
+     * the series without recursive CTEs, which v1.8.5 doesn't support.
+     */
+    seriesSql(timeDimension) {
+        const rows = timeDimension.timeSeries();
+        const union = rows
+            .map((row) => {
+            const [from, to] = row;
+            return `SELECT '${from}' f, '${to}' t`;
+        })
+            .join(' UNION ALL ');
+        const dateFrom = this.escapeColumnName('date_from');
+        const dateTo = this.escapeColumnName('date_to');
+        return `SELECT CAST(dates.f AS TIMESTAMP) AS ${dateFrom}, CAST(dates.t AS TIMESTAMP) AS ${dateTo} FROM (${union}) ${this.asSyntaxTable} dates`;
+    }
+    /**
+     * Override Cube's filter class for every filter on a MongoSQL query.
+     *
+     * Background (Gap 4 discovery): Cube's default `BaseFilter.likeIgnoreCase`
+     * emits `<col> [NOT] ILIKE <pattern>` for `contains`, `notContains`,
+     * `startsWith`, `notStartsWith`, `endsWith`, `notEndsWith`. mongosql
+     * v1.8.5's grammar does NOT include the `ILIKE` keyword (verified
+     * empirically against atlas-local — the parser reports
+     * `Error 2001: Unrecognized token ILIKE, expected: BETWEEN` /
+     * `expected COMMA, RIGHT_PAREN`). mongosql DOES support the standard
+     * SQL-92 `LIKE` keyword.
+     *
+     * Strategy: subclass BaseFilter and override `likeIgnoreCase` to
+     * emit `LOWER(<col>) LIKE LOWER(<pattern>)` instead of
+     * `<col> ILIKE <pattern>`. Wrapping both sides in `LOWER(...)`
+     * preserves case-insensitive semantics; mongosql's `LOWER` is the
+     * standard SQL function and round-trips strings unchanged for ASCII
+     * content. We do NOT use `ESCAPE` clauses here because Cube's
+     * `escapeWildcardChars` pre-escapes `%` and `_` with `\` and SQL's
+     * default LIKE escape character IS `\` per the SQL standard (mongosql
+     * v1.8.5 follows this).
+     *
+     * **Non-ASCII / Unicode caveat.** This override is ASCII-aware case
+     * folding only. mongosql v1.8.5 does not expose `COLLATE` at the SQL
+     * surface, so case-folding non-ASCII characters (e.g. the German
+     * sharp-s `ß` → `ss`, Turkish dotless-i, etc.) is NOT performed. For
+     * pure-Latin inputs (the dominant Cube use case) this is correct.
+     * For locale-sensitive case-insensitive search, use MongoDB's
+     * collation feature outside the SQL surface or pre-normalise data.
+     */
+    newFilter(filter) {
+        return new MongoSqlFilter(this, filter);
+    }
+    /**
+     * Patch the SQL templates that drive the rest of BaseQuery's builders.
+     * Mirrors MysqlQuery.sqlTemplates()'s pattern of `super` + targeted
+     * overrides.
+     *
+     * T12b additions: remove the `expressions.interval` template (BaseQuery's
+     * default emits `INTERVAL '<x>'` — invalid MongoSQL) so any caller that
+     * tries to render an interval literal surfaces an error rather than
+     * silently emitting unparseable SQL. The arithmetic-emitting paths
+     * (subtractInterval/addInterval/dateBin) don't go through this template.
+     * Also drop `statements.generated_time_series_*` for the same reason —
+     * those are recursive-CTE forms that mongosql doesn't accept.
+     */
+    sqlTemplates() {
+        const templates = super.sqlTemplates();
+        // Identifier quoting at the template layer (used by Cube's SQL planner).
+        templates.quotes.identifiers = '`';
+        templates.quotes.escape = '``';
+        // Type names — MongoSQL's spellings per the Language Reference.
+        // https://www.mongodb.com/docs/sql-interface/language-reference/data-types/
+        templates.types.string = 'STRING';
+        templates.types.boolean = 'BOOL';
+        templates.types.tinyint = 'INT';
+        templates.types.smallint = 'INT';
+        templates.types.integer = 'INT';
+        templates.types.bigint = 'LONG';
+        templates.types.float = 'DOUBLE';
+        templates.types.double = 'DOUBLE';
+        templates.types.decimal = 'DECIMAL';
+        templates.types.timestamp = 'TIMESTAMP';
+        // MongoSQL has no `DATE` / `TIME` / `INTERVAL` / `BINARY`; map to closest
+        // representable type or delete to surface an error if Cube ever asks.
+        templates.types.date = 'TIMESTAMP';
+        templates.types.time = 'TIMESTAMP';
+        delete templates.types.interval;
+        delete templates.types.binary;
+        // Drop INTERVAL-literal and recursive-CTE forms — mongosql v1.8.5
+        // rejects both. Anything that would have used these now routes through
+        // our typed overrides (addInterval/subtractInterval/seriesSql) or
+        // surfaces a clear missing-template error.
+        if (templates.expressions) {
+            delete templates.expressions.interval;
+        }
+        if (templates.statements) {
+            delete templates.statements.generated_time_series_select;
+            delete templates.statements.generated_time_series_with_cte_range_source;
+        }
+        return templates;
+    }
+}
+exports.MongoSqlQuery = MongoSqlQuery;
+/**
+ * Filter override for MongoSQL — rewrites `ILIKE` to `LOWER(...) LIKE LOWER(...)`.
+ *
+ * See `MongoSqlQuery.newFilter` for the rationale. Exported so unit tests
+ * can exercise `likeIgnoreCase` in isolation without instantiating the
+ * whole query stack.
+ */
+class MongoSqlFilter extends schema_compiler_1.BaseFilter {
+    /**
+     * Emit `LOWER(<col>) [NOT] LIKE LOWER(<wrapped-param>)` for mongosql.
+     *
+     * Layout mirrors BaseFilter.likeIgnoreCase:
+     *   - `type === 'contains'`: wrap pattern with `'%' || ... || '%'`
+     *   - `type === 'starts'`:   suffix with `|| '%'` only (no prefix)
+     *   - `type === 'ends'`:     prefix with `'%' ||` only (no suffix)
+     *
+     * Cube's BaseFilter passes type as 'contains' / 'starts' / 'ends'
+     * (NOT the camelized operator — see BaseFilter.likeOr where `type`
+     * is hardcoded to one of those three values).
+     *
+     * `allocateParam` returns Cube's `?` placeholder; the driver's
+     * `substituteParameters` inlines literals before sending to mongosql.
+     */
+    likeIgnoreCase(column, not, param, type) {
+        const p = !type || type === 'contains' || type === 'ends' ? "'%' || " : '';
+        const s = !type || type === 'contains' || type === 'starts' ? " || '%'" : '';
+        // Wrap the param-allocated placeholder in LOWER so the parser sees
+        // `LOWER(<col>) [NOT] LIKE LOWER('%' || ? || '%')`. mongosql's LOWER
+        // accepts the concatenated string expression as input.
+        //
+        // **Performance.** `LOWER(<col>)` is non-sargable — it prevents
+        // MongoDB from using any B-tree index on `<col>`. For high-volume
+        // case-insensitive search consider EITHER (a) materialising a
+        // lowercase shadow column at ingestion time and indexing that, OR
+        // (b) using MongoDB's collation feature outside the SQL surface
+        // (mongosql v1.8.5 does not expose `COLLATE`).
+        const wrapped = `${p}${this.allocateParam(param)}${s}`;
+        const direction = not ? ' NOT' : '';
+        return `LOWER(${column})${direction} LIKE LOWER(${wrapped})`;
+    }
+}
+exports.MongoSqlFilter = MongoSqlFilter;
+//# sourceMappingURL=MongoSqlQuery.js.map

package/dist/MongoSqlQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MongoSqlQuery.js","sourceRoot":"","sources":["../src/MongoSqlQuery.ts"],"names":[],"mappings":"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"}

package/dist/config.d.ts

@@ -0,0 +1,29 @@
+/** Subset of `process.env` we depend on. */
+export type EnvLike = NodeJS.ProcessEnv;
+/** Result of resolving env vars + overrides into a connection-string + driver options. */
+export interface ResolvedUriConfig {
+    /** Final URI to hand to the Rust client. Always contains all env-driven params. */
+    uri: string;
+    /**
+     * Effective per-query timeout in milliseconds (drives the aggregation
+     * pipeline's `maxTimeMS`). Resolved precedence:
+     *   1. `override.queryTimeoutMs` (constructor arg)
+     *   2. `CUBEJS_DB_QUERY_TIMEOUT` (Cube-standard, duration-aware)
+     *   3. `CUBEJS_MONGOSQL_QUERY_TIMEOUT_MS` (legacy, bare number)
+     * Undefined if none set; the native side then uses its built-in default.
+     */
+    queryTimeoutMs: number | undefined;
+}
+/**
+ * Resolve `(uri, queryTimeoutMs)` from constructor overrides + env.
+ *
+ * Throws `MONGOSQL_CONFIG_INVALID` when:
+ *   - neither explicit uri / `CUBEJS_DB_URL` / `CUBEJS_DB_URI` is set
+ *     AND `CUBEJS_DB_HOST` is also unset;
+ *   - a duration env var is malformed (e.g. `"forever"`);
+ *   - a numeric env var fails to parse.
+ */
+export declare function resolveUriConfig(overrideUri: string | undefined, env: EnvLike): ResolvedUriConfig;
+/** Same as `parseDurationToMillisString` but returns the integer directly. Throws on malformed input. */
+export declare function parseDurationToMillis(raw: string, envVarName: string): number;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAyEA,4CAA4C;AAC5C,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,UAAU,CAAC;AAExC,0FAA0F;AAC1F,MAAM,WAAW,iBAAiB;IAChC,mFAAmF;IACnF,GAAG,EAAE,MAAM,CAAC;IACZ;;;;;;;OAOG;IACH,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;CACpC;AA+CD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,EAAE,GAAG,EAAE,OAAO,GAAG,iBAAiB,CAiBjG;AAsLD,yGAAyG;AACzG,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAQ7E"}