@perspective-dev/client 4.1.0 → 4.2.0

package/src/rust/virtual_server.rs

@@ -20,22 +20,17 @@ use std::sync::{Arc, Mutex};
 use indexmap::IndexMap;
 use js_sys::{Array, Date, Object, Reflect};
 use perspective_client::proto::{ColumnType, HostedTable};
-use perspective_client::virtual_server::{
-    Features, ResultExt, VirtualDataSlice, VirtualServer, VirtualServerHandler,
-};
+use perspective_client::virtual_server;
+use perspective_client::virtual_server::{Features, ResultExt, VirtualServerHandler};
 use serde::Serialize;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen_futures::JsFuture;
 
+use crate::JsViewConfig;
 use crate::utils::{ApiError, ApiFuture, *};
 
-// Conditional type alias matching the trait definition
-#[cfg(target_arch = "wasm32")]
 type HandlerFuture<T> = Pin<Box<dyn Future<Output = T>>>;
 
-#[cfg(not(target_arch = "wasm32"))]
-type HandlerFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
-
 #[derive(Debug)]
 pub struct JsError(JsValue);
 
@@ -65,16 +60,8 @@ impl From<serde_wasm_bindgen::Error> for JsError {
     }
 }
 
-// SAFETY: In WASM, we're always single-threaded, so JsError can safely be Send
-// + Sync
-unsafe impl Send for JsError {}
-unsafe impl Sync for JsError {}
-
 pub struct JsServerHandler(Object);
 
