Struct GraphHandle 

pub struct GraphHandle<'a> { /* private fields */ }

A fluent knowledge-graph traversal, created by Laser::graph. Set a start (start_ids/start_match/start_nearest), add hops (out/incoming), pick what to return, and finish with .fetch().await. Gated on the graph feature: a traversal rides the managed binary transport.

Implementations

impl GraphHandle<'_>

pub fn in_session(self, session: SessionRef) -> Self

Link every upsert to session, so the deployment records which session wrote each element.

pub fn produced_by(self, producer: ProducerInfo) -> Self

Stamp producer on every upserted element that has none.

pub fn sourced_from(self, source: SourceRef) -> Self

Stamp source on every upserted element that has none.

pub fn conversation(self, conversation: ConversationId) -> Self

Narrow the traversal to elements a single conversation asserted (the conversation lens): only nodes and edges whose source records that conversation are traversed and returned. Applies to both fetch and neighbors. Reads the whole graph when unset.

pub fn start_ids(self, ids: Vec<NodeId>) -> Self

Start the traversal from explicit node ids.

pub fn start_match(self, filter: Filter) -> Self

Start from the nodes matching a predicate.

pub fn start_nearest(self, embedding: Vec<f32>, k: usize) -> Self

Start from the nodes nearest an embedding (vector-seeded traversal).

pub fn out(self, edge_type: impl Into<String>) -> Self

Follow outgoing edges of edge_type one hop.

pub fn incoming(self, edge_type: impl Into<String>) -> Self

Follow incoming edges of edge_type one hop.

pub fn both(self, edge_type: impl Into<String>) -> Self

Follow edges of edge_type one hop in both directions.

pub fn return_edges(self) -> Self

Return the traversed edges instead of the reachable nodes.

pub fn return_triplets(self) -> Self

Return the traversed edges as (source, type, destination) triplets instead of the reachable nodes.

pub fn return_paths(self) -> Self

Return whole paths (node and edge id sequences) instead of nodes.

pub fn limit(self, limit: usize) -> Self

Cap the number of elements returned.

pub fn as_of(self, micros: u64) -> Self

Read the graph as of micros (valid-time, epoch micros): only edges whose valid-time window contains that instant are traversed. Applies to both fetch and neighbors.

pub async fn fetch(self) -> Result<GraphResult, LaserError>

Run the traversal. Requires managed_graph. Otherwise returns LaserError::Unsupported.

pub async fn neighbors( self, node: NodeId, dir: EdgeDir, edge_type: Option<String>, depth: u32, ) -> Result<GraphResult, LaserError>

Read a node’s neighbors: the nodes reachable in dir over edge_type (or any type when None), following the same hop depth times. The cheap, common traversal. Requires managed_graph. Otherwise returns LaserError::Unsupported.

pub async fn link( self, from: impl Into<String>, relation: impl Into<String>, to: impl Into<String>, ) -> Result<(), LaserError>

Relate two entities in one call: link("operator:42", "opened", "ticket:7") upserts both content-addressed entity nodes and the typed edge between them. Sugar over upsert, so re-linking the same triple converges on the same nodes and edge. The entity ids double as their labels’ values (kind:value strings work well).

pub async fn relink( self, from: impl Into<String>, relation: impl Into<String>, to: impl Into<String>, ) -> Result<usize, LaserError>

Assert the latest value of a single-valued relationship: close every live relation edge from from that points at a DIFFERENT target (valid_to now, the bitemporal supersede), then link from to to. The deterministic fact-invalidation mechanics (same subject, same predicate, new object supersedes the old), returning how many edges were closed. Contradiction detection beyond same-subject-same-predicate is the caller’s policy, and recording an improve feedback item that links superseded to superseding is the caller’s memory concern.

pub async fn unlink( self, from: impl Into<String>, relation: impl Into<String>, to: impl Into<String>, ) -> Result<(), LaserError>

Close the relationship link opened: rewrite the edge with valid_to now, so the fact is superseded without being destroyed (a bitemporal close). The nodes stay.

pub async fn upsert( self, nodes: Vec<GraphNode>, edges: Vec<GraphEdge>, ) -> Result<(), LaserError>

Write nodes and edges into the graph: the projector path, surfaced for callers that build the graph directly rather than through a graph projection. Idempotent on content-addressed ids (GraphNode::entity, GraphEdge::relate), so re-applying the same entities is a no-op. Requires managed_graph. Otherwise returns LaserError::Unsupported.