turbine-orm 0.28.3 → 0.30.0

package/dist/powql.d.ts

@@ -156,6 +156,12 @@ export declare class PowqlInterface<T extends object = Record<string, unknown>>
      * it and the trailing `returning` reads it back — as is any non-string PK.
      */
     private applyPkDefault;
+    /**
+     * The table name as a PowQL type reference — backtick-quoted when it is a
+     * reserved word (e.g. a table named `order`). Used in every emitted
+     * statement; plain `this.table` stays in error messages.
+     */
+    private get qt();
     create(args: CreateArgs<T>): Promise<T>;
     createMany(args: CreateManyArgs<T>): Promise<T[]>;
     update(args: UpdateArgs<T>): Promise<T>;

package/dist/powql.js

@@ -37,9 +37,9 @@
 import { randomUUID } from 'node:crypto';
 import { NotFoundError, TimeoutError, UnsupportedFeatureError, ValidationError } from './errors.js';
 import { executeNestedCreate, executeNestedUpdate, hasRelationFields, } from './nested-write.js';
-import { PowdbFloatParam, powqlColumnType, rowToEntity } from './powdb.js';
+import { PowdbFloatParam, powqlColumnType, quotePowqlIdent, rowToEntity } from './powdb.js';
 import { escapeLike } from './query/utils.js';
