gqlite 1.5.0 → 1.7.0

data/ext/gqlparser/src/gqls/prelude.rs

@@ -0,0 +1,8 @@
+//! Import this prelude for base types
+
+pub use crate::gqls::{
+  constraint::Constraint,
+  properties::{LiteralAlternativeType, LiteralBaseType, Property},
+  resolve::resolve_constrained_type,
+};
+pub use graphcore;

data/ext/gqlparser/src/gqls/properties.rs

@@ -0,0 +1,115 @@
+//! Module with properties definitions
+
+use indexmap::IndexMap;
+
+use super::Error;
+
+/// Literal types
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum LiteralBaseType
+{
+  /// Boolean value
+  Boolean,
+  /// i64 value
+  Integer,
+  /// f64 value
+  Float,
+  /// String value
+  String,
+  /// Timestamp value
+  TimeStamp,
+}
+
+/// This structure allow to map several literal types
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct LiteralAlternativeType(u8);
+
+impl LiteralAlternativeType
+{
+  /// Check if the alternative contains the given type
+  pub fn has_type(&self, ltype: LiteralBaseType) -> bool
+  {
+    let c: LiteralAlternativeType = ltype.into();
+    (self.0 & c.0) != 0
+  }
+}
+
+impl From<LiteralBaseType> for LiteralAlternativeType
+{
+  fn from(value: LiteralBaseType) -> Self
+  {
+    LiteralAlternativeType(match value
+    {
+      LiteralBaseType::Boolean => 1,
+      LiteralBaseType::Integer => 1 << 1,
+      LiteralBaseType::Float => 1 << 2,
+      LiteralBaseType::String => 1 << 3,
+      LiteralBaseType::TimeStamp => 1 << 4,
+    })
+  }
+}
+
+impl TryFrom<LiteralAlternativeType> for LiteralBaseType
+{
+  type Error = Error;
+  fn try_from(value: LiteralAlternativeType) -> Result<Self, Self::Error>
+  {
+    if value.0.count_ones() == 1
+    {
+      if value.has_type(LiteralBaseType::Boolean)
+      {
+        Ok(LiteralBaseType::Boolean)
+      }
+      else if value.has_type(LiteralBaseType::Float)
+      {
+        Ok(LiteralBaseType::Float)
+      }
+      else if value.has_type(LiteralBaseType::Integer)
+      {
+        Ok(LiteralBaseType::Integer)
+      }
+      else if value.has_type(LiteralBaseType::String)
+      {
+        Ok(LiteralBaseType::String)
+      }
+      else if value.has_type(LiteralBaseType::TimeStamp)
+      {
+        Ok(LiteralBaseType::TimeStamp)
+      }
+      else
+      {
+        Err(Error::InvalidType)
+      }
+    }
+    else
+    {
+      Err(Error::MultiTypeCannotBeConvertedToSingle)
+    }
+  }
+}
+
+/// Type constraint on a property
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Property
+{
+  /// Can have any value
+  Any,
+  /// Is optional, other are assumed required, unless contained in optional
+  Optional(Box<Property>),
+  /// Literal value (string, float...)
+  Literal(LiteralAlternativeType),
+  /// A map of property
+  Map(IndexMap<String, Property>),
+  /// An array of property
+  Array(Box<Property>),
+  /// A reference to a named constrained type
+  Named(String),
+}
+
+impl From<LiteralBaseType> for Property
+{
+  fn from(value: LiteralBaseType) -> Self
+  {
+    Property::Literal(value.into())
+  }
+}

data/ext/gqlparser/src/gqls/resolve.rs

