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

stems removed from queryer

Browse Source
This commit is contained in:
Alex Groleau
2026-03-18 22:04:29 -04:00
parent e19e1921e5
commit 847e921b1c
12 changed files with 1475 additions and 796 deletions
Download Patch File Download Diff File Expand all files Collapse all files

239
src/database/mod.rs
View File

@ -18,14 +18,11 @@ use executors::pgrx::SpiExecutor;
#[cfg(test)]
use executors::mock::MockExecutor;
pub mod stem;
use punc::Punc;
use relation::Relation;
use schema::Schema;
use serde_json::Value;
use std::collections::{HashMap, HashSet};
use std::sync::Arc;
use stem::Stem;
use r#type::Type;
pub struct Database {
@ -34,8 +31,6 @@ pub struct Database {
pub puncs: HashMap<String, Punc>,
pub relations: Vec<Relation>,
pub schemas: HashMap<String, Schema>,
// Map of Schema ID -> { Entity Type -> Target Subschema Arc }
pub stems: HashMap<String, HashMap<String, Arc<Stem>>>,
pub descendants: HashMap<String, Vec<String>>,
pub depths: HashMap<String, usize>,
pub executor: Box<dyn DatabaseExecutor + Send + Sync>,
@ -49,7 +44,6 @@ impl Database {
relations: Vec::new(),
puncs: HashMap::new(),
schemas: HashMap::new(),
stems: HashMap::new(),
descendants: HashMap::new(),
depths: HashMap::new(),
#[cfg(not(test))]
@ -146,7 +140,6 @@ impl Database {
self.collect_depths();
self.collect_descendants();
self.compile_schemas();
self.collect_stems()?;
Ok(())
}
@ -325,236 +318,4 @@ impl Database {
}
}
}
fn collect_stems(&mut self) -> Result<(), crate::drop::Drop> {
let mut db_stems: HashMap<String, HashMap<String, Arc<Stem>>> = HashMap::new();
let mut errors: Vec<crate::drop::Error> = Vec::new();
let schema_ids: Vec<String> = self.schemas.keys().cloned().collect();
for schema_id in schema_ids {
if let Some(schema) = self.schemas.get(&schema_id) {
let mut inner_map = HashMap::new();
Self::discover_stems(
self,
&schema_id,
schema,
String::from(""),
None,
None,
false,
&mut inner_map,
Vec::new(),
&mut errors,
);
if !inner_map.is_empty() {
db_stems.insert(schema_id, inner_map);
}
}
}
self.stems = db_stems;
if !errors.is_empty() {
return Err(crate::drop::Drop::with_errors(errors));
}
Ok(())
}
fn discover_stems(
db: &Database,
root_schema_id: &str,
schema: &Schema,
current_path: String,
parent_type: Option<String>,
property_name: Option<String>,
is_polymorphic: bool,
inner_map: &mut HashMap<String, Arc<Stem>>,
seen_entities: Vec<String>,
errors: &mut Vec<crate::drop::Error>,
) {
let mut is_entity = false;
let mut entity_type = String::new();
// First check if the Schema's $id is a native Database Type
if let Some(ref id) = schema.obj.id {
let parts: Vec<&str> = id.split('.').collect();
if let Some(last_seg) = parts.last() {
if db.types.contains_key(*last_seg) {
is_entity = true;
entity_type = last_seg.to_string();
}
}
}
// If not found via $id, check the $ref pointer
// This allows ad-hoc schemas (like `save_person.response`) to successfully adopt the Type of what they $ref
if !is_entity {
if let Some(ref r) = schema.obj.r#ref {
let parts: Vec<&str> = r.split('.').collect();
if let Some(last_seg) = parts.last() {
if db.types.contains_key(*last_seg) {
is_entity = true;
entity_type = last_seg.to_string();
}
}
}
}
if is_entity {
if seen_entities.contains(&entity_type) {
return; // Break cyclical schemas!
}
}
let mut relation_col = None;
if is_entity {
if let (Some(pt), Some(prop)) = (&parent_type, &property_name) {
let expected_col = format!("{}_id", prop);
let mut found = false;
if let Some((rel, _)) = db.get_relation(pt, &entity_type, prop, None) {
if rel.source_columns.contains(&expected_col) {
relation_col = Some(expected_col.clone());
found = true;
}
}
if !found {
relation_col = Some(expected_col);
}
}
let mut final_path = current_path.clone();
if is_polymorphic && !final_path.is_empty() && !final_path.ends_with(&entity_type) {
if final_path.ends_with(".#") {
final_path = format!("{}(type==\"{}\")", final_path, entity_type);
} else {
final_path = format!("{}#(type==\"{}\")", final_path, entity_type);
}
}
let stem = Stem {
r#type: entity_type.clone(),
relation: relation_col,
schema: Arc::new(schema.clone()),
};
inner_map.insert(final_path, Arc::new(stem));
}
let next_parent = if is_entity {
Some(entity_type.clone())
} else {
parent_type.clone()
};
let pass_seen = if is_entity {
let mut ns = seen_entities.clone();
ns.push(entity_type.clone());
ns
} else {
seen_entities.clone()
};
// Properties branch
if let Some(props) = &schema.obj.properties {
for (k, v) in props {
// Standard Property Pathing
let next_path = if current_path.is_empty() {
k.clone()
} else {
format!("{}.{}", current_path, k)
};
Self::discover_stems(
db,
root_schema_id,
v,
next_path,
next_parent.clone(),
Some(k.clone()),
false,
inner_map,
pass_seen.clone(),
errors,
);
}
}
// Array Item branch
if let Some(items) = &schema.obj.items {
let next_path = if current_path.is_empty() {
String::from("#")
} else {
format!("{}.#", current_path)
};
Self::discover_stems(
db,
root_schema_id,
items,
next_path,
next_parent.clone(),
property_name.clone(),
false,
inner_map,
pass_seen.clone(),
errors,
);
}
// Follow external reference if we didn't just crawl local properties
if schema.obj.properties.is_none() && schema.obj.items.is_none() && schema.obj.one_of.is_none()
{
if let Some(ref r) = schema.obj.r#ref {
if let Some(target_schema) = db.schemas.get(r) {
Self::discover_stems(
db,
root_schema_id,
target_schema,
current_path.clone(),
next_parent.clone(),
property_name.clone(),
is_polymorphic,
inner_map,
seen_entities.clone(),
errors,
);
}
}
}
// Polymorphism branch
if let Some(arr) = &schema.obj.one_of {
for v in arr {
Self::discover_stems(
db,
root_schema_id,
v.as_ref(),
current_path.clone(),
next_parent.clone(),
property_name.clone(),
true,
inner_map,
pass_seen.clone(),
errors,
);
}
}
if let Some(arr) = &schema.obj.all_of {
for v in arr {
Self::discover_stems(
db,
root_schema_id,
v.as_ref(),
current_path.clone(),
next_parent.clone(),
property_name.clone(),
is_polymorphic,
inner_map,
pass_seen.clone(),
errors,
);
}
}
}
}

