Struct SbolObjectService 

pub struct SbolObjectService { /* private fields */ }

Implementations

impl SbolObjectService

pub fn new(pool: PgPool) -> Self

pub fn lab(&self) -> &LabRepository

pub fn pool(&self) -> &PgPool

pub async fn ping(&self) -> Result<(), DomainError>

Cheap liveness probe against the connection pool. Used by the HTTP /readyz endpoint; intentionally trivial so it can’t itself stall on application state.

pub fn graphs(&self) -> &GraphRepository

pub fn objects(&self) -> &SbolObjectRepository

pub fn triples(&self) -> &TripleRepository

pub fn accel(&self) -> &AccelRepository

pub fn neighborhood(&self) -> &NeighborhoodRepository

pub fn sequence_search(&self) -> &SequenceSearchRepository

pub fn ontology(&self) -> &OntologyRepository

pub async fn import_documents( &self, inputs: Vec<ImportInput>, ) -> Result<Vec<ImportReport>, DomainError>

Atomically import a batch of documents inside one Postgres transaction. Either every document commits or none do — there is no half-imported state. The implementation is sequential per-document inside the shared transaction; the caller controls batch composition. Per-document validation runs and projection events are still recorded individually (so the batch shows up as N separate document_imported events), but they share the outer transaction’s atomicity.

Callers wanting partial-success semantics for corpus-scale onboarding should fan out to [import_document] themselves; the CLI directory import is the reference for that pattern.

pub async fn import_document( &self, input: ImportInput, ) -> Result<ImportReport, DomainError>

pub async fn graph_store_write( &self, graph: &str, body: &str, format: SerializationFormat, mode: GraphWriteMode, ) -> Result<usize, DomainError>

Graph Store HTTP Protocol write: one ingest mode feeding the shared, graph-owned store. Parses body as RDF and writes its triples verbatim into graph (registered via TripleRepository::ensure_graph), with no SBOL interpretation at write time. Merge appends; Replace first clears the graph; both run in one transaction. Returns the inserted triple count.

This is the same storage substrate Self::import_document writes to — the difference is only how the triples arrive (a posted RDF graph here, a parsed/validated SBOL document there). The SBOL3 typed view ([Self::apply_sbol_view]) is a derivation over a graph’s triples; for graphs populated this way it is produced by the asynchronous reprojection path rather than inline (see the derived-view work).

pub async fn graph_store_clear(&self, graph: &str) -> Result<usize, DomainError>

Graph Store CRUD DELETE: drop a named graph entirely (its triples and sbol_graphs registry row). Returns the number of triples removed.

pub async fn graph_store_read( &self, graph: &str, ) -> Result<Vec<Triple>, DomainError>

Graph Store CRUD GET: read back a named graph’s triples.

impl SbolObjectService

pub fn triple_source(&self) -> Arc<dyn TripleSource>

A TripleSource view of this service’s triple store, for the SPARQL read engine.

pub fn triple_writer(&self) -> Arc<dyn TripleWriter>

A TripleWriter view of this service’s triple store, for SPARQL Update.

Trait Implementations

impl GraphStore for SbolObjectService

