GraphQueryCapable

Opt-in capability for querying the entity-relationship axis of the knowledge graph: neighbourhoods, paths between entities, and the provenance lineage behind a single proposition.

This is distinct from GraphTraversalCapable, which navigates the proposition abstraction hierarchy (source/derived links). This fragment treats entities as nodes and propositions that mention two resolved entities as edges.

All methods have default bodies that return empty results, making this a pure override seam for graph-native backends. The portable facade builds equivalent results store-agnostically and only routes here when the store declares this capability.

Inheritors

Properties

Link copied to clipboard

Whether this backend filters graph edges by source authority on its own.

Link copied to clipboard

Whether this backend confines entity-axis graph queries to a supplied context on its own.

Functions

Link copied to clipboard
open fun neighborhood(entityId: String, depth: Int = 1): GraphNeighborhood

The entity neighbourhood reachable from entityId within depth hops.

open fun neighborhood(entityId: String, depth: Int, contextId: <Error class: unknown class>?): GraphNeighborhood

The entity neighbourhood reachable from entityId, confined to contextId (a null context is unscoped — exactly the plain neighborhood overload).

open fun neighborhood(entityId: String, depth: Int, minAuthority: AuthorityTier?): GraphNeighborhood

The entity neighbourhood reachable from entityId, keeping only edges whose source authority is at least minAuthority (a null floor keeps everything).

open fun neighborhood(entityId: String, depth: Int, contextId: <Error class: unknown class>?, maxDepth: Int): GraphNeighborhood

Same as the context-scoped overload above, but also carries the caller's own depth ceiling (maxDepth) so a backend that enforces its own hard cap on the walk can clamp against the caller's ceiling instead of a value it hardcodes itself. The facade always calls this overload (passing its own configured maxDepth) rather than the three-arg one, so a store that only overrides the three-arg overload keeps working unchanged — it just never sees the caller's ceiling and falls back to whatever bound it enforces on its own.

open fun neighborhood(entityId: String, depth: Int, minAuthority: AuthorityTier?, maxDepth: Int): GraphNeighborhood

Same as the authority-aware overload above, but also carries the caller's own depth ceiling (maxDepth), for the same reason as the context-aware maxDepth-carrying overload.

Link copied to clipboard
open fun pathBetween(entityIdA: String, entityIdB: String): List<GraphPath>

The paths connecting entityIdA to entityIdB.

open fun pathBetween(entityIdA: String, entityIdB: String, contextId: <Error class: unknown class>?): List<GraphPath>

The paths connecting entityIdA to entityIdB, confined to contextId (a null context is unscoped — exactly the plain pathBetween overload). Routed here only when honorsContextFilter is true; the default body delegates to the unscoped overload.

open fun pathBetween(entityIdA: String, entityIdB: String, minAuthority: AuthorityTier?): List<GraphPath>

The paths connecting entityIdA to entityIdB, keeping only edges whose source authority is at least minAuthority (a null floor keeps everything).

open fun pathBetween(entityIdA: String, entityIdB: String, contextId: <Error class: unknown class>?, maxDepth: Int): List<GraphPath>

Same as the context-scoped overload above, but also carries the caller's own hop ceiling (maxDepth) for the walk, so a backend that enforces its own hard cap can clamp against the caller's ceiling instead of a value it hardcodes itself — mirroring the maxDepth-carrying neighborhood overload. The facade always calls this overload rather than the three-arg one, so a store that only overrides the three-arg overload keeps working unchanged, just without seeing the caller's ceiling.

open fun pathBetween(entityIdA: String, entityIdB: String, minAuthority: AuthorityTier?, maxDepth: Int): List<GraphPath>

Same as the authority-aware overload above, but also carries the caller's own hop ceiling (maxDepth), for the same reason as the context-aware maxDepth-carrying overload.

Link copied to clipboard
open fun whyExplain(propositionId: String): PropositionLineage?

The lineage behind the proposition with the given id, assembled from its durable fields.

open fun whyExplain(propositionId: String, contextId: <Error class: unknown class>?): PropositionLineage?

The lineage behind propositionId, confined to contextId: a proposition in another context is treated as absent (null). A null context is unscoped — exactly the plain whyExplain overload. Routed here only when honorsContextFilter is true; the default body delegates to the unscoped overload.