wip

switch to sats-based deserialization

ModuleInstance impl

wip

Author: coolreader18

.prettierrc

@@ -0,0 +1,11 @@
+{
+    "tabWidth": 4,
+    "useTabs": false,
+    "semi": true,
+    "singleQuote": true,
+    "arrowParens": "avoid",
+    "jsxSingleQuote": false,
+    "trailingComma": "es5",
+    "endOfLine": "auto",
+    "printWidth": 100
+}

Cargo.lock

@@ -260,7 +260,6 @@ termcolor = "1.2.0"
 thin-vec = "0.2.13"
 thiserror = "1.0.37"
 tokio = { version = "1.37", features = ["full"] }
-tokio_metrics = { version = "0.4.0" }
 tokio-postgres = { version = "0.7.8", features = ["with-chrono-0_4"] }
 tokio-stream = "0.1.17"
 tokio-tungstenite = { version = "0.26.2", features = ["native-tls"] }

Cargo.toml

@@ -347,7 +347,7 @@ pub(crate) fn derive_deserialize(ty: &SatsType<'_>) -> TokenStream {
     de_generics.params.insert(0, de_lt_param.into());
     let (de_impl_generics, _, de_where_clause) = de_generics.split_for_impl();
 
-    let (iter_n, iter_n2, iter_n3) = (0usize.., 0usize.., 0usize..);
+    let (iter_n, iter_n2, iter_n3, iter_n4) = (0usize.., 0usize.., 0usize.., 0usize..);
 
     match &ty.data {
         SatsTypeData::Product(fields) => {
@@ -447,12 +447,23 @@ pub(crate) fn derive_deserialize(ty: &SatsType<'_>) -> TokenStream {
                             names.extend::<&[&str]>(&[#(#field_strings),*])
                         }
 
+                        fn nth_name(&self, i: usize) -> Option<&str> {
+                            [#(#field_strings),*].get(i).copied()
+                        }
+
                         fn visit<__E: #spacetimedb_lib::de::Error>(self, name: &str) -> Result<Self::Output, __E> {
                             match name {
                                 #(#field_strings => Ok(__ProductFieldIdent::#field_names),)*
                                 _ => Err(#spacetimedb_lib::de::Error::unknown_field_name(name, &self)),
                             }
                         }
+
+                        fn visit_seq<__E: #spacetimedb_lib::de::Error>(self, i: usize) -> Result<Self::Output, __E> {
+                            match i {
+                                #(#iter_n4 => Ok(__ProductFieldIdent::#field_names),)*
+                                _ => Err(#spacetimedb_lib::de::Error::invalid_product_length(i.saturating_add(1), &self)),
+                            }
+                        }
                     }
 
                     #[allow(non_camel_case_types)]

crates/bindings-macro/src/sats.rs

@@ -116,6 +116,9 @@ jwks.workspace = true
 async_cache = "0.3.1"
 faststr = "0.2.23"
 core_affinity = "0.8"
+v8 = "137"
+num-traits = "0.2"
+# sourcemap = "9"
 
 [target.'cfg(not(target_env = "msvc"))'.dependencies]
 tikv-jemallocator = {workspace = true}

crates/core/Cargo.toml

@@ -816,12 +816,15 @@ pub struct ModuleKind(u8);
 impl ModuleKind {
     /// The [`ModuleKind`] of WASM-based modules.
     pub const WASM: ModuleKind = ModuleKind(0);
+    /// The [`ModuleKind`] of JS modules.
+    pub const JS: ModuleKind = ModuleKind(1);
 }
 
 impl From<crate::messages::control_db::HostType> for ModuleKind {
     fn from(host_type: crate::messages::control_db::HostType) -> Self {
         match host_type {
             crate::messages::control_db::HostType::Wasm => Self::WASM,
+            crate::messages::control_db::HostType::Js => Self::JS,
         }
     }
 }

crates/core/src/db/datastore/system_tables.rs

@@ -1,5 +1,6 @@
 use super::module_host::{EventStatus, ModuleHost, ModuleInfo, NoSuchModule};
 use super::scheduler::SchedulerStarter;
+use super::v8::V8Runtime;
 use super::wasmtime::WasmtimeRuntime;
 use super::{Scheduler, UpdateDatabaseResult};
 use crate::database_logger::DatabaseLogger;
@@ -106,12 +107,14 @@ pub struct HostController {
 
 struct HostRuntimes {
     wasmtime: WasmtimeRuntime,
+    v8: V8Runtime,
 }
 
 impl HostRuntimes {
     fn new(data_dir: Option<&ServerDataDir>) -> Arc<Self> {
         let wasmtime = WasmtimeRuntime::new(data_dir);
-        Arc::new(Self { wasmtime })
+        let v8 = V8Runtime::new();
+        Arc::new(Self { wasmtime, v8 })
     }
 }
 
@@ -668,19 +671,23 @@ async fn make_module_host(
     //       threads, but those aren't for computation. Also, wasmtime uses rayon
     //       to run compilation in parallel, so it'll need to run stuff in rayon anyway.
     asyncify(move || {
+        let mcc = ModuleCreationContext {
+            replica_ctx,
+            scheduler,
+            program: &program,
+            energy_monitor,
+        };
         let module_host = match host_type {
             HostType::Wasm => {
-                let mcc = ModuleCreationContext {
-                    replica_ctx,
-                    scheduler,
-                    program: &program,
-                    energy_monitor,
-                };
                 let start = Instant::now();
                 let actor = runtimes.wasmtime.make_actor(mcc)?;
                 trace!("wasmtime::make_actor blocked for {:?}", start.elapsed());
                 ModuleHost::new(actor, unregister, core)
             }
+            HostType::Js => {
+                let actor = runtimes.v8.make_actor(mcc)?;
+                ModuleHost::new(actor, unregister)
+            }
         };
         Ok((program, module_host))
     })

crates/core/src/host/host_controller.rs

@@ -18,6 +18,7 @@ pub mod scheduler;
 pub mod wasmtime;
 // Visible for integration testing.
 pub mod instance_env;
+pub mod v8; // only pub for testing
 mod wasm_common;
 
 pub use disk_storage::DiskStorage;

crates/core/src/host/mod.rs

@@ -0,0 +1 @@
+*.js