fix(wasm): prevent panic in the wasm (#382)

flipt-io · Sep 13, 2024 · 6b9ab25 · 6b9ab25
1 parent 53be2b7
commit 6b9ab25
Show file tree

Hide file tree

Showing 3 changed files with 23 additions and 44 deletions.
diff --git a/flipt-client-browser/src/index.ts b/flipt-client-browser/src/index.ts
@@ -100,7 +100,8 @@ export class FliptEvaluationClient {
 
     const data = await resp.json();
 
-    const engine = new Engine(namespace, data);
+    const engine = new Engine(namespace);
+    engine.snapshot(data);
     return new FliptEvaluationClient(engine, fetcher);
   }
 

diff --git a/flipt-client-node/src/index.ts b/flipt-client-node/src/index.ts
@@ -95,7 +95,8 @@ export class FliptEvaluationClient {
     }
 
     const data = await resp.json();
-    const engine = new Engine(namespace, data);
+    const engine = new Engine(namespace);
+    engine.snapshot(data);
     const client = new FliptEvaluationClient(engine, fetcher);
 
     if (options.updateInterval && options.updateInterval > 0) {

diff --git a/flipt-engine-wasm/src/lib.rs b/flipt-engine-wasm/src/lib.rs
@@ -54,89 +54,66 @@ where
 #[wasm_bindgen]
 impl Engine {
     #[wasm_bindgen(constructor)]
-    pub fn new(namespace: &str, data: JsValue) -> Self {
+    pub fn new(namespace: &str) -> Self {
         console_error_panic_hook::set_once();
-        let doc: source::Document = match serde_wasm_bindgen::from_value(data) {
-            Ok(document) => document,
-            Err(e) => {
-                panic!("Invalid JSON: {}", e);
-            }
-        };
-
-        let store = match Snapshot::build(namespace, doc) {
-            Ok(s) => s,
-            Err(e) => {
-                panic!("Error building snapshot: {}", e);
-            }
-        };
+        let store = Snapshot::empty(namespace);
 
         Self {
             namespace: namespace.to_string(),
             store,
         }
     }
 
-    pub fn snapshot(&mut self, data: JsValue) {
+    pub fn snapshot(&mut self, data: JsValue) -> Result<(), JsValue> {
         let doc: source::Document = match serde_wasm_bindgen::from_value(data) {
             Ok(document) => document,
             Err(e) => {
-                panic!("Invalid JSON: {}", e);
+                return Err(JsValue::from(e.to_string()));
             }
         };
 
         let store = match Snapshot::build(&self.namespace, doc) {
             Ok(s) => s,
             Err(e) => {
-                panic!("Error building snapshot: {}", e);
+                return Err(JsValue::from(e.to_string()));
             }
         };
 
         self.store = store;
+        Ok(())
     }
 
     pub fn evaluate_boolean(&self, request: JsValue) -> Result<JsValue, JsValue> {
-        let req: fliptevaluation::EvaluationRequest = match serde_wasm_bindgen::from_value(request)
-        {
-            Ok(r) => r,
-            Err(e) => {
-                panic!("Invalid JSON: {}", e);
-            }
-        };
-
-        let result = boolean_evaluation(&self.store, &self.namespace, &req);
+        let result: Result<fliptevaluation::BooleanEvaluationResponse, Error> =
+            match serde_wasm_bindgen::from_value(request) {
+                Ok(req) => boolean_evaluation(&self.store, &self.namespace, &req),
+                Err(e) => Err(Error::InvalidRequest(e.to_string())),
+            };
 
         let response = JsResponse::from(result);
 
         Ok(serde_wasm_bindgen::to_value(&response)?)
     }
 
     pub fn evaluate_variant(&self, request: JsValue) -> Result<JsValue, JsValue> {
-        let req: fliptevaluation::EvaluationRequest = match serde_wasm_bindgen::from_value(request)
-        {
-            Ok(r) => r,
-            Err(e) => {
-                panic!("Invalid JSON: {}", e);
-            }
-        };
-
-        let result = variant_evaluation(&self.store, &self.namespace, &req);
+        let result: Result<fliptevaluation::VariantEvaluationResponse, Error> =
+            match serde_wasm_bindgen::from_value(request) {
+                Ok(req) => variant_evaluation(&self.store, &self.namespace, &req),
+                Err(e) => Err(Error::InvalidRequest(e.to_string())),
+            };
 
         let response = JsResponse::from(result);
 
         Ok(serde_wasm_bindgen::to_value(&response)?)
     }
 
     pub fn evaluate_batch(&self, request: JsValue) -> Result<JsValue, JsValue> {
-        let req: Vec<fliptevaluation::EvaluationRequest> =
+        let result: Result<fliptevaluation::BatchEvaluationResponse, Error> =
             match serde_wasm_bindgen::from_value(request) {
-                Ok(r) => r,
-                Err(e) => {
-                    panic!("Invalid JSON: {}", e);
-                }
+                Ok(req) => batch_evaluation(&self.store, &self.namespace, req),
+                Err(e) => Err(Error::InvalidRequest(e.to_string())),
             };
 
-        let result = batch_evaluation(&self.store, &self.namespace, req);
-
         let response = JsResponse::from(result);
 
         Ok(serde_wasm_bindgen::to_value(&response)?)