feat(js-connectors): add support for "last insert id" in ResultSet (#…

…4124)

* feat(js-connectors): enable last_insert_id support in Rust

* feat(js-connectors): enable lastInsertId in TypeScript, fix panic on prisma.model.create for autoincrement columns in PlanetScale

* chore(js-connectors): add smoke tests for createOne with autoincrement columns

quaint/src/connector/result_set.rs

@@ -28,8 +28,7 @@ impl ResultSet {
         }
     }
 
-    #[cfg(any(feature = "sqlite", feature = "mysql"))]
-    pub(crate) fn set_last_insert_id(&mut self, id: u64) {
+    pub fn set_last_insert_id(&mut self, id: u64) {
         self.last_insert_id = Some(id);
     }
 

query-engine/js-connectors/js/js-connector-utils/src/types.ts

@@ -3,9 +3,28 @@ import { ColumnTypeEnum } from './const'
 export type ColumnType = typeof ColumnTypeEnum[keyof typeof ColumnTypeEnum]
 
 export interface ResultSet {
+  /**
+   * List of column types appearing in a database query, in the same order as `columnNames`.
+   * They are used within the Query Engine to convert values from JS to Quaint values.
+   */
   columnTypes: Array<ColumnType>
+
+  /**
+   * List of column names appearing in a database query, in the same order as `columnTypes`.
+   */
   columnNames: Array<string>
+
+  /**
+   * List of rows retrieved from a database query.
+   * Each row is a list of values, whose length matches `columnNames` and `columnTypes`.
+   */
   rows: Array<Array<any>>
+
+  /**
+   * The last ID of an `INSERT` statement, if any.
+   * This is required for `AUTO_INCREMENT` columns in MySQL and SQLite-flavoured databases.
+   */
+  lastInsertId?: string
 }
 
 export interface Query {

query-engine/js-connectors/js/planetscale-js-connector/src/planetscale.ts

@@ -77,13 +77,14 @@ class PrismaPlanetScale implements Connector, Closeable {
     const tag = '[js::query_raw]'
     debug(`${tag} %O`, query)
 
-    const { fields, rows: results } = await this.performIO(query)
+    const { fields, insertId: lastInsertId, rows: results } = await this.performIO(query)
 
     const columns = fields.map(field => field.name)
     const resultSet: ResultSet = {
       columnNames: columns,
       columnTypes: fields.map(field => fieldToColumnType(field.type as PlanetScaleColumnType)),
       rows: results.map(result => columns.map(column => result[column])),
+      lastInsertId,
     }
 
     return resultSet

query-engine/js-connectors/js/smoke-test-js/package.json

@@ -21,10 +21,10 @@
     "@jkomyno/prisma-js-connector-utils": "workspace:*",
     "@jkomyno/prisma-neon-js-connector": "workspace:*",
     "@jkomyno/prisma-planetscale-js-connector": "workspace:*",
-    "@prisma/client": "5.1.0"
+    "@prisma/client": "5.2.0-dev.30"
   },
   "devDependencies": {
-    "prisma": "^5.1.0",
+    "prisma": "5.2.0-dev.30",
     "tsx": "^3.12.7"
   }
 }

query-engine/js-connectors/js/smoke-test-js/prisma/mysql-planetscale/schema.prisma

@@ -91,3 +91,12 @@ model Parent {
 
   @@unique([p_1, p_2])
 }
+
+model Author {
+  id        Int             @id @default(autoincrement())
+  firstName String
+  lastName  String
+  age       Int
+
+  @@map("authors")
+}

query-engine/js-connectors/js/smoke-test-js/prisma/postgres-neon/schema.prisma

@@ -75,3 +75,12 @@ enum type_test_enum_column_null {
   value2
   value3
 }
+
+model Author {
+  id        Int             @id @default(autoincrement())
+  firstName String
+  lastName  String
+  age       Int
+
+  @@map("authors")
+}

query-engine/js-connectors/js/smoke-test-js/src/test.ts

@@ -20,6 +20,7 @@ export async function smokeTest(db: Connector & Closeable, prismaSchemaRelativeP
   const test = new SmokeTest(engine, db.flavour)
 
   await test.testFindManyTypeTest()
+  await test.createAutoIncrement()
   await test.testCreateAndDeleteChildParent()
 
   // Note: calling `engine.disconnect` won't actually close the database connection.
@@ -124,6 +125,45 @@ class SmokeTest {
     return resultSet
   }
 
+  async createAutoIncrement() {
+    await this.engine.query(`
+      {
+        "modelName": "Author",
+        "action": "deleteMany",
+        "query": {
+          "arguments": {
+            "where": {}
+          },
+          "selection": {
+            "count": true
+          }
+        }
+      }
+    `, 'trace', undefined)
+
+    const author = await this.engine.query(`
+      {
+        "modelName": "Author",
+        "action": "createOne",
+        "query": {
+          "arguments": {
+            "data": {
+              "firstName": "Firstname from autoincrement",
+              "lastName": "Lastname from autoincrement",
+              "age": 99
+            }
+          },
+          "selection": {
+            "id": true,
+            "firstName": true,
+            "lastName": true
+          }
+        }
+      }
+    `, 'trace', undefined)
+    console.log('[nodejs] author', JSON.stringify(JSON.parse(author), null, 2))
+  }
+
   async testCreateAndDeleteChildParent() {
     /* Delete all child and parent records */
 

query-engine/js-connectors/src/proxy.rs

@@ -88,6 +88,7 @@ pub struct JSResultSet {
     pub column_names: Vec<String>,
     // Note this might be encoded differently for performance reasons
     pub rows: Vec<Vec<serde_json::Value>>,
+    pub last_insert_id: Option<String>,
 }
 
 impl JSResultSet {
@@ -288,6 +289,7 @@ impl From<JSResultSet> for QuaintResultSet {
             rows,
             column_names,
             column_types,
+            last_insert_id,
         } = js_result_set;
 
         let quaint_rows = rows
@@ -301,7 +303,17 @@ impl From<JSResultSet> for QuaintResultSet {
             })
             .collect::<Vec<_>>();
 
-        QuaintResultSet::new(column_names, quaint_rows)
+        let last_insert_id = last_insert_id.and_then(|id| id.parse::<u64>().ok());
+        let mut quaint_result_set = QuaintResultSet::new(column_names, quaint_rows);
+
+        // Not a fan of this (extracting the `Some` value from an `Option` and pass it to a method that creates a new `Some` value),
+        // but that's Quaint's ResultSet API and that's how the MySQL connector does it.
+        // Sqlite, on the other hand, uses a `last_insert_id.unwrap_or(0)` approach.
+        if let Some(last_insert_id) = last_insert_id {
+            quaint_result_set.set_last_insert_id(last_insert_id);
+        }
+
+        quaint_result_set
     }
 }