pub struct PostgresStore { /* private fields */ }Expand description
PostgreSQL storage backend.
Implementations§
Source§impl PostgresStore
impl PostgresStore
Sourcepub fn new(pool: Pool<Postgres>) -> PostgresStore
pub fn new(pool: Pool<Postgres>) -> PostgresStore
Create a new store with default table names.
Sourcepub fn with_prefix(
pool: Pool<Postgres>,
prefix: impl Into<String>,
) -> PostgresStore
pub fn with_prefix( pool: Pool<Postgres>, prefix: impl Into<String>, ) -> PostgresStore
Create a new store with a custom table prefix.
Source§impl PostgresStore
impl PostgresStore
Sourcepub async fn ensure_schema(&self) -> Result<(), StorageError>
pub async fn ensure_schema(&self) -> Result<(), StorageError>
Ensure all tables exist. Called lazily on first access.
Trait Implementations§
Source§impl Clone for PostgresStore
impl Clone for PostgresStore
Source§fn clone(&self) -> PostgresStore
fn clone(&self) -> PostgresStore
Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from
source. Read moreSource§impl ConfigChangeNotifier for PostgresStore
impl ConfigChangeNotifier for PostgresStore
fn subscribe<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = Result<Box<dyn ConfigChangeSubscriber>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
PostgresStore: 'async_trait,
Source§impl ConfigStore for PostgresStore
impl ConfigStore for PostgresStore
Source§fn get<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
namespace: &'life1 str,
id: &'life2 str,
) -> Pin<Box<dyn Future<Output = Result<Option<Value>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
PostgresStore: 'async_trait,
fn get<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
namespace: &'life1 str,
id: &'life2 str,
) -> Pin<Box<dyn Future<Output = Result<Option<Value>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
PostgresStore: 'async_trait,
Get a single entry by namespace and ID.
Source§fn list<'life0, 'life1, 'async_trait>(
&'life0 self,
namespace: &'life1 str,
offset: usize,
limit: usize,
) -> Pin<Box<dyn Future<Output = Result<Vec<(String, Value)>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
fn list<'life0, 'life1, 'async_trait>(
&'life0 self,
namespace: &'life1 str,
offset: usize,
limit: usize,
) -> Pin<Box<dyn Future<Output = Result<Vec<(String, Value)>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
List entries in a namespace ordered by ID.
Source§fn put<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
namespace: &'life1 str,
id: &'life2 str,
value: &'life3 Value,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
PostgresStore: 'async_trait,
fn put<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
namespace: &'life1 str,
id: &'life2 str,
value: &'life3 Value,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
PostgresStore: 'async_trait,
Create or overwrite an entry.
Source§fn put_if_absent<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
namespace: &'life1 str,
id: &'life2 str,
value: &'life3 Value,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
PostgresStore: 'async_trait,
fn put_if_absent<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
namespace: &'life1 str,
id: &'life2 str,
value: &'life3 Value,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
PostgresStore: 'async_trait,
Create an entry only when it does not already exist. Read more
Source§fn delete<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
namespace: &'life1 str,
id: &'life2 str,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
PostgresStore: 'async_trait,
fn delete<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
namespace: &'life1 str,
id: &'life2 str,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
PostgresStore: 'async_trait,
Delete an entry. Missing entries are not an error.
Source§fn put_if_revision<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
namespace: &'life1 str,
id: &'life2 str,
value: &'life3 Value,
expected_revision: u64,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
PostgresStore: 'async_trait,
fn put_if_revision<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
namespace: &'life1 str,
id: &'life2 str,
value: &'life3 Value,
expected_revision: u64,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
PostgresStore: 'async_trait,
Atomic compare-and-set on the record’s
meta.revision. Read moreSource§fn delete_if_revision<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
namespace: &'life1 str,
id: &'life2 str,
expected_revision: u64,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
PostgresStore: 'async_trait,
fn delete_if_revision<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
namespace: &'life1 str,
id: &'life2 str,
expected_revision: u64,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
PostgresStore: 'async_trait,
Source§fn exists<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
namespace: &'life1 str,
id: &'life2 str,
) -> Pin<Box<dyn Future<Output = Result<bool, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
fn exists<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
namespace: &'life1 str,
id: &'life2 str,
) -> Pin<Box<dyn Future<Output = Result<bool, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
Check whether an entry exists.
Source§impl EventLookup for PostgresStore
impl EventLookup for PostgresStore
fn load_event<'life0, 'life1, 'async_trait>(
&'life0 self,
event_id: &'life1 CanonicalEventId,
) -> Pin<Box<dyn Future<Output = Result<CanonicalEvent, EventStoreError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
Source§impl EventReader for PostgresStore
impl EventReader for PostgresStore
fn list<'life0, 'async_trait>(
&'life0 self,
scope: EventScope,
from: Option<EventCursor>,
limit: usize,
) -> Pin<Box<dyn Future<Output = Result<EventPage, EventStoreError>> + Send + 'async_trait>>where
'life0: 'async_trait,
PostgresStore: 'async_trait,
fn count<'life0, 'async_trait>(
&'life0 self,
scope: EventScope,
) -> Pin<Box<dyn Future<Output = Result<u64, EventStoreError>> + Send + 'async_trait>>where
'life0: 'async_trait,
PostgresStore: 'async_trait,
Source§impl EventSubscriber for PostgresStore
impl EventSubscriber for PostgresStore
fn subscribe<'life0, 'async_trait>(
&'life0 self,
scope: EventScope,
start: SubscribeStart,
) -> Pin<Box<dyn Future<Output = Result<SubscribeHandle, EventStoreError>> + Send + 'async_trait>>where
'life0: 'async_trait,
PostgresStore: 'async_trait,
Source§impl EventWriter for PostgresStore
impl EventWriter for PostgresStore
fn append<'life0, 'async_trait>(
&'life0 self,
draft: CanonicalEventDraft,
options: AppendOptions,
) -> Pin<Box<dyn Future<Output = Result<AppendResult, EventStoreError>> + Send + 'async_trait>>where
'life0: 'async_trait,
PostgresStore: 'async_trait,
Source§impl OutboxStore for PostgresStore
impl OutboxStore for PostgresStore
Source§fn enqueue_outbox<'life0, 'async_trait>(
&'life0 self,
draft: OutboxMessageDraft,
) -> Pin<Box<dyn Future<Output = Result<OutboxEnqueueResult, OutboxError>> + Send + 'async_trait>>where
'life0: 'async_trait,
PostgresStore: 'async_trait,
fn enqueue_outbox<'life0, 'async_trait>(
&'life0 self,
draft: OutboxMessageDraft,
) -> Pin<Box<dyn Future<Output = Result<OutboxEnqueueResult, OutboxError>> + Send + 'async_trait>>where
'life0: 'async_trait,
PostgresStore: 'async_trait,
Enqueue an outbox row in the backend’s own transaction. Use the
concrete-type transactional method (see trait docs) when the caller
needs to share a transaction with other writes.
fn claim_outbox<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
lane: &'life1 str,
target: &'life2 str,
limit: usize,
lease_ms: u64,
consumer_id: &'life3 str,
now: u64,
) -> Pin<Box<dyn Future<Output = Result<Vec<OutboxMessage>, OutboxError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
PostgresStore: 'async_trait,
fn ack_outbox<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
outbox_id: &'life1 str,
claim_token: &'life2 str,
now: u64,
) -> Pin<Box<dyn Future<Output = Result<bool, OutboxError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
PostgresStore: 'async_trait,
fn nack_outbox<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
outbox_id: &'life1 str,
claim_token: &'life2 str,
error: &'life3 str,
retry_at: u64,
now: u64,
) -> Pin<Box<dyn Future<Output = Result<OutboxNackOutcome, OutboxError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
PostgresStore: 'async_trait,
fn list_outbox<'life0, 'async_trait>(
&'life0 self,
status: Option<OutboxStatus>,
limit: usize,
) -> Pin<Box<dyn Future<Output = Result<Vec<OutboxMessage>, OutboxError>> + Send + 'async_trait>>where
'life0: 'async_trait,
PostgresStore: 'async_trait,
Source§impl PendingMessageStore for PostgresStore
impl PendingMessageStore for PostgresStore
fn load_pending_message_records<'life0, 'life1, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<Vec<PendingMessageRecord>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
Source§fn list_threads_with_pending_messages<'life0, 'life1, 'async_trait>(
&'life0 self,
limit: usize,
after: Option<&'life1 str>,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
fn list_threads_with_pending_messages<'life0, 'life1, 'async_trait>(
&'life0 self,
limit: usize,
after: Option<&'life1 str>,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
List up to
limit thread ids (ascending; limit == 0 means unbounded)
that currently hold at least one pending message, strictly greater than
after (the previous page’s last id) for cursor pagination. Startup
recovery pages through this to detect threads whose consume opportunity
may have been lost — pending was persisted but the dispatch/notification
did not survive — without scanning the whole table at once (ADR-0042 D7).fn append_pending_message_records<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
messages: &'life2 [Message],
delivery_mode: DeliveryMode,
) -> Pin<Box<dyn Future<Output = Result<Vec<PendingMessageRecord>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
PostgresStore: 'async_trait,
fn update_pending_message_record_checked<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
pending_id: &'life2 str,
expected_revision: Option<u64>,
message: Message,
) -> Pin<Box<dyn Future<Output = Result<PendingMessageRecord, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
PostgresStore: 'async_trait,
fn retract_pending_message_record_checked<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
pending_id: &'life2 str,
expected_revision: Option<u64>,
) -> Pin<Box<dyn Future<Output = Result<PendingMessageRecord, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
PostgresStore: 'async_trait,
fn reorder_pending_message_records_checked<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
expected_queue_revision: Option<u64>,
ordered_pending_ids: &'life2 [String],
) -> Pin<Box<dyn Future<Output = Result<Vec<PendingMessageRecord>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
PostgresStore: 'async_trait,
fn freeze_pending_message_records<'life0, 'life1, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
boundary: DeliveryBoundary,
expected_message_version: Option<u64>,
) -> Pin<Box<dyn Future<Output = Result<Vec<MessageRecord>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
fn freeze_pending_message_records_with_run<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
boundary: DeliveryBoundary,
expected_message_version: Option<u64>,
expected_pending_ids: &'life2 [String],
run: &'life3 RunRecord,
) -> Pin<Box<dyn Future<Output = Result<Vec<MessageRecord>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
PostgresStore: 'async_trait,
Source§fn append_and_freeze_pending_message_records_with_run<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
new_messages: &'life2 [Message],
append_delivery_mode: DeliveryMode,
boundary: DeliveryBoundary,
expected_message_version: Option<u64>,
expected_pending_ids: &'life3 [String],
run: &'life4 RunRecord,
) -> Pin<Box<dyn Future<Output = Result<Vec<MessageRecord>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
'life4: 'async_trait,
PostgresStore: 'async_trait,
fn append_and_freeze_pending_message_records_with_run<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
new_messages: &'life2 [Message],
append_delivery_mode: DeliveryMode,
boundary: DeliveryBoundary,
expected_message_version: Option<u64>,
expected_pending_ids: &'life3 [String],
run: &'life4 RunRecord,
) -> Pin<Box<dyn Future<Output = Result<Vec<MessageRecord>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
'life4: 'async_trait,
PostgresStore: 'async_trait,
Atomically append
new_messages to pending and freeze the selected
pending entries (existing + newly appended) with the run record, in one
backend boundary (ADR-0042 D7). Read morefn update_pending_message_record<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
pending_id: &'life2 str,
message: Message,
) -> Pin<Box<dyn Future<Output = Result<PendingMessageRecord, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
fn retract_pending_message_record<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
pending_id: &'life2 str,
) -> Pin<Box<dyn Future<Output = Result<PendingMessageRecord, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
fn reorder_pending_message_records<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
ordered_pending_ids: &'life2 [String],
) -> Pin<Box<dyn Future<Output = Result<Vec<PendingMessageRecord>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
Source§impl ProtocolReplayLookup for PostgresStore
impl ProtocolReplayLookup for PostgresStore
fn load_replay<'life0, 'life1, 'async_trait>(
&'life0 self,
protocol_replay_id: &'life1 ProtocolReplayId,
) -> Pin<Box<dyn Future<Output = Result<Option<ProtocolReplayRecord>, ProtocolReplayError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
Source§impl ProtocolReplayReader for PostgresStore
impl ProtocolReplayReader for PostgresStore
fn list_replay<'life0, 'async_trait>(
&'life0 self,
stream: ProtocolStreamKey,
from: Option<ProtocolReplayCursor>,
limit: usize,
) -> Pin<Box<dyn Future<Output = Result<ProtocolReplayPage, ProtocolReplayError>> + Send + 'async_trait>>where
'life0: 'async_trait,
PostgresStore: 'async_trait,
Source§impl ProtocolReplayWriter for PostgresStore
impl ProtocolReplayWriter for PostgresStore
fn append_replay<'life0, 'async_trait>(
&'life0 self,
draft: ProtocolReplayDraft,
) -> Pin<Box<dyn Future<Output = Result<ProtocolReplayAppendResult, ProtocolReplayError>> + Send + 'async_trait>>where
'life0: 'async_trait,
PostgresStore: 'async_trait,
Source§impl RunStore for PostgresStore
impl RunStore for PostgresStore
Source§fn create_run<'life0, 'life1, 'async_trait>(
&'life0 self,
record: &'life1 RunRecord,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
fn create_run<'life0, 'life1, 'async_trait>(
&'life0 self,
record: &'life1 RunRecord,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
Create a new run record.
Source§fn load_run<'life0, 'life1, 'async_trait>(
&'life0 self,
run_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<Option<RunRecord>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
fn load_run<'life0, 'life1, 'async_trait>(
&'life0 self,
run_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<Option<RunRecord>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
Load a run record by
run_id.Source§fn latest_run<'life0, 'life1, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<Option<RunRecord>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
fn latest_run<'life0, 'life1, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<Option<RunRecord>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
Find the latest run for a thread (by
updated_at).Source§fn list_runs<'life0, 'life1, 'async_trait>(
&'life0 self,
query: &'life1 RunQuery,
) -> Pin<Box<dyn Future<Output = Result<RunPage, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
fn list_runs<'life0, 'life1, 'async_trait>(
&'life0 self,
query: &'life1 RunQuery,
) -> Pin<Box<dyn Future<Output = Result<RunPage, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
List runs with optional filtering and pagination.
Source§impl StreamCheckpointStore for PostgresStore
impl StreamCheckpointStore for PostgresStore
Source§fn put<'life0, 'async_trait>(
&'life0 self,
checkpoint: StreamCheckpoint,
) -> Pin<Box<dyn Future<Output = Result<(), StreamCheckpointError>> + Send + 'async_trait>>where
'life0: 'async_trait,
PostgresStore: 'async_trait,
fn put<'life0, 'async_trait>(
&'life0 self,
checkpoint: StreamCheckpoint,
) -> Pin<Box<dyn Future<Output = Result<(), StreamCheckpointError>> + Send + 'async_trait>>where
'life0: 'async_trait,
PostgresStore: 'async_trait,
Upsert a checkpoint for
checkpoint.run_id.Source§fn get<'life0, 'life1, 'async_trait>(
&'life0 self,
run_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<Option<StreamCheckpoint>, StreamCheckpointError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
fn get<'life0, 'life1, 'async_trait>(
&'life0 self,
run_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<Option<StreamCheckpoint>, StreamCheckpointError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
Look up the most recent checkpoint for
run_id, if any.Source§fn delete<'life0, 'life1, 'async_trait>(
&'life0 self,
run_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<(), StreamCheckpointError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
fn delete<'life0, 'life1, 'async_trait>(
&'life0 self,
run_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<(), StreamCheckpointError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
Remove the checkpoint for
run_id. Idempotent: removing a
nonexistent key is not an error.Source§impl ThreadRunStore for PostgresStore
impl ThreadRunStore for PostgresStore
Source§fn load_checkpoint<'life0, 'life1, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<Option<CheckpointSnapshot>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
fn load_checkpoint<'life0, 'life1, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<Option<CheckpointSnapshot>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
Consistent resume read in one transaction (ADR-0038 C5): committed messages, latest run, and thread state are read together so a concurrent commit cannot tear the snapshot.
Source§fn thread_run_storage_identity(&self) -> Option<String>
fn thread_run_storage_identity(&self) -> Option<String>
Return an identity for the backing thread/run store, when the
implementation can prove it. This is intentionally narrower than a
coordinator transaction scope: it only identifies the thread/run read
and write backend used by mailbox/server code.
Source§fn checkpoint<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
messages: &'life2 [Message],
run: &'life3 RunRecord,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
PostgresStore: 'async_trait,
fn checkpoint<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
messages: &'life2 [Message],
run: &'life3 RunRecord,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
PostgresStore: 'async_trait,
👎Deprecated since 0.6.0:
use CommitCoordinator (ADR-0038 D7)
Source§fn checkpoint_append<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
messages: &'life2 [Message],
expected_version: Option<u64>,
run: &'life3 RunRecord,
) -> Pin<Box<dyn Future<Output = Result<u64, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
PostgresStore: 'async_trait,
fn checkpoint_append<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
messages: &'life2 [Message],
expected_version: Option<u64>,
run: &'life3 RunRecord,
) -> Pin<Box<dyn Future<Output = Result<u64, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
PostgresStore: 'async_trait,
Append to the committed log and persist
run, guarded by message count.Source§impl ThreadStore for PostgresStore
impl ThreadStore for PostgresStore
Source§fn load_thread<'life0, 'life1, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<Option<Thread>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
fn load_thread<'life0, 'life1, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<Option<Thread>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
Load a thread by ID. Returns
None if not found.Source§fn save_thread<'life0, 'life1, 'async_trait>(
&'life0 self,
thread: &'life1 Thread,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
fn save_thread<'life0, 'life1, 'async_trait>(
&'life0 self,
thread: &'life1 Thread,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
Persist a thread (create or overwrite). Read more
Source§fn save_thread_validated<'life0, 'life1, 'async_trait>(
&'life0 self,
thread: &'life1 Thread,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
fn save_thread_validated<'life0, 'life1, 'async_trait>(
&'life0 self,
thread: &'life1 Thread,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
Persist a thread after validating parent-child hierarchy invariants. Read more
Source§fn save_thread_state<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
state: &'life2 PersistedState,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
PostgresStore: 'async_trait,
fn save_thread_state<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
state: &'life2 PersistedState,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
PostgresStore: 'async_trait,
Persist thread-scoped state for
thread_id (overwrite the prior value). Read moreSource§fn load_thread_state<'life0, 'life1, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<Option<PersistedState>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
fn load_thread_state<'life0, 'life1, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<Option<PersistedState>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
Load thread-scoped state for
thread_id, if any. Default None.Source§fn delete_thread<'life0, 'life1, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
fn delete_thread<'life0, 'life1, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
Delete a thread and its associated messages. Read more
Source§fn delete_thread_with_strategy<'life0, 'life1, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
strategy: ChildThreadDeleteStrategy,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
fn delete_thread_with_strategy<'life0, 'life1, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
strategy: ChildThreadDeleteStrategy,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
Delete a thread while managing direct and transitive children. Read more
Source§fn list_threads<'life0, 'async_trait>(
&'life0 self,
offset: usize,
limit: usize,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
PostgresStore: 'async_trait,
fn list_threads<'life0, 'async_trait>(
&'life0 self,
offset: usize,
limit: usize,
) -> Pin<Box<dyn Future<Output = Result<Vec<String>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
PostgresStore: 'async_trait,
List thread IDs with pagination.
Source§fn list_threads_query<'life0, 'life1, 'async_trait>(
&'life0 self,
query: &'life1 ThreadQuery,
) -> Pin<Box<dyn Future<Output = Result<ThreadPage, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
fn list_threads_query<'life0, 'life1, 'async_trait>(
&'life0 self,
query: &'life1 ThreadQuery,
) -> Pin<Box<dyn Future<Output = Result<ThreadPage, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
List thread IDs with first-class filters and page metadata.
fn load_messages<'life0, 'life1, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<Message>>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
fn load_committed_messages<'life0, 'life1, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<Message>>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
fn load_message_records<'life0, 'life1, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<Option<Vec<MessageRecord>>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
Source§fn list_message_records<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
query: &'life2 MessageQuery,
) -> Pin<Box<dyn Future<Output = Result<MessagePage, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
PostgresStore: 'async_trait,
fn list_message_records<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
query: &'life2 MessageQuery,
) -> Pin<Box<dyn Future<Output = Result<MessagePage, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
PostgresStore: 'async_trait,
List thread-owned message records with filtering and page metadata.
Source§fn save_messages<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
messages: &'life2 [Message],
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
PostgresStore: 'async_trait,
fn save_messages<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
messages: &'life2 [Message],
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
PostgresStore: 'async_trait,
Persist messages for a thread (full overwrite).
Source§fn delete_messages<'life0, 'life1, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
fn delete_messages<'life0, 'life1, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
Delete all messages for a thread. Returns
NotFound if the thread does not exist.Source§fn update_thread_metadata<'life0, 'life1, 'async_trait>(
&'life0 self,
id: &'life1 str,
metadata: ThreadMetadata,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
fn update_thread_metadata<'life0, 'life1, 'async_trait>(
&'life0 self,
id: &'life1 str,
metadata: ThreadMetadata,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
Update only the metadata of an existing thread.
Returns
NotFound if the thread does not exist.Source§fn list_child_threads<'life0, 'life1, 'async_trait>(
&'life0 self,
parent_thread_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<Vec<Thread>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
fn list_child_threads<'life0, 'life1, 'async_trait>(
&'life0 self,
parent_thread_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<Vec<Thread>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
Load all direct child threads for a given parent thread.
Source§fn validate_thread_hierarchy<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
parent_thread_id: Option<&'life2 str>,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
fn validate_thread_hierarchy<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
parent_thread_id: Option<&'life2 str>,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
Validate parent-child hierarchy invariants for a thread.
Source§fn append_message_records<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
messages: &'life2 [Message],
) -> Pin<Box<dyn Future<Output = Result<Vec<MessageRecord>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
fn append_message_records<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
messages: &'life2 [Message],
) -> Pin<Box<dyn Future<Output = Result<Vec<MessageRecord>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
Append messages to a thread’s durable log and return their records.
Source§fn load_message_record<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
message_id: &'life2 str,
) -> Pin<Box<dyn Future<Output = Result<Option<MessageRecord>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
fn load_message_record<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
message_id: &'life2 str,
) -> Pin<Box<dyn Future<Output = Result<Option<MessageRecord>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
Load one message record by message ID.
Source§fn load_message_records_range<'life0, 'life1, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
range: MessageSeqRange,
) -> Pin<Box<dyn Future<Output = Result<Vec<MessageRecord>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
fn load_message_records_range<'life0, 'life1, 'async_trait>(
&'life0 self,
thread_id: &'life1 str,
range: MessageSeqRange,
) -> Pin<Box<dyn Future<Output = Result<Vec<MessageRecord>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
Load message records by inclusive sequence range.
Source§impl VersionedRegistryStore for PostgresStore
impl VersionedRegistryStore for PostgresStore
fn resource_state<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
scope_id: &'life1 str,
kind: &'life2 str,
id: &'life3 str,
) -> Pin<Box<dyn Future<Output = Result<Option<VersionedResourceState>, VersionedRegistryError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
PostgresStore: 'async_trait,
fn current<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
scope_id: &'life1 str,
kind: &'life2 str,
id: &'life3 str,
) -> Pin<Box<dyn Future<Output = Result<Option<VersionedRecord<Value>>, VersionedRegistryError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
PostgresStore: 'async_trait,
fn get<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
scope_id: &'life1 str,
kind: &'life2 str,
id: &'life3 str,
version: u64,
) -> Pin<Box<dyn Future<Output = Result<Option<VersionedRecord<Value>>, VersionedRegistryError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
PostgresStore: 'async_trait,
fn list_versions<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
scope_id: &'life1 str,
kind: &'life2 str,
id: &'life3 str,
) -> Pin<Box<dyn Future<Output = Result<Vec<VersionedRecord<Value>>, VersionedRegistryError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
PostgresStore: 'async_trait,
fn publish_resource<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
scope_id: &'life1 str,
kind: &'life2 str,
id: &'life3 str,
value: Value,
value_schema_version: u32,
metadata: Value,
) -> Pin<Box<dyn Future<Output = Result<PublishOutcome<Value>, VersionedRegistryError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
PostgresStore: 'async_trait,
fn rollback_resource<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
scope_id: &'life1 str,
kind: &'life2 str,
id: &'life3 str,
to_version: u64,
metadata: Value,
) -> Pin<Box<dyn Future<Output = Result<VersionedRecord<Value>, VersionedRegistryError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
PostgresStore: 'async_trait,
fn archive_resource<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
scope_id: &'life1 str,
kind: &'life2 str,
id: &'life3 str,
) -> Pin<Box<dyn Future<Output = Result<(), VersionedRegistryError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
PostgresStore: 'async_trait,
fn unarchive_resource<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
scope_id: &'life1 str,
kind: &'life2 str,
id: &'life3 str,
) -> Pin<Box<dyn Future<Output = Result<(), VersionedRegistryError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
PostgresStore: 'async_trait,
fn publish_resources_and_create_publication<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
scope_id: &'life1 str,
publication_id: &'life2 str,
resources: Vec<RegistryResourcePublish>,
source_config_revisions: Vec<ConfigRevisionRef>,
created_by: Option<String>,
metadata: Value,
) -> Pin<Box<dyn Future<Output = Result<RegistryPublication, VersionedRegistryError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
PostgresStore: 'async_trait,
fn create_publication<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
scope_id: &'life1 str,
publication_id: &'life2 str,
entries: Vec<VersionRef>,
source_config_revisions: Vec<ConfigRevisionRef>,
created_by: Option<String>,
metadata: Value,
) -> Pin<Box<dyn Future<Output = Result<RegistryPublication, VersionedRegistryError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
PostgresStore: 'async_trait,
fn latest_publication<'life0, 'life1, 'async_trait>(
&'life0 self,
scope_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<Option<RegistryPublication>, VersionedRegistryError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
fn get_publication<'life0, 'life1, 'async_trait>(
&'life0 self,
scope_id: &'life1 str,
snapshot_version: u64,
) -> Pin<Box<dyn Future<Output = Result<Option<RegistryPublication>, VersionedRegistryError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
PostgresStore: 'async_trait,
fn rollback_publication<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
scope_id: &'life1 str,
source_snapshot_version: u64,
publication_id: &'life2 str,
created_by: Option<String>,
metadata: Value,
) -> Pin<Box<dyn Future<Output = Result<RegistryPublication, VersionedRegistryError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
fn pinned_manifest_for_publication<'life0, 'life1, 'async_trait>(
&'life0 self,
scope_id: &'life1 str,
snapshot_version: u64,
) -> Pin<Box<dyn Future<Output = Result<Option<PinnedRegistryManifest>, VersionedRegistryError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
fn latest_pinned_manifest<'life0, 'life1, 'async_trait>(
&'life0 self,
scope_id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<Option<PinnedRegistryManifest>, VersionedRegistryError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
Auto Trait Implementations§
impl !Freeze for PostgresStore
impl !RefUnwindSafe for PostgresStore
impl !UnwindSafe for PostgresStore
impl Send for PostgresStore
impl Sync for PostgresStore
impl Unpin for PostgresStore
impl UnsafeUnpin for PostgresStore
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
Source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> EventStore for T
Source§impl<T> Instrument for T
impl<T> Instrument for T
Source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
Source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
Converts
self into a Left variant of Either<Self, Self>
if into_left is true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
Converts
self into a Left variant of Either<Self, Self>
if into_left(&self) returns true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read more