fn get_graph<'life0, 'async_trait>( &'life0 self, id: GraphId, ) -> Pin<Box<dyn Future<Output = Result<Option<GraphRecord>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn list_graphs<'life0, 'life1, 'async_trait>( &'life0 self, filter: &'life1 ListGraphsFilter, ) -> Pin<Box<dyn Future<Output = Result<Vec<GraphRecord>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn delete_graph<'life0, 'async_trait>( &'life0 self, id: GraphId, ) -> Pin<Box<dyn Future<Output = Result<bool, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn graph_exists_by_hash<'life0, 'life1, 'async_trait>( &'life0 self, hash: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<bool, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl LabStore for SbolObjectService

fn corpus_counts<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<CorpusCounts, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn recent_graphs<'life0, 'async_trait>( &'life0 self, limit: i64, ) -> Pin<Box<dyn Future<Output = Result<Vec<GraphOverview>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn top_classes<'life0, 'async_trait>( &'life0 self, limit: i64, ) -> Pin<Box<dyn Future<Output = Result<Vec<ClassCount>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn count_graphs<'life0, 'life1, 'async_trait>( &'life0 self, kind: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Result<i64, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn list_graph_overviews<'life0, 'life1, 'async_trait>( &'life0 self, kind: Option<&'life1 str>, limit: i64, offset: i64, ) -> Pin<Box<dyn Future<Output = Result<Vec<GraphOverview>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_graph_overview<'life0, 'async_trait>( &'life0 self, id: GraphId, ) -> Pin<Box<dyn Future<Output = Result<Option<GraphOverview>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn graph_triples<'life0, 'async_trait>( &'life0 self, id: GraphId, limit: i64, offset: i64, ) -> Pin<Box<dyn Future<Output = Result<Option<GraphTriplesPage>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

One graph’s triples (paginated) plus the total, or None if the graph does not exist.

impl NeighborhoodStore for SbolObjectService

fn walk<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 NeighborhoodQuery, ) -> Pin<Box<dyn Future<Output = Result<NeighborhoodResult, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl ObjectStore for SbolObjectService

fn get_object_by_iri<'life0, 'life1, 'async_trait>( &'life0 self, iri: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<SbolObjectRecord>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_objects_by_iris<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, iris: &'life1 [&'life2 str], ) -> Pin<Box<dyn Future<Output = Result<Vec<SbolObjectRecord>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn list_objects<'life0, 'life1, 'async_trait>( &'life0 self, filter: &'life1 ListObjectsFilter, ) -> Pin<Box<dyn Future<Output = Result<Vec<SbolObjectRecord>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_object_iri_by_id<'life0, 'async_trait>( &'life0 self, id: ObjectId, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

impl OntologyStore for SbolObjectService

fn load_ontology_from_url<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, prefix: &'life1 str, name: &'life2 str, source_url: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<OntologyLoadReport, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn load_ontology_from_text<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, prefix: &'life1 str, name: &'life2 str, source_url: Option<&'life3 str>, text: &'life4 str, ) -> Pin<Box<dyn Future<Output = Result<OntologyLoadReport, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

fn list_ontologies<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<OntologyRecord>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn canonicalize<'life0, 'life1, 'async_trait>( &'life0 self, iri: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn descendants<'life0, 'life1, 'async_trait>( &'life0 self, iri: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<(String, i16)>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn list_ontology_terms<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, prefix: &'life1 str, limit: i64, offset: i64, search: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = Result<(Vec<OntologyTermRecord>, i64), DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn get_ontology_term<'life0, 'life1, 'async_trait>( &'life0 self, iri: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<OntologyTermRecord>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl SbolStore for SbolObjectService

fn import_document<'life0, 'async_trait>( &'life0 self, input: ImportInput, ) -> Pin<Box<dyn Future<Output = Result<ImportReport, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn import_documents<'life0, 'async_trait>( &'life0 self, inputs: Vec<ImportInput>, ) -> Pin<Box<dyn Future<Output = Result<Vec<ImportReport>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn graph_store_write<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, graph: &'life1 str, body: &'life2 str, format: SerializationFormat, mode: GraphWriteMode, ) -> Pin<Box<dyn Future<Output = Result<usize, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn graph_store_clear<'life0, 'life1, 'async_trait>( &'life0 self, graph: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<usize, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn graph_store_read<'life0, 'life1, 'async_trait>( &'life0 self, graph: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<Triple>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn triples_for_subject<'life0, 'life1, 'async_trait>( &'life0 self, subject_iri: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<Triple>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Every triple with the given subject IRI, for single-object RDF export.

fn ping<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

impl SequenceSearchStore for SbolObjectService

fn search<'life0, 'life1, 'async_trait>( &'life0 self, pattern: &'life1 str, options: SequenceSearchOptions, ) -> Pin<Box<dyn Future<Output = Result<Vec<SequenceMatch>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn search_many<'life0, 'life1, 'async_trait>( &'life0 self, patterns: &'life1 [String], options: SequenceSearchOptions, ) -> Pin<Box<dyn Future<Output = Result<Vec<BatchSequenceMatch>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,