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

massively improves the jspg validator by removing mathmatical functions like allOf, anyOf, ref, etc to effectively use discriminators and OOP with types to determine valid pathing an nno intersections, unions, or guesswork; added cases to replace the former conditionals

Browse Source
This commit is contained in:
Alex Groleau
2026-04-08 13:08:24 -04:00
parent e4286ac6a9
commit 7c8df22709
30 changed files with 2526 additions and 4816 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
src/queryer/compiler.rs
View File

@ -47,7 +47,7 @@ impl<'a> Compiler<'a> {
};
let (sql, _) = compiler.compile_node(node)?;
Ok(sql)
Ok(format!("(SELECT jsonb_strip_nulls({}))", sql))
}
/// Recursively walks the schema AST emitting native PostgreSQL jsonb mapping
@ -63,7 +63,7 @@ impl<'a> Compiler<'a> {
}
fn compile_array(&mut self, node: Node<'a>) -> Result<(String, String), String> {
// 1. Array of DB Entities (`$ref` or `$family` pointing to a table limit)
// 1. Array of DB Entities (`type` or `$family` pointing to a table limit)
if let Some(items) = &node.schema.obj.items {
let mut resolved_type = None;
if let Some(family_target) = items.obj.family.as_ref() {
@ -112,15 +112,17 @@ impl<'a> Compiler<'a> {
return self.compile_entity(type_def, node.clone(), false);
}
// Handle Direct Refs
if let Some(ref_id) = &node.schema.obj.r#ref {
// If it's just an ad-hoc struct ref, we should resolve it
if let Some(target_schema) = self.db.schemas.get(ref_id) {
let mut ref_node = node.clone();
ref_node.schema = std::sync::Arc::new(target_schema.clone());
return self.compile_node(ref_node);
// Handle Direct Refs via type pointer
if let Some(crate::database::schema::SchemaTypeOrArray::Single(t)) = &node.schema.obj.type_ {
if !crate::database::schema::is_primitive_type(t) {
// If it's just an ad-hoc struct ref, we should resolve it
if let Some(target_schema) = self.db.schemas.get(t) {
let mut ref_node = node.clone();
ref_node.schema = std::sync::Arc::new(target_schema.clone());
return self.compile_node(ref_node);
}
return Err(format!("Unresolved schema type pointer: {}", t));
}
return Err(format!("Unresolved $ref: {}", ref_id));
}
// Handle $family Polymorphism fallbacks for relations
if let Some(family_target) = &node.schema.obj.family {
@ -131,7 +133,7 @@ impl<'a> Compiler<'a> {
if all_targets.len() == 1 {
let mut bypass_schema = crate::database::schema::Schema::default();
bypass_schema.obj.r#ref = Some(all_targets[0].clone());
bypass_schema.obj.type_ = Some(crate::database::schema::SchemaTypeOrArray::Single(all_targets[0].clone()));
let mut bypass_node = node.clone();
bypass_node.schema = std::sync::Arc::new(bypass_schema);
return self.compile_node(bypass_node);
@ -141,7 +143,7 @@ impl<'a> Compiler<'a> {
let mut family_schemas = Vec::new();
for variation in &all_targets {
let mut ref_schema = crate::database::schema::Schema::default();
ref_schema.obj.r#ref = Some(variation.clone());
ref_schema.obj.type_ = Some(crate::database::schema::SchemaTypeOrArray::Single(variation.clone()));
family_schemas.push(std::sync::Arc::new(ref_schema));
}
@ -185,9 +187,9 @@ impl<'a> Compiler<'a> {
select_args.append(&mut poly_args);
let jsonb_obj_sql = if select_args.is_empty() {
"jsonb_strip_nulls(jsonb_build_object())".to_string()
"jsonb_build_object()".to_string()
} else {
format!("jsonb_strip_nulls(jsonb_build_object({}))", select_args.join(", "))
format!("jsonb_build_object({})", select_args.join(", "))
};
// 3. Build WHERE clauses
@ -325,7 +327,7 @@ impl<'a> Compiler<'a> {
}
build_args.push(format!("'{}', {}", k, child_sql));
}
let combined = format!("jsonb_strip_nulls(jsonb_build_object({}))", build_args.join(", "));
let combined = format!("jsonb_build_object({})", build_args.join(", "));
Ok((combined, "object".to_string()))
}
@ -416,7 +418,14 @@ impl<'a> Compiler<'a> {
_ => false,
};
let is_primitive = prop_schema.obj.r#ref.is_none()
let is_custom_object_pointer = match &prop_schema.obj.type_ {
Some(crate::database::schema::SchemaTypeOrArray::Single(s)) => {
!crate::database::schema::is_primitive_type(s)
}
_ => false,
};
let is_primitive = !is_custom_object_pointer
&& !is_object_or_array
&& prop_schema.obj.family.is_none()
&& prop_schema.obj.one_of.is_none();