tina4-nodejs 3.13.85 → 3.13.87

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

@@ -115,7 +115,7 @@ export class SQLiteAdapter implements DatabaseAdapter {
     return result;
   }
 
-  executeMany(sql: string, paramsList: unknown[][]): { totalAffected: number; lastInsertId?: number | bigint } {
+  executeMany(sql: string, paramsList: unknown[][]): { totalAffected: number; lastId?: number | bigint } {
     const stmt = this.db.prepare(sql);
     let totalAffected = 0;
     let lastId: number | bigint | undefined;
@@ -136,7 +136,7 @@ export class SQLiteAdapter implements DatabaseAdapter {
       throw e;
     }
 
-    return { totalAffected, lastInsertId: lastId };
+    return { totalAffected, lastId: lastId };
   }
 
   query<T = Record<string, unknown>>(sql: string, params?: unknown[]): T[] {
@@ -167,13 +167,13 @@ export class SQLiteAdapter implements DatabaseAdapter {
 
   insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): DatabaseResult {
     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]));
       const result = this.executeMany(sql, paramsList);
-      return { success: true, rowsAffected: result.totalAffected, lastInsertId: result.lastInsertId };
+      return { success: true, affectedRows: result.totalAffected, lastId: result.lastId };
     }
 
     const keys = Object.keys(data);
@@ -184,9 +184,9 @@ export class SQLiteAdapter implements DatabaseAdapter {
     try {
       const result = this.db.prepare(sql).run(...toSqlParams(values));
       this._lastInsertId = result.lastInsertRowid;
-      return { success: true, rowsAffected: Number(result.changes), lastInsertId: result.lastInsertRowid };
+      return { success: true, affectedRows: Number(result.changes), lastId: result.lastInsertRowid };
     } catch (e) {
-      return { success: false, rowsAffected: 0, error: (e as Error).message };
+      return { success: false, affectedRows: 0, error: (e as Error).message };
     }
   }
 
@@ -198,9 +198,9 @@ export class SQLiteAdapter implements DatabaseAdapter {
 
     try {
       const result = this.db.prepare(sql).run(...toSqlParams(values));
-      return { success: true, rowsAffected: Number(result.changes) };
+      return { success: true, affectedRows: Number(result.changes) };
     } catch (e) {
-      return { success: false, rowsAffected: 0, error: (e as Error).message };
+      return { success: false, affectedRows: 0, error: (e as Error).message };
     }
   }
 
@@ -209,18 +209,18 @@ export class SQLiteAdapter implements DatabaseAdapter {
       let totalAffected = 0;
       for (const row of filter) {
         const result = this.delete(table, row);
-        totalAffected += result.rowsAffected;
+        totalAffected += result.affectedRows;
       }
-      return { success: true, rowsAffected: totalAffected };
+      return { success: true, affectedRows: totalAffected };
     }
 
     if (typeof filter === "string") {
       const sql = filter ? `DELETE FROM "${table}" WHERE ${filter}` : `DELETE FROM "${table}"`;
       try {
         const result = this.db.prepare(sql).run(...toSqlParams(params ?? []));
-        return { success: true, rowsAffected: Number(result.changes) };
+        return { success: true, affectedRows: Number(result.changes) };
       } catch (e) {
-        return { success: false, rowsAffected: 0, error: (e as Error).message };
+        return { success: false, affectedRows: 0, error: (e as Error).message };
       }
     }
 
