feat(query-engine-wasm): slimmer core on wasm32 target arch

libs/prisma-value/src/lib.rs

@@ -69,18 +69,18 @@ pub fn decode_bytes(s: &str) -> PrismaValueResult<Vec<u8>> {
     base64::decode(s).map_err(|_| ConversionFailure::new("base64 encoded bytes", "PrismaValue::Bytes"))
 }
 
-impl TryFrom<serde_json::Value> for PrismaValue {
+impl TryFrom<&serde_json::Value> for PrismaValue {
     type Error = crate::error::ConversionFailure;
 
-    fn try_from(v: serde_json::Value) -> PrismaValueResult<Self> {
+    fn try_from(v: &serde_json::Value) -> PrismaValueResult<Self> {
         match v {
-            serde_json::Value::String(s) => Ok(PrismaValue::String(s)),
+            serde_json::Value::String(s) => Ok(PrismaValue::String(s.to_owned())),
             serde_json::Value::Array(v) => {
-                let vals: PrismaValueResult<Vec<PrismaValue>> = v.into_iter().map(PrismaValue::try_from).collect();
+                let vals: PrismaValueResult<Vec<PrismaValue>> = v.iter().map(PrismaValue::try_from).collect();
                 Ok(PrismaValue::List(vals?))
             }
             serde_json::Value::Null => Ok(PrismaValue::Null),
-            serde_json::Value::Bool(b) => Ok(PrismaValue::Boolean(b)),
+            serde_json::Value::Bool(b) => Ok(PrismaValue::Boolean(*b)),
             serde_json::Value::Number(num) => {
                 if num.is_i64() {
                     Ok(PrismaValue::Int(num.as_i64().unwrap()))

query-engine/core/src/executor/request_context.rs

@@ -64,3 +64,26 @@ where
         REQUEST_CONTEXT.scope(ctx, fut).await
     }
 }
+
+#[cfg(target_arch = "wasm32")]
+mod arch {
+    #[inline(always)]
+    pub(crate) fn is_engine_protocol_json() -> bool {
+        true
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+mod arch {
+    use super::*;
+
+    pub(crate) fn is_engine_protocol_json() -> bool {
+        REQUEST_CONTEXT
+            .try_with(|rc| rc.engine_protocol)
+            .ok()
+            .map(|p| p.is_json())
+            == Some(true)
+    }
+}
+
+pub(crate) use arch::is_engine_protocol_json;

query-engine/core/src/query_document/parser.rs

@@ -1,5 +1,5 @@
 use super::*;
-use crate::{executor::get_engine_protocol, schema::*};
+use crate::{executor::is_engine_protocol_json, schema::*};
 use bigdecimal::{BigDecimal, ToPrimitive};
 use chrono::prelude::*;
 use core::fmt;
@@ -229,29 +229,29 @@ impl QueryDocumentParser {
             };
         }
 
+        let is_protocol_json = is_engine_protocol_json();
+
         for input_type in possible_input_types {
-            match (value.clone(), input_type) {
+            match (&value, input_type) {
                 // With the JSON protocol, JSON values are sent as deserialized values.
                 // This means JSON can match with pretty much anything. A string, an int, an object, an array.
                 // This is an early catch-all.
                 // We do not get into this catch-all _if_ the value is already Json, if it's a FieldRef or if it's an Enum.
                 // We don't because they've already been desambiguified at the procotol adapter level.
                 (value, InputType::<'a>::Scalar(ScalarType::Json))
-                    if value.should_be_parsed_as_json() && get_engine_protocol().is_json() =>
+                    if value.should_be_parsed_as_json() && is_protocol_json =>
                 {
                     return Ok(ParsedInputValue::Single(self.to_json(
                         &selection_path,
                         &argument_path,
-                        &value,
+                        value,
                     )?))
                 }
                 // With the JSON protocol, JSON values are sent as deserialized values.
                 // This means that a JsonList([1, 2]) will be coerced as an `ArgumentValue::List([1, 2])`.
                 // We need this early matcher to make sure we coerce this array back to JSON.
-                (list @ ArgumentValue::List(_), InputType::Scalar(ScalarType::JsonList))
-                    if get_engine_protocol().is_json() =>
-                {
-                    let json_val = serde_json::to_value(list.clone()).map_err(|err| {
+                (list @ ArgumentValue::List(_), InputType::Scalar(ScalarType::JsonList)) if is_protocol_json => {
+                    let json_val = serde_json::to_value(list).map_err(|err| {
                         ValidationError::invalid_argument_value(
                             selection_path.segments(),
                             argument_path.segments(),
@@ -264,7 +264,7 @@ impl QueryDocumentParser {
 
                     return Ok(ParsedInputValue::Single(json_list));
                 }
-                (ArgumentValue::Scalar(pv), input_type) => match (pv, input_type) {
+                (ArgumentValue::Scalar(pv), input_type) => match (pv.clone(), input_type) {
                     // Null handling
                     (PrismaValue::Null, InputType::Scalar(ScalarType::Null)) => {
                         return Ok(ParsedInputValue::Single(PrismaValue::Null))
@@ -502,7 +502,7 @@ impl QueryDocumentParser {
         let mut prisma_values = Vec::with_capacity(values.len());
 
         for v in values.iter() {
-            let pv = PrismaValue::try_from(v.clone()).map_err(|err| {
+            let pv = PrismaValue::try_from(v).map_err(|err| {
                 ValidationError::invalid_argument_value(
                     selection_path.segments(),
                     argument_path.segments(),

query-engine/core/src/query_graph_builder/builder.rs

@@ -43,7 +43,7 @@ impl<'a> QueryGraphBuilder<'a> {
         root_object: ObjectType<'a>, // Either the query or mutation object.
         root_object_fields: &dyn Fn(&str) -> Option<OutputField<'a>>,
     ) -> QueryGraphBuilderResult<(QueryGraph, IrSerializer<'a>)> {
-        let mut selections = vec![selection];
+        let selections = vec![selection.clone()];
         let mut parsed_object = QueryDocumentParser::new(crate::executor::get_request_now()).parse(
             &selections,
             &root_object,
@@ -53,7 +53,7 @@ impl<'a> QueryGraphBuilder<'a> {
 
         // Because we're processing root objects, there can only be one query / mutation.
         let field_pair = parsed_object.fields.pop().unwrap();
-        let serializer = Self::derive_serializer(&selections.pop().unwrap(), field_pair.schema_field.clone());
+        let serializer = Self::derive_serializer(&selection, field_pair.schema_field.clone());
 
         if field_pair.schema_field.query_info().is_some() {
             let graph = self.dispatch_build(field_pair)?;