cellular/jspg
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fixed naming, added back json_schema_cached

Browse Source
This commit is contained in:
Alex Groleau
2025-04-14 20:23:18 -04:00
parent 48e74815d3
commit f88c27aa70
1 changed files with 36 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
src/lib.rs
View File

@ -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)));