Struct Storage 

pub struct Storage { /* private fields */ }

Implementations

impl Storage

pub async fn migrate(&self) -> Result<(), StorageError>

Applies bundled migrations to PostgreSQL.

pub async fn readiness(&self) -> Result<(), StorageError>

Executes lightweight probes across PostgreSQL and Redis.

pub async fn read_user_blob( &self, user_id: &str, key: &str, ) -> Result<Option<String>, StorageError>

Reads a user-scoped blob entry.

pub async fn write_user_blob( &self, user_id: &str, key: &str, payload: &str, ) -> Result<(), StorageError>

Upserts a user-scoped blob entry.

pub async fn insert_server_secret( &self, record: &ServerSecretRecord, ) -> Result<(), StorageError>

Inserts a server-scoped secret version.

pub async fn active_server_secrets( &self, name: &str, moment: DateTime<Utc>, ) -> Result<Vec<ServerSecretRecord>, StorageError>

Loads active secret material for a given name.

pub async fn latest_server_secret_version( &self, name: &str, ) -> Result<i64, StorageError>

Returns the most recent version number for a secret name.

pub async fn delete_expired_server_secrets( &self, name: &str, threshold: DateTime<Utc>, ) -> Result<u64, StorageError>

Deletes expired secret versions.

pub async fn create_pairing_token( &self, user_id: &str, issuer_device_id: &str, ttl_seconds: i64, ) -> Result<PairingTokenIssued, StorageError>

Creates a short-lived pairing code bound to an issuer device.

pub async fn upsert_device( &self, record: &DeviceRecord, ) -> Result<(), StorageError>

Registers or rotates a device key.

pub async fn record_device_key_event( &self, event: &DeviceKeyEvent, ) -> Result<(), StorageError>

Persists an audit trail entry for device key material.

