turbine-orm 0.29.0 → 0.31.0

package/dist/cjs/powql.js

@@ -142,7 +142,14 @@ 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[(0, schema_js_1.snakeToCamel)(table)]) !== false
+                : warnOpt !== false;
         this.onQuery = options._onQuery;
     }
     // -------------------------------------------------------------------------
@@ -447,7 +454,7 @@ 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(`${(0, powdb_js_1.quotePowqlIdent)(through.table)} filter .${targetJCol} in (${ph}) { .${sourceJCol} }`, params, timeout);
                 for (const r of rows) {
                     const v = r[sourceJCol];
                     if (v != null)
@@ -599,7 +606,7 @@ 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;
     }
@@ -748,7 +755,7 @@ 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 = `${(0, powdb_js_1.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]);
@@ -830,6 +837,14 @@ 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 (0, powdb_js_1.quotePowqlIdent)(this.table);
+    }
     async create(args) {
         return this.withMiddleware('create', args, async () => {
             if ((0, nested_write_js_1.hasRelationFields)(args.data, this.meta)) {
@@ -838,9 +853,11 @@ 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) => `${(0, powdb_js_1.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 errors_js_1.NotFoundError({ table: this.table, where: data });
@@ -855,10 +872,10 @@ 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) => `${(0, powdb_js_1.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);
         });
     }
@@ -873,7 +890,7 @@ 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 errors_js_1.NotFoundError({ table: this.table, where: args.where });
@@ -888,7 +905,7 @@ 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 };
         });
     }
@@ -903,7 +920,7 @@ class PowqlInterface {
             }
             const colMeta = this.column(field);
             const ref = this.ref(field);
-            const col = colMeta.name;
+            const col = (0, powdb_js_1.quotePowqlIdent)(colMeta.name);
             if (value !== null && typeof value === 'object' && !(value instanceof Date)) {
                 const opObj = value;
                 if ('set' in opObj)
@@ -961,21 +978,34 @@ 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 Promise.resolve().then(() => __importStar(require('./client.js')));
             const tx = new TransactionClient(client, this.schema, this.middlewares, this.options);
             const ctx = { schema: this.schema, tx: tx };
-            const result = await fn(ctx);
+            // Plant the single-writer re-entrancy marker for the implicit tx's
+            // subtree (same seam TurbineClient.$transaction uses) — user code that
+            // fires db.$transaction from inside (e.g. $use middleware around a
+            // nested-write child op) must fast-fail E017, not queue into deadlock.
+            const wrap = client
+                .wrapTransactionCallback;
+            const result = await (wrap ? wrap(() => fn(ctx)) : fn(ctx));
             await client.query(d?.commitStatement?.() ?? 'commit');
             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;
         }
@@ -998,7 +1028,7 @@ 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 errors_js_1.NotFoundError({ table: this.table, where: args.where });
@@ -1012,7 +1042,7 @@ 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 };
         });
     }
@@ -1027,14 +1057,14 @@ class PowqlInterface {
             }
             const params = [];
             const createBody = this.scalarData(createData)
-                .map((a) => `${a.col.name} := ${this.writeRef(a.value, a.col, params)}`)
+                .map((a) => `${(0, powdb_js_1.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)
@@ -1079,7 +1109,7 @@ 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));
         });
     }
@@ -1099,12 +1129,12 @@ 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;
                 }
@@ -1116,7 +1146,7 @@ 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;
             }
@@ -1150,7 +1180,7 @@ 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) => {