query test progress

src/lib.rs

@@ -9,7 +9,6 @@ pub mod merger;
 pub mod queryer;
 pub mod validator;
 
-use serde_json::json;
 use std::sync::{Arc, RwLock};
 
 lazy_static::lazy_static! {
@@ -22,7 +21,7 @@ lazy_static::lazy_static! {
 }
 
 #[pg_extern(strict)]
-pub fn jspg_cache_database(database: JsonB) -> JsonB {
+pub fn jspg_setup(database: JsonB) -> JsonB {
   let new_jspg = crate::jspg::Jspg::new(&database.0);
   let new_arc = Arc::new(new_jspg);
 
@@ -35,10 +34,85 @@ pub fn jspg_cache_database(database: JsonB) -> JsonB {
   let drop = crate::drop::Drop::success();
   JsonB(serde_json::to_value(drop).unwrap())
 }
+
+#[pg_extern]
+pub fn jspg_merge(data: JsonB) -> JsonB {
+  // Try to acquire a read lock to get a clone of the Engine Arc
+  let engine_opt = {
+    let lock = GLOBAL_JSPG.read().unwrap();
+    lock.clone()
+  };
+
+  match engine_opt {
+    Some(engine) => match engine.merger.merge(data.0) {
+      Ok(result) => JsonB(result),
+      Err(e) => {
+        let error = crate::drop::Error {
+          code: "MERGE_FAILED".to_string(),
+          message: e,
+          details: crate::drop::ErrorDetails {
+            path: "".to_string(),
+          },
+        };
+        let drop = crate::drop::Drop::with_errors(vec![error]);
+        JsonB(serde_json::to_value(drop).unwrap())
+      }
+    },
+    None => {
+      let error = crate::drop::Error {
+        code: "VALIDATOR_NOT_INITIALIZED".to_string(),
+        message: "The JSPG database has not been cached yet. Run jspg_setup()".to_string(),
+        details: crate::drop::ErrorDetails {
+          path: "".to_string(),
+        },
+      };
+      let drop = crate::drop::Drop::with_errors(vec![error]);
+      JsonB(serde_json::to_value(drop).unwrap())
+    }
+  }
+}
+
+#[pg_extern]
+pub fn jspg_query(schema_id: &str, stem: Option<&str>, filters: Option<JsonB>) -> JsonB {
+  let engine_opt = {
+    let lock = GLOBAL_JSPG.read().unwrap();
+    lock.clone()
+  };
+
+  match engine_opt {
+    Some(engine) => match engine
+      .queryer
+      .query(schema_id, stem, filters.as_ref().map(|f| &f.0))
+    {
+      Ok(res) => JsonB(res),
+      Err(e) => {
+        let error = crate::drop::Error {
+          code: "QUERY_FAILED".to_string(),
+          message: e,
+          details: crate::drop::ErrorDetails {
+            path: schema_id.to_string(),
+          },
+        };
+        JsonB(serde_json::to_value(crate::drop::Drop::with_errors(vec![error])).unwrap())
+      }
+    },
+    None => {
+      let error = crate::drop::Error {
+        code: "ENGINE_NOT_INITIALIZED".to_string(),
+        message: "JSPG extension has not been initialized via jspg_setup".to_string(),
+        details: crate::drop::ErrorDetails {
+          path: "".to_string(),
+        },
+      };
+      JsonB(serde_json::to_value(crate::drop::Drop::with_errors(vec![error])).unwrap())
+    }
+  }
+}
+
 // `mask_json_schema` has been removed as the mask architecture is fully replaced by Spi string queries during DB interactions.
 
 #[pg_extern(strict, parallel_safe)]
-pub fn validate_json_schema(schema_id: &str, instance: JsonB) -> JsonB {
+pub fn jspg_validate(schema_id: &str, instance: JsonB) -> JsonB {
   // 1. Acquire Snapshot
   let jspg_arc = {
     let lock = GLOBAL_JSPG.read().unwrap();
@@ -79,7 +153,7 @@ pub fn validate_json_schema(schema_id: &str, instance: JsonB) -> JsonB {
   } else {
     let error = crate::drop::Error {
       code: "VALIDATOR_NOT_INITIALIZED".to_string(),
-      message: "The JSPG database has not been cached yet. Run jspg_cache_database()".to_string(),
+      message: "The JSPG database has not been cached yet. Run jspg_setup()".to_string(),
       details: crate::drop::ErrorDetails {
         path: "".to_string(),
       },
@@ -89,42 +163,33 @@ pub fn validate_json_schema(schema_id: &str, instance: JsonB) -> JsonB {
   }
 }
 
-#[pg_extern(strict, parallel_safe)]
-pub fn json_schema_cached(schema_id: &str) -> bool {
-  if let Some(engine) = GLOBAL_JSPG.read().unwrap().as_ref() {
-    match engine
-      .validator
-      .validate(schema_id, &serde_json::Value::Null)
-    {
-      Err(e) if e.code == "SCHEMA_NOT_FOUND" => false,
-      _ => true,
+#[pg_extern]
+pub fn jspg_get_punc_stems(punc_name: &str) -> JsonB {
+  let engine_opt = {
+    let lock = GLOBAL_JSPG.read().unwrap();
+    lock.clone()
+  };
+
+  match engine_opt {
+    Some(engine) => {
+      if let Some(punc) = engine.database.puncs.get(punc_name) {
+        JsonB(serde_json::to_value(&punc.stems).unwrap_or(serde_json::Value::Array(vec![])))
+      } else {
+        JsonB(serde_json::Value::Array(vec![]))
+      }
     }
-  } else {
-    false
+    None => JsonB(serde_json::Value::Array(vec![])),
   }
 }
 
 #[pg_extern(strict)]
-pub fn clear_json_schemas() -> JsonB {
+pub fn jspg_teardown() -> JsonB {
   let mut lock = GLOBAL_JSPG.write().unwrap();
   *lock = None;
   let drop = crate::drop::Drop::success();
   JsonB(serde_json::to_value(drop).unwrap())
 }
 
-#[pg_extern(strict, parallel_safe)]
-pub fn show_json_schemas() -> JsonB {
-  if let Some(engine) = GLOBAL_JSPG.read().unwrap().as_ref() {
-    let mut keys = engine.validator.get_schema_ids();
-    keys.sort();
-    let drop = crate::drop::Drop::success_with_val(json!(keys));
-    JsonB(serde_json::to_value(drop).unwrap())
-  } else {
-    let drop = crate::drop::Drop::success_with_val(json!([]));
-    JsonB(serde_json::to_value(drop).unwrap())
-  }
-}
-
 #[cfg(any(test, feature = "pg_test"))]
 #[pg_schema]
 mod tests {