pub async fn apply_device_key_rotation( &self, rotation: &DeviceRotationRecord<'_>, ) -> Result<(), StorageError>

Applies a device key rotation atomically.

pub async fn claim_pairing_token( &self, pair_code: &str, device_id: &str, public_key: &[u8], ) -> Result<PairingClaimResult, StorageError>

Claims a pairing token and registers a new device for the associated user.

pub async fn invalidate_expired_pairings(&self) -> Result<u64, StorageError>

Removes expired or exhausted pairing tokens.

pub async fn latest_device_key_event( &self, device_id: &str, ) -> Result<Option<DeviceKeyEvent>, StorageError>

Fetches the newest device key event for a device identifier.

pub async fn record_session( &self, session: &SessionRecord, ) -> Result<(), StorageError>

Creates a session binding a device to a TLS fingerprint.

pub async fn load_session( &self, session_id: &str, ) -> Result<SessionRecord, StorageError>

Loads a persisted session by identifier.

pub async fn load_device( &self, device_id: &str, ) -> Result<DeviceRecord, StorageError>

Fetches device metadata by identifier.

pub async fn load_device_pq_keys( &self, device_id: &str, ) -> Result<Option<DevicePqKeys>, StorageError>

Loads stored post-quantum key material for a device when available.

pub async fn upsert_device_pq_keys( &self, keys: &DevicePqKeys, ) -> Result<(), StorageError>

Upserts post-quantum key material for a device.

pub async fn count_active_devices( &self, user_id: &str, ) -> Result<i64, StorageError>

Counts active devices registered for a user.

pub async fn list_devices_for_user( &self, user_id: &str, ) -> Result<Vec<DeviceRecord>, StorageError>

Lists devices associated with a user ordered by creation time.

pub async fn activate_device(&self, device_id: &str) -> Result<(), StorageError>

Marks a device as active.

pub async fn deactivate_device( &self, device_id: &str, ) -> Result<(), StorageError>

Marks a device as revoked.

pub async fn create_user( &self, profile: &NewUserProfile, ) -> Result<UserProfile, StorageError>

Creates a new user profile entry.

pub async fn load_user( &self, user_id: &str, ) -> Result<UserProfile, StorageError>

Loads a user profile by identifier.

pub async fn load_user_by_handle( &self, handle: &str, ) -> Result<UserProfile, StorageError>

Loads a user profile by handle.

pub async fn update_user_profile( &self, user_id: &str, display_name: Option<&str>, avatar_url: Option<&str>, ) -> Result<(), StorageError>

Applies partial updates to user profile metadata.

pub async fn update_user_avatar( &self, user_id: &str, avatar_url: &str, ) -> Result<(), StorageError>

Updates user avatar URL

pub async fn load_user_by_federated_id( &self, handle: &str, domain: &str, ) -> Result<UserProfile, StorageError>

Loads user by handle@domain

pub async fn cache_remote_user( &self, profile: &RemoteUserProfile, ) -> Result<(), StorageError>

Caches remote user profile

pub async fn load_remote_user_cache( &self, user_id: &str, ) -> Result<Option<RemoteUserProfile>, StorageError>

Loads cached remote user profile

pub async fn update_federation_peer_status( &self, status: &FederationPeerConnectionStatus, ) -> Result<(), StorageError>

Updates federation peer status

pub async fn create_federated_friend_request( &self, request: &FederatedFriendRequest, ) -> Result<(), StorageError>

Creates federated friend request

pub async fn update_federated_friend_request_status( &self, request_id: &str, status: &str, ) -> Result<(), StorageError>

Updates federated friend request status

pub async fn list_federated_friend_requests( &self, user_id: &str, incoming: bool, ) -> Result<Vec<FederatedFriendRequest>, StorageError>

Lists federated friend requests for user

pub async fn create_group(&self, group: &ChatGroup) -> Result<(), StorageError>

Creates a chat group entry and enrolls the owner as a member.

pub async fn add_group_member( &self, member: &GroupMember, ) -> Result<(), StorageError>

Adds or updates group membership information.

pub async fn remove_group_member( &self, group_id: &str, device_id: &str, ) -> Result<(), StorageError>

Removes a member from the given group.

pub async fn list_group_members( &self, group_id: &str, ) -> Result<Vec<GroupMember>, StorageError>

Lists all members of a group ordered by join time.

pub async fn load_group( &self, group_id: &str, ) -> Result<ChatGroup, StorageError>

Loads group metadata by identifier.

pub async fn list_groups_for_device( &self, device_id: &str, ) -> Result<Vec<ChatGroup>, StorageError>

Lists groups that include the target device.

pub async fn upsert_federation_peer( &self, peer: &FederationPeerRecord, ) -> Result<(), StorageError>

Upserts federation peer descriptors for S2S routing.

pub async fn load_federation_peer( &self, domain: &str, ) -> Result<FederationPeerRecord, StorageError>

Loads a federation peer by domain.

pub async fn list_federation_peers( &self, ) -> Result<Vec<FederationPeerRecord>, StorageError>

Enumerates all known federation peers.

pub async fn set_federation_peer_status( &self, domain: &str, status: FederationPeerStatus, ) -> Result<(), StorageError>

Sets the peer status and refresh timestamp.

pub async fn enqueue_relay( &self, envelope: &RelayEnvelope, ) -> Result<(), StorageError>

Schedules an encrypted relay envelope for delivery.

pub async fn claim_envelopes( &self, channel_id: &str, limit: i64, ) -> Result<Vec<RelayEnvelope>, StorageError>

Claims pending relay envelopes for a channel.

pub async fn enqueue_federation_outbox( &self, record: &FederationOutboxInsert<'_>, ) -> Result<(), StorageError>

Registers a federation event for outbound delivery.

pub async fn claim_federation_outbox( &self, limit: i64, lease: Duration, now: DateTime<Utc>, ) -> Result<Vec<FederationOutboxMessage>, StorageError>

Claims due federation events and leases them for processing.

pub async fn delete_federation_outbox( &self, outbox_id: &str, ) -> Result<(), StorageError>

Removes a federation outbox entry once delivery succeeds.

pub async fn reschedule_federation_outbox( &self, outbox_id: &str, delay: Duration, now: DateTime<Utc>, error: Option<&str>, ) -> Result<(), StorageError>

Reschedules a federation outbox entry after a failed attempt.

pub async fn store_inbox_offset( &self, offset: &InboxOffset, ) -> Result<(), StorageError>

Stores the last delivered envelope reference for an entity/channel pair.

pub async fn read_inbox_offset( &self, entity_id: &str, channel_id: &str, ) -> Result<Option<InboxOffset>, StorageError>

Reads the stored inbox offset if present.

pub async fn store_idempotency( &self, key: &IdempotencyKey, ) -> Result<bool, StorageError>

Records an idempotency key for deduplication.

pub async fn create_friend_request( &self, id: &str, from_user_id: &str, to_user_id: &str, message: Option<&str>, ) -> Result<FriendRequest, StorageError>

Creates a friend request

pub async fn get_friend_request( &self, id: &str, ) -> Result<FriendRequest, StorageError>

Gets a friend request by ID

pub async fn list_incoming_friend_requests( &self, user_id: &str, ) -> Result<Vec<FriendRequest>, StorageError>

Lists incoming friend requests for a user

pub async fn list_outgoing_friend_requests( &self, user_id: &str, ) -> Result<Vec<FriendRequest>, StorageError>

Lists outgoing friend requests from a user

pub async fn accept_friend_request( &self, id: &str, ) -> Result<FriendRequest, StorageError>

Accepts a friend request

pub async fn reject_friend_request( &self, id: &str, ) -> Result<FriendRequest, StorageError>

Rejects a friend request

pub async fn delete_friend_request(&self, id: &str) -> Result<(), StorageError>

Deletes a friend request

pub async fn friend_request_exists( &self, from_user_id: &str, to_user_id: &str, ) -> Result<Option<FriendRequest>, StorageError>

Checks if a friend request exists between two users

pub async fn publish_presence( &self, snapshot: &PresenceSnapshot, ) -> Result<(), StorageError>

Publishes local presence information into Redis.

pub async fn read_presence( &self, entity: &str, ) -> Result<Option<PresenceSnapshot>, StorageError>

Reads presence state from Redis.

pub async fn register_route( &self, entity: &str, session_id: &str, ttl_seconds: i64, ) -> Result<(), StorageError>

Registers a routing entry in Redis for direct message delivery.

pub async fn clear_route(&self, entity: &str) -> Result<(), StorageError>

Removes a routing entry from Redis.