Merge branch 'main' into main

Cargo.toml

@@ -20,7 +20,7 @@ members = [
   "query-engine/black-box-tests",
   "query-engine/dmmf",
   "query-engine/metrics",
-  "query-engine/js-drivers",
+  "query-engine/js-connectors",
   "query-engine/prisma-models",
   "query-engine/query-engine",
   "query-engine/query-engine-node-api",

psl/psl-core/src/common/preview_features.rs

@@ -64,7 +64,7 @@ features!(
     NamedConstraints,
     NApi,
     NativeTypes,
-    NodeDrivers,
+    JsConnectors,
     OrderByAggregateGroup,
     OrderByNulls,
     OrderByRelation,
@@ -124,7 +124,7 @@ pub const ALL_PREVIEW_FEATURES: FeatureMap = FeatureMap {
         | UncheckedScalarInputs
     }),
     hidden: enumflags2::make_bitflags!(PreviewFeature::{
-        NodeDrivers
+        JsConnectors
     }),
 };
 

quaint/src/ast/function/uuid.rs

@@ -56,7 +56,7 @@ pub fn uuid_to_bin_swapped() -> Expression<'static> {
 /// # Ok(())
 /// # }
 /// ```
-#[cfg(any(feature = "mysql"))]
+#[cfg(feature = "mysql")]
 pub fn native_uuid() -> Expression<'static> {
     let func = Function {
         typ_: FunctionType::Uuid,

quaint/src/connector/mysql.rs

@@ -603,16 +603,16 @@ mod tests {
     fn should_parse_prefer_socket() {
         let url =
             MysqlUrl::new(Url::parse("mysql://root:root@localhost:3307/testdb?prefer_socket=false").unwrap()).unwrap();
-        assert_eq!(false, url.prefer_socket().unwrap());
+        assert!(!url.prefer_socket().unwrap());
     }
 
     #[test]
     fn should_parse_sslaccept() {
         let url =
             MysqlUrl::new(Url::parse("mysql://root:root@localhost:3307/testdb?sslaccept=strict").unwrap()).unwrap();
-        assert_eq!(true, url.query_params.use_ssl);
-        assert_eq!(false, url.query_params.ssl_opts.skip_domain_validation());
-        assert_eq!(false, url.query_params.ssl_opts.accept_invalid_certs());
+        assert!(url.query_params.use_ssl);
+        assert!(!url.query_params.ssl_opts.skip_domain_validation());
+        assert!(!url.query_params.ssl_opts.accept_invalid_certs());
     }
 
     #[test]

quaint/src/connector/postgres.rs

@@ -1501,41 +1501,38 @@ mod tests {
     #[test]
     fn test_safe_ident() {
         // Safe
-        assert_eq!(is_safe_identifier("hello"), true);
-        assert_eq!(is_safe_identifier("_hello"), true);
-        assert_eq!(is_safe_identifier("àbracadabra"), true);
-        assert_eq!(is_safe_identifier("h3ll0"), true);
-        assert_eq!(is_safe_identifier("héllo"), true);
-        assert_eq!(is_safe_identifier("héll0$"), true);
-        assert_eq!(is_safe_identifier("héll_0$"), true);
-        assert_eq!(
-            is_safe_identifier("disconnect_security_must_honor_connect_scope_one2m"),
-            true
-        );
+        assert!(is_safe_identifier("hello"));
+        assert!(is_safe_identifier("_hello"));
+        assert!(is_safe_identifier("àbracadabra"));
+        assert!(is_safe_identifier("h3ll0"));
+        assert!(is_safe_identifier("héllo"));
+        assert!(is_safe_identifier("héll0$"));
+        assert!(is_safe_identifier("héll_0$"));
+        assert!(is_safe_identifier("disconnect_security_must_honor_connect_scope_one2m"));
 
         // Not safe
-        assert_eq!(is_safe_identifier(""), false);
-        assert_eq!(is_safe_identifier("Hello"), false);
-        assert_eq!(is_safe_identifier("hEllo"), false);
-        assert_eq!(is_safe_identifier("$hello"), false);
-        assert_eq!(is_safe_identifier("hello!"), false);
-        assert_eq!(is_safe_identifier("hello#"), false);
-        assert_eq!(is_safe_identifier("he llo"), false);
-        assert_eq!(is_safe_identifier(" hello"), false);
-        assert_eq!(is_safe_identifier("he-llo"), false);
-        assert_eq!(is_safe_identifier("hÉllo"), false);
-        assert_eq!(is_safe_identifier("1337"), false);
-        assert_eq!(is_safe_identifier("_HELLO"), false);
-        assert_eq!(is_safe_identifier("HELLO"), false);
-        assert_eq!(is_safe_identifier("HELLO$"), false);
-        assert_eq!(is_safe_identifier("ÀBRACADABRA"), false);
+        assert!(!is_safe_identifier(""));
+        assert!(!is_safe_identifier("Hello"));
+        assert!(!is_safe_identifier("hEllo"));
+        assert!(!is_safe_identifier("$hello"));
+        assert!(!is_safe_identifier("hello!"));
+        assert!(!is_safe_identifier("hello#"));
+        assert!(!is_safe_identifier("he llo"));
+        assert!(!is_safe_identifier(" hello"));
+        assert!(!is_safe_identifier("he-llo"));
+        assert!(!is_safe_identifier("hÉllo"));
+        assert!(!is_safe_identifier("1337"));
+        assert!(!is_safe_identifier("_HELLO"));
+        assert!(!is_safe_identifier("HELLO"));
+        assert!(!is_safe_identifier("HELLO$"));
+        assert!(!is_safe_identifier("ÀBRACADABRA"));
 
         for ident in RESERVED_KEYWORDS {
-            assert_eq!(is_safe_identifier(ident), false);
+            assert!(!is_safe_identifier(ident));
         }
 
         for ident in RESERVED_TYPE_FUNCTION_NAMES {
-            assert_eq!(is_safe_identifier(ident), false);
+            assert!(!is_safe_identifier(ident));
         }
     }
 

quaint/src/tests/query/error.rs

@@ -103,8 +103,8 @@ async fn unique_constraint_violation(api: &mut dyn TestApi) -> crate::Result<()>
                 let fields = fields.iter().map(|s| s.as_str()).collect::<Vec<_>>();
                 assert_eq!(vec!["id1", "id2"], fields)
             }
-            DatabaseConstraint::ForeignKey => assert!(false, "Expecting index or field constraints."),
-            DatabaseConstraint::CannotParse => assert!(false, "Couldn't parse the error message."),
+            DatabaseConstraint::ForeignKey => panic!("Expecting index or field constraints."),
+            DatabaseConstraint::CannotParse => panic!("Couldn't parse the error message."),
         },
         _ => panic!("{}", err),
     }