-import { normalizeKeyColumns, } from './schema.js';
+import { normalizeKeyColumns, snakeToCamel, } from './schema.js';
 /**
  * Max parent keys per relation-loader `in (…)` query. A `with` over a large
  * parent set is split into batches of this size so a single query never exceeds
@@ -106,7 +106,14 @@ export class PowqlInterface {
         }
         this.meta = meta;
         this.defaultLimit = options.defaultLimit;
-        this.warnOnUnlimited = options.warnOnUnlimited !== false;
+        // Same per-table resolution as QueryInterface: an object map accepts BOTH
+        // the snake_case table name and the camelCase accessor as keys (snake_case
+        // wins on conflict); unlisted tables keep the default (warn on).
+        const warnOpt = options.warnOnUnlimited;
+        this.warnOnUnlimited =
+            typeof warnOpt === 'object' && warnOpt !== null
+                ? (warnOpt[table] ?? warnOpt[snakeToCamel(table)]) !== false
+                : warnOpt !== false;
         this.onQuery = options._onQuery;
     }
     // -------------------------------------------------------------------------
@@ -411,7 +418,7 @@ export class PowqlInterface {
                 const chunk = targetPks.slice(i, i + MAX_RELATION_KEYS);
                 const params = [];
                 const ph = chunk.map((v) => this.param(v, params)).join(', ');
-                const { rows } = await this.exec(`${through.table} filter .${targetJCol} in (${ph}) { .${sourceJCol} }`, params, timeout);
+                const { rows } = await this.exec(`${quotePowqlIdent(through.table)} filter .${targetJCol} in (${ph}) { .${sourceJCol} }`, params, timeout);
                 for (const r of rows) {
                     const v = r[sourceJCol];
                     if (v != null)
@@ -563,7 +570,7 @@ export class PowqlInterface {
         }
         const limitClause = limit !== undefined ? ` limit ${this.param(limit, params)}` : '';
         const offsetClause = args.offset ? ` offset ${this.param(args.offset, params)}` : '';
-        const powql = `${this.table}${distinct}${filter}${order}${limitClause}${offsetClause} ${this.projection(cols)}`;
+        const powql = `${this.qt}${distinct}${filter}${order}${limitClause}${offsetClause} ${this.projection(cols)}`;
         const { rows } = await this.exec(powql, params, args.timeout);
         return rows;
     }
@@ -712,7 +719,7 @@ export class PowqlInterface {
             const chunk = parentKeys.slice(i, i + MAX_RELATION_KEYS);
             const params = [];
             const placeholders = chunk.map((v) => this.param(v, params)).join(', ');
-            const powql = `${through.table} filter .${sourceJCol} in (${placeholders}) { .${sourceJCol}, .${targetJCol} }`;
+            const powql = `${quotePowqlIdent(through.table)} filter .${sourceJCol} in (${placeholders}) { .${sourceJCol}, .${targetJCol} }`;
             const { rows } = await this.exec(powql, params, timeout);
             for (const row of rows) {
                 const sv = String(row[sourceJCol]);
@@ -794,6 +801,14 @@ export class PowqlInterface {
         }
         return out;
     }
+    /**
+     * The table name as a PowQL type reference — backtick-quoted when it is a
+     * reserved word (e.g. a table named `order`). Used in every emitted
+     * statement; plain `this.table` stays in error messages.
+     */
+    get qt() {
+        return quotePowqlIdent(this.table);
+    }
     async create(args) {
         return this.withMiddleware('create', args, async () => {
             if (hasRelationFields(args.data, this.meta)) {
@@ -802,9 +817,11 @@ export class PowqlInterface {
             const data = this.applyPkDefault(args.data);
             const assigns = this.scalarData(data);
             const params = [];
-            const body = assigns.map((a) => `${a.col.name} := ${this.writeRef(a.value, a.col, params)}`).join(', ');
+            const body = assigns
+                .map((a) => `${quotePowqlIdent(a.col.name)} := ${this.writeRef(a.value, a.col, params)}`)
+                .join(', ');
             // `returning` surfaces the inserted row (all columns, schema order) in one round-trip.
-            const { rows } = await this.exec(`insert ${this.table} { ${body} } returning`, params, args.timeout);
+            const { rows } = await this.exec(`insert ${this.qt} { ${body} } returning`, params, args.timeout);
             const row = rows.length ? this.shape(rows)[0] : null;
             if (!row)
                 throw new NotFoundError({ table: this.table, where: data });
@@ -819,10 +836,10 @@ export class PowqlInterface {
             const params = [];
             const tuples = inputs.map((d) => {
                 const assigns = this.scalarData(d);
-                return `{ ${assigns.map((a) => `${a.col.name} := ${this.writeRef(a.value, a.col, params)}`).join(', ')} }`;
+                return `{ ${assigns.map((a) => `${quotePowqlIdent(a.col.name)} := ${this.writeRef(a.value, a.col, params)}`).join(', ')} }`;
             });
             // Multi-row insert with `returning` hands back every inserted row in one round-trip.
-            const { rows } = await this.exec(`insert ${this.table} ${tuples.join(', ')} returning`, params, args.timeout);
+            const { rows } = await this.exec(`insert ${this.qt} ${tuples.join(', ')} returning`, params, args.timeout);
             return this.shape(rows);
         });
     }
@@ -837,7 +854,7 @@ export class PowqlInterface {
             this.assertCompiledWhere(where, false, 'update');
             const setClause = this.buildUpdateAssignments(args.data, params);
             // `returning` hands back the post-update row(s); take the first (single-row contract).
-            const { rows } = await this.exec(`${this.table} filter ${where} update { ${setClause} } returning`, params, args.timeout);
+            const { rows } = await this.exec(`${this.qt} filter ${where} update { ${setClause} } returning`, params, args.timeout);
             const row = rows.length ? this.shape(rows)[0] : null;
             if (!row)
                 throw new NotFoundError({ table: this.table, where: args.where });
@@ -852,7 +869,7 @@ export class PowqlInterface {
             this.assertCompiledWhere(where, args.allowFullTableScan, 'updateMany');
             const setClause = this.buildUpdateAssignments(args.data, params);
             const filter = where ? ` filter ${where}` : '';
-            const { rowCount } = await this.exec(`${this.table}${filter} update { ${setClause} }`, params, args.timeout);
+            const { rowCount } = await this.exec(`${this.qt}${filter} update { ${setClause} }`, params, args.timeout);
             return { count: rowCount };
         });
     }
@@ -867,7 +884,7 @@ export class PowqlInterface {
             }
             const colMeta = this.column(field);
             const ref = this.ref(field);
-            const col = colMeta.name;
+            const col = quotePowqlIdent(colMeta.name);
             if (value !== null && typeof value === 'object' && !(value instanceof Date)) {
                 const opObj = value;
                 if ('set' in opObj)
@@ -925,8 +942,10 @@ export class PowqlInterface {
         // drifts from `powdbDialect`; falls back to the literal lowercase keywords.
         const d = this.options.dialect;
         const client = await this.pool.connect();
+        let began = false;
         try {
             await client.query(d?.beginStatement?.() ?? 'begin');
+            began = true;
             const { TransactionClient } = await import('./client.js');
             const tx = new TransactionClient(client, this.schema, this.middlewares, this.options);
             const ctx = { schema: this.schema, tx: tx };
@@ -935,11 +954,16 @@ export class PowqlInterface {
             return result;
         }
         catch (err) {
-            try {
-                await client.query(d?.rollbackStatement?.() ?? 'rollback');
-            }
-            catch {
-                /* best-effort — the connection may be gone */
+            // Only roll back a transaction we actually opened — a failed BEGIN
+            // (queue timeout, re-entrancy E017) must not emit a stray ROLLBACK that
+            // could land inside another transaction on a shared engine handle.
+            if (began) {
+                try {
+                    await client.query(d?.rollbackStatement?.() ?? 'rollback');
+                }
+                catch {
+                    /* best-effort — the connection may be gone */
+                }
             }
             throw err;
         }
@@ -962,7 +986,7 @@ export class PowqlInterface {
             const where = this.buildWhere(resolvedWhere, params);
             this.assertCompiledWhere(where, false, 'delete');
             // `returning` hands back the deleted row(s) — no separate pre-image reselect needed.
-            const { rows } = await this.exec(`${this.table} filter ${where} delete returning`, params, args.timeout);
+            const { rows } = await this.exec(`${this.qt} filter ${where} delete returning`, params, args.timeout);
             const row = rows.length ? this.shape(rows)[0] : null;
             if (!row)
                 throw new NotFoundError({ table: this.table, where: args.where });
@@ -976,7 +1000,7 @@ export class PowqlInterface {
             const where = this.buildWhere(resolvedWhere, params);
             this.assertCompiledWhere(where, args.allowFullTableScan, 'deleteMany');
             const filter = where ? ` filter ${where}` : '';
-            const { rowCount } = await this.exec(`${this.table}${filter} delete`, params, args.timeout);
+            const { rowCount } = await this.exec(`${this.qt}${filter} delete`, params, args.timeout);
             return { count: rowCount };
         });
     }
@@ -991,14 +1015,14 @@ export class PowqlInterface {
             }
             const params = [];
             const createBody = this.scalarData(createData)
-                .map((a) => `${a.col.name} := ${this.writeRef(a.value, a.col, params)}`)
+                .map((a) => `${quotePowqlIdent(a.col.name)} := ${this.writeRef(a.value, a.col, params)}`)
                 .join(', ');
             const updateBody = this.buildUpdateAssignments(args.update, params);
             // PowDB 0.7.0's `upsert` statement does NOT accept a trailing `returning`
             // (verified: "unexpected trailing token … 'returning'"), because it is one
             // atomic insert-or-update, not two branches. So upsert alone keeps the
             // reselect-by-PK fetch; create/update/delete all use `returning`.
-            await this.exec(`upsert ${this.table} on .${pkCol} { ${createBody} } on conflict { ${updateBody} }`, params, args.timeout);
+            await this.exec(`upsert ${this.qt} on .${pkCol} { ${createBody} } on conflict { ${updateBody} }`, params, args.timeout);
             const pkField = this.meta.reverseColumnMap[pkCol] ?? pkCol;
             const row = await this.reselectByPk(createData[pkField], args.timeout);
             if (!row)
@@ -1043,7 +1067,7 @@ export class PowqlInterface {
             const resolvedWhere = await this.resolveRelationFilters(args.where, args.timeout);
             const where = this.buildWhere(resolvedWhere, params);
             const filter = where ? ` filter ${where}` : '';
-            const { rows } = await this.exec(`count(${this.table}${filter})`, params, args.timeout);
+            const { rows } = await this.exec(`count(${this.qt}${filter})`, params, args.timeout);
             return Number((rows[0]?.value ?? rows[0]?.count ?? 0));
         });
     }
@@ -1063,12 +1087,12 @@ export class PowqlInterface {
             };
             if (args._count) {
                 if (args._count === true) {
-                    result._count = (await scalar(`count(${this.table}${filter})`)) ?? 0;
+                    result._count = (await scalar(`count(${this.qt}${filter})`)) ?? 0;
                 }
                 else {
                     const counts = {};
                     for (const field of Object.keys(args._count).filter((f) => args._count[f])) {
-                        counts[field] = (await scalar(`count(${this.table}${filter} { ${this.ref(field)} })`)) ?? 0;
+                        counts[field] = (await scalar(`count(${this.qt}${filter} { ${this.ref(field)} })`)) ?? 0;
                     }
                     result._count = counts;
                 }
@@ -1080,7 +1104,7 @@ export class PowqlInterface {
                 const acc = {};
                 for (const field of Object.keys(spec).filter((f) => spec[f])) {
                     const powfn = fn.slice(1); // sum/avg/min/max
-                    acc[field] = await scalar(`${powfn}(${this.table}${filter} { ${this.ref(field)} })`);
+                    acc[field] = await scalar(`${powfn}(${this.qt}${filter} { ${this.ref(field)} })`);
                 }
                 result[fn] = acc;
             }
@@ -1114,7 +1138,7 @@ export class PowqlInterface {
             }
             const having = this.buildHaving(args.having, params);
             const order = this.buildOrder(args.orderBy);
-            const powql = `${this.table}${filter} group ${groupKeys.join(', ')}${having}${order} { ${proj.join(', ')} }`;
+            const powql = `${this.qt}${filter} group ${groupKeys.join(', ')}${having}${order} { ${proj.join(', ')} }`;
             const { rows } = await this.exec(powql, params, args.timeout);
             // Reshape: group keys → camel fields + coerced; aggregates → nested {_sum:{field}}.
             return rows.map((raw) => {

package/dist/query/builder.d.ts

@@ -55,6 +55,12 @@ export declare class QueryInterface<T extends object, R extends object = {}> {
     /** Pre-computed column type lookups (avoids linear scans per query) */
     private readonly columnPgTypeMap;
     private readonly columnArrayTypeMap;
+    /**
+     * Columns whose type lives in a DIFFERENT schema than the introspected one
+     * (ColumnMetadata.pgTypeSchema is recorded only in that case) — such columns
+     * must never receive this schema's `::"enum"` cast (see enumTypeForColumn).
+     */
+    private readonly crossSchemaTypeColumns;
     /** Tracks tables that have already triggered a deep-with warning (one-time) */
     private readonly deepWithWarned;
     /**
@@ -249,7 +255,10 @@ export declare class QueryInterface<T extends object, R extends object = {}> {
      * loop calling `db.users.findMany()` thousands of times only logs once.
      * Suppressed when `defaultLimit` is configured (the caller has already
      * opted in to a bounded query) and when the user passed an explicit
-     * `limit`, `take`, or `cursor`.
+     * `limit`, `take`, or `cursor`. A per-call `warnOnUnlimited` overrides the
+     * config-level setting in either direction (`false` silences a call that
+     * intentionally reads the full set; `true` forces the warning even when
+     * disabled in config).
      */
     private maybeWarnUnlimited;
     /**
@@ -429,7 +438,12 @@ export declare class QueryInterface<T extends object, R extends object = {}> {
     private collectRelFilterParams;
     /** Collect params from operator clauses. Mirrors buildOperatorClauses. */
     private collectOperatorParams;
-    /** Collect params from JSON filter. Mirrors buildJsonFilterClauses. */
+    /**
+     * Collect params from JSON filter. Mirrors buildJsonFilterClauses exactly:
+     * the `path` is bound at most once (its placeholder is shared by every
+     * extraction clause), then equals/contains/hasKey values, then the range
+     * comparison values in {@link JSON_RANGE_OPERATORS} order.
+     */
     private collectJsonFilterParams;
     /** Collect params from array filter. Mirrors buildArrayFilterClauses. */
     private collectArrayFilterParams;
@@ -545,6 +559,28 @@ export declare class QueryInterface<T extends object, R extends object = {}> {
      * (relation targets, not just `this.table`).
      */
     private pgTypeForColumn;
+    /**
+     * The Postgres enum type name for a column, when the schema knows one.
+     *
+     * Introspection stores each column's `udt_name` in `pgTypes` and every
+     * database enum in `schema.enums` (typname → labels); a column whose type
+     * matches an enum key needs an explicit `::"EnumName"` cast on its write
+     * binds — bulk-insert forms like `UNNEST($1::text[])` otherwise type the
+     * value as text and Postgres refuses the implicit text→enum coercion
+     * ("column X is of type Y but expression is of type text").
+     *
+     * Postgres-only by construction: gated on the active dialect being
+     * `postgresql` AND on `schema.enums` having entries (only PG introspection
+     * produces them — `defineSchema` and the other engines leave it empty), so
+     * SQLite/MySQL/MSSQL/PowDB output is byte-identical.
+     */
+    private enumTypeForColumn;
+    /**
+     * `::"EnumName"` cast suffix for a write-bind placeholder on an enum
+     * column; `''` for every other column, so non-enum SQL stays byte-identical.
+     * The type name is an introspected identifier and is quoted via the dialect.
+     */
+    private enumCastSuffix;
     /**
      * Equality-fallthrough guard shared by every SQL-build path AND every
      * cache-hit param-collect path. A plain object literal that matched no known
@@ -899,11 +935,32 @@ export declare class QueryInterface<T extends object, R extends object = {}> {
      * E.g. '_text' → 'text', '_int4' → 'integer'
      */
     private getArrayElementType;
+    /**
+     * Validate and enumerate the range comparisons (`gt`/`gte`/`lt`/`lte`) on a
+     * JSON filter, in the fixed {@link JSON_RANGE_OPERATORS} order. Shared by
+     * the SQL-build path ({@link buildJsonFilterClauses}) and the cache-hit
+     * param-collect path ({@link collectJsonFilterParams}) so both always agree
+     * on which params are pushed — and both throw identically for invalid
+     * shapes, so a warmed cache can never skip validation.
+     */
+    private jsonRangeEntries;
     /**
      * Build SQL clauses for JSONB filter operators on a column.
-     * Supports: path, equals, contains, hasKey.
+     * Supports: path, equals, contains, hasKey, gt, gte, lt, lte.
+     *
+     * The `path` param is bound at most once and its placeholder is shared by
+     * every clause that extracts it (equals + range ops), so the param list
+     * stays byte-identical to {@link collectJsonFilterParams}.
      */
     private buildJsonFilterClauses;
+    /**
+     * Cast an extracted JSON path text value to a numeric type for range
+     * comparison. PostgreSQL uses `(expr)::numeric` (exact — the right way to
+     * compare JSON numbers, and `::float` would lose precision on big ints);
+     * other dialects route through {@link Dialect.castAggregate} (SQLite/MySQL/
+     * SQL Server have no `::` operator) as a float cast.
+     */
+    private castJsonNumeric;
     /**
      * Build SQL clauses for Array filter operators on a column.
      * Supports: has, hasEvery, hasSome, isEmpty.