infer codec in main.rs, only check for v2

Author: mssalemi

src/engine.rs

@@ -20,14 +20,13 @@ pub struct ProfileOpts {
 #[folder = "providers/"]
 struct StandardProviders;
 
-fn uses_msgpack_provider(module: &Module) -> bool {
+pub fn uses_msgpack_provider(module: &Module) -> bool {
     let imported_modules: HashSet<String> =
         module.imports().map(|i| i.module().to_string()).collect();
 
-    imported_modules.iter().any(|name| {
-        name.starts_with("shopify_function_v")
-            || (name.starts_with("shopify_functions_javy_v") && name != "shopify_functions_javy_v1")
-    })
+    imported_modules
+        .iter()
+        .any(|name| name.starts_with("shopify_function_v") || name == "shopify_functions_javy_v2")
 }
 
 fn import_modules<T>(
@@ -139,13 +138,8 @@ pub fn run(params: FunctionRunParams) -> Result<FunctionRunResult> {
     let module = Module::from_file(&engine, &function_path)
         .map_err(|e| anyhow!("Couldn't load the Function {:?}: {}", &function_path, e))?;
 
-    let uses_msgpack = uses_msgpack_provider(&module);
-    let input_stream = if input.codec == Codec::Messagepack || uses_msgpack {
-        let msgpack_bytes = rmp_serde::to_vec(&input.json_value.as_ref().unwrap())?;
-        MemoryInputPipe::new(msgpack_bytes)
-    } else {
-        MemoryInputPipe::new(input.raw.clone())
-    };
+    // We now infer the codec in main.rs, so the input should already have the right format
+    let input_stream = MemoryInputPipe::new(input.raw.clone());
     let output_stream = MemoryOutputPipe::new(usize::MAX);
     let error_stream = MemoryOutputPipe::new(usize::MAX);
 
@@ -220,18 +214,14 @@ pub fn run(params: FunctionRunParams) -> Result<FunctionRunResult> {
 
     logs.extend_from_slice(error_logs.as_bytes());
 
-    // When codec is not specified, we infer it from the input
-    let inferered_codec = if uses_msgpack {
-        Codec::Messagepack
-    } else {
-        input.codec
-    };
+    // The input codec is already inferred in main.rs, use it directly
+    let output_codec = input.codec;
     let raw_output = output_stream
         .try_into_inner()
         .expect("Output stream reference still exists");
     let output = BytesContainer::new(
         BytesContainerType::Output,
-        inferered_codec,
+        output_codec,
         raw_output.to_vec(),
     )?;
 

src/main.rs

@@ -1,4 +1,5 @@
 use function_runner::{BytesContainer, BytesContainerType, Codec};
+use wasmtime::{Config, Engine, Module};
 
 use std::{
     fs::File,
@@ -135,7 +136,26 @@ fn main() -> Result<()> {
 
     let query_string = opts.read_query_to_string().transpose()?;
 
-    let input = BytesContainer::new(BytesContainerType::Input, opts.codec, buffer)?;
+    let engine = Engine::new(
+        Config::new()
+            .wasm_multi_memory(true)
+            .wasm_threads(false)
+            .consume_fuel(true)
+            .epoch_interruption(true),
+    )?;
+
+    // Load the module to check if it uses messagepack
+    let module = Module::from_file(&engine, &opts.function)
+        .map_err(|e| anyhow!("Couldn't load the Function {:?}: {}", &opts.function, e))?;
+
+    // Infer codec from the module if it uses msgpack, otherwise use the codec from the command line
+    let inferred_codec = if function_runner::engine::uses_msgpack_provider(&module) {
+        Codec::Messagepack
+    } else {
+        opts.codec
+    };
+
+    let input = BytesContainer::new(BytesContainerType::Input, inferred_codec, buffer)?;
     let scale_factor = if let (Some(schema_string), Some(query_string), Some(json_value)) =
         (schema_string, query_string, input.json_value.clone())
     {