Couple of fixes

1. Build schema and connect sequentually
2. Print full stacktrace for WASM error
3. Expand example to attempt a query

query-engine/driver-adapters/src/wasm/error.rs

@@ -1,11 +1,13 @@
+use js_sys::Reflect;
 use quaint::error::Error as QuaintError;
 use wasm_bindgen::JsValue;
 
-type WasmError = JsValue;
-
 /// transforms a Wasm error into a Quaint error
-pub(crate) fn into_quaint_error(wasm_err: WasmError) -> QuaintError {
+pub(crate) fn into_quaint_error(wasm_err: JsValue) -> QuaintError {
     let status = "WASM_ERROR".to_string();
-    let reason = wasm_err.as_string().unwrap_or_else(|| "unknown error".to_string());
+    let reason = Reflect::get(&wasm_err, &JsValue::from_str("stack"))
+        .ok()
+        .and_then(|value| value.as_string())
+        .unwrap_or_else(|| "Unknown error".to_string());
     QuaintError::raw_connector_error(status, reason)
 }

query-engine/query-engine-wasm/example.js

@@ -6,7 +6,7 @@
 import { Pool } from '@neondatabase/serverless'
 import { PrismaNeon } from '@prisma/adapter-neon'
 import { bindAdapter } from '@prisma/driver-adapter-utils'
-import { init, QueryEngine, getBuildTimeInfo } from './pkg/query_engine_wasm.js'
+import { init, QueryEngine, getBuildTimeInfo } from './pkg/query_engine.js'
 
 async function main() {
   // Always initialize the Wasm library before using it.
@@ -48,7 +48,22 @@ async function main() {
   const queryEngine = new QueryEngine(options, callback, driverAdapter)
 
   await queryEngine.connect('trace')
+  const res = await queryEngine.query(JSON.stringify({
+    modelName: 'User',
+    action: 'findMany',
+    query: {
+      arguments: {},
+      selection: {
+        $scalars: true
+      }
+    }
+  }), 'trace')
+  const parsed = JSON.parse(res);
+  console.log('query result = ', parsed)
   await queryEngine.disconnect('trace')
+  console.log('after disconnect')
+  queryEngine.free()
+  await driverAdapter.close()
 }
 
 main()

query-engine/query-engine-wasm/src/wasm/engine.rs

@@ -240,31 +240,24 @@ impl QueryEngine {
 
                 let preview_features = arced_schema.configuration.preview_features();
 
-                let executor = async {
-                    let executor = load_executor(self.connector_mode, data_source, preview_features, &url).await?;
-                    let connector = executor.primary_connector();
+                let executor = load_executor(self.connector_mode, data_source, preview_features, &url).await?;
+                let connector = executor.primary_connector();
 
-                    let conn_span = tracing::info_span!(
-                        "prisma:engine:connection",
-                        user_facing = true,
-                        "db.type" = connector.name(),
-                    );
+                let conn_span = tracing::info_span!(
+                    "prisma:engine:connection",
+                    user_facing = true,
+                    "db.type" = connector.name(),
+                );
 
-                    connector.get_connection().instrument(conn_span).await?;
+                connector.get_connection().instrument(conn_span).await?;
 
-                    crate::Result::<_>::Ok(executor)
-                }
-                .await;
-
-                let query_schema = {
-                    let enable_raw_queries = true;
-                    schema::build(arced_schema_2, enable_raw_queries)
-                };
+                let query_schema_span = tracing::info_span!("prisma:engine:schema");
+                let query_schema = query_schema_span.in_scope(|| schema::build(arced_schema_2, true));
 
                 Ok(ConnectedEngine {
                     schema: builder.schema.clone(),
                     query_schema: Arc::new(query_schema),
-                    executor: executor?,
+                    executor,
                     config_dir: builder.config_dir.clone(),
                     env: builder.env.clone(),
                     engine_protocol: builder.engine_protocol,
@@ -285,30 +278,32 @@ impl QueryEngine {
     /// Disconnect and drop the core. Can be reconnected later with `#connect`.
     #[wasm_bindgen]
     pub async fn disconnect(&self, trace: String) -> Result<(), wasm_bindgen::JsError> {
-        async_panic_to_js_error(async {
-            let span = tracing::info_span!("prisma:engine:disconnect");
+        // async_panic_to_js_error(async {
+        // let span = tracing::info_span!("prisma:engine:disconnect");
 
-            // TODO: when using Node Drivers, we need to call Driver::close() here.
+        // TODO: when using Node Drivers, we need to call Driver::close() here.
 
-            async {
-                let mut inner = self.inner.write().await;
-                let engine = inner.as_engine()?;
+        // async {
+        let mut inner = self.inner.write().await;
+        let engine = inner.as_engine()?;
 
-                let builder = EngineBuilder {
-                    schema: engine.schema.clone(),
-                    config_dir: engine.config_dir.clone(),
-                    env: engine.env.clone(),
-                    engine_protocol: engine.engine_protocol(),
-                };
+        let builder = EngineBuilder {
+            schema: engine.schema.clone(),
+            config_dir: engine.config_dir.clone(),
+            env: engine.env.clone(),
+            engine_protocol: engine.engine_protocol(),
+        };
 
-                *inner = Inner::Builder(builder);
+        log::info!("Recreated builder");
+        *inner = Inner::Builder(builder);
+        log::info!("Recreated inner builder");
 
-                Ok(())
-            }
-            .instrument(span)
-            .await
-        })
-        .await
+        Ok(())
+        // }
+        // .instrument(span)
+        // .await
+        // })
+        // .await
     }
 
     /// If connected, sends a query to the core and returns the response.