@@ -0,0 +1,207 @@
+//! Type resolution with cycle detection for named constrained types.
+
+use indexmap::IndexMap;
+use std::collections::HashSet;
+
+use crate::gqls::{
+  Error,
+  ast::{ConstrainedTypeDef, TypeRef},
+  constraint::Constraint,
+  properties::LiteralBaseType,
+};
+
+/// Resolves a named constrained type to its flattened `(base type, combined constraint)`,
+/// walking `TypeRef::Named` references and accumulating each link's constraint via `And`.
+/// This mirrors `gqls-macros`'s existing `expand_element` recursion pattern for `<:` parent
+/// chains — but adds the cycle detection that pattern currently lacks.
+pub fn resolve_constrained_type(
+  types: &IndexMap<String, ConstrainedTypeDef>,
+  name: &str,
+) -> Result<(LiteralBaseType, Constraint), Error>
+{
+  let mut path = Vec::new();
+  let mut visiting = HashSet::new();
+  resolve_inner(types, name, &mut path, &mut visiting)
+}
+
+fn resolve_inner(
+  types: &IndexMap<String, ConstrainedTypeDef>,
+  name: &str,
+  path: &mut Vec<String>,
+  visiting: &mut HashSet<String>,
+) -> Result<(LiteralBaseType, Constraint), Error>
+{
+  if !visiting.insert(name.to_string())
+  {
+    path.push(name.to_string());
+    return Err(Error::Cycle(path.clone()));
+  }
+  path.push(name.to_string());
+
+  let def = types
+    .get(name)
+    .ok_or_else(|| Error::UndefinedType(name.to_string()))?;
+
+  let result = match &def.base
+  {
+    TypeRef::Base(base) =>
+    {
+      let constraint = def.constraint.clone().unwrap_or(Constraint::And(vec![]));
+      Ok((base.clone(), constraint))
+    }
+    TypeRef::Named(parent_name) =>
+    {
+      let (base, parent_constraint) = resolve_inner(types, parent_name, path, visiting)?;
+      let combined = match &def.constraint
+      {
+        Some(c) => Constraint::And(vec![parent_constraint, c.clone()]),
+        None => parent_constraint,
+      };
+      Ok((base, combined))
+    }
+  };
+
+  visiting.remove(name);
+  path.pop();
+  result
+}
+
+#[cfg(test)]
+mod tests
+{
+  use super::*;
+  use graphcore::Value;
+
+  fn types(pairs: &[(&str, TypeRef, Option<Constraint>)]) -> IndexMap<String, ConstrainedTypeDef>
+  {
+    pairs
+      .iter()
+      .map(|(name, base, constraint)| {
+        (
+          name.to_string(),
+          ConstrainedTypeDef {
+            base: base.clone(),
+            constraint: constraint.clone(),
+          },
+        )
+      })
+      .collect()
+  }
+
+  #[test]
+  fn resolves_single_level_type()
+  {
+    let ts = types(&[(
+      "FactTier",
+      TypeRef::Base(LiteralBaseType::String),
+      Some(Constraint::In(vec![
+        Value::String("Context".into()),
+        Value::String("Critical".into()),
+      ])),
+    )]);
+    let (base, constraint) = resolve_constrained_type(&ts, "FactTier").unwrap();
+    assert_eq!(base, LiteralBaseType::String);
+    assert_eq!(
+      constraint,
+      Constraint::In(vec![
+        Value::String("Context".into()),
+        Value::String("Critical".into())
+      ])
+    );
+  }
+
+  #[test]
+  fn resolves_two_level_chain_combining_constraints()
+  {
+    let ts = types(&[
+      (
+        "Bob",
+        TypeRef::Base(LiteralBaseType::Integer),
+        Some(Constraint::GreaterThan(Value::Integer(10))),
+      ),
+      (
+        "SuperBob",
+        TypeRef::Named("Bob".into()),
+        Some(Constraint::LessThan(Value::Integer(20))),
+      ),
+    ]);
+    let (base, constraint) = resolve_constrained_type(&ts, "SuperBob").unwrap();
+    assert_eq!(base, LiteralBaseType::Integer);
+    assert_eq!(
+      constraint,
+      Constraint::And(vec![
+        Constraint::GreaterThan(Value::Integer(10)),
+        Constraint::LessThan(Value::Integer(20)),
+      ])
+    );
+  }
+
+  #[test]
+  fn resolves_three_level_chain()
+  {
+    let ts = types(&[
+      (
+        "A",
+        TypeRef::Base(LiteralBaseType::Integer),
+        Some(Constraint::GreaterThan(Value::Integer(0))),
+      ),
+      (
+        "B",
+        TypeRef::Named("A".into()),
+        Some(Constraint::LessThan(Value::Integer(100))),
+      ),
+      (
+        "C",
+        TypeRef::Named("B".into()),
+        Some(Constraint::Ne(Value::Integer(50))),
+      ),
+    ]);
+    let (base, constraint) = resolve_constrained_type(&ts, "C").unwrap();
+    assert_eq!(base, LiteralBaseType::Integer);
+    assert_eq!(
+      constraint,
+      Constraint::And(vec![
+        Constraint::And(vec![
+          Constraint::GreaterThan(Value::Integer(0)),
+          Constraint::LessThan(Value::Integer(100)),
+        ]),
+        Constraint::Ne(Value::Integer(50)),
+      ])
+    );
+  }
+
+  #[test]
+  fn direct_self_reference_is_a_cycle_not_a_stack_overflow()
+  {
+    let ts = types(&[("A", TypeRef::Named("A".into()), None)]);
+    let err = resolve_constrained_type(&ts, "A").unwrap_err();
+    assert!(matches!(err, Error::Cycle(_)));
+  }
+
+  #[test]
+  fn indirect_cycle_is_detected()
+  {
+    let ts = types(&[
+      ("A", TypeRef::Named("B".into()), None),
+      ("B", TypeRef::Named("A".into()), None),
+    ]);
+    let err = resolve_constrained_type(&ts, "A").unwrap_err();
+    match err
+    {
+      Error::Cycle(path) =>
+      {
+        assert!(path.contains(&"A".to_string()));
+        assert!(path.contains(&"B".to_string()));
+      }
+      other => panic!("expected Cycle, got {other:?}"),
+    }
+  }
+
+  #[test]
+  fn undefined_type_reference_is_a_clear_error()
+  {
+    let ts = types(&[("SuperBob", TypeRef::Named("Bob".into()), None)]);
+    let err = resolve_constrained_type(&ts, "SuperBob").unwrap_err();
+    assert_eq!(err, Error::UndefinedType("Bob".to_string()));
+  }
+}

