version: 1.0.10

src/lib.rs

@@ -20,7 +20,7 @@ lazy_static! {
 }
 
 #[pg_extern(strict)]
-fn cache_schema(schema_id: &str, schema: JsonB) -> JsonB {
+fn cache_json_schema(schema_id: &str, schema: JsonB) -> JsonB {
     let mut cache = SCHEMA_CACHE.write().unwrap();
     let schema_value: Value = schema.0;
 
@@ -54,7 +54,7 @@ fn cache_schema(schema_id: &str, schema: JsonB) -> JsonB {
 }
 
 #[pg_extern(strict, parallel_safe)]
-fn validate_schema(schema_id: &str, instance: JsonB) -> JsonB {
+fn validate_json_schema(schema_id: &str, instance: JsonB) -> JsonB {
     let cache = SCHEMA_CACHE.read().unwrap();
 
     match cache.id_to_index.get(schema_id) {
@@ -95,8 +95,14 @@ fn format_boon_errors(error: &ValidationError) -> Value {
     })
 }
 
+#[pg_extern(strict, parallel_safe)]
+fn json_schema_cached(schema_id: &str) -> bool {
+    let cache = SCHEMA_CACHE.read().unwrap();
+    cache.id_to_index.contains_key(schema_id)
+}
+
 #[pg_extern(strict)]
-fn clear_schema_cache() -> JsonB {
+fn clear_json_schemas() -> JsonB {
     let mut cache = SCHEMA_CACHE.write().unwrap();
     *cache = BoonCache {
         schemas: Schemas::new(),
@@ -109,7 +115,7 @@ fn clear_schema_cache() -> JsonB {
 }
 
 #[pg_extern(strict, parallel_safe)]
-fn show_schema_cache() -> JsonB {
+fn show_json_schemas() -> JsonB {
     let cache = SCHEMA_CACHE.read().unwrap();
     let ids: Vec<&String> = cache.id_to_index.keys().collect();
     JsonB(json!({
@@ -130,11 +136,11 @@ mod tests {
     }
 
     fn setup_test() {
-        clear_schema_cache();
+        clear_json_schemas();
     }
 
     #[pg_test]
-    fn test_cache_and_validate_schema() {
+    fn test_cache_and_validate_json_schema() {
         setup_test();
         let schema_id = "my_schema";
         let schema = json!({
@@ -149,13 +155,13 @@ mod tests {
         let invalid_instance_type = json!({ "name": "Bob", "age": -5 });
         let invalid_instance_missing = json!({ "name": "Charlie" });
 
-        let cache_result = cache_schema(schema_id, jsonb(schema.clone()));
+        let cache_result = cache_json_schema(schema_id, jsonb(schema.clone()));
         assert!(cache_result.0["success"].as_bool().unwrap());
 
-        let valid_result = validate_schema(schema_id, jsonb(valid_instance));
+        let valid_result = validate_json_schema(schema_id, jsonb(valid_instance));
         assert!(valid_result.0["success"].as_bool().unwrap());
 
-        let invalid_result_type = validate_schema(schema_id, jsonb(invalid_instance_type));
+        let invalid_result_type = validate_json_schema(schema_id, jsonb(invalid_instance_type));
         assert!(!invalid_result_type.0["success"].as_bool().unwrap());
 
         // --- Assertions for invalid_result_type --- 
@@ -190,7 +196,7 @@ mod tests {
                 "Incorrect message prefix for age error. Expected prefix '{}'. Error: {:?}. All errors: {:?}",
                 expected_prefix, age_error, top_level_errors);
 
-        let invalid_result_missing = validate_schema(schema_id, jsonb(invalid_instance_missing));
+        let invalid_result_missing = validate_json_schema(schema_id, jsonb(invalid_instance_missing));
         assert!(!invalid_result_missing.0["success"].as_bool().unwrap(), "Validation should fail for missing required field");
 
         // --- Assertions for invalid_result_missing --- 
@@ -221,10 +227,10 @@ mod tests {
     }
 
     #[pg_test]
-    fn test_schema_not_cached() {
+    fn test_validate_json_schema_not_cached() {
         setup_test();
         let instance = json!({ "foo": "bar" });
-        let result = validate_schema("non_existent_schema", jsonb(instance));
+        let result = validate_json_schema("non_existent_schema", jsonb(instance));
         assert!(!result.0["success"].as_bool().unwrap());
         let errors = result.0["errors"].as_array().unwrap();
         assert_eq!(errors.len(), 1);
@@ -233,7 +239,7 @@ mod tests {
     }
 
     #[pg_test]
-    fn test_invalid_schema_cache() {
+    fn test_cache_invalid_json_schema() {
         setup_test();
         let schema_id = "invalid_schema";
         let invalid_schema_json = "{\"type\": \"string\" \"maxLength\": 5}";
@@ -244,13 +250,13 @@ mod tests {
             "type": 123
         });
 
-        let result = cache_schema(schema_id, jsonb(schema_representing_invalid.clone()));
+        let result = cache_json_schema(schema_id, jsonb(schema_representing_invalid.clone()));
         assert!(!result.0["success"].as_bool().unwrap());
         assert!(result.0["error"].as_str().unwrap().contains("Schema compilation failed"));
     }
 
     #[pg_test]
-    fn test_detailed_validation_errors() {
+    fn test_validate_json_schema_detailed_validation_errors() {
         setup_test();
         let schema_id = "detailed_schema";
         let schema = json!({
@@ -273,8 +279,8 @@ mod tests {
             }
         });
 
-        assert!(cache_schema(schema_id, jsonb(schema.clone())).0["success"].as_bool().unwrap());
-        let result = validate_schema(schema_id, jsonb(invalid_instance));
+        assert!(cache_json_schema(schema_id, jsonb(schema.clone())).0["success"].as_bool().unwrap());
+        let result = validate_json_schema(schema_id, jsonb(invalid_instance));
         assert!(!result.0["success"].as_bool().unwrap());
 
         let errors = result.0["errors"].as_array().expect("Errors should be an array");
@@ -296,7 +302,7 @@ mod tests {
     }
 
     #[pg_test]
-    fn test_oneof_validation_errors() {
+    fn test_validate_json_schema_oneof_validation_errors() {
         setup_test();
         let schema_id = "oneof_schema";
         let schema = json!({
@@ -311,10 +317,10 @@ mod tests {
             },
             "required": ["value"]
         });
-        assert!(cache_schema(schema_id, jsonb(schema.clone())).0["success"].as_bool().unwrap());
+        assert!(cache_json_schema(schema_id, jsonb(schema.clone())).0["success"].as_bool().unwrap());
 
         let invalid_instance = json!({ "value": "abc" });
-        let result = validate_schema(schema_id, jsonb(invalid_instance));
+        let result = validate_json_schema(schema_id, jsonb(invalid_instance));
 
         assert!(!result.0["success"].as_bool().unwrap());
 
@@ -344,38 +350,38 @@ mod tests {
     }
 
     #[pg_test]
-    fn test_clear_schema_cache() {
+    fn test_clear_json_schemas() {
         setup_test();
         let schema_id = "schema_to_clear";
         let schema = json!({ "type": "string" });
-        cache_schema(schema_id, jsonb(schema.clone()));
+        cache_json_schema(schema_id, jsonb(schema.clone()));
 
-        let show_result1 = show_schema_cache();
+        let show_result1 = show_json_schemas();
         assert!(show_result1.0["cached_schema_ids"].as_array().unwrap().iter().any(|id| id.as_str() == Some(schema_id)));
 
-        let clear_result = clear_schema_cache();
+        let clear_result = clear_json_schemas();
         assert!(clear_result.0["success"].as_bool().unwrap());
 
-        let show_result2 = show_schema_cache();
+        let show_result2 = show_json_schemas();
         assert!(show_result2.0["cached_schema_ids"].as_array().unwrap().is_empty());
 
         let instance = json!("test");
-        let validate_result = validate_schema(schema_id, jsonb(instance));
+        let validate_result = validate_json_schema(schema_id, jsonb(instance));
         assert!(!validate_result.0["success"].as_bool().unwrap());
         assert_eq!(validate_result.0["errors"].as_array().unwrap()[0]["kind"], json!("SchemaNotFound"));
     }
 
     #[pg_test]
-    fn test_show_schema_cache() {
+    fn test_show_json_schemas() {
         setup_test();
         let schema_id1 = "schema1";
         let schema_id2 = "schema2";
         let schema = json!({ "type": "boolean" });
 
-        cache_schema(schema_id1, jsonb(schema.clone()));
-        cache_schema(schema_id2, jsonb(schema.clone()));
+        cache_json_schema(schema_id1, jsonb(schema.clone()));
+        cache_json_schema(schema_id2, jsonb(schema.clone()));
 
-        let result = show_schema_cache();
+        let result = show_json_schemas();
         let ids = result.0["cached_schema_ids"].as_array().unwrap();
         assert_eq!(ids.len(), 2);
         assert!(ids.contains(&json!(schema_id1)));

version

@@ -1 +1 @@
-1.0.9
+1.0.10