-unsafe impl Send for JsServerHandler {}
-unsafe impl Sync for JsServerHandler {}
-
 impl JsServerHandler {
     fn call_method_js(&self, method: &str, args: &Array) -> Result<JsValue, JsError> {
         let func = Reflect::get(&self.0, &JsValue::from_str(method))?;
@@ -90,7 +77,7 @@ impl JsServerHandler {
         // Check if result is a Promise
         if result.is_instance_of::<js_sys::Promise>() {
             let promise = js_sys::Promise::from(result);
-            JsFuture::from(promise).await.map_err(|e| JsError(e))
+            JsFuture::from(promise).await.map_err(JsError)
         } else {
             Ok(result)
         }
@@ -293,11 +280,7 @@ impl VirtualServerHandler for JsServerHandler {
 
         let handler = self.0.clone();
         let view_id = view_id.to_string();
-        let config_value = if has_view_schema {
-            serde_wasm_bindgen::to_value(config).ok()
-        } else {
-            None
-        };
+        let config_value = JsValue::from_serde_ext(config).ok();
 
         Box::pin(async move {
             let this = JsServerHandler(handler);
@@ -446,7 +429,6 @@ impl VirtualServerHandler for JsServerHandler {
 
         let handler = self.0.clone();
         let table_id = table_id.to_string();
-
         use perspective_client::proto::make_table_data::Data;
         let data_value = match &data.data {
             Some(Data::FromCsv(csv)) => JsValue::from_str(csv),
@@ -474,22 +456,25 @@ impl VirtualServerHandler for JsServerHandler {
         &self,
         view_id: &str,
         config: &perspective_client::config::ViewConfig,
+        schema: &IndexMap<String, ColumnType>,
         viewport: &perspective_client::proto::ViewPort,
-    ) -> HandlerFuture<Result<VirtualDataSlice, Self::Error>> {
+    ) -> HandlerFuture<Result<virtual_server::VirtualDataSlice, Self::Error>> {
         let handler = self.0.clone();
         let view_id = view_id.to_string();
         let window: JsViewPort = viewport.clone().into();
         let config_value = serde_wasm_bindgen::to_value(config).unwrap();
         let window_value = serde_wasm_bindgen::to_value(&window).unwrap();
+        let schema_value = JsValue::from_serde_ext(&schema).unwrap();
 
         Box::pin(async move {
             let this = JsServerHandler(handler);
-            let data = JsVirtualDataSlice::default();
+            let data = VirtualDataSlice::new(config_value.clone().unchecked_into());
 
             {
                 let args = Array::new();
                 args.push(&JsValue::from_str(&view_id));
                 args.push(&config_value);
+                args.push(&schema_value);
                 args.push(&window_value);
                 args.push(&JsValue::from(data.clone()));
                 this.call_method_js_async("viewGetData", &args).await?;
@@ -497,8 +482,8 @@ impl VirtualServerHandler for JsServerHandler {
 
             // Lock the mutex and take ownership of the inner data
             // We can't unwrap the Arc because the JsValue might still hold a reference
-            let JsVirtualDataSlice(_obj, arc) = data;
-            let slice = std::mem::take(&mut *arc.lock().unwrap());
+            let VirtualDataSlice(_obj, arc) = data;
+            let slice = std::mem::take(&mut *arc.lock().unwrap()).unwrap();
             Ok(slice)
         })
     }
@@ -530,24 +515,20 @@ impl From<perspective_client::proto::ViewPort> for JsViewPort {
     }
 }
 
-#[wasm_bindgen]
+#[wasm_bindgen(js_name = "VirtualDataSlice")]
 #[derive(Clone)]
-pub struct JsVirtualDataSlice(Object, Arc<Mutex<VirtualDataSlice>>);
-
-impl Default for JsVirtualDataSlice {
-    fn default() -> Self {
-        JsVirtualDataSlice(
-            Object::new(),
-            Arc::new(Mutex::new(VirtualDataSlice::default())),
-        )
-    }
-}
+pub struct VirtualDataSlice(Object, Arc<Mutex<Option<virtual_server::VirtualDataSlice>>>);
 
 #[wasm_bindgen]
-impl JsVirtualDataSlice {
+impl VirtualDataSlice {
     #[wasm_bindgen(constructor)]
-    pub fn new() -> Self {
-        Self::default()
+    pub fn new(config: JsViewConfig) -> Self {
+        VirtualDataSlice(
+            Object::new(),
+            Arc::new(Mutex::new(Some(virtual_server::VirtualDataSlice::new(
+                config.into_serde_ext().unwrap(),
+            )))),
+        )
     }
 
     #[wasm_bindgen(js_name = "setCol")]
@@ -582,12 +563,16 @@ impl JsVirtualDataSlice {
             self.1
                 .lock()
                 .unwrap()
+                .as_mut()
+                .unwrap()
                 .set_col(name, group_by_index, index as usize, None as Option<String>)
                 .unwrap();
         } else if let Some(s) = val.as_string() {
             self.1
                 .lock()
                 .unwrap()
+                .as_mut()
+                .unwrap()
                 .set_col(name, group_by_index, index as usize, Some(s))
                 .unwrap();
         } else {
@@ -608,12 +593,16 @@ impl JsVirtualDataSlice {
             self.1
                 .lock()
                 .unwrap()
+                .as_mut()
+                .unwrap()
                 .set_col(name, group_by_index, index as usize, None as Option<i32>)
                 .unwrap();
         } else if let Some(n) = val.as_f64() {
             self.1
                 .lock()
                 .unwrap()
+                .as_mut()
+                .unwrap()
                 .set_col(name, group_by_index, index as usize, Some(n as i32))
                 .unwrap();
         } else {
@@ -634,12 +623,16 @@ impl JsVirtualDataSlice {
             self.1
                 .lock()
                 .unwrap()
+                .as_mut()
+                .unwrap()
                 .set_col(name, group_by_index, index as usize, None as Option<f64>)
                 .unwrap();
         } else if let Some(n) = val.as_f64() {
             self.1
                 .lock()
                 .unwrap()
+                .as_mut()
+                .unwrap()
                 .set_col(name, group_by_index, index as usize, Some(n))
                 .unwrap();
         } else {
@@ -660,12 +653,16 @@ impl JsVirtualDataSlice {
             self.1
                 .lock()
                 .unwrap()
+                .as_mut()
+                .unwrap()
                 .set_col(name, group_by_index, index as usize, None as Option<bool>)
                 .unwrap();
         } else if let Some(b) = val.as_bool() {
             self.1
                 .lock()
                 .unwrap()
+                .as_mut()
+                .unwrap()
                 .set_col(name, group_by_index, index as usize, Some(b))
                 .unwrap();
         } else {
@@ -686,6 +683,8 @@ impl JsVirtualDataSlice {
             self.1
                 .lock()
                 .unwrap()
+                .as_mut()
+                .unwrap()
                 .set_col(name, group_by_index, index as usize, None as Option<i64>)
                 .unwrap();
         } else if let Some(date) = val.dyn_ref::<Date>() {
@@ -693,30 +692,35 @@ impl JsVirtualDataSlice {
             self.1
                 .lock()
                 .unwrap()
+                .as_mut()
+                .unwrap()
                 .set_col(name, group_by_index, index as usize, Some(timestamp))
                 .unwrap();
         } else if let Some(n) = val.as_f64() {
             self.1
                 .lock()
                 .unwrap()
+                .as_mut()
+                .unwrap()
                 .set_col(name, group_by_index, index as usize, Some(n as i64))
                 .unwrap();
         } else {
             tracing::error!("Unhandled datetime value");
         }
+
         Ok(())
     }
 }
 
 #[wasm_bindgen]
-pub struct JsVirtualServer(Rc<UnsafeCell<VirtualServer<JsServerHandler>>>);
+pub struct VirtualServer(Rc<UnsafeCell<virtual_server::VirtualServer<JsServerHandler>>>);
 
 #[wasm_bindgen]
-impl JsVirtualServer {
+impl VirtualServer {
     #[wasm_bindgen(constructor)]
-    pub fn new(handler: Object) -> Result<JsVirtualServer, JsValue> {
-        Ok(JsVirtualServer(Rc::new(UnsafeCell::new(
-            VirtualServer::new(JsServerHandler(handler)),
+    pub fn new(handler: Object) -> Result<VirtualServer, JsValue> {
+        Ok(VirtualServer(Rc::new(UnsafeCell::new(
+            virtual_server::VirtualServer::new(JsServerHandler(handler)),
         ))))
     }
 

package/src/ts/perspective.browser.ts

@@ -13,13 +13,23 @@
 export type * from "../../dist/wasm/perspective-js.d.ts";
 import type * as psp from "../../dist/wasm/perspective-js.d.ts";
 export type * from "./virtual_server.ts";
-
 import * as psp_virtual from "./virtual_server.ts";
-
 import * as wasm_module from "../../dist/wasm/perspective-js.js";
 import * as api from "./wasm/browser.ts";
 import { load_wasm_stage_0 } from "./wasm/decompress.ts";
 
+export {
+    GenericSQLVirtualServerModel,
+    VirtualDataSlice,
+    VirtualServer,
+} from "../../dist/wasm/perspective-js.js";
+
+import {
+    GenericSQLVirtualServerModel,
+    VirtualDataSlice,
+    VirtualServer,
+} from "../../dist/wasm/perspective-js.js";
+
 let GLOBAL_SERVER_WASM: Promise<ArrayBuffer | WebAssembly.Module>;
 
 export async function createMessageHandler(
@@ -144,4 +154,7 @@ export default {
     init_client,
     init_server,
     createMessageHandler,
+    GenericSQLVirtualServerModel,
+    VirtualDataSlice,
+    VirtualServer,
 };

package/src/ts/perspective.node.ts

@@ -29,9 +29,20 @@ import * as engine from "./wasm/engine.ts";
 import { compile_perspective } from "./wasm/emscripten_api.ts";
 import * as psp_websocket from "./websocket.ts";
 import * as api from "./wasm/browser.ts";
-
 import * as virtual_server from "./virtual_server.ts";
 
+export {
+    GenericSQLVirtualServerModel,
+    VirtualDataSlice,
+    VirtualServer,
+} from "../../dist/wasm/perspective-js.js";
+
+import {
+    GenericSQLVirtualServerModel,
+    VirtualDataSlice,
+    VirtualServer,
+} from "../../dist/wasm/perspective-js.js";
+
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
 
 const { resolve } = createRequire(import.meta.url);
@@ -337,6 +348,12 @@ export function createMessageHandler(
     return virtual_server.createMessageHandler(perspective_client, handler);
 }
 
+/**
+ * The initialized WASM module. Use this when you need to pass the module
+ * to components that require it, such as `DuckDBHandler`.
+ */
+export { perspective_client as wasmModule };
+
 export default {
     table,
     websocket,
@@ -347,4 +364,7 @@ export default {
     on_error,
     system_info,
     WebSocketServer,
+    GenericSQLVirtualServerModel,
+    VirtualDataSlice,
+    VirtualServer,
 };

package/src/ts/virtual_server.ts

@@ -55,8 +55,9 @@ export interface VirtualServerHandler {
     viewGetData(
         viewId: string,
         config: ViewConfig,
+        schema: Record<string, ColumnType>,
         viewport: ViewWindow,
-        dataSlice: perspective.JsVirtualDataSlice,
+        dataSlice: perspective.VirtualDataSlice,
     ): void | Promise<void>;
     viewSchema?(
         viewId: string,
@@ -78,11 +79,11 @@ export function createMessageHandler(
     mod: typeof perspective,
     handler: VirtualServerHandler,
 ) {
-    let virtualServer: perspective.JsVirtualServer;
+    let virtualServer: perspective.VirtualServer;
     async function postMessage(port: MessagePort, msg: MessageEvent) {
         if (msg.data.cmd === "init") {
             try {
-                virtualServer = new mod.JsVirtualServer(handler);
+                virtualServer = new mod.VirtualServer(handler);
                 if (msg.data.id !== undefined) {
                     port.postMessage({ id: msg.data.id });
                 } else {
@@ -113,14 +114,3 @@ export function createMessageHandler(
 
     return channel.port2;
 }
-
-/**
- * Re-export the WASM VirtualServer and VirtualDataSlice classes with better names.
- *
- * VirtualServer: Handles Perspective protocol messages using your custom handler
- * VirtualDataSlice: Used to fill data in viewGetData callbacks
- */
-export {
-    JsVirtualServer as VirtualServer,
-    JsVirtualDataSlice as VirtualDataSlice,
-} from "../../dist/wasm/perspective-js.js";