quaint/src/tests/types/mssql.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::approx_constant)]
+
 #[cfg(feature = "bigdecimal")]
 mod bigdecimal;
 

quaint/src/tests/types/mysql.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::approx_constant)]
+
 use crate::tests::test_api::*;
 
 #[cfg(feature = "bigdecimal")]

quaint/src/tests/types/sqlite.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::approx_constant)]
+
 use crate::tests::test_api::sqlite_test_api;
 #[cfg(feature = "chrono")]
 use crate::tests::test_api::TestApi;

quaint/src/visitor/mssql.rs

@@ -717,7 +717,7 @@ mod tests {
         (String::from(sql), params.into_iter().map(|p| p.into()).collect())
     }
 
-    fn default_params<'a>(mut additional: Vec<Value<'a>>) -> Vec<Value<'a>> {
+    fn default_params(mut additional: Vec<Value<'_>>) -> Vec<Value<'_>> {
         let mut result = Vec::new();
 
         for param in additional.drain(0..) {

quaint/src/visitor/mysql.rs

@@ -635,7 +635,7 @@ mod tests {
         (String::from(sql), params.into_iter().map(|p| p.into()).collect())
     }
 
-    fn default_params<'a>(mut additional: Vec<Value<'a>>) -> Vec<Value<'a>> {
+    fn default_params(mut additional: Vec<Value<'_>>) -> Vec<Value<'_>> {
         let mut result = Vec::new();
 
         for param in additional.drain(0..) {

quaint/src/visitor/postgres.rs

@@ -533,7 +533,7 @@ mod tests {
         (String::from(sql), params.into_iter().map(|p| p.into()).collect())
     }
 
-    fn default_params<'a>(mut additional: Vec<Value<'a>>) -> Vec<Value<'a>> {
+    fn default_params(mut additional: Vec<Value<'_>>) -> Vec<Value<'_>> {
         let mut result = Vec::new();
 
         for param in additional.drain(0..) {

quaint/src/visitor/sqlite.rs

@@ -400,7 +400,7 @@ mod tests {
         (String::from(sql), params.into_iter().map(|p| p.into()).collect())
     }
 
-    fn default_params<'a>(mut additional: Vec<Value<'a>>) -> Vec<Value<'a>> {
+    fn default_params(mut additional: Vec<Value<'_>>) -> Vec<Value<'_>> {
         let mut result = Vec::new();
 
         for param in additional.drain(0..) {

query-engine/connector-test-kit-rs/query-engine-tests/tests/queries/batch/select_one_singular.rs

@@ -308,6 +308,46 @@ mod singular_batch {
         Ok(())
     }
 
+    fn enum_id() -> String {
+        let schema = indoc! {
+            r#"
+            enum IdEnum {
+                A
+                B
+            }
+
+            model TestModel {
+                #id(id, IdEnum, @id)
+            }
+            "#
+        };
+
+        schema.to_owned()
+    }
+
+    #[connector_test(schema(enum_id), capabilities(Enums))]
+    async fn batch_enum(runner: Runner) -> TestResult<()> {
+        run_query!(&runner, r#"mutation { createOneTestModel(data: { id: "A" }) { id } }"#);
+        run_query!(&runner, r#"mutation { createOneTestModel(data: { id: "B" }) { id } }"#);
+
+        let (res, compact_doc) = compact_batch(
+            &runner,
+            vec![
+                r#"{ findUniqueTestModel(where: { id: "A" }) { id } }"#.to_string(),
+                r#"{ findUniqueTestModel(where: { id: "B" }) { id } }"#.to_string(),
+            ],
+        )
+        .await?;
+
+        insta::assert_snapshot!(
+          res.to_string(),
+          @r###"{"batchResult":[{"data":{"findUniqueTestModel":{"id":"A"}}},{"data":{"findUniqueTestModel":{"id":"B"}}}]}"###
+        );
+        assert!(compact_doc.is_compact());
+
+        Ok(())
+    }
+
     // Regression test for https://github.com/prisma/prisma/issues/16548
     #[connector_test(schema(schemas::generic))]
     async fn repro_16548(runner: Runner) -> TestResult<()> {

query-engine/connectors/sql-query-connector/Cargo.toml

@@ -5,7 +5,7 @@ version = "0.1.0"
 
 [features]
 vendored-openssl = ["quaint/vendored-openssl"]
-js-drivers = []
+js-connectors = []
 
 [dependencies]
 psl.workspace = true

query-engine/connectors/sql-query-connector/src/database/mod.rs

@@ -1,4 +1,4 @@
-#[cfg(feature = "js-drivers")]
+#[cfg(feature = "js-connectors")]
 pub mod js;
 mod runtime;
 

query-engine/connectors/sql-query-connector/src/database/mysql.rs

@@ -44,7 +44,7 @@ impl FromSource for Mysql {
         features: psl::PreviewFeatures,
     ) -> connector_interface::Result<Mysql> {
         if source.provider == "@prisma/mysql" {
-            #[cfg(feature = "js-drivers")]
+            #[cfg(feature = "js-connectors")]
             {
                 let driver = super::js::registered_driver();
                 let connection_info = get_connection_info(url)?;
@@ -56,10 +56,10 @@ impl FromSource for Mysql {
                 });
             }
 
-            #[cfg(not(feature = "js-drivers"))]
+            #[cfg(not(feature = "js-connectors"))]
             {
                 return Err(ConnectorError::from_kind(ErrorKind::UnsupportedConnector(
-                    "The @prisma/mysql connector requires the `nodeDrivers` preview feature to be enabled.".into(),
+                    "The @prisma/mysql connector requires the `jsConnectors` preview feature to be enabled.".into(),
                 )));
             }
         }