ts-prorm-orm 1.1.0

package/dist/query-builders/functions/fulltext.js

@@ -0,0 +1,439 @@
+"use strict";
+/**
+ * Typed, cross-dialect full-text-SEARCH-QUERY API.
+ *
+ * Several dialect drivers in this ORM already expose native FULLTEXT
+ * *index creation* helpers (grep `createFulltextIndex` in
+ * `src/dialects/*​/index.ts`: mysql, mariadb, postgres, cockroachdb, mssql,
+ * oracle, sqlite, clickhouse all have one; db2/redshift throw a documented
+ * "not supported" error; snowflake is a documented no-op). What has been
+ * missing is a typed helper for the *query* side — the actual
+ * `MATCH() AGAINST()` / `@@ plainto_tsquery()` / `CONTAINS()` / `MATCH`
+ * predicate that goes in a `WHERE` (or `ORDER BY`, for relevance ranking).
+ * This module fills that gap.
+ *
+ * This module is intentionally self-contained: it does not add any new
+ * dispatch branches to `src/operators.ts`, `src/query-builders/sql-compiler.ts`,
+ * or any `src/dialects/**` file. Every function resolves directly to a final,
+ * dialect-correct SQL fragment string, which is then wrapped with the
+ * existing `literal()` helper from `src/operators.ts` (returns `{ $literal: sql }`,
+ * the same shape produced by `Op.literal(...)` and consumed throughout the
+ * where-builder/sql-compiler for raw-SQL escape hatches).
+ *
+ * IMPORTANT — verified limitation of the current WHERE-clause builder
+ * ---------------------------------------------------------------------
+ * `literal()`/`{ $literal }` is fully supported (and the recommended,
+ * documented way to inject raw SQL) when it is used as the *value* of a
+ * field/operator, e.g.:
+ *   `where: { createdAt: { [Op.lt]: literal('NOW()') } }`
+ * However, at the time this module was written, `WhereBuilder`
+ * (`src/query-builders/where-builder.ts`) and the per-dialect
+ * `buildWhereClause()` implementations only support `{ $literal }` as an
+ * *operator value*; they do not currently accept a bare `{ $literal }` (or a
+ * plain raw-SQL string) as an entire standalone condition — whether at the
+ * top level of `where`, or nested inside `$and`/`Op.and`/`$or`/`Op.or`
+ * arrays. This was verified empirically: such conditions are silently
+ * dropped rather than raising an error (a pre-existing gap in the shared
+ * where-builder, not something this module can fix without editing that
+ * file, which is out of scope here).
+ *
+ * Because of that, the SQL fragments produced by `fullTextMatch()` /
+ * `fullTextRank()` are safe and correct to use:
+ *   - directly in hand-built / raw SQL (`prorm.query(...)`), by reading
+ *     `.$literal` off the returned value,
+ *   - in `attributes: [...]` (SELECT) and `order: [...]` (ORDER BY) arrays,
+ *     both of which DO correctly render raw literal SQL fragments today
+ *     (verified against `sql-compiler.ts`'s `processAttributeValue()` and
+ *     `order-limit-builder.ts`'s `buildOrderItem()`, which passes through
+ *     plain strings/literal SQL unchanged).
+ * They are returned in the canonical `{ $literal: sql }` shape (rather than
+ * a bare string) so that call sites which build `where` conditions through
+ * `Op`-based helpers remain forward-compatible: if/when the WHERE-clause gap
+ * above is fixed, code using this module keeps working with no changes.
+ *
+ * @example
+ * ```typescript
+ * import { fullTextMatch, fullTextRank } from './query-builders/functions/fulltext';
+ *
+ * const match = fullTextMatch('mysql', ['title', 'body'], 'red widgets');
+ * // match.$literal === "MATCH(`title`, `body`) AGAINST('red widgets' IN NATURAL LANGUAGE MODE)"
+ *
+ * // Use for scoring/ordering (works today via ORDER BY / attributes):
+ * const rank = fullTextRank('postgres', 'body', 'red widgets');
+ * Article.findAll({
+ *   attributes: ['id', 'title', [rank, 'relevance']],
+ *   order: [[rank.$literal, 'DESC']],
+ * });
+ *
+ * // Use directly in a raw query for WHERE (recommended today):
+ * await prorm.query(
+ *   `SELECT * FROM articles WHERE ${match.$literal}`
+ * );
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FullTextSearchMode = void 0;
+exports.fullTextMatch = fullTextMatch;
+exports.fullTextRank = fullTextRank;
+const operators_1 = require("../../operators");
+/**
+ * Companion enum for `FullTextMatchMode`. Provided for callers who prefer a
+ * typed enum over hand-written string literals (e.g. `FullTextSearchMode.Boolean`
+ * instead of `'boolean'`). The two are interchangeable: `FullTextSearchMode`'s
+ * members are assignable to `FullTextMatchMode` (and vice versa, since the
+ * enum is string-valued), and `FullTextMatchOptions.mode` accepts either.
+ * This is purely additive — no existing string-literal call sites need to
+ * change.
+ */
+var FullTextSearchMode;
+(function (FullTextSearchMode) {
+    FullTextSearchMode["Natural"] = "natural";
+    FullTextSearchMode["Boolean"] = "boolean";
+    FullTextSearchMode["Phrase"] = "phrase";
+})(FullTextSearchMode || (exports.FullTextSearchMode = FullTextSearchMode = {}));
+// ---------------------------------------------------------------------------
+// Local helpers (self-contained — do not import dialect escaping utilities)
+// ---------------------------------------------------------------------------
+function toColumnArray(columns) {
+    return Array.isArray(columns) ? columns : [columns];
+}
+/**
+ * Convert a column-reference argument to a dialect-appropriately-quoted SQL
+ * identifier fragment. Kept local/minimal (mirrors the quoting conventions
+ * already used by each dialect's own `escapeId`), since this module must not
+ * import from `src/dialects/**`.
+ */
+function toSqlFragment(dialect, columnName) {
+    const quote = (part) => {
+        switch (dialect) {
+            case 'mysql':
+            case 'mariadb':
+                return `\`${part.replace(/`/g, '``')}\``;
+            case 'mssql':
+                return `[${part.replace(/]/g, ']]')}]`;
+            default:
+                // postgres, cockroachdb, sqlite, oracle, db2, snowflake, redshift, clickhouse
+                return `"${part.replace(/"/g, '""')}"`;
+        }
+    };
+    return columnName
+        .split('.')
+        .map((part) => quote(part))
+        .join('.');
+}
+/** Escape a plain string for embedding as a single-quoted SQL string literal. */
+function escapeStringLiteral(value) {
+    return value.replace(/'/g, "''");
+}
+/** Splits on whitespace, ignoring surrounding whitespace, to detect multi-word search terms. */
+function isMultiWord(term) {
+    return term.trim().split(/\s+/).filter(Boolean).length > 1;
+}
+function quotedColumnList(dialect, columns) {
+    return columns.map((c) => toSqlFragment(dialect, c)).join(', ');
+}
+// ---------------------------------------------------------------------------
+// fullTextMatch
+// ---------------------------------------------------------------------------
+/**
+ * Build a dialect-correct full-text-search WHERE-predicate SQL fragment.
+ *
+ * Returns `{ $literal: sql }` (see module header for the supported/verified
+ * usage patterns for this shape).
+ *
+ * Per-dialect behavior:
+ *   - mysql/mariadb: `MATCH(col1, col2) AGAINST('term' IN NATURAL LANGUAGE MODE | IN BOOLEAN MODE)`.
+ *     `mode: 'phrase'` uses boolean mode with the term wrapped in `"..."` for
+ *     an exact-phrase match (MySQL boolean-mode phrase syntax).
+ *     NOTE: requires a `FULLTEXT` index on the given column(s) — see
+ *     `createFulltextIndex()` in `src/dialects/mysql/index.ts` / `mariadb/index.ts`.
+ *   - postgres/cockroachdb: `to_tsvector('english', col1 || ' ' || col2) @@ plainto_tsquery('english', 'term')`.
+ *     `mode: 'phrase'` uses `websearch_to_tsquery` instead of `plainto_tsquery`
+ *     for more natural, phrase-aware parsing (supports quoted phrases, `-`,
+ *     `OR`). NOTE: works on any text column; a GIN index
+ *     (`createFulltextIndex()`) is only needed for performance, not correctness.
+ *   - mssql: `mode: 'natural'` (default) uses `FREETEXT(col, 'term')`;
+ *     `mode: 'boolean'` / `mode: 'phrase'` uses `CONTAINS(col, 'term')`
+ *     (phrase mode wraps the term in `"..."`, which is exact-phrase syntax
+ *     for `CONTAINS`). NOTE: requires a full-text index/catalog — see
+ *     `createFulltextIndex()` in `src/dialects/mssql/index.ts`.
+ *   - oracle: `CONTAINS(col, 'term', 1) > 0` (Oracle Text). Multiple columns
+ *     are OR-ed together, since Oracle Text indexes and scores one column at
+ *     a time. NOTE: requires an Oracle Text index — see `createFulltextIndex()`
+ *     in `src/dialects/oracle/index.ts`.
+ *   - sqlite: `col MATCH 'term'`. STRUCTURAL REQUIREMENT (unlike every other
+ *     dialect above): this only works against an FTS5 virtual table/column
+ *     (see `createFulltextIndex()` / `createFTS5Table()` in
+ *     `src/dialects/sqlite/index.ts`) — SQLite has no secondary full-text
+ *     index you can bolt onto an ordinary table the way MySQL/Postgres/MSSQL
+ *     do; the table itself must be an `fts5` virtual table.
+ *   - clickhouse: uses `hasToken(col, 'term')` for a single-token exact
+ *     match, or `multiSearchAny(col, ['term1', 'term2', ...])` when
+ *     `searchTerm` contains multiple whitespace-separated words. Multiple
+ *     columns are OR-ed together. See `createFulltextIndex()` (ClickHouse
+ *     `ngrambf_v1`/`tokenbf_v1` index) in `src/dialects/clickhouse/index.ts`.
+ *   - db2: THROWS. Db2's optional Text Search feature (Net Search Extender)
+ *     has its own `CONTAINS`-like predicate syntax, but it could not be
+ *     verified with confidence here, and `createFulltextIndex()` in
+ *     `src/dialects/db2/index.ts` itself throws
+ *     "Fulltext indexes are not supported in Db2 LUW (requires Net Search
+ *     Extender)" — so there is no verified index-creation path to pair a
+ *     query against either. Throwing here rather than guessing avoids
+ *     shipping silently-wrong SQL.
+ *   - snowflake: FALLBACK, not true full-text search. Snowflake has no
+ *     Postgres-style `tsvector`/`tsquery` full-text search primitive (its
+ *     closest offerings are Cortex Search / Search Optimization Service,
+ *     which are not plain-SQL predicates); `createFulltextIndex()` in
+ *     `src/dialects/snowflake/index.ts` is a documented no-op for the same
+ *     reason. Falls back to `ILIKE '%term%'` (case-insensitive substring
+ *     match — no tokenization, stemming, or relevance ranking).
+ *   - redshift: FALLBACK, not true full-text search. Redshift (unlike
+ *     Postgres, which it forked from) does not implement `tsvector`/`tsquery`;
+ *     `createFulltextIndex()` in `src/dialects/redshift/index.ts` throws
+ *     accordingly. Falls back to `ILIKE '%term%'`, same caveat as Snowflake.
+ *
+ * @param dialect - Target SQL dialect.
+ * @param columns - Column name, or array of column names, to search.
+ * @param searchTerm - The user's search text.
+ * @param options - `{ mode, config }`, see `FullTextMatchOptions`.
+ */
+function fullTextMatch(dialect, columns, searchTerm, options) {
+    const cols = toColumnArray(columns);
+    const mode = options?.mode ?? 'natural';
+    const term = escapeStringLiteral(searchTerm);
+    switch (dialect) {
+        case 'mysql':
+        case 'mariadb':
+        // TiDB and SingleStore are MySQL-wire-compatible and implement the same
+        // MATCH(...) AGAINST(...) full-text syntax.
+        case 'tidb':
+        case 'singlestore': {
+            const colList = quotedColumnList(dialect, cols);
+            if (mode === 'phrase') {
+                return (0, operators_1.literal)(`MATCH(${colList}) AGAINST('"${term}"' IN BOOLEAN MODE)`);
+            }
+            if (mode === 'boolean') {
+                return (0, operators_1.literal)(`MATCH(${colList}) AGAINST('${term}' IN BOOLEAN MODE)`);
+            }
+            return (0, operators_1.literal)(`MATCH(${colList}) AGAINST('${term}' IN NATURAL LANGUAGE MODE)`);
+        }
+        case 'postgres':
+        case 'cockroachdb':
+        // YugabyteDB, TimescaleDB and Greenplum are PostgreSQL-derived and support
+        // the same tsvector/tsquery full-text search.
+        case 'yugabytedb':
+        case 'timescaledb':
+        case 'greenplum': {
+            const config = escapeStringLiteral(options?.config ?? 'english');
+            const tsvectorArg = cols.length === 1
+                ? toSqlFragment(dialect, cols[0])
+                : cols.map((c) => toSqlFragment(dialect, c)).join(" || ' ' || ");
+            const tsqueryFn = mode === 'phrase' ? 'websearch_to_tsquery' : 'plainto_tsquery';
+            return (0, operators_1.literal)(`to_tsvector('${config}', ${tsvectorArg}) @@ ${tsqueryFn}('${config}', '${term}')`);
+        }
+        case 'mssql': {
+            // CONTAINS/FREETEXT accept a single column or a parenthesized column
+            // list: CONTAINS((col1, col2), 'term').
+            const colArg = cols.length === 1 ? toSqlFragment(dialect, cols[0]) : `(${quotedColumnList(dialect, cols)})`;
+            if (mode === 'natural') {
+                return (0, operators_1.literal)(`FREETEXT(${colArg}, '${term}')`);
+            }
+            const searchValue = mode === 'phrase' ? `"${term}"` : term;
+            return (0, operators_1.literal)(`CONTAINS(${colArg}, '${searchValue}')`);
+        }
+        case 'oracle': {
+            const searchValue = mode === 'phrase' ? `"${term}"` : term;
+            const predicates = cols.map((c) => `CONTAINS(${toSqlFragment(dialect, c)}, '${searchValue}', 1) > 0`);
+            return predicates.length === 1 ? (0, operators_1.literal)(predicates[0]) : (0, operators_1.literal)(`(${predicates.join(' OR ')})`);
+        }
+        case 'sqlite':
+        case 'turso': {
+            const searchValue = mode === 'phrase' ? `"${term}"` : term;
+            const predicates = cols.map((c) => `${toSqlFragment(dialect, c)} MATCH '${searchValue}'`);
+            return predicates.length === 1 ? (0, operators_1.literal)(predicates[0]) : (0, operators_1.literal)(`(${predicates.join(' OR ')})`);
+        }
+        case 'clickhouse': {
+            const multi = isMultiWord(searchTerm);
+            const predicates = cols.map((c) => {
+                const colSql = toSqlFragment(dialect, c);
+                if (multi) {
+                    const words = searchTerm
+                        .trim()
+                        .split(/\s+/)
+                        .filter(Boolean)
+                        .map((w) => `'${escapeStringLiteral(w)}'`)
+                        .join(', ');
+                    return `multiSearchAny(${colSql}, [${words}])`;
+                }
+                return `hasToken(${colSql}, '${term}')`;
+            });
+            return predicates.length === 1 ? (0, operators_1.literal)(predicates[0]) : (0, operators_1.literal)(`(${predicates.join(' OR ')})`);
+        }
+        case 'db2': {
+            throw new Error('fullTextMatch: Db2 Text Search CONTAINS-equivalent syntax could not be verified with ' +
+                "confidence, and this ORM's own createFulltextIndex() throws for Db2 LUW (requires the " +
+                'optional Net Search Extender feature). Refusing to guess at SQL syntax — consult IBM Db2 ' +
+                'Text Search / Net Search Extender documentation and use a raw query instead.');
+        }
+        case 'duckdb': {
+            throw new Error("fullTextMatch: DuckDB's FTS extension (fts, match_bm25()) syntax was not verified with " +
+                'confidence in this pass. Refusing to guess at SQL syntax — consult the DuckDB FTS ' +
+                'extension documentation and use a raw query instead.');
+        }
+        case 'hana': {
+            throw new Error("fullTextMatch: SAP HANA's CONTAINS()/fuzzy-search full-text syntax was not verified with " +
+                'confidence in this pass. Refusing to guess at SQL syntax — consult SAP HANA Search ' +
+                'documentation and use a raw query instead.');
+        }
+        case 'spanner': {
+            throw new Error("fullTextMatch: Google Cloud Spanner's native full-text search (SEARCH/TOKENLIST) syntax " +
+                'was not verified with confidence in this pass. Refusing to guess at SQL syntax — ' +
+                'consult Spanner full-text search documentation and use a raw query instead.');
+        }
+        case 'snowflake': {
+            const predicates = cols.map((c) => `${toSqlFragment(dialect, c)} ILIKE '%${term}%'`);
+            // Documented fallback: Snowflake has no tsvector/tsquery-style full-text
+            // search; this is a plain case-insensitive substring match, not
+            // tokenized/relevance-ranked full-text search.
+            return predicates.length === 1 ? (0, operators_1.literal)(predicates[0]) : (0, operators_1.literal)(`(${predicates.join(' OR ')})`);
+        }
+        case 'redshift': {
+            const predicates = cols.map((c) => `${toSqlFragment(dialect, c)} ILIKE '%${term}%'`);
+            // Documented fallback: Redshift (despite being Postgres-derived) does
+            // not implement tsvector/tsquery full-text search.
+            return predicates.length === 1 ? (0, operators_1.literal)(predicates[0]) : (0, operators_1.literal)(`(${predicates.join(' OR ')})`);
+        }
+        // Extended dialects whose native full-text syntax was not verified with
+        // confidence in this pass (CrateDB MATCH, QuestDB, Trino, Vertica, Exasol,
+        // Firebird, Databricks/Spark all differ). Refusing to guess — use a raw query.
+        case 'vertica':
+        case 'trino':
+        case 'exasol':
+        case 'questdb':
+        case 'cratedb':
+        case 'firebird':
+        case 'databricks': {
+            throw new Error(`fullTextMatch: native full-text search for '${dialect}' is not implemented; ` +
+                'its syntax differs from the supported dialects and was not verified. ' +
+                'Use a raw query for full-text search on this dialect.');
+        }
+        default: {
+            const exhaustiveCheck = dialect;
+            throw new Error(`fullTextMatch: unsupported dialect '${String(exhaustiveCheck)}'`);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// fullTextRank
+// ---------------------------------------------------------------------------
+/**
+ * Build a dialect-correct full-text relevance-SCORE SQL expression, for use
+ * in `SELECT`/`attributes` or `ORDER BY`/`order` — NOT a boolean WHERE
+ * predicate (use `fullTextMatch()` for that).
+ *
+ * Returns `{ $literal: sql }`. This shape is safe to use directly in
+ * `attributes: [...]` and `order: [...]` today (see module header) —
+ * both channels render raw literal SQL fragments correctly, unlike
+ * the WHERE-clause builder.
+ *
+ * Support by dialect:
+ *   - postgres/cockroachdb: `ts_rank(to_tsvector('english', col), plainto_tsquery('english', 'term'))`.
+ *   - mysql/mariadb: `MATCH(col1, col2) AGAINST('term')` — in MySQL/MariaDB,
+ *     using `MATCH() AGAINST()` outside of a boolean context (e.g. in
+ *     `SELECT`/`ORDER BY`) naturally evaluates to the relevance score
+ *     (a floating point number), so the same construct doubles as both a
+ *     predicate (via `fullTextMatch`) and a score.
+ *   - oracle: `SCORE(1)` (Oracle Text). REQUIRES a `CONTAINS(col, 'term', 1) > 0`
+ *     predicate using the *same* label (`1`) to appear in the query's WHERE
+ *     clause (e.g. from `fullTextMatch(dialect, col, term)`), per Oracle Text
+ *     rules — `SCORE(n)` reads the score computed by the `CONTAINS` call
+ *     labeled `n` elsewhere in the same query.
+ *   - mssql, sqlite, clickhouse, db2, redshift, snowflake: THROWS. None of
+ *     these has a genuine, verifiable relevance-scoring mechanism usable as
+ *     a plain SQL expression:
+ *       - mssql: `CONTAINS`/`FREETEXT` are boolean predicates only; ranked
+ *         results require `CONTAINSTABLE`/`FREETEXTTABLE` (table-valued
+ *         functions joined in, not an expression usable inline).
+ *       - sqlite FTS5: ranking requires the `bm25()` auxiliary function,
+ *         which (like MSSQL's *TABLE functions) can only be selected from
+ *         the FTS5 virtual table itself, not expressed against an arbitrary
+ *         base-table column the way `fullTextMatch()`'s column argument
+ *         implies — so it does not fit this API's per-column shape.
+ *       - clickhouse: `hasToken`/`multiSearchAny` return booleans; there is
+ *         no built-in relevance score function.
+ *       - db2/redshift/snowflake: no native full-text search at all (see
+ *         `fullTextMatch()` docs above), so there is nothing to rank.
+ */
+function fullTextRank(dialect, columns, searchTerm, options) {
+    const cols = toColumnArray(columns);
+    const term = escapeStringLiteral(searchTerm);
+    switch (dialect) {
+        case 'postgres':
+        case 'cockroachdb':
+        // PostgreSQL-derived: same ts_rank/tsvector relevance scoring.
+        case 'yugabytedb':
+        case 'timescaledb':
+        case 'greenplum': {
+            const config = escapeStringLiteral(options?.config ?? 'english');
+            const tsvectorArg = cols.length === 1
+                ? toSqlFragment(dialect, cols[0])
+                : cols.map((c) => toSqlFragment(dialect, c)).join(" || ' ' || ");
+            return (0, operators_1.literal)(`ts_rank(to_tsvector('${config}', ${tsvectorArg}), plainto_tsquery('${config}', '${term}'))`);
+        }
+        case 'mysql':
+        case 'mariadb':
+        // MySQL-wire-compatible: same MATCH(...) AGAINST(...) relevance score.
+        case 'tidb':
+        case 'singlestore': {
+            const colList = quotedColumnList(dialect, cols);
+            return (0, operators_1.literal)(`MATCH(${colList}) AGAINST('${term}')`);
+        }
+        case 'oracle': {
+            return (0, operators_1.literal)('SCORE(1)');
+        }
+        case 'mssql':
+            throw new Error("fullTextRank: MSSQL has no relevance-score expression usable inline — CONTAINS/FREETEXT " +
+                'are boolean predicates only. Ranked results require CONTAINSTABLE()/FREETEXTTABLE() ' +
+                '(table-valued functions joined into the query), which does not fit a single SQL ' +
+                'expression; use a raw query instead.');
+        case 'sqlite':
+        case 'turso':
+            throw new Error('fullTextRank: SQLite FTS5 ranking requires the bm25() auxiliary function selected ' +
+                'directly from the FTS5 virtual table (not an expression against an arbitrary column); ' +
+                'use a raw query selecting bm25(<fts5_table>) instead.');
+        case 'clickhouse':
+            throw new Error('fullTextRank: ClickHouse has no built-in full-text relevance-score function — ' +
+                'hasToken()/multiSearchAny() return booleans, not scores.');
+        case 'db2':
+            throw new Error('fullTextRank: not supported — Db2 Text Search relevance-scoring syntax could not be ' +
+                'verified with confidence (see fullTextMatch() for details).');
+        case 'redshift':
+            throw new Error('fullTextRank: not supported — Redshift has no native full-text search/relevance-ranking ' +
+                "mechanism (see fullTextMatch()'s ILIKE fallback for a substring-match alternative).");
+        case 'snowflake':
+            throw new Error('fullTextRank: not supported — Snowflake has no native full-text search/relevance-ranking ' +
+                "mechanism (see fullTextMatch()'s ILIKE fallback for a substring-match alternative).");
+        case 'duckdb':
+            throw new Error('fullTextRank: not supported — DuckDB FTS relevance-scoring syntax was not verified with ' +
+                'confidence in this pass (see fullTextMatch()).');
+        case 'hana':
+            throw new Error('fullTextRank: not supported — SAP HANA relevance-scoring syntax was not verified with ' +
+                'confidence in this pass (see fullTextMatch()).');
+        case 'spanner':
+            throw new Error('fullTextRank: not supported — Google Cloud Spanner relevance-scoring syntax was not ' +
+                'verified with confidence in this pass (see fullTextMatch()).');
+        case 'vertica':
+        case 'trino':
+        case 'exasol':
+        case 'questdb':
+        case 'cratedb':
+        case 'firebird':
+        case 'databricks':
+            throw new Error(`fullTextRank: not supported — relevance-scoring syntax for '${dialect}' was not verified ` +
+                'with confidence in this pass (see fullTextMatch()). Use a raw query.');
+        default: {
+            const exhaustiveCheck = dialect;
+            throw new Error(`fullTextRank: unsupported dialect '${String(exhaustiveCheck)}'`);
+        }
+    }
+}

package/dist/query-builders/functions/index.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rpad = exports.lpad = exports.replace = exports.length = exports.lower = exports.upper = exports.rtrim = exports.ltrim = exports.trim = exports.substring = exports.concat = exports.truncate = exports.least = exports.greatest = exports.random = exports.mod = exports.sign = exports.abs = exports.sqrt = exports.power = exports.floor = exports.ceil = exports.round = exports.jsonTypeOf = exports.jsonKeys = exports.jsonHasKey = exports.jsonContains = exports.jsonExtract = exports.fullTextRank = exports.fullTextMatch = exports.formatDate = exports.currentTimestamp = exports.currentDate = exports.now = exports.dateDiff = exports.dateSub = exports.dateAdd = exports.dateTrunc = exports.caseOf = exports.caseWhen = exports.SimpleCaseBuilder = exports.CaseBuilder = exports.arrayAgg = exports.stringAgg = exports.max = exports.min = exports.avg = exports.sum = exports.countDistinct = exports.count = void 0;
+exports.NullsOrder = exports.windowFn = exports.maxOver = exports.minOver = exports.countOver = exports.avgOver = exports.sumOver = exports.nthValue = exports.lastValue = exports.firstValue = exports.lead = exports.lag = exports.ntile = exports.cumeDist = exports.percentRank = exports.denseRank = exports.rank = exports.rowNumber = exports.WindowFunctionBuilder = exports.reverse = exports.repeat = exports.split = void 0;
+/**
+ * Barrel export for the typed SQL function-builder library.
+ * Lets callers do `import { rowNumber, jsonExtract, fullTextMatch } from 'prorm'`
+ * instead of hand-writing raw SQL fragments.
+ *
+ * Explicit (not `export *`) because several of these modules independently
+ * declare their own local `SqlExpr` type alias (same shape, different
+ * files) - re-exporting all three under one name is ambiguous.
+ */
+var aggregate_1 = require("./aggregate");
+Object.defineProperty(exports, "count", { enumerable: true, get: function () { return aggregate_1.count; } });
+Object.defineProperty(exports, "countDistinct", { enumerable: true, get: function () { return aggregate_1.countDistinct; } });
+Object.defineProperty(exports, "sum", { enumerable: true, get: function () { return aggregate_1.sum; } });
+Object.defineProperty(exports, "avg", { enumerable: true, get: function () { return aggregate_1.avg; } });
+Object.defineProperty(exports, "min", { enumerable: true, get: function () { return aggregate_1.min; } });
+Object.defineProperty(exports, "max", { enumerable: true, get: function () { return aggregate_1.max; } });
+Object.defineProperty(exports, "stringAgg", { enumerable: true, get: function () { return aggregate_1.stringAgg; } });
+Object.defineProperty(exports, "arrayAgg", { enumerable: true, get: function () { return aggregate_1.arrayAgg; } });
+var conditional_1 = require("./conditional");
+Object.defineProperty(exports, "CaseBuilder", { enumerable: true, get: function () { return conditional_1.CaseBuilder; } });
+Object.defineProperty(exports, "SimpleCaseBuilder", { enumerable: true, get: function () { return conditional_1.SimpleCaseBuilder; } });
+Object.defineProperty(exports, "caseWhen", { enumerable: true, get: function () { return conditional_1.caseWhen; } });
+Object.defineProperty(exports, "caseOf", { enumerable: true, get: function () { return conditional_1.caseOf; } });
+var datetime_1 = require("./datetime");
+Object.defineProperty(exports, "dateTrunc", { enumerable: true, get: function () { return datetime_1.dateTrunc; } });
+Object.defineProperty(exports, "dateAdd", { enumerable: true, get: function () { return datetime_1.dateAdd; } });
+Object.defineProperty(exports, "dateSub", { enumerable: true, get: function () { return datetime_1.dateSub; } });
+Object.defineProperty(exports, "dateDiff", { enumerable: true, get: function () { return datetime_1.dateDiff; } });
+Object.defineProperty(exports, "now", { enumerable: true, get: function () { return datetime_1.now; } });
+Object.defineProperty(exports, "currentDate", { enumerable: true, get: function () { return datetime_1.currentDate; } });
+Object.defineProperty(exports, "currentTimestamp", { enumerable: true, get: function () { return datetime_1.currentTimestamp; } });
+Object.defineProperty(exports, "formatDate", { enumerable: true, get: function () { return datetime_1.formatDate; } });
+var fulltext_1 = require("./fulltext");
+Object.defineProperty(exports, "fullTextMatch", { enumerable: true, get: function () { return fulltext_1.fullTextMatch; } });
+Object.defineProperty(exports, "fullTextRank", { enumerable: true, get: function () { return fulltext_1.fullTextRank; } });
+var json_1 = require("./json");
+Object.defineProperty(exports, "jsonExtract", { enumerable: true, get: function () { return json_1.jsonExtract; } });
+Object.defineProperty(exports, "jsonContains", { enumerable: true, get: function () { return json_1.jsonContains; } });
+Object.defineProperty(exports, "jsonHasKey", { enumerable: true, get: function () { return json_1.jsonHasKey; } });
+Object.defineProperty(exports, "jsonKeys", { enumerable: true, get: function () { return json_1.jsonKeys; } });
+Object.defineProperty(exports, "jsonTypeOf", { enumerable: true, get: function () { return json_1.jsonTypeOf; } });
+var math_1 = require("./math");
+Object.defineProperty(exports, "round", { enumerable: true, get: function () { return math_1.round; } });
+Object.defineProperty(exports, "ceil", { enumerable: true, get: function () { return math_1.ceil; } });
+Object.defineProperty(exports, "floor", { enumerable: true, get: function () { return math_1.floor; } });
+Object.defineProperty(exports, "power", { enumerable: true, get: function () { return math_1.power; } });
+Object.defineProperty(exports, "sqrt", { enumerable: true, get: function () { return math_1.sqrt; } });
+Object.defineProperty(exports, "abs", { enumerable: true, get: function () { return math_1.abs; } });
+Object.defineProperty(exports, "sign", { enumerable: true, get: function () { return math_1.sign; } });
+Object.defineProperty(exports, "mod", { enumerable: true, get: function () { return math_1.mod; } });
+Object.defineProperty(exports, "random", { enumerable: true, get: function () { return math_1.random; } });
+Object.defineProperty(exports, "greatest", { enumerable: true, get: function () { return math_1.greatest; } });
+Object.defineProperty(exports, "least", { enumerable: true, get: function () { return math_1.least; } });
+Object.defineProperty(exports, "truncate", { enumerable: true, get: function () { return math_1.truncate; } });
+var string_1 = require("./string");
+Object.defineProperty(exports, "concat", { enumerable: true, get: function () { return string_1.concat; } });
+Object.defineProperty(exports, "substring", { enumerable: true, get: function () { return string_1.substring; } });
+Object.defineProperty(exports, "trim", { enumerable: true, get: function () { return string_1.trim; } });
+Object.defineProperty(exports, "ltrim", { enumerable: true, get: function () { return string_1.ltrim; } });
+Object.defineProperty(exports, "rtrim", { enumerable: true, get: function () { return string_1.rtrim; } });
+Object.defineProperty(exports, "upper", { enumerable: true, get: function () { return string_1.upper; } });
+Object.defineProperty(exports, "lower", { enumerable: true, get: function () { return string_1.lower; } });
+Object.defineProperty(exports, "length", { enumerable: true, get: function () { return string_1.length; } });
+Object.defineProperty(exports, "replace", { enumerable: true, get: function () { return string_1.replace; } });
+Object.defineProperty(exports, "lpad", { enumerable: true, get: function () { return string_1.lpad; } });
+Object.defineProperty(exports, "rpad", { enumerable: true, get: function () { return string_1.rpad; } });
+Object.defineProperty(exports, "split", { enumerable: true, get: function () { return string_1.split; } });
+Object.defineProperty(exports, "repeat", { enumerable: true, get: function () { return string_1.repeat; } });
+Object.defineProperty(exports, "reverse", { enumerable: true, get: function () { return string_1.reverse; } });
+var window_1 = require("./window");
+Object.defineProperty(exports, "WindowFunctionBuilder", { enumerable: true, get: function () { return window_1.WindowFunctionBuilder; } });
+Object.defineProperty(exports, "rowNumber", { enumerable: true, get: function () { return window_1.rowNumber; } });
+Object.defineProperty(exports, "rank", { enumerable: true, get: function () { return window_1.rank; } });
+Object.defineProperty(exports, "denseRank", { enumerable: true, get: function () { return window_1.denseRank; } });
+Object.defineProperty(exports, "percentRank", { enumerable: true, get: function () { return window_1.percentRank; } });
+Object.defineProperty(exports, "cumeDist", { enumerable: true, get: function () { return window_1.cumeDist; } });
+Object.defineProperty(exports, "ntile", { enumerable: true, get: function () { return window_1.ntile; } });
+Object.defineProperty(exports, "lag", { enumerable: true, get: function () { return window_1.lag; } });
+Object.defineProperty(exports, "lead", { enumerable: true, get: function () { return window_1.lead; } });
+Object.defineProperty(exports, "firstValue", { enumerable: true, get: function () { return window_1.firstValue; } });
+Object.defineProperty(exports, "lastValue", { enumerable: true, get: function () { return window_1.lastValue; } });
+Object.defineProperty(exports, "nthValue", { enumerable: true, get: function () { return window_1.nthValue; } });
+Object.defineProperty(exports, "sumOver", { enumerable: true, get: function () { return window_1.sumOver; } });
+Object.defineProperty(exports, "avgOver", { enumerable: true, get: function () { return window_1.avgOver; } });
+Object.defineProperty(exports, "countOver", { enumerable: true, get: function () { return window_1.countOver; } });
+Object.defineProperty(exports, "minOver", { enumerable: true, get: function () { return window_1.minOver; } });
+Object.defineProperty(exports, "maxOver", { enumerable: true, get: function () { return window_1.maxOver; } });
+Object.defineProperty(exports, "windowFn", { enumerable: true, get: function () { return window_1.windowFn; } });
+Object.defineProperty(exports, "NullsOrder", { enumerable: true, get: function () { return window_1.NullsOrder; } });