12
src/database/stem.rs
View File

@ -1,12 +0,0 @@
use crate::database::schema::Schema;
use serde::{Deserialize, Serialize};
use std::sync::Arc;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Stem {
pub r#type: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub relation: Option<String>,
pub schema: Arc<Schema>,
}

22
src/lib.rs
View File

@ -77,7 +77,7 @@ pub fn jspg_merge(data: JsonB) -> JsonB {
}
#[cfg_attr(not(test), pg_extern)]
pub fn jspg_query(schema_id: &str, stem: Option<&str>, filters: Option<JsonB>) -> JsonB {
pub fn jspg_query(schema_id: &str, filters: Option<JsonB>) -> JsonB {
let engine_opt = {
let lock = GLOBAL_JSPG.read().unwrap();
lock.clone()
@ -87,7 +87,7 @@ pub fn jspg_query(schema_id: &str, stem: Option<&str>, filters: Option<JsonB>) -
Some(engine) => {
let drop = engine
.queryer
.query(schema_id, stem, filters.as_ref().map(|f| &f.0));
.query(schema_id, filters.as_ref().map(|f| &f.0));
JsonB(serde_json::to_value(drop).unwrap())
}
None => jspg_failure(),
@ -131,24 +131,6 @@ pub fn jspg_schemas() -> JsonB {
}
}
#[cfg_attr(not(test), pg_extern)]
pub fn jspg_stems() -> JsonB {
let engine_opt = {
let lock = GLOBAL_JSPG.read().unwrap();
lock.clone()
};
match engine_opt {
Some(engine) => {
let stems_json = serde_json::to_value(&engine.database.stems)
.unwrap_or(serde_json::Value::Object(serde_json::Map::new()));
let drop = crate::drop::Drop::success_with_val(stems_json);
JsonB(serde_json::to_value(drop).unwrap())
}
None => jspg_failure(),
}
}
#[cfg_attr(not(test), pg_extern(strict))]
pub fn jspg_teardown() -> JsonB {
let mut lock = GLOBAL_JSPG.write().unwrap();

59
src/queryer/compiler.rs
View File

@ -3,7 +3,6 @@ use std::sync::Arc;
pub struct Compiler<'a> {
pub db: &'a Database,
pub filter_keys: &'a [String],
pub is_stem_query: bool,
pub alias_counter: usize,
}
@ -15,7 +14,7 @@ pub struct Node<'a> {
pub parent_type: Option<&'a crate::database::r#type::Type>,
pub property_name: Option<String>,
pub depth: usize,
pub stem_path: String,
pub ast_path: String,
}
impl<'a> Compiler<'a> {
@ -23,7 +22,6 @@ impl<'a> Compiler<'a> {
pub fn compile(
&self,
schema_id: &str,
stem_path: Option<&str>,
filter_keys: &[String],
) -> Result<String, String> {
let schema = self
@ -32,32 +30,11 @@ impl<'a> Compiler<'a> {
.get(schema_id)
.ok_or_else(|| format!("Schema not found: {}", schema_id))?;
let target_schema = if let Some(path) = stem_path.filter(|p| !p.is_empty() && *p != "/") {
if let Some(stems_map) = self.db.stems.get(schema_id) {
if let Some(stem) = stems_map.get(path) {
stem.schema.clone()
} else {
return Err(format!(
"Stem entity type '{}' not found in schema '{}'",
path, schema_id
));
}
} else {
return Err(format!(
"Stem entity type '{}' not found in schema '{}'",
path, schema_id
));
}
} else {
std::sync::Arc::new(schema.clone())
};
let is_stem_query = stem_path.is_some();
let target_schema = std::sync::Arc::new(schema.clone());
let mut compiler = Compiler {
db: &self.db,
filter_keys,
is_stem_query,
alias_counter: 0,
};
@ -68,7 +45,7 @@ impl<'a> Compiler<'a> {
parent_type: None,
property_name: None,
depth: 0,
stem_path: String::new(),
ast_path: String::new(),
};
let (sql, _) = compiler.compile_node(node)?;
@ -89,24 +66,24 @@ impl<'a> Compiler<'a> {
fn compile_array(&mut self, node: Node<'a>) -> Result<(String, String), String> {
if let Some(items) = &node.schema.obj.items {
let next_path = if node.stem_path.is_empty() {
let next_path = if node.ast_path.is_empty() {
String::from("#")
} else {
format!("{}.#", node.stem_path)
format!("{}.#", node.ast_path)
};
if let Some(ref_id) = &items.obj.r#ref {
if let Some(type_def) = self.db.types.get(ref_id) {
let mut entity_noke = node.clone();
entity_noke.stem_path = next_path;
entity_noke.schema = std::sync::Arc::clone(items);
return self.compile_entity(type_def, entity_noke, true);
let mut entity_node = node.clone();
entity_node.ast_path = next_path;
entity_node.schema = std::sync::Arc::clone(items);
return self.compile_entity(type_def, entity_node, true);
}
}
let mut next_node = node.clone();
next_node.depth += 1;
next_node.stem_path = next_path;
next_node.ast_path = next_path;
next_node.schema = std::sync::Arc::clone(items);
let (item_sql, _) = self.compile_node(next_node)?;
return Ok((
@ -328,16 +305,16 @@ impl<'a> Compiler<'a> {
) -> Result<(String, String), String> {
let mut build_args = Vec::new();
for (k, v) in props {
let next_path = if node.stem_path.is_empty() {
let next_path = if node.ast_path.is_empty() {
k.clone()
} else {
format!("{}.{}", node.stem_path, k)
format!("{}.{}", node.ast_path, k)
};
let mut child_node = node.clone();
child_node.property_name = Some(k.clone());
child_node.depth += 1;
child_node.stem_path = next_path;
child_node.ast_path = next_path;
child_node.schema = std::sync::Arc::clone(v);
let (child_sql, val_type) = self.compile_node(child_node)?;
@ -479,13 +456,13 @@ impl<'a> Compiler<'a> {
child_node.parent_type = Some(r#type);
child_node.property_name = Some(prop_key.clone());
child_node.depth += 1;
let next_path = if node.stem_path.is_empty() {
let next_path = if node.ast_path.is_empty() {
prop_key.clone()
} else {
format!("{}.{}", node.stem_path, prop_key)
format!("{}.{}", node.ast_path, prop_key)
};
child_node.stem_path = next_path;
child_node.ast_path = next_path;
child_node.schema = std::sync::Arc::clone(prop_schema);
let (val_sql, val_type) = self.compile_node(child_node)?;
@ -593,13 +570,13 @@ impl<'a> Compiler<'a> {
let full_field_path = parts.next().unwrap_or(filter_key);
let op = parts.next().unwrap_or("$eq");
let field_name = if node.stem_path.is_empty() {
let field_name = if node.ast_path.is_empty() {
if full_field_path.contains('.') || full_field_path.contains('#') {
continue;
}
full_field_path
} else {
let prefix = format!("{}.", node.stem_path);
let prefix = format!("{}.", node.ast_path);
if full_field_path.starts_with(&prefix) {
let remainder = &full_field_path[prefix.len()..];
if remainder.contains('.') || remainder.contains('#') {

10
src/queryer/mod.rs
View File

@ -21,7 +21,6 @@ impl Queryer {
pub fn query(
&self,
schema_id: &str,
stem_opt: Option<&str>,
filters: Option<&serde_json::Value>,
) -> crate::drop::Drop {
let filters_map = filters.and_then(|f| f.as_object());
@ -43,11 +42,10 @@ impl Queryer {
}
};
let stem_key = stem_opt.unwrap_or("/");
let cache_key = format!("{}(Stem:{}):{}", schema_id, stem_key, filter_keys.join(","));
let cache_key = format!("{}:{}", schema_id, filter_keys.join(","));
// 2. Fetch from cache or compile
let sql = match self.get_or_compile_sql(&cache_key, schema_id, stem_opt, &filter_keys) {
let sql = match self.get_or_compile_sql(&cache_key, schema_id, &filter_keys) {
Ok(sql) => sql,
Err(drop) => return drop,
};
@ -90,7 +88,6 @@ impl Queryer {
&self,
cache_key: &str,
schema_id: &str,
stem_opt: Option<&str>,
filter_keys: &[String],
) -> Result<String, crate::drop::Drop> {
if let Some(cached_sql) = self.cache.get(cache_key) {
@ -100,11 +97,10 @@ impl Queryer {
let compiler = compiler::Compiler {
db: &self.db,
filter_keys: filter_keys,
is_stem_query: stem_opt.is_some(),
alias_counter: 0,
};
match compiler.compile(schema_id, stem_opt, filter_keys) {
match compiler.compile(schema_id, filter_keys) {
Ok(compiled_sql) => {
self
.cache

30
src/tests/fixtures.rs
View File

@ -1451,30 +1451,6 @@ fn test_queryer_0_6() {
crate::tests::runner::run_test_case(&path, 0, 6).unwrap();
}
#[test]
fn test_queryer_0_7() {
let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR"));
crate::tests::runner::run_test_case(&path, 0, 7).unwrap();
}
#[test]
fn test_queryer_0_8() {
let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR"));
crate::tests::runner::run_test_case(&path, 0, 8).unwrap();
}
#[test]
fn test_queryer_0_9() {
let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR"));
crate::tests::runner::run_test_case(&path, 0, 9).unwrap();
}
#[test]
fn test_queryer_0_10() {
let path = format!("{}/fixtures/queryer.json", env!("CARGO_MANIFEST_DIR"));
crate::tests::runner::run_test_case(&path, 0, 10).unwrap();
}
#[test]
fn test_not_0_0() {
let path = format!("{}/fixtures/not.json", env!("CARGO_MANIFEST_DIR"));
@ -3449,12 +3425,6 @@ fn test_if_then_else_13_1() {
crate::tests::runner::run_test_case(&path, 13, 1).unwrap();
}
#[test]
fn test_stems_0_0() {
let path = format!("{}/fixtures/stems.json", env!("CARGO_MANIFEST_DIR"));
crate::tests::runner::run_test_case(&path, 0, 0).unwrap();
}
#[test]
fn test_empty_string_0_0() {
let path = format!("{}/fixtures/emptyString.json", env!("CARGO_MANIFEST_DIR"));

26
src/tests/types/case.rs
View File

@ -16,9 +16,6 @@ pub struct Case {
pub schema_id: String,
// For Query
#[serde(default)]
pub stem: Option<String>,
#[serde(default)]
pub filters: Option<serde_json::Value>,
@ -38,7 +35,7 @@ fn default_action() -> String {
}
impl Case {
pub fn run_compile(&self, db: Arc<Database>) -> Result<(), String> {
pub fn run_compile(&self, _db: Arc<Database>) -> Result<(), String> {
let expected_success = self.expect.as_ref().map(|e| e.success).unwrap_or(false);
// We assume db has already been setup and compiled successfully by runner.rs's `jspg_setup`
@ -52,24 +49,6 @@ impl Case {
));
}
// Assert stems
if let Some(expect) = &self.expect {
if let Some(expected_stems) = &expect.stems {
// Convert the Db stems (HashMap<String, HashMap<String, Arc<Stem>>>) to matching JSON shape
let db_stems_json = serde_json::to_value(&db.stems).unwrap();
let expect_stems_json = serde_json::to_value(expected_stems).unwrap();
if db_stems_json != expect_stems_json {
let expected_pretty = serde_json::to_string_pretty(&expect_stems_json).unwrap();
let got_pretty = serde_json::to_string_pretty(&db_stems_json).unwrap();
return Err(format!(
"Stem validation failed.\nExpected:\n{}\n\nGot:\n{}",
expected_pretty, got_pretty
));
}
}
}
Ok(())
}
@ -158,8 +137,7 @@ impl Case {
use crate::queryer::Queryer;
let queryer = Queryer::new(db.clone());
let stem_opt = self.stem.as_deref();
let result = queryer.query(&self.schema_id, stem_opt, self.filters.as_ref());
let result = queryer.query(&self.schema_id, self.filters.as_ref());
let expected_success = self.expect.as_ref().map(|e| e.success).unwrap_or(false);
let got_success = result.errors.is_empty();

2
src/tests/types/expect/mod.rs
View File

@ -2,7 +2,6 @@ pub mod pattern;
pub mod sql;
use serde::Deserialize;
use std::collections::HashMap;
#[derive(Debug, Deserialize)]
#[serde(untagged)]
@ -16,7 +15,6 @@ pub struct Expect {
pub success: bool,
pub result: Option<serde_json::Value>,
pub errors: Option<Vec<serde_json::Value>>,
pub stems: Option<HashMap<String, HashMap<String, serde_json::Value>>>,
#[serde(default)]
pub sql: Option<Vec<SqlExpectation>>,
}