@rudderjs/database 1.1.0 → 1.2.1

package/dist/native/compiler.d.ts

@@ -0,0 +1,371 @@
+import type { WhereClause, WhereOperator, OrderClause, RelationExistencePredicate, AggregateRequest, LockOptions } from '@rudderjs/contracts';
+import { type Dialect, type DatePart, type JsonPathSegment } from './dialect.js';
+/** A raw SQL fragment + its `?`-placeholder bindings, threaded through a clause. */
+export interface RawFragment {
+    sql: string;
+    bindings: readonly unknown[];
+}
+/**
+ * A node in the WHERE condition tree.
+ *
+ * - `clause` — a single `column <op> value` predicate.
+ * - `group`  — a parenthesized sub-tree with its own boolean roots, produced by
+ *   `whereGroup` / `orWhereGroup`. Nesting is unbounded. `negated: true`
+ *   (from `whereNot` / `orWhereNot`) wraps the parenthesized tree in `NOT`.
+ * - `date`   — a date-component predicate (`whereDate`/`whereTime`/`whereDay`/
+ *   `whereMonth`/`whereYear`): the column runs through the dialect's
+ *   `dateExtract` seam, the value binds.
+ * - `json`   — a JSON-path comparison (`where('meta->prefs->lang', …)`): the
+ *   column + validated segments run through the dialect's `jsonExtract` seam,
+ *   the value binds (booleans normalized via `jsonBoolean`).
+ * - `jsonContains` / `jsonLength` — `whereJsonContains` / `whereJsonLength`
+ *   predicates through the matching dialect seams.
+ *
+ * Each node carries `boolean: 'AND' | 'OR'` recording how it joins to the
+ * predicate *before* it at the same level. The first node's boolean is ignored.
+ */
+export type ConditionNode = {
+    kind: 'clause';
+    boolean: 'AND' | 'OR';
+    clause: WhereClause;
+} | {
+    kind: 'group';
+    boolean: 'AND' | 'OR';
+    children: ConditionNode[];
+    negated?: boolean;
+} | {
+    kind: 'raw';
+    boolean: 'AND' | 'OR';
+    raw: RawFragment;
+} | {
+    kind: 'column';
+    boolean: 'AND' | 'OR';
+    left: string;
+    operator: WhereOperator;
+    right: string;
+} | {
+    kind: 'date';
+    boolean: 'AND' | 'OR';
+    part: DatePart;
+    column: string;
+    operator: WhereOperator;
+    value: unknown;
+} | {
+    kind: 'json';
+    boolean: 'AND' | 'OR';
+    column: string;
+    segments: readonly JsonPathSegment[];
+    operator: WhereOperator;
+    value: unknown;
+} | {
+    kind: 'jsonContains';
+    boolean: 'AND' | 'OR';
+    column: string;
+    segments: readonly JsonPathSegment[];
+    value: unknown;
+    negated: boolean;
+} | {
+    kind: 'jsonLength';
+    boolean: 'AND' | 'OR';
+    column: string;
+    segments: readonly JsonPathSegment[];
+    operator: WhereOperator;
+    value: number;
+} | {
+    kind: 'exists';
+    boolean: 'AND' | 'OR';
+    negated: boolean;
+    body: SubqueryBody;
+};
+/**
+ * A subquery body — another native query's captured state (`Model.query()` /
+ * `adapter.query(...)` chains) or a raw SQL fragment. Shared by CTE bodies
+ * ({@link CteNode}) and `whereExists` predicates. Builder-backed bodies keep
+ * their own UNION members but drop ORDER BY / LIMIT (same rule as `union()`).
+ */
+export type SubqueryBody = {
+    kind: 'state';
+    state: NativeQueryState;
+} | {
+    kind: 'raw';
+    raw: RawFragment;
+};
+/**
+ * A single ORDER BY entry — either a structured `column direction` clause or a
+ * raw SQL fragment from `orderByRaw` / `orderBy(raw(...))`.
+ */
+export type OrderItem = OrderClause | {
+    kind: 'raw';
+    raw: RawFragment;
+};
+/**
+ * One common table expression from `withExpression` / `withRecursiveExpression`.
+ * The body is either another native query's state (`Model.query()` /
+ * `adapter.query(...)` chains, captured like a UNION member) or a raw SQL
+ * fragment — recursive bodies are usually raw, because they reference the CTE's
+ * own name (`… UNION ALL SELECT … FROM cte_name …`), which a table-rooted
+ * builder can't express. `columns` (optional) emits the explicit column list
+ * (`name (col1, col2)`) most useful on recursive CTEs.
+ */
+export interface CteNode {
+    name: string;
+    recursive: boolean;
+    columns?: readonly string[];
+    body: SubqueryBody;
+}
+/** The four join flavors. `cross` carries no ON conditions. */
+export type JoinType = 'inner' | 'left' | 'right' | 'cross';
+/**
+ * One condition inside a join's ON clause.
+ * - `on`    — column-vs-column (`"posts"."userId" = "users"."id"`); nothing binds.
+ * - `where` — column-vs-value (`"posts"."active" = ?`); the value binds.
+ */
+export type JoinCondition = {
+    kind: 'on';
+    boolean: 'AND' | 'OR';
+    left: string;
+    operator: WhereOperator;
+    right: string;
+} | {
+    kind: 'where';
+    boolean: 'AND' | 'OR';
+    clause: WhereClause;
+};
+/** A single JOIN: type + table + its ON condition list (empty for `cross`). */
+export interface JoinNode {
+    type: JoinType;
+    table: string;
+    conditions: JoinCondition[];
+}
+/** Window functions `selectWindow` accepts. The map to SQL names lives in
+ *  {@link WINDOW_FUNCTION_SQL} — like the isolation-level map, the closed set
+ *  IS the injection gate (the function name is spliced, never bound). All five
+ *  are zero-argument ranking functions with identical syntax on SQLite ≥3.25,
+ *  Postgres, and MySQL 8 — no dialect seam needed. */
+export type WindowFunction = 'rowNumber' | 'rank' | 'denseRank' | 'percentRank' | 'cumeDist';
+/** Runtime membership check for {@link WindowFunction} — the builder's
+ *  injection gate for the spliced function name (JS callers bypass the TS
+ *  union). */
+export declare function isWindowFunction(fn: string): fn is WindowFunction;
+/** One `fn() OVER (PARTITION BY … ORDER BY …) AS alias` projection entry from
+ *  `selectWindow`. Identifiers quote at compile time; directions are validated
+ *  to `asc`/`desc` by the builder. No bindings — the whole entry is identifiers
+ *  + keywords. */
+export interface WindowSelect {
+    fn: WindowFunction;
+    as: string;
+    partitionBy: string[];
+    orderBy: Array<{
+        column: string;
+        direction: 'asc' | 'desc';
+    }>;
+}
+/**
+ * One entry in a HAVING clause.
+ * - `clause` — `column <op> value` (the value binds); the column may be a
+ *   SELECT alias (`having('post_count', '>', 3)`).
+ * - `raw`    — a raw fragment, e.g. `havingRaw('COUNT(*) > ?', [3])` (the
+ *   portable way to filter on an aggregate — Postgres won't accept an alias here).
+ */
+export type HavingNode = {
+    kind: 'clause';
+    boolean: 'AND' | 'OR';
+    clause: WhereClause;
+} | {
+    kind: 'raw';
+    boolean: 'AND' | 'OR';
+    raw: RawFragment;
+};
+/**
+ * Everything the read compiler needs from a query. The `NativeQueryBuilder`
+ * accumulates this; the compiler is otherwise stateless.
+ */
+export interface NativeQueryState {
+    table: string;
+    primaryKey: string;
+    conditions: ConditionNode[];
+    orders: OrderItem[];
+    limitN: number | null;
+    offsetN: number | null;
+    /** Structured projection columns from `select(...)`. When present (with or
+     *  without `rawSelects`) they REPLACE the default `*`. Each is identifier-
+     *  quoted (qualified `table.col` supported); raw aliasing goes via `selectRaw`. */
+    selects?: string[];
+    /** Raw projection fragments from `selectRaw`. When present they REPLACE the
+     *  default `*` (Laravel semantics — `selectRaw` is a projection, not additive).
+     *  Combined with `selects` in call order (structured first, then raw). */
+    rawSelects?: RawFragment[];
+    /** JOIN clauses from `join`/`leftJoin`/`rightJoin`/`crossJoin`, emitted
+     *  between FROM and WHERE in declaration order. */
+    joins?: JoinNode[];
+    /** `GROUP BY` columns from `groupBy(...)`, emitted after WHERE. Quoted
+     *  (qualified `table.col` supported); no bindings. */
+    groupBy?: string[];
+    /** `HAVING` predicates from `having`/`havingRaw`, emitted after GROUP BY.
+     *  Their bound values follow the WHERE's and precede ORDER BY's. */
+    having?: HavingNode[];
+    /** `UNION` / `UNION ALL` members from `union(...)`/`unionAll(...)`. Each member's
+     *  own ORDER BY / LIMIT / OFFSET / lock are ignored — the BASE query's apply to
+     *  the whole combined result. Member bindings follow the base body's in order. */
+    unions?: Array<{
+        all: boolean;
+        state: NativeQueryState;
+    }>;
+    /** Common table expressions from `withExpression(...)`/`withRecursiveExpression(...)`.
+     *  Emitted as a `WITH [RECURSIVE] name [(cols)] AS (body), …` prefix on reads
+     *  (`compileSelect` + `compileCount`); their bindings come FIRST (SQL text
+     *  order — the WITH clause precedes the main SELECT). */
+    ctes?: CteNode[];
+    /** `SELECT DISTINCT` from `distinct()` — de-duplicates the projected rows. */
+    distinct?: boolean;
+    /** Window-function projections from `selectWindow(...)`. ADDITIVE — appended
+     *  to the projection (after structured/raw selects, or after the default `*`
+     *  when none replace it), unlike `selectRaw`'s REPLACE semantics: a ranking
+     *  column is almost always wanted *alongside* the row. */
+    windows?: WindowSelect[];
+    /** Soft-delete scoping resolved by the builder from the Model + with/onlyTrashed. */
+    softDelete: 'exclude' | 'only' | 'with';
+    /** Column the soft-delete filter targets. Default `deletedAt`. */
+    deletedAtColumn: string;
+    /** Correlated EXISTS / NOT EXISTS predicates from `whereRelationExists`
+     *  (`whereHas` / `whereDoesntHave`). AND-merged into the WHERE. */
+    relationExists?: RelationExistencePredicate[];
+    /** Aggregate subselect requests from `withAggregate` (`withCount`/`withSum`/…).
+     *  Each becomes a `(subselect) AS alias` column in the SELECT list. */
+    aggregates?: AggregateRequest[];
+    /** Pessimistic row lock from `lockForUpdate()` / `sharedLock()`. Emitted as
+     *  the dialect's `FOR UPDATE` / `FOR SHARE` suffix after ORDER BY / LIMIT
+     *  (no-op on SQLite). `null`/absent = no lock. */
+    lock?: 'update' | 'shared' | null;
+    /** Wait behavior for the lock (`SKIP LOCKED` / `NOWAIT` on pg/mysql) —
+     *  already validated mutually exclusive by the QueryBuilder. Only consulted
+     *  when `lock` is set. `null`/absent = default blocking wait. */
+    lockOptions?: LockOptions | null;
+}
+/** A compiled statement: parameterized SQL + the positional bindings. */
+export interface CompiledQuery {
+    sql: string;
+    bindings: unknown[];
+}
+/**
+ * Accumulates positional bindings and hands out the matching placeholder. One
+ * instance per compile so `$n` indices (Postgres, later) stay correct across
+ * the whole statement, not per-fragment.
+ */
+declare class Bindings {
+    private readonly dialect;
+    readonly values: unknown[];
+    constructor(dialect: Dialect);
+    add(value: unknown): string;
+}
+/**
+ * Compile a SELECT for the read terminals (`get`/`all`/`first`/`find`).
+ *
+ * `overrides` lets terminals tweak the shape without mutating state:
+ * - `limit`         — force a LIMIT (e.g. `first()` → 1), overriding `state.limitN`.
+ * - `selectColumns` — projection list; defaults to `*`.
+ * - `extraConditions` — additional clauses AND-ed in (e.g. `find(id)` → PK match),
+ *   applied at the top level *outside* the user predicate parens.
+ */
+export declare function compileSelect(state: NativeQueryState, dialect: Dialect, overrides?: {
+    limit?: number | null;
+    selectColumns?: string;
+    extraConditions?: ConditionNode[];
+}): CompiledQuery;
+/** Compile `SELECT COUNT(*) AS count FROM ... WHERE ...` for `count()` /
+ *  `paginate()` totals. Orders/limit/offset are irrelevant to a count. */
+export declare function compileCount(state: NativeQueryState, dialect: Dialect): CompiledQuery;
+/** Shared options for write compilers. */
+interface WriteOpts {
+    /** Clauses AND-ed onto the WHERE (e.g. the primary-key match for by-id writes). */
+    extraConditions?: ConditionNode[];
+    /** Append `RETURNING *` so the executor returns the affected rows. */
+    returning?: boolean;
+}
+/**
+ * Compile an INSERT for one or more rows. Single-row (`create`) and multi-row
+ * (`insertMany`) share this. The column list is the first-seen union of every
+ * row's defined keys; a row missing a union column binds `null`. With
+ * `returning`, appends `RETURNING *` (single-row `create` reads the inserted
+ * row back). Throws on an empty `rows` array — callers guard the no-op.
+ */
+export declare function compileInsert(state: NativeQueryState, dialect: Dialect, rows: Array<Record<string, unknown>>, opts?: {
+    returning?: boolean;
+    upsert?: {
+        uniqueBy: readonly string[];
+        update: readonly string[];
+    };
+}): CompiledQuery;
+/**
+ * Compile `INSERT INTO table (cols) SELECT …` for `insertUsing(columns, query)`
+ * — the rows come from a subquery (builder state or raw SQL), not VALUES
+ * tuples. Column names are identifier-quoted; the subquery compiles through
+ * the shared {@link Bindings} (raw `?` placeholders rebound per dialect). The
+ * column list is REQUIRED — the subquery's projection order must be pinned to
+ * named target columns, a bare `INSERT INTO t SELECT …` is a column-order
+ * footgun.
+ */
+export declare function compileInsertUsing(state: NativeQueryState, dialect: Dialect, columns: readonly string[], body: SubqueryBody, opts?: {
+    returning?: boolean;
+}): CompiledQuery;
+/**
+ * Compile `UPDATE <table> SET col = ? [, …] [WHERE …] [RETURNING *]`.
+ *
+ * SET bindings are emitted before WHERE bindings, matching positional `?`
+ * order. `undefined`-valued columns are dropped (see {@link definedEntries}).
+ * Throws when there's nothing to set.
+ *
+ * Arrow-path keys (`'meta->prefs->lang'`) write into a JSON column via the
+ * dialect's `jsonSet` seam — see {@link compileJsonSetClause}. Payloads with
+ * no arrow key take the original plain path (byte-identical SQL).
+ */
+export declare function compileUpdate(state: NativeQueryState, dialect: Dialect, data: Record<string, unknown>, opts?: WriteOpts): CompiledQuery;
+/**
+ * Compile an atomic counter update: `UPDATE <table> SET col = col + ? [, extra = ?]
+ * [WHERE …] [RETURNING *]`. `delta` is the signed amount (decrement passes a
+ * negative). `extra` columns are written in the same statement. Pure SQL —
+ * `col = col + ?` reads and writes atomically at the DB, safe under concurrency.
+ */
+export declare function compileIncrement(state: NativeQueryState, dialect: Dialect, column: string, delta: number, extra: Record<string, unknown>, opts?: WriteOpts): CompiledQuery;
+/** Compile `DELETE FROM <table> [WHERE …] [RETURNING *]`. With `returning`,
+ *  the executor returns the deleted rows so the caller can take `rows.length`
+ *  as the affected count (no driver `changes` metadata needed). */
+export declare function compileDelete(state: NativeQueryState, dialect: Dialect, opts?: WriteOpts): CompiledQuery;
+/**
+ * Compile a correlated `EXISTS (…)` / `NOT EXISTS (…)` fragment for a
+ * {@link RelationExistencePredicate}. Shares the caller's {@link Bindings} so
+ * its parameters stay in positional order with the surrounding WHERE.
+ *
+ * - **Direct** (hasMany/hasOne/belongsTo/morphMany/morphOne): single subquery
+ *   joining `related.relatedColumn = outer.parentColumn`, plus `extraEquals`
+ *   (morph discriminator) on the related table and the constraint wheres.
+ * - **Through-pivot** (belongsToMany/morphToMany/morphedByMany): nested EXISTS —
+ *   pivot rows for this parent (+ `extraEquals` on the pivot) whose related row
+ *   exists (+ constraint wheres on the related table).
+ *
+ * Soft-delete scoping is intentionally NOT applied here — it's the constrain
+ * callback's responsibility (documented), matching the other adapters.
+ */
+export declare function compileExists(outerTable: string, predicate: RelationExistencePredicate, dialect: Dialect, b: Bindings): string;
+/**
+ * Compile one aggregate request into a correlated subselect expression, aliased
+ * as `(…) AS "alias"`, for injection into the main SELECT list. `exists` wraps
+ * the COUNT in `(… ) > 0`. Mirrors the orm-drizzle aggregate-subquery shape.
+ */
+export declare function compileAggregateSubselect(outerTable: string, req: AggregateRequest, dialect: Dialect, b: Bindings): string;
+/**
+ * Compile a single-scalar aggregate terminal — `SELECT fn(col) AS value FROM
+ * table WHERE <wheres>` — for the `_aggregate(fn, column?)` contract method
+ * (powers `instance.loadSum`/`loadMin`/etc.). `count`/`exists` ignore the
+ * column and use `COUNT(*)`; the builder coerces the scalar afterward.
+ */
+export declare function compileScalarAggregate(state: NativeQueryState, dialect: Dialect, fn: AggregateRequest['fn'], column: string | undefined): CompiledQuery;
+/** Engine-internal seam — exported for the query builder so it can share one
+ *  `Bindings` run across the WHERE (clauses + EXISTS fragments) and the
+ *  SELECT-list aggregate subselects. Construction is otherwise module-private.
+ *  (Deliberately NOT tagged internal: `stripInternal` would drop it from the
+ *  emitted d.ts, and it is consumed cross-package by @rudderjs/orm's engine
+ *  suites until PR-A3.) */
+export declare function makeBindings(dialect: Dialect): Bindings;
+export type { Bindings };
+//# sourceMappingURL=compiler.d.ts.map

package/dist/native/compiler.d.ts.map

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