feat: MSSQL driver adapter (#5469)

[ORM-1057](https://linear.app/prisma-company/issue/ORM-1057/support-mssql-driver-adapter-in-the-query-engine)

Doesn't add any engines tests yet, this just makes it possible to build
a wasm bundle for MSSQL and fixes compilation errors

Author: jacek-prisma

libs/driver-adapters/Cargo.toml

@@ -7,6 +7,7 @@ edition = "2021"
 mysql = ["quaint/mysql"]
 sqlite = ["quaint/sqlite"]
 postgresql = ["quaint/postgresql"]
+mssql = ["quaint/mssql"]
 
 [lints]
 workspace = true

libs/driver-adapters/executor/src/query-compiler-wasm.ts

@@ -1,6 +1,7 @@
 import * as wasmPostgres from '../../../../query-compiler/query-compiler-wasm/pkg/postgresql/query_compiler_bg.js'
 import * as wasmMysql from '../../../../query-compiler/query-compiler-wasm/pkg/mysql/query_compiler_bg.js'
 import * as wasmSqlite from '../../../../query-compiler/query-compiler-wasm/pkg/sqlite/query_compiler_bg.js'
+import * as wasmSqlServer from '../../../../query-compiler/query-compiler-wasm/pkg/sqlserver/query_compiler_bg.js'
 import fs from 'node:fs/promises'
 import path from 'node:path'
 import { __dirname } from './utils.js'
@@ -9,6 +10,7 @@ const wasm = {
   postgres: wasmPostgres,
   mysql: wasmMysql,
   sqlite: wasmSqlite,
+  sqlserver: wasmSqlServer,
 }
 
 type EngineName = keyof typeof wasm

libs/driver-adapters/executor/src/query-compiler.ts

@@ -5,7 +5,7 @@ import { QueryPlanNode } from '@prisma/client-engine-runtime'
 export type QueryCompilerParams = {
   // TODO: support multiple datamodels
   datamodel: string
-  provider: 'postgres' | 'mysql' | 'sqlite'
+  provider: 'postgres' | 'mysql' | 'sqlite' | 'sqlserver'
   connectionInfo: ConnectionInfo
 }
 

libs/driver-adapters/src/conversion/mod.rs

@@ -2,6 +2,8 @@ pub(crate) mod js_arg;
 pub(crate) mod js_arg_type;
 pub(crate) mod js_to_quaint;
 
+#[cfg(feature = "mssql")]
+pub(crate) mod mssql;
 #[cfg(feature = "mysql")]
 pub(crate) mod mysql;
 #[cfg(feature = "postgresql")]

libs/driver-adapters/src/conversion/mssql.rs

@@ -0,0 +1,22 @@
+use crate::conversion::JSArg;
+use serde_json::value::Value as JsonValue;
+
+#[rustfmt::skip]
+pub fn value_to_js_arg(value: &quaint::Value) -> serde_json::Result<JSArg> {
+    let res = match (&value.typed, value.native_column_type_name()) {
+        (quaint::ValueType::DateTime(Some(dt)), _) => JSArg::Value(JsonValue::String(dt.naive_utc().to_string())),
+        (quaint::ValueType::Json(Some(s)), _) => JSArg::Value(JsonValue::String(serde_json::to_string(s)?)),
+        (quaint::ValueType::Bytes(Some(bytes)), _) => JSArg::Buffer(bytes.to_vec()),
+        (quaint::ValueType::Int32(Some(value)), _) => JSArg::SafeInt(*value),
+        (quaint::ValueType::Numeric(Some(bd)), _) =>  JSArg::Value(JsonValue::String(bd.to_string())),
+        (quaint::ValueType::Array(Some(items)), _) => JSArg::Array(
+            items
+                .iter()
+                .map(value_to_js_arg)
+                .collect::<serde_json::Result<Vec<JSArg>>>()?,
+        ),
+        (quaint_value, _) => JSArg::from(JsonValue::from(quaint_value.clone())),
+    };
+
+    Ok(res)
+}

libs/driver-adapters/src/error.rs

@@ -6,6 +6,10 @@ use quaint::error::PostgresError;
 
 #[cfg(feature = "sqlite")]
 use quaint::error::SqliteError;
+
+#[cfg(feature = "mssql")]
+use quaint::error::MssqlError;
+
 use serde::Deserialize;
 
 #[cfg(feature = "postgresql")]
@@ -37,6 +41,14 @@ pub struct SqliteErrorDef {
     pub message: Option<String>,
 }
 
+#[cfg(feature = "mssql")]
+#[derive(Deserialize)]
+#[serde(remote = "MssqlError")]
+pub struct MssqlErrorDef {
+    pub code: u32,
+    pub message: String,
+}
+
 #[derive(Deserialize)]
 #[serde(tag = "kind")]
 /// Wrapper for JS-side errors
@@ -91,6 +103,9 @@ pub(crate) enum DriverAdapterError {
         cause: String,
     },
     MissingFullTextSearchIndex,
+    TransactionAlreadyClosed {
+        cause: String,
+    },
     #[cfg(feature = "postgresql")]
     #[serde(rename = "postgres")]
     Postgres(#[serde(with = "PostgresErrorDef")] PostgresError),
@@ -100,6 +115,9 @@ pub(crate) enum DriverAdapterError {
     #[cfg(feature = "sqlite")]
     #[serde(rename = "sqlite")]
     Sqlite(#[serde(with = "SqliteErrorDef")] SqliteError),
+    #[cfg(feature = "mssql")]
+    #[serde(rename = "mssql")]
+    Mssql(#[serde(with = "MssqlErrorDef")] MssqlError),
 }
 
 #[derive(Deserialize)]

libs/driver-adapters/src/lib.rs

@@ -88,13 +88,18 @@ impl From<DriverAdapterError> for QuaintError {
             DriverAdapterError::MissingFullTextSearchIndex => {
                 QuaintError::builder(ErrorKind::MissingFullTextSearchIndex).build()
             }
+            DriverAdapterError::TransactionAlreadyClosed { cause } => {
+                QuaintError::builder(ErrorKind::TransactionAlreadyClosed(cause)).build()
+            }
             DriverAdapterError::GenericJs { id } => QuaintError::external_error(id),
             #[cfg(feature = "postgresql")]
             DriverAdapterError::Postgres(e) => e.into(),
             #[cfg(feature = "mysql")]
             DriverAdapterError::Mysql(e) => e.into(),
             #[cfg(feature = "sqlite")]
             DriverAdapterError::Sqlite(e) => e.into(),
+            #[cfg(feature = "mssql")]
+            DriverAdapterError::Mssql(e) => e.into(),
             // in future, more error types would be added and we'll need to convert them to proper QuaintErrors here
         }
     }

libs/driver-adapters/src/proxy.rs

@@ -56,7 +56,10 @@ pub(crate) struct DriverProxy {
     get_connection_info: Option<AdapterMethod<(), JsConnectionInfo>>,
 
     /// Start a new transaction.
-    start_transaction: AdapterMethod<Option<String>, JsTransaction>,
+    start_transaction: AdapterMethod<(), JsTransaction>,
+
+    /// Start a new transaction with a specific isolation level.
+    start_transaction_with_isolation_level: AdapterMethod<String, JsTransaction>,
 
     /// Dispose of the underlying driver.
     dispose: AdapterMethod<(), ()>,
@@ -146,6 +149,7 @@ impl DriverProxy {
         Ok(Self {
             execute_script: get_named_property(object, "executeScript")?,
             start_transaction: get_named_property(object, "startTransaction")?,
+            start_transaction_with_isolation_level: get_named_property(object, "startTransaction")?,
             get_connection_info: get_optional_named_property(object, "getConnectionInfo")?,
             dispose: get_named_property(object, "dispose")?,
         })
@@ -156,10 +160,13 @@ impl DriverProxy {
     }
 
     async fn start_transaction_inner(&self, isolation: Option<IsolationLevel>) -> quaint::Result<Box<JsTransaction>> {
-        let tx = self
-            .start_transaction
-            .call_as_async(isolation.map(|lvl| lvl.to_string()))
-            .await?;
+        let tx = if let Some(level) = isolation {
+            self.start_transaction_with_isolation_level
+                .call_as_async(level.to_string())
+                .await?
+        } else {
+            self.start_transaction.call_as_async(()).await?
+        };
 
         // Decrement for this gauge is done in JsTransaction::commit/JsTransaction::rollback
         // Previously, it was done in JsTransaction::new, similar to the native Transaction.

libs/driver-adapters/src/queryable.rs

@@ -56,6 +56,8 @@ impl JsBaseQueryable {
             AdapterProvider::Postgres => visitor::Postgres::build(q),
             #[cfg(feature = "sqlite")]
             AdapterProvider::Sqlite => visitor::Sqlite::build(q),
+            #[cfg(feature = "mssql")]
+            AdapterProvider::SqlServer => visitor::Mssql::build(q),
         }
     }
 
@@ -69,6 +71,8 @@ impl JsBaseQueryable {
             AdapterProvider::Sqlite => conversion::sqlite::value_to_js_arg,
             #[cfg(feature = "mysql")]
             AdapterProvider::Mysql => conversion::mysql::value_to_js_arg,
+            #[cfg(feature = "mssql")]
+            AdapterProvider::SqlServer => conversion::mssql::value_to_js_arg,
         };
 
         let args = values
@@ -134,16 +138,18 @@ impl QuaintQueryable for JsBaseQueryable {
 
     // Note: Needed by the Wasm Schema Engine only.
     async fn version(&self) -> quaint::Result<Option<String>> {
-        let version_fn: &'static str = match self.provider {
+        let version_expr: &'static str = match self.provider {
             #[cfg(feature = "mysql")]
-            AdapterProvider::Mysql => visitor::Mysql::version_fn(),
+            AdapterProvider::Mysql => visitor::Mysql::version_expr(),
             #[cfg(feature = "postgresql")]
-            AdapterProvider::Postgres => visitor::Postgres::version_fn(),
+            AdapterProvider::Postgres => visitor::Postgres::version_expr(),
             #[cfg(feature = "sqlite")]
-            AdapterProvider::Sqlite => visitor::Sqlite::version_fn(),
+            AdapterProvider::Sqlite => visitor::Sqlite::version_expr(),
+            #[cfg(feature = "mssql")]
+            AdapterProvider::SqlServer => visitor::Mssql::version_expr(),
         };
 
-        let query = format!(r#"SELECT {}() AS version"#, version_fn);
+        let query = format!(r#"SELECT {} AS version"#, version_expr);
         let rows = self.query_raw(query.as_str(), &[]).await?;
 
         let version_string = rows
@@ -173,6 +179,8 @@ impl QuaintQueryable for JsBaseQueryable {
             AdapterProvider::Postgres => false,
             #[cfg(feature = "sqlite")]
             AdapterProvider::Sqlite => false,
+            #[cfg(feature = "mssql")]
+            AdapterProvider::SqlServer => true,
         }
     }
 }

libs/driver-adapters/src/types.rs

@@ -53,6 +53,8 @@ impl JsConnectionInfo {
             AdapterProvider::Postgres => quaint::connector::DEFAULT_POSTGRES_SCHEMA,
             #[cfg(feature = "sqlite")]
             AdapterProvider::Sqlite => quaint::connector::DEFAULT_SQLITE_DATABASE,
+            #[cfg(feature = "mssql")]
+            AdapterProvider::SqlServer => quaint::connector::DEFAULT_MSSQL_SCHEMA,
         }
     }
 }