data/ext/gqlparser/src/gqls.rs

@@ -0,0 +1,265 @@
+//! GQL Schema parser
+
+pub mod ast;
+pub mod constraint;
+mod error;
+mod parser;
+pub mod prelude;
+pub mod properties;
+pub mod resolve;
+
+pub use error::Error;
+
+/// Result type used by this crate
+pub type Result<T, E = error::Error> = std::result::Result<T, E>;
+
+use indexmap::IndexMap;
+use nom::Finish;
+
+/// Parse a schmea into an AST.
+pub fn parse_schema(input: &str) -> Result<ast::Ast>
+{
+  // Parse schema
+  let (rem, parse_tree) = parser::parse_schema(input)
+    .finish()
+    .map_err(|e| Error::Parse(nom_language::error::convert_error(input, e)))?;
+
+  if !rem.is_empty()
+  {
+    return Err(Error::IncompleteParsing(rem.to_string()));
+  }
+
+  // Convert to AST
+  let mut nodes: Vec<ast::Node> = Default::default();
+  let mut edges: Vec<ast::Edge> = Default::default();
+  let mut properties_definitions: IndexMap<String, ast::PropertiesDefinition> = Default::default();
+  let mut constrained_types: IndexMap<String, ast::ConstrainedTypeDef> = Default::default();
+
+  for element in parse_tree
+  {
+    match element
+    {
+      parser::ParseTreeElement::Property {
+        label,
+        properties,
+        parent,
+      } =>
+      {
+        let parents = parent.map_or_else(Vec::new, |x| vec![x]);
+        properties_definitions.insert(
+          label,
+          ast::PropertiesDefinition {
+            parents,
+            properties,
+          },
+        );
+      }
+      parser::ParseTreeElement::Node { label } =>
+      {
+        nodes.push(ast::Node { label });
+      }
+      parser::ParseTreeElement::Edge {
+        source,
+        label,
+        destination,
+      } =>
+      {
+        edges.push(ast::Edge {
+          source,
+          label,
+          destination,
+        });
+      }
+      parser::ParseTreeElement::ConstrainedType { name, def } =>
+      {
+        constrained_types.insert(name, def);
+      }
+    }
+  }
+
+  Ok(ast::Ast {
+    elements: properties_definitions,
+    nodes,
+    edges,
+    constrained_types,
+  })
+}
+
+#[cfg(test)]
+mod test
+{
+  use crate::gqls::prelude::*;
+
+  #[test]
+  fn parse_simple()
+  {
+    let ast = super::parse_schema(
+      r#"
+// Properties definitions
+Person{
+  firstName: STRING, lastName : STRING
+},
+Message {
+  creationDate: TIMESTAMP, browserUsed: STRING
+},
+Comment <: Message {},
+Post <: Message {
+  imageFile: STRING?
+},
+REPLY_OF {},
+KNOWS {
+  creationDate : TIMESTAMP
+},
+
+// Nodes
+(Person), (Post), (Comment),
+
+// Edges
+(Person)-[KNOWS]->(Person),
+(Person)-[LIKES]->(Message),
+(Message)-[HAS_CREATOR]->(Person),
+(Comment)-[REPLY_OF]->(Message)
+    "#,
+    )
+    .unwrap();
+
+    // Check nodes
+    assert_eq!(ast.nodes.len(), 3);
+    assert_eq!(&ast.nodes[0].label, "Person");
+    assert_eq!(&ast.nodes[1].label, "Post");
+    assert_eq!(&ast.nodes[2].label, "Comment");
+
+    assert_eq!(ast.edges.len(), 4);
+    let e0 = &ast.edges[0];
+    assert_eq!(&e0.source, "Person");
+    assert_eq!(&e0.label, "KNOWS");
+    assert_eq!(&e0.destination, "Person");
+    let e1 = &ast.edges[1];
+    assert_eq!(&e1.source, "Person");
+    assert_eq!(&e1.label, "LIKES");
+    assert_eq!(&e1.destination, "Message");
+    let e2 = &ast.edges[2];
+    assert_eq!(&e2.source, "Message");
+    assert_eq!(&e2.label, "HAS_CREATOR");
+    assert_eq!(&e2.destination, "Person");
+    let e3 = &ast.edges[3];
+    assert_eq!(&e3.source, "Comment");
+    assert_eq!(&e3.label, "REPLY_OF");
+    assert_eq!(&e3.destination, "Message");
+
+    let (pd0_key, pd0_v) = &ast.elements.get_index(0).unwrap();
+    assert_eq!(pd0_key.as_str(), "Person");
+    assert!(pd0_v.parents.is_empty());
+    assert_eq!(pd0_v.properties.len(), 2);
+    assert_eq!(
+      pd0_v.properties["firstName"],
+      LiteralBaseType::String.into()
+    );
+    assert_eq!(pd0_v.properties["lastName"], LiteralBaseType::String.into());
+
+    let (pd1_key, pd1_v) = &ast.elements.get_index(1).unwrap();
+    assert_eq!(pd1_key.as_str(), "Message");
+    assert!(pd1_v.parents.is_empty());
+    assert_eq!(pd1_v.properties.len(), 2);
+    assert_eq!(
+      pd1_v.properties["creationDate"],
+      LiteralBaseType::TimeStamp.into()
+    );
+    assert_eq!(
+      pd1_v.properties["browserUsed"],
+      LiteralBaseType::String.into()
+    );
+
+    let (pd2_key, pd2_v) = &ast.elements.get_index(2).unwrap();
+    assert_eq!(pd2_key.as_str(), "Comment");
+    assert_eq!(pd2_v.parents, vec!["Message".to_string()]);
+    assert!(pd2_v.properties.is_empty());
+
+    let (pd3_key, pd3_v) = &ast.elements.get_index(3).unwrap();
+    assert_eq!(pd3_key.as_str(), "Post");
+    assert_eq!(pd3_v.parents, vec!["Message".to_string()]);
+    assert_eq!(pd3_v.properties.len(), 1);
+    assert_eq!(
+      pd3_v.properties["imageFile"],
+      Property::Optional(Box::new(LiteralBaseType::String.into()))
+    );
+
+    let (pd4_key, pd4_v) = &ast.elements.get_index(4).unwrap();
+    assert_eq!(pd4_key.as_str(), "REPLY_OF");
+    assert!(pd4_v.parents.is_empty());
+    assert!(pd4_v.properties.is_empty());
+
+    let (pd5_key, pd5_v) = &ast.elements.get_index(5).unwrap();
+    assert_eq!(pd5_key.as_str(), "KNOWS");
+    assert!(pd5_v.parents.is_empty());
+    assert_eq!(pd5_v.properties.len(), 1);
+    assert_eq!(
+      pd5_v.properties["creationDate"],
+      LiteralBaseType::TimeStamp.into()
+    );
+  }
+
+  #[test]
+  fn parse_with_type_declarations()
+  {
+    use crate::gqls::ast::TypeRef;
+    use crate::gqls::constraint::Constraint;
+    use graphcore::Value;
+
+    let ast = super::parse_schema(
+      r#"
+// Type declarations
+type Age = INTEGER: > 0,
+type Priority = INTEGER,
+type HighPriority = Priority: > 50,
+
+// Properties definitions
+Person{
+  firstName: STRING, lastName : STRING
+},
+Message {
+  creationDate: TIMESTAMP, browserUsed: STRING
+},
+
+// Nodes
+(Person), (Message),
+
+// Edges
+(Person)-[KNOWS]->(Person)
+    "#,
+    )
+    .unwrap();
+
+    // Verify type declarations were parsed
+    assert_eq!(ast.constrained_types.len(), 3);
+
+    // Check Age type
+    let age_def = &ast.constrained_types["Age"];
+    assert_eq!(age_def.base, TypeRef::Base(LiteralBaseType::Integer));
+    assert_eq!(
+      age_def.constraint,
+      Some(Constraint::GreaterThan(Value::Integer(0)))
+    );
+
+    // Check Priority type (no constraint)
+    let priority_def = &ast.constrained_types["Priority"];
+    assert_eq!(priority_def.base, TypeRef::Base(LiteralBaseType::Integer));
+    assert!(priority_def.constraint.is_none());
+
+    // Check HighPriority type (references another type)
+    let high_priority_def = &ast.constrained_types["HighPriority"];
+    assert_eq!(
+      high_priority_def.base,
+      TypeRef::Named("Priority".to_string())
+    );
+    assert_eq!(
+      high_priority_def.constraint,
+      Some(Constraint::GreaterThan(Value::Integer(50)))
+    );
+
+    // Verify regular elements still work
+    assert_eq!(ast.elements.len(), 2);
+    assert_eq!(ast.nodes.len(), 2);
+    assert_eq!(ast.edges.len(), 1);
+  }
+}

data/ext/gqlparser/src/lib.rs

@@ -0,0 +1,7 @@
+#![doc = include_str!("../README.MD")]
+// #![warn(missing_docs)]
+
+mod common;
+pub mod gqls;
+pub mod oc;
+pub mod prelude;