Changed schema for Value -> Term, majorly breaking change (#622)

* Changed schema for Value -> Term, majorly breaking change

* Following the schema change, Value -> Term into all processing

* Updated Cassandra for g, p, s, o index patterns (7 indexes)

* Reviewed and updated all tests

* Neo4j, Memgraph and FalkorDB remain broken, will look at once settled down

trustgraph-base/trustgraph/messaging/translators/__init__.py

@@ -1,5 +1,5 @@
 from .base import Translator, MessageTranslator
-from .primitives import ValueTranslator, TripleTranslator, SubgraphTranslator, RowSchemaTranslator, FieldTranslator, row_schema_translator, field_translator
+from .primitives import TermTranslator, ValueTranslator, TripleTranslator, SubgraphTranslator, RowSchemaTranslator, FieldTranslator, row_schema_translator, field_translator
 from .metadata import DocumentMetadataTranslator, ProcessingMetadataTranslator
 from .agent import AgentRequestTranslator, AgentResponseTranslator
 from .embeddings import EmbeddingsRequestTranslator, EmbeddingsResponseTranslator

trustgraph-base/trustgraph/messaging/translators/primitives.py

@@ -1,37 +1,133 @@
 from typing import Dict, Any, List
-from ...schema import Value, Triple, RowSchema, Field
+from ...schema import Term, Triple, RowSchema, Field, IRI, BLANK, LITERAL, TRIPLE
 from .base import Translator
 
 
-class ValueTranslator(Translator):
-    """Translator for Value schema objects"""
-    
-    def to_pulsar(self, data: Dict[str, Any]) -> Value:
-        return Value(value=data["v"], is_uri=data["e"])
-    
-    def from_pulsar(self, obj: Value) -> Dict[str, Any]:
-        return {"v": obj.value, "e": obj.is_uri}
+class TermTranslator(Translator):
+    """
+    Translator for Term schema objects.
+
+    Wire format (compact keys):
+    - "t": type (i/b/l/t)
+    - "i": iri (for IRI type)
+    - "d": id (for BLANK type)
+    - "v": value (for LITERAL type)
+    - "dt": datatype (for LITERAL type)
+    - "ln": language (for LITERAL type)
+    - "tr": triple (for TRIPLE type, nested)
+    """
+
+    def to_pulsar(self, data: Dict[str, Any]) -> Term:
+        term_type = data.get("t", "")
+
+        if term_type == IRI:
+            return Term(type=IRI, iri=data.get("i", ""))
+
+        elif term_type == BLANK:
+            return Term(type=BLANK, id=data.get("d", ""))
+
+        elif term_type == LITERAL:
+            return Term(
+                type=LITERAL,
+                value=data.get("v", ""),
+                datatype=data.get("dt", ""),
+                language=data.get("ln", ""),
+            )
+
+        elif term_type == TRIPLE:
+            # Nested triple - use TripleTranslator
+            triple_data = data.get("tr")
+            if triple_data:
+                triple = _triple_translator_to_pulsar(triple_data)
+            else:
+                triple = None
+            return Term(type=TRIPLE, triple=triple)
+
+        else:
+            # Unknown or empty type
+            return Term(type=term_type)
+
+    def from_pulsar(self, obj: Term) -> Dict[str, Any]:
+        result: Dict[str, Any] = {"t": obj.type}
+
+        if obj.type == IRI:
+            result["i"] = obj.iri
+
+        elif obj.type == BLANK:
+            result["d"] = obj.id
+
+        elif obj.type == LITERAL:
+            result["v"] = obj.value
+            if obj.datatype:
+                result["dt"] = obj.datatype
+            if obj.language:
+                result["ln"] = obj.language
+
+        elif obj.type == TRIPLE:
+            if obj.triple:
+                result["tr"] = _triple_translator_from_pulsar(obj.triple)
+
+        return result
+
+
+# Module-level helper functions to avoid circular instantiation
+def _triple_translator_to_pulsar(data: Dict[str, Any]) -> Triple:
+    term_translator = TermTranslator()
+    return Triple(
+        s=term_translator.to_pulsar(data["s"]) if data.get("s") else None,
+        p=term_translator.to_pulsar(data["p"]) if data.get("p") else None,
+        o=term_translator.to_pulsar(data["o"]) if data.get("o") else None,
+        g=data.get("g"),
+    )
+
+
+def _triple_translator_from_pulsar(obj: Triple) -> Dict[str, Any]:
+    term_translator = TermTranslator()
+    result: Dict[str, Any] = {}
+
+    if obj.s:
+        result["s"] = term_translator.from_pulsar(obj.s)
+    if obj.p:
+        result["p"] = term_translator.from_pulsar(obj.p)
+    if obj.o:
+        result["o"] = term_translator.from_pulsar(obj.o)
+    if obj.g:
+        result["g"] = obj.g
+
+    return result
 
 
 class TripleTranslator(Translator):
-    """Translator for Triple schema objects"""
-    
+    """Translator for Triple schema objects (quads with optional graph)"""
+
     def __init__(self):
-        self.value_translator = ValueTranslator()
-    
+        self.term_translator = TermTranslator()
+
     def to_pulsar(self, data: Dict[str, Any]) -> Triple:
         return Triple(
-            s=self.value_translator.to_pulsar(data["s"]),
-            p=self.value_translator.to_pulsar(data["p"]),
-            o=self.value_translator.to_pulsar(data["o"])
+            s=self.term_translator.to_pulsar(data["s"]) if data.get("s") else None,
+            p=self.term_translator.to_pulsar(data["p"]) if data.get("p") else None,
+            o=self.term_translator.to_pulsar(data["o"]) if data.get("o") else None,
+            g=data.get("g"),
         )
-    
+
     def from_pulsar(self, obj: Triple) -> Dict[str, Any]:
-        return {
-            "s": self.value_translator.from_pulsar(obj.s),
-            "p": self.value_translator.from_pulsar(obj.p),
-            "o": self.value_translator.from_pulsar(obj.o)
-        }
+        result: Dict[str, Any] = {}
+
+        if obj.s:
+            result["s"] = self.term_translator.from_pulsar(obj.s)
+        if obj.p:
+            result["p"] = self.term_translator.from_pulsar(obj.p)
+        if obj.o:
+            result["o"] = self.term_translator.from_pulsar(obj.o)
+        if obj.g:
+            result["g"] = obj.g
+
+        return result
+
+
+# Backward compatibility alias
+ValueTranslator = TermTranslator
 
 
 class SubgraphTranslator(Translator):

trustgraph-base/trustgraph/messaging/translators/triples.py

@@ -14,11 +14,13 @@ class TriplesQueryRequestTranslator(MessageTranslator):
         s = self.value_translator.to_pulsar(data["s"]) if "s" in data else None
         p = self.value_translator.to_pulsar(data["p"]) if "p" in data else None
         o = self.value_translator.to_pulsar(data["o"]) if "o" in data else None
-        
+        g = data.get("g")  # None=default graph, "*"=all graphs
+
         return TriplesQueryRequest(
             s=s,
             p=p,
             o=o,
+            g=g,
             limit=int(data.get("limit", 10000)),
             user=data.get("user", "trustgraph"),
             collection=data.get("collection", "default")
@@ -30,14 +32,16 @@ class TriplesQueryRequestTranslator(MessageTranslator):
             "user": obj.user,
             "collection": obj.collection
         }
-        
+
         if obj.s:
             result["s"] = self.value_translator.from_pulsar(obj.s)
         if obj.p:
             result["p"] = self.value_translator.from_pulsar(obj.p)
         if obj.o:
             result["o"] = self.value_translator.from_pulsar(obj.o)
-            
+        if obj.g is not None:
+            result["g"] = obj.g
+
         return result