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.

pub async fn graph_store_read_page( &self, graph: &str, after: Option<&str>, limit: usize, ) -> Result<TripleScanPage, DomainError>

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 AclStore for SbolObjectService

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

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

Named graphs whose contents carry <subject> sbh:ownedBy <owner_iri>, i.e. the graphs owner_iri owns and may read. Distinct, order unspecified.

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

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

Objects shared with owner_iri through <owner_iri> sbh:canView <object>. Distinct, order unspecified.

impl CorpusStatsStore for SbolObjectService

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

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

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,

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

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

Resolve a document graph’s surrogate id from its document IRI, for delete-by-IRI. Returns None when no sbol3-kind graph carries it.

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 NamedGraphCatalogStore for SbolObjectService

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

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

fn catalog_graphs<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 NamedGraphQuery, ) -> Pin<Box<dyn Future<Output = Result<CursorPage<NamedGraphRecord>, DomainError>> + Send + 'async_trait>>

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

fn catalog_graph_triples<'life0, 'life1, 'async_trait>( &'life0 self, id: GraphId, query: &'life1 TriplePageQuery, ) -> Pin<Box<dyn Future<Output = Result<Option<CursorPage<Triple>>, DomainError>> + Send + 'async_trait>>

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

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 ResourceCatalogStore for SbolObjectService

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

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

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

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

fn catalog_resources<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 ResourceQuery, ) -> Pin<Box<dyn Future<Output = Result<CursorPage<ResourceRecord>, DomainError>> + Send + 'async_trait>>

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

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

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

Resolve a bounded caller-provided identity list in its original order. Backends may batch the expansion rather than issuing one query per IRI.

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

where Self: 'async_trait, 'life0: '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 graph_store_read_page<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, graph: &'life1 str, after: Option<&'life2 str>, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<TripleScanPage, DomainError>> + Send + 'async_trait>>

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

One stable keyset page from a named graph. The opaque cursor belongs to the backend and allows HTTP exports and migration verification to avoid both OFFSET scans and whole-graph memory limits.

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 SequenceCatalogStore for SbolObjectService

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

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

fn catalog_sequences<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 SequenceQuery, ) -> Pin<Box<dyn Future<Output = Result<CursorPage<CatalogSequenceRecord>, DomainError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: '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,

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

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

Candidate (sequence_iri, elements) pairs for the banded aligner: every indexed DNA/RNA sequence sharing at least one canonical k-mer with query (on either strand, since the seeds are canonical). This is the k-mer prefilter feeding the alignment verify step in the application facade; the store gathers candidates and never aligns, so rust-bio stays out of the backends. A query shorter than the k-mer width has no seed, so every indexed nucleotide sequence is returned as a candidate.

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

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

The (sequence_iri, elements) for the DNA/RNA sequences among iris, dropping any IRI that is absent or non-nucleotide. This materializes the elements of the SketchStore candidate set so the application facade can align them; order is unspecified.

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

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

Every DNA/RNA (sequence_iri, elements) in the derived view, the full set the search-index rebuild sketches into the SketchStore. Keyed by the Sequence object’s IRI, the same key the align path materializes elements by, so the sketch index and the align candidates stay aligned regardless of the source SBOL version. Order is unspecified.

impl TextSearchStore for SbolObjectService

fn search_objects<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 TextSearchQuery, ) -> Pin<Box<dyn Future<Output = Result<(Vec<SbolObjectRecord>, i64), DomainError>> + Send + 'async_trait>>

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

Search objects by substring, returning one page plus the total match count. A limit of 0 returns an empty page with the total only, so a caller wanting just the count pays for no row materialization.