Struct Service 

pub struct Service {
    services: Arc<OnceServices>,
    db: Data,
}

Stores and queries global and room-scoped account data.

Updates commit the secondary pointer and new event blob in one transaction while retaining monotonic counters for sync. Typed accessors deserialize the complete account data event envelope.

Fields

services: Arc<OnceServices>

db: Data

Implementations

impl Service

pub async fn direct_rooms(&self, user_id: &UserId) -> BTreeSet<OwnedRoomId>

The rooms the user’s m.direct names, whoever the counterparty is.

The map is keyed by counterparty rather than by room, so answering for one room means flattening all of it. A user with no m.direct at all has no direct rooms.

impl Service

pub async fn mark_direct( &self, user_id: &UserId, target: &UserId, room_id: &RoomId, ) -> Result

Record a room as a direct chat with target in the user’s m.direct.

The room joins the counterparty’s list, which is created when this is their first direct room. A list already naming the room is left alone, so repeated calls settle on one entry.

Panics

Panics when storing a changed mapping requires a global sequence number that cannot be allocated or persisted.

impl Service

async fn direct_content(&self, user_id: &UserId) -> Result<DirectEventContent>

The user’s m.direct content, absent when they have never had one.

Account data is stored as the whole event rather than as its content, so the record deserializes as an event and the content comes off it.

impl Service

pub async fn copy_room_push_rule( &self, user_id: &UserId, from_room: &RoomId, to_room: &RoomId, ) -> Result

Copies a room’s push rule to a successor room.

The source rule’s enabled state travels with it, so a rule the user had switched off does not come back on in the successor. A destination rule that already exists keeps its own enabled state and takes only the actions.

Panics

Panics when dispatching the global sequence number for the changed ruleset fails.

impl Service

pub async fn set_room_tag( &self, user_id: &UserId, room_id: &RoomId, tag: TagName, info: Option<TagInfo>, ) -> Result

Add a tag to the room in the user’s account data.

The whole tag set is rewritten on every call. A readable stored set is merged with the new tag, while a read failure starts from an empty set. A tag already present is replaced.

Panics

Panics when dispatching the global sequence number for the changed tag set fails.

impl Service

pub async fn get_room_tags( &self, user_id: &UserId, room_id: &RoomId, ) -> Result<Tags>

The tags the user has placed on the room, absent when there are none.

Account data is stored as the whole event rather than as its content, so a read naming the content type here fails on every record.

impl Service

pub async fn update( &self, room_id: Option<&RoomId>, user_id: &UserId, event_type: RoomAccountDataEventType, data: &Value, ) -> Result

Stores an account data event and replaces its previous revision.

The input must contain complete type and content fields. A new global counter value keys the event blob, secondary pointer, and removal of the superseded blob in one transaction.

Panics

Panics when dispatching the global sequence number fails.

impl Service

pub async fn delete( &self, room_id: Option<&RoomId>, user_id: &UserId, event_type: RoomAccountDataEventType, ) -> Result

Replaces an account data event with an MSC3391 tombstone.

Delta sync surfaces the empty content so clients can apply the deletion. Zero-token V3 and V5 sync responses and client account-data GET routes treat the tombstone as absent.

Panics

Panics when dispatching the global sequence number fails.

impl Service

pub async fn get_global<T>( &self, user_id: &UserId, kind: GlobalAccountDataEventType, ) -> Result<T>

where T: for<'de> Deserialize<'de>,

Searches the global account data for a specific kind.

Global data is stored under no room, so one kind can be held once globally and once in every room without collision. The record is the whole {type, content} event, so T names the event rather than its content.

impl Service

pub async fn get_room<T>( &self, room_id: &RoomId, user_id: &UserId, kind: RoomAccountDataEventType, ) -> Result<T>

where T: for<'de> Deserialize<'de>,

Searches the room account data for a specific kind.

The room scopes the lookup, so one kind may hold different data in each of them. The record is the whole {type, content} event, so T names the event rather than its content.

impl Service

pub async fn get_raw( &self, room_id: Option<&RoomId>, user_id: &UserId, kind: &str, ) -> Result<Handle<'_>>

Loads a stored account data event without deserializing it.

The optional room ID selects room-scoped or global account data. The lookup resolves the current secondary index entry before borrowing the raw event from storage.

impl Service

pub fn changes_since<'a>( &'a self, room_id: Option<&'a RoomId>, user_id: &'a UserId, since: u64, to: Option<u64>, ) -> impl Stream<Item = AnyRawAccountDataEvent> + Send + 'a

Streams account data changes after a counter value.

The optional upper bound is inclusive. Cursor and decoding failures are logged and omitted from this convenience stream.

impl Service

pub fn changes_since_fallible<'a>( &'a self, room_id: Option<&'a RoomId>, user_id: &'a UserId, since: u64, to: Option<u64>, ) -> impl Stream<Item = Result<AnyRawAccountDataEvent>> + Send + 'a

Returns bounded account-data changes without suppressing failures.

The lower bound is exclusive and the optional upper bound is inclusive. Cursor, decode, and deserialization failures remain in the stream for an atomic caller to handle.

impl Service

pub async fn erase_user(&self, user_id: &UserId, room_id: Option<&RoomId>)

Erases a user’s account data within one MSC4025 namespace.

An absent room selects global data, while a room selects only that room’s data. Rows yielded successfully from both prefix scans are deleted together; scan errors are skipped.

impl Service

pub async fn last_count<'a>( &'a self, room_id: Option<&'a RoomId>, user_id: &'a UserId, upper: Option<u64>, ) -> Result<u64>

Returns the latest account data counter at or below an optional bound.

The lookup is scoped to one user and either global data or a single room. An empty scope produces a not-found request error.

Trait Implementations

impl Service for Service

fn build(args: &Args<'_>) -> Result<Arc<Self>>

Implement the construction of the service instance. Services are generally singletons so expect this to only be called once for a service type. Note that it may be called again after a server reload, but the prior instance will have been dropped first. Failure will shutdown the server with an error.

fn name(&self) -> &str

Return the name of the service. i.e. crate::service::make_name(std::module_path!())

fn worker<'async_trait>( self: Arc<Self>, ) -> Pin<Box<dyn Future<Output = Result> + Send + 'async_trait>>

where Self: 'async_trait,

Implement the service’s worker loop. The service manager spawns a task and calls this function after all services have been built.

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

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

Interrupt the service. This is sent to initiate a graceful shutdown. The service worker should return from its work loop.

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

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

Clear any caches or similar runtime state.

fn memory_usage<'life0, 'life1, 'async_trait>( &'life0 self, _out: &'life1 mut (dyn Write + Send), ) -> Pin<Box<dyn Future<Output = Result> + Send + 'async_trait>>

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

Memory usage report in a markdown string.

fn unconstrained(&self) -> bool

Return true if the service worker opts out of the tokio cooperative budgeting. This can reduce tail latency at the risk of event loop starvation.