tina4-nodejs 3.13.85 → 3.13.87

package/packages/orm/src/adapters/firebird.ts

@@ -236,10 +236,36 @@ export class FirebirdAdapter implements DatabaseAdapter {
     return translated;
   }
 
+  /**
+   * The handle every statement runs on. While an explicit transaction is open
+   * (startTransactionAsync set `this.transaction`), statements MUST run on that
+   * transaction object so they are undone by rollbackAsync() / persisted by
+   * commitAsync() — node-firebird's transaction exposes the same
+   * query()/execute() as the connection. With no transaction open we run on
+   * `this.db`, whose per-statement work auto-commits on the connection.
+   *
+   * This matches the Python master's contract (tina4_python/database/firebird.py):
+   * there, ALL statements run on the single connection and start_transaction()
+   * merely suppresses the per-statement autocommit in execute() so the batch
+   * stays open until commit()/rollback(). node-firebird has no such suppression
+   * hook — its `db.query/execute` always auto-commit — so the equivalent is to
+   * route statements through the transaction object instead. Same observable
+   * behaviour: an open transaction is atomic and rolls back cleanly.
+   *
+   * Previously every statement ran on `this.db` unconditionally, so the
+   * transaction created by startTransactionAsync() never saw a single statement
+   * — rollbackAsync() rolled back an EMPTY transaction and the already
+   * auto-committed write survived (silent no-op). Twin of the PHP pdo_firebird
+   * bug fixed in 3.13.86.
+   */
+  private statementHandle(): any {
+    return this.transaction ?? this.db;
+  }
+
   private queryPromise(sql: string, params?: unknown[]): Promise<any[]> {
     return new Promise((resolve, reject) => {
       const translated = this.translateSql(sql);
-      this.db.query(translated, params ?? [], (err: Error | null, result: any[]) => {
+      this.statementHandle().query(translated, params ?? [], (err: Error | null, result: any[]) => {
         if (err) reject(err);
         else resolve(result ?? []);
       });
@@ -249,7 +275,7 @@ export class FirebirdAdapter implements DatabaseAdapter {
   private executePromise(sql: string, params?: unknown[]): Promise<void> {
     return new Promise((resolve, reject) => {
       const translated = this.translateSql(sql);
-      this.db.execute(translated, params ?? [], (err: Error | null) => {
+      this.statementHandle().execute(translated, params ?? [], (err: Error | null) => {
         if (err) reject(err);
         else resolve();
       });
@@ -260,11 +286,11 @@ export class FirebirdAdapter implements DatabaseAdapter {
     throw new Error("Use executeAsync() for Firebird — async adapter requires async methods.");
   }
 
-  executeMany(sql: string, paramsList: unknown[][]): { totalAffected: number; lastInsertId?: number | bigint } {
+  executeMany(sql: string, paramsList: unknown[][]): { totalAffected: number; lastId?: number | bigint } {
     throw new Error("Use executeManyAsync() for Firebird — async adapter requires async methods.");
   }
 
-  async executeManyAsync(sql: string, paramsList: unknown[][]): Promise<{ totalAffected: number; lastInsertId?: number | bigint }> {
+  async executeManyAsync(sql: string, paramsList: unknown[][]): Promise<{ totalAffected: number; lastId?: number | bigint }> {
     let totalAffected = 0;
     for (const params of paramsList) {
       await this.executeAsync(sql, params);
@@ -333,16 +359,16 @@ export class FirebirdAdapter implements DatabaseAdapter {
     // the batch reports affectedRows == row count and no lastInsertId (same as the
     // single-row path). See PostgresAdapter for the array-crash rationale.
     if (Array.isArray(data)) {
-      if (data.length === 0) return { success: true, rowsAffected: 0 };
+      if (data.length === 0) return { success: true, affectedRows: 0 };
       const keys = Object.keys(data[0]);
       const placeholders = keys.map(() => "?").join(", ");
       const sql = `INSERT INTO "${table}" ("${keys.join('", "')}") VALUES (${placeholders})`;
       const paramsList = data.map((row) => keys.map((k) => row[k]));
       try {
         const result = await this.executeManyAsync(sql, paramsList);
-        return { success: true, rowsAffected: result.totalAffected, lastInsertId: result.lastInsertId };
+        return { success: true, affectedRows: result.totalAffected, lastId: result.lastId };
       } catch (e) {
-        return { success: false, rowsAffected: 0, error: (e as Error).message };
+        return { success: false, affectedRows: 0, error: (e as Error).message };
       }
     }
 
@@ -356,10 +382,10 @@ export class FirebirdAdapter implements DatabaseAdapter {
       // Firebird doesn't have a generic last_insert_id — return success without id
       return {
         success: true,
-        rowsAffected: 1,
+        affectedRows: 1,
       };
     } catch (e) {
-      return { success: false, rowsAffected: 0, error: (e as Error).message };
+      return { success: false, affectedRows: 0, error: (e as Error).message };
     }
   }
 
@@ -376,9 +402,9 @@ export class FirebirdAdapter implements DatabaseAdapter {
 
     try {
       await this.executePromise(sql, values);
-      return { success: true, rowsAffected: 1 };
+      return { success: true, affectedRows: 1 };
     } catch (e) {
-      return { success: false, rowsAffected: 0, error: (e as Error).message };
+      return { success: false, affectedRows: 0, error: (e as Error).message };
     }
   }
 
@@ -394,9 +420,9 @@ export class FirebirdAdapter implements DatabaseAdapter {
 
     try {
       await this.executePromise(sql, values);
-      return { success: true, rowsAffected: 1 };
+      return { success: true, affectedRows: 1 };
     } catch (e) {
-      return { success: false, rowsAffected: 0, error: (e as Error).message };
+      return { success: false, affectedRows: 0, error: (e as Error).message };
     }
   }
 

package/packages/orm/src/adapters/mongodb.ts

@@ -370,11 +370,11 @@ export class MongodbAdapter implements DatabaseAdapter {
     }
   }
 
-  executeMany(sql: string, paramsList: unknown[][]): { totalAffected: number; lastInsertId?: number | bigint } {
+  executeMany(sql: string, paramsList: unknown[][]): { totalAffected: number; lastId?: number | bigint } {
     throw new Error("Use executeManyAsync() for MongoDB — async adapter requires async methods.");
   }
 
-  async executeManyAsync(sql: string, paramsList: unknown[][]): Promise<{ totalAffected: number; lastInsertId?: number | bigint }> {
+  async executeManyAsync(sql: string, paramsList: unknown[][]): Promise<{ totalAffected: number; lastId?: number | bigint }> {
     let totalAffected = 0;
     for (const params of paramsList) {
       await this.executeAsync(sql, params);
@@ -453,14 +453,14 @@ export class MongodbAdapter implements DatabaseAdapter {
     const col = this.db.collection(table);
     try {
       if (Array.isArray(data)) {
-        if (data.length === 0) return { success: true, rowsAffected: 0 };
+        if (data.length === 0) return { success: true, affectedRows: 0 };
         const result = await col.insertMany(data, { session: this.session });
-        return { success: true, rowsAffected: result.insertedCount };
+        return { success: true, affectedRows: result.insertedCount };
       }
       const result = await col.insertOne(data, { session: this.session });
-      return { success: true, rowsAffected: 1, lastInsertId: undefined };
+      return { success: true, affectedRows: 1, lastId: undefined };
     } catch (e) {
-      return { success: false, rowsAffected: 0, error: (e as Error).message };
+      return { success: false, affectedRows: 0, error: (e as Error).message };
     }
   }
 
@@ -473,9 +473,9 @@ export class MongodbAdapter implements DatabaseAdapter {
     const col = this.db.collection(table);
     try {
       const result = await col.updateMany(filter, { $set: data }, { session: this.session });
-      return { success: true, rowsAffected: result.modifiedCount };
+      return { success: true, affectedRows: result.modifiedCount };
     } catch (e) {
-      return { success: false, rowsAffected: 0, error: (e as Error).message };
+      return { success: false, affectedRows: 0, error: (e as Error).message };
     }
   }
 
@@ -493,7 +493,7 @@ export class MongodbAdapter implements DatabaseAdapter {
           const r = await col.deleteMany(f, { session: this.session });
           total += r.deletedCount;
         }
-        return { success: true, rowsAffected: total };
+        return { success: true, affectedRows: total };
       }
 
       // String WHERE clause — not directly translatable; delete nothing safely
@@ -501,18 +501,18 @@ export class MongodbAdapter implements DatabaseAdapter {
         if (!filter.trim()) {
           // Empty filter = delete all documents
           const r = await col.deleteMany({}, { session: this.session });
-          return { success: true, rowsAffected: r.deletedCount };
+          return { success: true, affectedRows: r.deletedCount };
         }
         // Attempt parse via dummy SELECT wrapping
         const { filter: parsedFilter } = parseWhereClause(filter, []);
         const r = await col.deleteMany(parsedFilter, { session: this.session });
-        return { success: true, rowsAffected: r.deletedCount };
+        return { success: true, affectedRows: r.deletedCount };
       }
 
       const result = await col.deleteMany(filter as Record<string, unknown>, { session: this.session });
-      return { success: true, rowsAffected: result.deletedCount };
+      return { success: true, affectedRows: result.deletedCount };
     } catch (e) {
-      return { success: false, rowsAffected: 0, error: (e as Error).message };
+      return { success: false, affectedRows: 0, error: (e as Error).message };
     }
   }
 

package/packages/orm/src/adapters/mssql.ts

@@ -178,11 +178,11 @@ export class MssqlAdapter implements DatabaseAdapter {
     throw new Error("Use executeAsync() for MSSQL — async adapter requires async methods.");
   }
 
-  executeMany(sql: string, paramsList: unknown[][]): { totalAffected: number; lastInsertId?: number | bigint } {
+  executeMany(sql: string, paramsList: unknown[][]): { totalAffected: number; lastId?: number | bigint } {
     throw new Error("Use executeManyAsync() for MSSQL — async adapter requires async methods.");
   }
 
-  async executeManyAsync(sql: string, paramsList: unknown[][]): Promise<{ totalAffected: number; lastInsertId?: number | bigint }> {
+  async executeManyAsync(sql: string, paramsList: unknown[][]): Promise<{ totalAffected: number; lastId?: number | bigint }> {
     // Run the whole batch in ONE transaction so it is atomic (all-or-nothing) —
     // a bad row mid-batch rolls back the rows already inserted instead of
     // leaving a partial write. Mirrors the documented "wrapped in a transaction"
@@ -268,7 +268,7 @@ export class MssqlAdapter implements DatabaseAdapter {
     // tracked for a batch — affectedRows == row count is what callers rely on).
     // See PostgresAdapter for the array-crash rationale this branch fixes.
     if (Array.isArray(data)) {
-      if (data.length === 0) return { success: true, rowsAffected: 0 };
+      if (data.length === 0) return { success: true, affectedRows: 0 };
       const keys = Object.keys(data[0]);
       // `?` placeholders — executeManyAsync -> executeAsync runs convertPlaceholders,
       // which rewrites them to @p0, @p1, ... for tedious.
@@ -277,10 +277,10 @@ export class MssqlAdapter implements DatabaseAdapter {
       const paramsList = data.map((row) => keys.map((k) => row[k]));
       try {
         const result = await this.executeManyAsync(sql, paramsList);
-        if (result.lastInsertId !== undefined) this._lastInsertId = result.lastInsertId;
-        return { success: true, rowsAffected: result.totalAffected, lastInsertId: result.lastInsertId };
+        if (result.lastId !== undefined) this._lastInsertId = result.lastId;
+        return { success: true, affectedRows: result.totalAffected, lastId: result.lastId };
       } catch (e) {
-        return { success: false, rowsAffected: 0, error: (e as Error).message };
+        return { success: false, affectedRows: 0, error: (e as Error).message };
       }
     }
 
@@ -298,12 +298,12 @@ export class MssqlAdapter implements DatabaseAdapter {
         // A single-object insert affects exactly one row. Do NOT use
         // result.rowCount here: the statement is "INSERT ...; SELECT
         // SCOPE_IDENTITY()", and tedious sums the row counts of BOTH statements
-        // (1 for the INSERT + 1 for the SELECT), which reported rowsAffected=2.
-        rowsAffected: 1,
-        lastInsertId: id ?? undefined,
+        // (1 for the INSERT + 1 for the SELECT), which reported affectedRows=2.
+        affectedRows: 1,
+        lastId: id ?? undefined,
       };
     } catch (e) {
-      return { success: false, rowsAffected: 0, error: (e as Error).message };
+      return { success: false, affectedRows: 0, error: (e as Error).message };
     }
   }
 
@@ -324,9 +324,9 @@ export class MssqlAdapter implements DatabaseAdapter {
 
     try {
       const result = await this.execSqlPromise(sql, values);
-      return { success: true, rowsAffected: result.rowCount };
+      return { success: true, affectedRows: result.rowCount };
     } catch (e) {
-      return { success: false, rowsAffected: 0, error: (e as Error).message };
+      return { success: false, affectedRows: 0, error: (e as Error).message };
     }
   }
 
@@ -344,9 +344,9 @@ export class MssqlAdapter implements DatabaseAdapter {
 
     try {
       const result = await this.execSqlPromise(sql, values);
-      return { success: true, rowsAffected: result.rowCount };
+      return { success: true, affectedRows: result.rowCount };
     } catch (e) {
-      return { success: false, rowsAffected: 0, error: (e as Error).message };
+      return { success: false, affectedRows: 0, error: (e as Error).message };
     }
   }
 

package/packages/orm/src/adapters/mysql.ts

@@ -107,11 +107,11 @@ export class MysqlAdapter implements DatabaseAdapter {
     throw new Error("Use executeAsync() for MySQL — async adapter requires async methods.");
   }
 
-  executeMany(sql: string, paramsList: unknown[][]): { totalAffected: number; lastInsertId?: number | bigint } {
+  executeMany(sql: string, paramsList: unknown[][]): { totalAffected: number; lastId?: number | bigint } {
     throw new Error("Use executeManyAsync() for MySQL — async adapter requires async methods.");
   }
 
-  async executeManyAsync(sql: string, paramsList: unknown[][]): Promise<{ totalAffected: number; lastInsertId?: number | bigint }> {
+  async executeManyAsync(sql: string, paramsList: unknown[][]): Promise<{ totalAffected: number; lastId?: number | bigint }> {
     // Run the whole batch in ONE transaction so it is atomic (all-or-nothing) —
     // a bad row mid-batch rolls back the rows already inserted instead of
     // leaving a partial write. Mirrors the documented "wrapped in a transaction"
@@ -135,7 +135,7 @@ export class MysqlAdapter implements DatabaseAdapter {
       }
       throw e;
     }
-    return { totalAffected, lastInsertId: lastId };
+    return { totalAffected, lastId: lastId };
   }
 
   async executeAsync(sql: string, params?: unknown[]): Promise<unknown> {
@@ -193,17 +193,17 @@ export class MysqlAdapter implements DatabaseAdapter {
     // executeManyAsync (ONE connection). See PostgresAdapter for the rationale;
     // without this branch a list crashed/mis-built SQL via Object.keys() on the array.
     if (Array.isArray(data)) {
-      if (data.length === 0) return { success: true, rowsAffected: 0 };
+      if (data.length === 0) return { success: true, affectedRows: 0 };
       const keys = Object.keys(data[0]);
       const placeholders = keys.map(() => "?").join(", ");
       const sql = `INSERT INTO \`${table}\` (\`${keys.join("`, `")}\`) VALUES (${placeholders})`;
       const paramsList = data.map((row) => keys.map((k) => row[k]));
       try {
         const result = await this.executeManyAsync(sql, paramsList);
-        if (result.lastInsertId !== undefined) this._lastInsertId = result.lastInsertId;
-        return { success: true, rowsAffected: result.totalAffected, lastInsertId: result.lastInsertId };
+        if (result.lastId !== undefined) this._lastInsertId = result.lastId;
+        return { success: true, affectedRows: result.totalAffected, lastId: result.lastId };
       } catch (e) {
-        return { success: false, rowsAffected: 0, error: (e as Error).message };
+        return { success: false, affectedRows: 0, error: (e as Error).message };
       }
     }
 
@@ -217,11 +217,11 @@ export class MysqlAdapter implements DatabaseAdapter {
       this._lastInsertId = result.insertId ?? null;
       return {
         success: true,
-        rowsAffected: result.affectedRows ?? 1,
-        lastInsertId: result.insertId,
+        affectedRows: result.affectedRows ?? 1,
+        lastId: result.insertId,
       };
     } catch (e) {
-      return { success: false, rowsAffected: 0, error: (e as Error).message };
+      return { success: false, affectedRows: 0, error: (e as Error).message };
     }
   }
 
@@ -238,9 +238,9 @@ export class MysqlAdapter implements DatabaseAdapter {
 
     try {
       const result = await this.queryPromise(sql, values);
-      return { success: true, rowsAffected: result.affectedRows ?? 0 };
+      return { success: true, affectedRows: result.affectedRows ?? 0 };
     } catch (e) {
-      return { success: false, rowsAffected: 0, error: (e as Error).message };
+      return { success: false, affectedRows: 0, error: (e as Error).message };
     }
   }
 
@@ -256,9 +256,9 @@ export class MysqlAdapter implements DatabaseAdapter {
 
     try {
       const result = await this.queryPromise(sql, values);
-      return { success: true, rowsAffected: result.affectedRows ?? 0 };
+      return { success: true, affectedRows: result.affectedRows ?? 0 };
     } catch (e) {
-      return { success: false, rowsAffected: 0, error: (e as Error).message };
+      return { success: false, affectedRows: 0, error: (e as Error).message };
     }
   }
 

package/packages/orm/src/adapters/odbc.ts

@@ -79,7 +79,7 @@ export class OdbcAdapter implements DatabaseAdapter {
     throw new Error("Use executeAsync() for ODBC — async adapter requires async methods.");
   }
 
-  executeMany(sql: string, paramsList: unknown[][]): { totalAffected: number; lastInsertId?: number | bigint } {
+  executeMany(sql: string, paramsList: unknown[][]): { totalAffected: number; lastId?: number | bigint } {
     throw new Error("Use executeManyAsync() for ODBC — async adapter requires async methods.");
   }
 
@@ -152,14 +152,14 @@ export class OdbcAdapter implements DatabaseAdapter {
     this.ensureConnected();
     const result = await this.connection.query(sql, params ?? []);
     // Try to capture last insert id from result metadata if present
-    if (result && typeof result === "object" && "lastInsertId" in result) {
-      this._lastInsertId = (result as any).lastInsertId;
+    if (result && typeof result === "object" && "lastId" in result) {
+      this._lastInsertId = (result as any).lastId;
     }
     return result;
   }
 
   /** Execute a statement with multiple parameter sets inside a single transaction. */
-  async executeManyAsync(sql: string, paramsList: unknown[][]): Promise<{ totalAffected: number; lastInsertId?: number | bigint }> {
+  async executeManyAsync(sql: string, paramsList: unknown[][]): Promise<{ totalAffected: number; lastId?: number | bigint }> {
     this.ensureConnected();
     let totalAffected = 0;
     let lastId: number | bigint | undefined;
@@ -177,7 +177,7 @@ export class OdbcAdapter implements DatabaseAdapter {
     }
 
     if (lastId !== undefined) this._lastInsertId = lastId;
-    return { totalAffected, lastInsertId: lastId };
+    return { totalAffected, lastId: lastId };
   }
 
   /** Run a SELECT and return all matching rows. */
@@ -224,9 +224,9 @@ export class OdbcAdapter implements DatabaseAdapter {
 
     try {
       await this.connection.query(sql, values);
-      return { success: true, rowsAffected: 1, lastInsertId: this._lastInsertId ?? undefined };
+      return { success: true, affectedRows: 1, lastId: this._lastInsertId ?? undefined };
     } catch (e) {
-      return { success: false, rowsAffected: 0, error: (e as Error).message };
+      return { success: false, affectedRows: 0, error: (e as Error).message };
     }
   }
 
@@ -240,9 +240,9 @@ export class OdbcAdapter implements DatabaseAdapter {
 
     try {
       await this.connection.query(sql, values);
-      return { success: true, rowsAffected: 1 };
+      return { success: true, affectedRows: 1 };
     } catch (e) {
-      return { success: false, rowsAffected: 0, error: (e as Error).message };
+      return { success: false, affectedRows: 0, error: (e as Error).message };
     }
   }
 
@@ -257,9 +257,9 @@ export class OdbcAdapter implements DatabaseAdapter {
       let totalAffected = 0;
       for (const row of filter) {
         const result = await this.deleteAsync(table, row);
-        totalAffected += result.rowsAffected;
+        totalAffected += result.affectedRows;
       }
-      return { success: true, rowsAffected: totalAffected };
+      return { success: true, affectedRows: totalAffected };
     }
 
     if (typeof filter === "string") {
@@ -268,9 +268,9 @@ export class OdbcAdapter implements DatabaseAdapter {
         : `DELETE FROM "${table}"`;
       try {
         await this.connection.query(sql, []);
-        return { success: true, rowsAffected: 1 };
+        return { success: true, affectedRows: 1 };
       } catch (e) {
-        return { success: false, rowsAffected: 0, error: (e as Error).message };
+        return { success: false, affectedRows: 0, error: (e as Error).message };
       }
     }
 
@@ -280,9 +280,9 @@ export class OdbcAdapter implements DatabaseAdapter {
 
     try {
       await this.connection.query(sql, values);
-      return { success: true, rowsAffected: 1 };
+      return { success: true, affectedRows: 1 };
     } catch (e) {
-      return { success: false, rowsAffected: 0, error: (e as Error).message };
+      return { success: false, affectedRows: 0, error: (e as Error).message };
     }
   }
 

package/packages/orm/src/adapters/postgres.ts

@@ -122,7 +122,7 @@ export class PostgresAdapter implements DatabaseAdapter {
 
   /**
    * Normalise an `id` column value (typed `unknown` because pg row values are
-   * `unknown`) into the shape `_lastInsertId` / `DatabaseResult.lastInsertId`
+   * `unknown`) into the shape `_lastInsertId` / `DatabaseResult.lastId`
    * expect. At runtime PG returns numeric PKs as number/bigint (the int8/numeric
    * type parsers above coerce them to Number); a numeric string is coerced to a
    * number so the SERIAL path always returns the integer id.
@@ -148,12 +148,12 @@ export class PostgresAdapter implements DatabaseAdapter {
     throw new Error("Use executeAsync() for PostgreSQL — async adapter requires async methods.");
   }
 
-  executeMany(sql: string, paramsList: unknown[][]): { totalAffected: number; lastInsertId?: number | bigint } {
+  executeMany(sql: string, paramsList: unknown[][]): { totalAffected: number; lastId?: number | bigint } {
     throw new Error("Use executeManyAsync() for PostgreSQL — async adapter requires async methods.");
   }
 
   /** Async executeMany for real usage. */
-  async executeManyAsync(sql: string, paramsList: unknown[][]): Promise<{ totalAffected: number; lastInsertId?: number | bigint }> {
+  async executeManyAsync(sql: string, paramsList: unknown[][]): Promise<{ totalAffected: number; lastId?: number | bigint }> {
     // Run the whole batch in ONE transaction so it is atomic (all-or-nothing) —
     // a bad row mid-batch rolls back the rows already inserted instead of
     // leaving a partial write. Mirrors the documented "wrapped in a transaction"
@@ -168,8 +168,8 @@ export class PostgresAdapter implements DatabaseAdapter {
       for (const params of paramsList) {
         const result = await this.executeAsync(sql, params);
         totalAffected++;
-        if (result && typeof result === "object" && "lastInsertId" in (result as any)) {
-          lastId = (result as any).lastInsertId;
+        if (result && typeof result === "object" && "lastId" in (result as any)) {
+          lastId = (result as any).lastId;
         }
       }
       if (owns) await this.commitAsync();
@@ -179,7 +179,7 @@ export class PostgresAdapter implements DatabaseAdapter {
       }
       throw e;
     }
-    return { totalAffected, lastInsertId: lastId };
+    return { totalAffected, lastId: lastId };
   }
 
   /** Async execute for real usage. */
@@ -242,17 +242,17 @@ export class PostgresAdapter implements DatabaseAdapter {
     // — producing garbage SQL (mirrors the Python `'list' has no attribute keys`
     // crash this fix addresses).
     if (Array.isArray(data)) {
-      if (data.length === 0) return { success: true, rowsAffected: 0 };
+      if (data.length === 0) return { success: true, affectedRows: 0 };
       const keys = Object.keys(data[0]);
       const placeholders = keys.map(() => "?").join(", ");
       const sql = `INSERT INTO "${table}" ("${keys.join('", "')}") VALUES (${placeholders})`;
       const paramsList = data.map((row) => keys.map((k) => row[k]));
       try {
         const result = await this.executeManyAsync(sql, paramsList);
-        if (result.lastInsertId !== undefined) this._lastInsertId = result.lastInsertId;
-        return { success: true, rowsAffected: result.totalAffected, lastInsertId: result.lastInsertId };
+        if (result.lastId !== undefined) this._lastInsertId = result.lastId;
+        return { success: true, affectedRows: result.totalAffected, lastId: result.lastId };
       } catch (e) {
-        return { success: false, rowsAffected: 0, error: (e as Error).message };
+        return { success: false, affectedRows: 0, error: (e as Error).message };
       }
     }
 
@@ -268,11 +268,11 @@ export class PostgresAdapter implements DatabaseAdapter {
       if (id !== null) this._lastInsertId = id;
       return {
         success: true,
-        rowsAffected: result.rowCount ?? 1,
-        lastInsertId: id ?? undefined,
+        affectedRows: result.rowCount ?? 1,
+        lastId: id ?? undefined,
       };
     } catch (e) {
-      return { success: false, rowsAffected: 0, error: (e as Error).message };
+      return { success: false, affectedRows: 0, error: (e as Error).message };
     }
   }
 
@@ -293,9 +293,9 @@ export class PostgresAdapter implements DatabaseAdapter {
 
     try {
       const result = await this.client!.query(sql, values);
-      return { success: true, rowsAffected: result.rowCount ?? 0 };
+      return { success: true, affectedRows: result.rowCount ?? 0 };
     } catch (e) {
-      return { success: false, rowsAffected: 0, error: (e as Error).message };
+      return { success: false, affectedRows: 0, error: (e as Error).message };
     }
   }
 
@@ -313,9 +313,9 @@ export class PostgresAdapter implements DatabaseAdapter {
 
     try {
       const result = await this.client!.query(sql, values);
-      return { success: true, rowsAffected: result.rowCount ?? 0 };
+      return { success: true, affectedRows: result.rowCount ?? 0 };
     } catch (e) {
-      return { success: false, rowsAffected: 0, error: (e as Error).message };
+      return { success: false, affectedRows: 0, error: (e as Error).message };
     }
   }
 
@@ -325,6 +325,12 @@ export class PostgresAdapter implements DatabaseAdapter {
 
   async startTransactionAsync(): Promise<void> {
     await this.executeAsync("BEGIN");
+    // Mark the connection as inside an explicit transaction so executeManyAsync's
+    // owns-guard (owns = !_inTransaction) joins THIS transaction instead of
+    // opening its own inner BEGIN/COMMIT (which would commit this outer
+    // transaction early and defeat a later rollback). Mirrors the Python master
+    // (tina4_python/database/postgres.py start_transaction -> _in_transaction = True).
+    this._inTransaction = true;
   }
 
   commit(): void {
@@ -333,6 +339,9 @@ export class PostgresAdapter implements DatabaseAdapter {
 
   async commitAsync(): Promise<void> {
     await this.executeAsync("COMMIT");
+    // Transaction closed — clear the flag so subsequent standalone batches own
+    // their own transaction again (parity with Python master commit()).
+    this._inTransaction = false;
   }
 
   rollback(): void {
@@ -341,6 +350,8 @@ export class PostgresAdapter implements DatabaseAdapter {
 
   async rollbackAsync(): Promise<void> {
     await this.executeAsync("ROLLBACK");
+    // Transaction closed — clear the flag (parity with Python master rollback()).
+    this._inTransaction = false;
   }
 
   tables(): string[] {