@@ -230,9 +230,9 @@ export class SQLiteAdapter implements DatabaseAdapter {
 
     try {
       const result = this.db.prepare(sql).run(...toSqlParams(values));
-      return { success: true, rowsAffected: Number(result.changes) };
+      return { success: true, affectedRows: Number(result.changes) };
     } 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/autoCrud.ts

@@ -233,7 +233,7 @@ export function generateCrudRoutes(models: DiscoveredModel[], options: AutoCrudO
 
         // Non-SQLite engines can't read a plain INSERT's auto-id back via
         // lastInsertId(); RETURNING the PK column lets us recover it. SQLite
-        // tolerates RETURNING but we still prefer its lastInsertId below.
+        // tolerates RETURNING but we still prefer its lastId below.
         const isSqlite = adapter.constructor.name === "SQLiteAdapter";
         const insertSql =
           `INSERT INTO "${tableName}" (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${placeholders})` +

package/packages/orm/src/cachedDatabase.ts

@@ -301,7 +301,7 @@ export class CachedDatabaseAdapter implements DatabaseAdapter {
     return this.adapter.execute(sql, params);
   }
 
-  executeMany(sql: string, paramsList: unknown[][]): { totalAffected: number; lastInsertId?: number | bigint } {
+  executeMany(sql: string, paramsList: unknown[][]): { totalAffected: number; lastId?: number | bigint } {
     if (this.enabled) this.invalidate();
     return this.adapter.executeMany(sql, paramsList);
   }

package/packages/orm/src/database.ts

@@ -117,7 +117,7 @@ export async function adapterCreateTable(
  *
  * SQLite returns `{ lastInsertRowid }`. PostgreSQL (pg) returns a result whose
  * `rows[0].id` holds the value when the statement had a `RETURNING` clause
- * (insertAsync adds one). MySQL/MSSQL adapters set the adapter's lastInsertId,
+ * (insertAsync adds one). MySQL/MSSQL adapters set the adapter's lastId,
  * so callers fall back to `adapter.lastInsertId()` when the result has neither.
  */
 export function extractLastInsertId(result: unknown): number | bigint | null {
@@ -125,7 +125,7 @@ export function extractLastInsertId(result: unknown): number | bigint | null {
     const r = result as any;
     if (r.lastInsertRowid !== undefined && r.lastInsertRowid !== null) return r.lastInsertRowid;
     if (r.rows?.[0]?.id !== undefined && r.rows[0].id !== null) return r.rows[0].id;
-    if (r.lastInsertId !== undefined && r.lastInsertId !== null) return r.lastInsertId;
+    if (r.lastId !== undefined && r.lastId !== null) return r.lastId;
   }
   return null;
 }
@@ -962,14 +962,26 @@ export class Database {
     const adapter = this.getNextAdapter();
     const results: unknown[] = [];
 
-    await adapterStartTransaction(adapter);
+    // Own the batch transaction ONLY when not already inside a caller's explicit
+    // transaction. inExplicitTransaction() is true when startTransaction() has
+    // pinned an adapter to this async context (getNextAdapter() returns that same
+    // pinned connection). If we owned a BEGIN/COMMIT here regardless, the inner
+    // COMMIT would commit the caller's OUTER transaction early and their later
+    // rollback() would undo nothing (the batch rows survive). So: standalone
+    // batch -> own BEGIN/COMMIT (atomic, all-or-nothing); nested batch -> join
+    // the caller's transaction and let their commit/rollback decide. Mirrors the
+    // sibling execute()/insert()/update()/delete() owns-guard, the PostgreSQL
+    // adapter's executeManyAsync owns-guard, and the Python master
+    // (Database.execute_many delegating to adapter.execute_many's owns_txn guard).
+    const owns = !this.inExplicitTransaction();
+    if (owns) await adapterStartTransaction(adapter);
     try {
       for (const params of paramSets) {
         results.push(await adapterExecute(adapter, sql, params));
       }
-      await adapterCommit(adapter);
+      if (owns) await adapterCommit(adapter);
     } catch (e) {
-      await adapterRollback(adapter);
+      if (owns) await adapterRollback(adapter);
       throw e;
     }
 

package/packages/orm/src/types.ts

@@ -51,10 +51,10 @@ export interface ColumnInfo {
 
 export interface DatabaseResult {
   success: boolean;
-  rowsAffected: number;
+  affectedRows: number;
   // string covers a non-integer primary key (e.g. a PostgreSQL UUID PK returns
   // its id as a string via RETURNING, not a SERIAL integer) — #256.
-  lastInsertId?: number | bigint | string;
+  lastId?: number | bigint | string;
   error?: string;
 }
 
@@ -63,7 +63,7 @@ export interface DatabaseAdapter {
   execute(sql: string, params?: unknown[]): unknown;
 
   /** Execute a single SQL statement with multiple parameter sets (batch). */
-  executeMany(sql: string, paramsList: unknown[][]): { totalAffected: number; lastInsertId?: number | bigint };
+  executeMany(sql: string, paramsList: unknown[][]): { totalAffected: number; lastId?: number | bigint };
 
   /** Query rows. */
   query<T = Record<string, unknown>>(sql: string, params?: unknown[]): T[];
@@ -74,7 +74,7 @@ export interface DatabaseAdapter {
   /** Fetch a single row or null. */
   fetchOne<T = Record<string, unknown>>(sql: string, params?: unknown[]): T | null;
 
-  /** Insert one or more rows into a table, returns result with lastInsertId. */
+  /** Insert one or more rows into a table, returns result with lastId. */
   insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): DatabaseResult;
 
   /** Update rows in a table matching filter, returns affected row count. */