chore(driver-adapters): rename "flavour" to "provider"

query-engine/driver-adapters/src/proxy.rs

@@ -22,8 +22,8 @@ pub(crate) struct CommonProxy {
     /// returning the number of affected rows.
     execute_raw: AsyncJsFunction<Query, u32>,
 
-    /// Return the flavour for this driver.
-    pub(crate) flavour: String,
+    /// Return the provider for this driver.
+    pub(crate) provider: String,
 }
 
 /// This is a JS proxy for accessing the methods specific to top level
@@ -52,12 +52,12 @@ pub(crate) struct TransactionProxy {
 
 impl CommonProxy {
     pub fn new(object: &JsObject) -> JsResult<Self> {
-        let flavour: JsString = get_named_property(object, "flavour")?;
+        let provider: JsString = get_named_property(object, "provider")?;
 
         Ok(Self {
             query_raw: get_named_property(object, "queryRaw")?,
             execute_raw: get_named_property(object, "executeRaw")?,
-            flavour: to_rust_str(flavour)?,
+            provider: to_rust_str(provider)?,
         })
     }
 

query-engine/driver-adapters/src/queryable.rs

@@ -1,5 +1,5 @@
 use crate::proxy::{CommonProxy, DriverProxy};
-use crate::types::{AdapterFlavour, Query};
+use crate::types::{AdapterProvider, Query};
 use crate::JsObject;
 
 use super::conversion;
@@ -32,31 +32,31 @@ use wasm_bindgen::prelude::wasm_bindgen;
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(getter_with_clone))]
 pub(crate) struct JsBaseQueryable {
     pub(crate) proxy: CommonProxy,
-    pub flavour: AdapterFlavour,
+    pub provider: AdapterProvider,
 }
 
 impl JsBaseQueryable {
     pub(crate) fn new(proxy: CommonProxy) -> Self {
-        let flavour: AdapterFlavour = proxy.flavour.parse().unwrap();
-        Self { proxy, flavour }
+        let provider: AdapterProvider = proxy.provider.parse().unwrap();
+        Self { proxy, provider }
     }
 
-    /// visit a quaint query AST according to the flavour of the JS connector
+    /// visit a quaint query AST according to the provider of the JS connector
     fn visit_quaint_query<'a>(&self, q: QuaintQuery<'a>) -> quaint::Result<(String, Vec<quaint::Value<'a>>)> {
-        match self.flavour {
-            AdapterFlavour::Mysql => visitor::Mysql::build(q),
-            AdapterFlavour::Postgres => visitor::Postgres::build(q),
-            AdapterFlavour::Sqlite => visitor::Sqlite::build(q),
+        match self.provider {
+            AdapterProvider::Mysql => visitor::Mysql::build(q),
+            AdapterProvider::Postgres => visitor::Postgres::build(q),
+            AdapterProvider::Sqlite => visitor::Sqlite::build(q),
         }
     }
 
     async fn build_query(&self, sql: &str, values: &[quaint::Value<'_>]) -> quaint::Result<Query> {
         let sql: String = sql.to_string();
 
-        let converter = match self.flavour {
-            AdapterFlavour::Postgres => conversion::postgres::value_to_js_arg,
-            AdapterFlavour::Sqlite => conversion::sqlite::value_to_js_arg,
-            AdapterFlavour::Mysql => conversion::mysql::value_to_js_arg,
+        let converter = match self.provider {
+            AdapterProvider::Postgres => conversion::postgres::value_to_js_arg,
+            AdapterProvider::Sqlite => conversion::sqlite::value_to_js_arg,
+            AdapterProvider::Mysql => conversion::mysql::value_to_js_arg,
         };
 
         let args = values
@@ -128,7 +128,7 @@ impl QuaintQueryable for JsBaseQueryable {
             return Err(Error::builder(ErrorKind::invalid_isolation_level(&isolation_level)).build());
         }
 
-        if self.flavour == AdapterFlavour::Sqlite {
+        if self.provider == AdapterProvider::Sqlite {
             return match isolation_level {
                 IsolationLevel::Serializable => Ok(()),
                 _ => Err(Error::builder(ErrorKind::invalid_isolation_level(&isolation_level)).build()),
@@ -140,9 +140,9 @@ impl QuaintQueryable for JsBaseQueryable {
     }
 
     fn requires_isolation_first(&self) -> bool {
-        match self.flavour {
-            AdapterFlavour::Mysql => true,
-            AdapterFlavour::Postgres | AdapterFlavour::Sqlite => false,
+        match self.provider {
+            AdapterProvider::Mysql => true,
+            AdapterProvider::Postgres | AdapterProvider::Sqlite => false,
         }
     }
 }

query-engine/driver-adapters/src/types.rs

@@ -15,21 +15,21 @@ use serde_repr::{Deserialize_repr, Serialize_repr};
 #[cfg_attr(target_arch = "wasm32", derive(Serialize, Deserialize, Tsify))]
 #[cfg_attr(target_arch = "wasm32", tsify(into_wasm_abi, from_wasm_abi))]
 #[derive(Debug, Eq, PartialEq, Clone)]
-pub enum AdapterFlavour {
+pub enum AdapterProvider {
     Mysql,
     Postgres,
     Sqlite,
 }
 
-impl FromStr for AdapterFlavour {
+impl FromStr for AdapterProvider {
     type Err = String;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
             "postgres" => Ok(Self::Postgres),
             "mysql" => Ok(Self::Mysql),
             "sqlite" => Ok(Self::Sqlite),
-            _ => Err(format!("Unsupported adapter flavour: {:?}", s)),
+            _ => Err(format!("Unsupported adapter provider: {:?}", s)),
         }
     }
 }