slidge 0.2.11__py3-none-any.whl → 0.3.0__py3-none-any.whl

slidge/group/room.py

@@ -3,11 +3,23 @@ import logging
 import re
 import string
 import warnings
+from asyncio import Lock
+from contextlib import asynccontextmanager
 from copy import copy
 from datetime import datetime, timedelta, timezone
-from typing import TYPE_CHECKING, AsyncIterator, Generic, Optional, Self, Union
+from typing import (
+    TYPE_CHECKING,
+    AsyncIterator,
+    Generic,
+    Literal,
+    Optional,
+    Type,
+    Union,
+    overload,
+)
 from uuid import uuid4
 
+import sqlalchemy as sa
 from slixmpp import JID, Iq, Message, Presence
 from slixmpp.exceptions import IqError, IqTimeout, XMPPError
 from slixmpp.plugins.xep_0004 import Form
@@ -17,18 +29,14 @@ from slixmpp.plugins.xep_0469.stanza import NS as PINNING_NS
 from slixmpp.plugins.xep_0492.stanza import NS as NOTIFY_NS
 from slixmpp.plugins.xep_0492.stanza import WhenLiteral
 from slixmpp.xmlstream import ET
+from sqlalchemy.orm import Session as OrmSession
 
 from ..contact.contact import LegacyContact
 from ..contact.roster import ContactIsUser
-from ..core import config
-from ..core.mixins import StoredAttributeMixin
 from ..core.mixins.avatar import AvatarMixin
-from ..core.mixins.db import UpdateInfoMixin
 from ..core.mixins.disco import ChatterDiscoMixin
-from ..core.mixins.lock import NamedLockMixin
 from ..core.mixins.recipient import ReactionRecipientMixin, ThreadRecipientMixin
-from ..db.models import Room
-from ..util import ABCSubclassableOnceAtMost
+from ..db.models import Participant, Room
 from ..util.jid_escaping import unescape_node
 from ..util.types import (
     HoleBound,
@@ -40,12 +48,11 @@ from ..util.types import (
     MucAffiliation,
     MucType,
 )
-from ..util.util import deprecated, timeit, with_session
+from ..util.util import SubclassableOnce, deprecated, timeit
 from .archive import MessageArchive
 from .participant import LegacyParticipant, escape_nickname
 
 if TYPE_CHECKING:
-    from ..core.gateway import BaseGateway
     from ..core.session import BaseSession
 
 ADMIN_NS = "http://jabber.org/protocol/muc#admin"
@@ -57,14 +64,11 @@ class LegacyMUC(
     Generic[
         LegacyGroupIdType, LegacyMessageType, LegacyParticipantType, LegacyUserIdType
     ],
-    UpdateInfoMixin,
-    StoredAttributeMixin,
     AvatarMixin,
-    NamedLockMixin,
     ChatterDiscoMixin,
     ReactionRecipientMixin,
     ThreadRecipientMixin,
-    metaclass=ABCSubclassableOnceAtMost,
+    metaclass=SubclassableOnce,
 ):
     """
     A room, a.k.a. a Multi-User Chat.
@@ -75,12 +79,10 @@ class LegacyMUC(
 
     max_history_fetch = 100
 
-    type = MucType.CHANNEL
     is_group = True
 
     DISCO_TYPE = "text"
     DISCO_CATEGORY = "conference"
-    DISCO_NAME = "unnamed-room"
 
     STABLE_ARCHIVE = False
     """
@@ -94,17 +96,6 @@ class LegacyMUC(
     This is just a flag on archive responses that most clients ignore anyway.
     """
 
-    KEEP_BACKFILLED_PARTICIPANTS = False
-    """
-    Set this to ``True`` if the participant list is not full after calling
-    ``fill_participants()``. This is a workaround for networks with huge
-    participant lists which do not map really well the MUCs where all presences
-    are sent on join.
-    It allows to ensure that the participants that last spoke (within the
-    ``fill_history()`` method are effectively participants, thus making possible
-    for XMPP clients to fetch their avatars.
-    """
-
     _ALL_INFO_FILLED_ON_STARTUP = False
     """
     Set this to true if the fill_participants() / fill_participants() design does not
@@ -128,150 +119,200 @@ class LegacyMUC(
     tries to set the room subject.
     """
 
-    _avatar_bare_jid = True
     archive: MessageArchive
+    session: "BaseSession"
 
-    def __init__(self, session: "BaseSession", legacy_id: LegacyGroupIdType, jid: JID):
-        self.session = session
-        self.xmpp: "BaseGateway" = session.xmpp
+    stored: Room
 
-        self.legacy_id = legacy_id
-        self.jid = jid
+    _participant_cls: Type[LegacyParticipantType]
 
-        self._user_resources = set[str]()
+    def __init__(self, session: "BaseSession", stored: Room) -> None:
+        self.session = session
+        self.xmpp = session.xmpp
+        self.stored = stored
+        self._set_logger()
+        super().__init__()
 
-        self.Participant = LegacyParticipant.get_self_or_unique_subclass()
+        self.archive = MessageArchive(stored, self.xmpp.store.mam)
 
-        self._subject = ""
-        self._subject_setter: Optional[str] = None
+    def participant_from_store(
+        self, stored: Participant, contact: LegacyContact | None = None
+    ) -> LegacyParticipantType:
+        if contact is None and stored.contact is not None:
+            contact = self.session.contacts.from_store(stored.contact)
+        return self._participant_cls(self, stored=stored, contact=contact)
 
-        self.pk: Optional[int] = None
-        self._user_nick: Optional[str] = None
+    @property
+    def jid(self) -> JID:
+        return self.stored.jid
 
-        self._participants_filled = False
-        self._history_filled = False
-        self._description = ""
-        self._subject_date: Optional[datetime] = None
+    @jid.setter
+    def jid(self, x: JID):
+        # FIXME: without this, mypy yields
+        #        "Cannot override writeable attribute with read-only property"
+        #        But it does not happen for LegacyContact. WTF?
+        raise RuntimeError
 
-        self.__participants_store = self.xmpp.store.participants
-        self.__store = self.xmpp.store.rooms
+    @property
+    def legacy_id(self):
+        return self.xmpp.LEGACY_ROOM_ID_TYPE(self.stored.legacy_id)
 
-        self._n_participants: Optional[int] = None
+    def orm(self) -> OrmSession:
+        return self.xmpp.store.session()
 
-        self.log = logging.getLogger(self.jid.bare)
-        self._set_logger_name()
-        super().__init__()
+    @property
+    def type(self) -> MucType:
+        return self.stored.muc_type
+
+    @type.setter
+    def type(self, type_: MucType) -> None:
+        if self.type == type_:
+            return
+        self.stored.muc_type = type_
+        self.commit()
 
     @property
     def n_participants(self):
-        return self._n_participants
+        return self.stored.n_participants
 
     @n_participants.setter
-    def n_participants(self, n_participants: Optional[int]):
-        if self._n_participants == n_participants:
-            return
-        self._n_participants = n_participants
-        if self._updating_info:
+    def n_participants(self, n_participants: Optional[int]) -> None:
+        if self.stored.n_participants == n_participants:
             return
-        assert self.pk is not None
-        self.__store.update_n_participants(self.pk, n_participants)
+        self.stored.n_participants = n_participants
+        self.commit()
 
     @property
     def user_jid(self):
         return self.session.user_jid
 
-    def _set_logger_name(self):
+    def _set_logger(self) -> None:
         self.log = logging.getLogger(f"{self.user_jid}:muc:{self}")
 
-    def __repr__(self):
-        return f"<MUC #{self.pk} '{self.name}' ({self.legacy_id} - {self.jid.user})'>"
+    def __repr__(self) -> str:
+        return f"<MUC #{self.stored.id} '{self.name}' ({self.stored.legacy_id} - {self.jid.user})'>"
 
     @property
     def subject_date(self) -> Optional[datetime]:
-        return self._subject_date
+        if self.stored.subject_date is None:
+            return None
+        return self.stored.subject_date.replace(tzinfo=timezone.utc)
 
     @subject_date.setter
     def subject_date(self, when: Optional[datetime]) -> None:
-        self._subject_date = when
-        if self._updating_info:
+        if self.subject_date == when:
             return
-        assert self.pk is not None
-        self.__store.update_subject_date(self.pk, when)
+        self.stored.subject_date = when
+        self.commit()
 
-    def __send_configuration_change(self, codes):
+    def __send_configuration_change(self, codes) -> None:
         part = self.get_system_participant()
         part.send_configuration_change(codes)
 
     @property
     def user_nick(self):
-        return self._user_nick or self.session.bookmarks.user_nick or self.user_jid.node
+        return (
+            self.stored.user_nick
+            or self.session.bookmarks.user_nick
+            or self.user_jid.node
+        )
 
     @user_nick.setter
-    def user_nick(self, nick: str):
-        self._user_nick = nick
-        if not self._updating_info:
-            self.__store.update_user_nick(self.pk, nick)
+    def user_nick(self, nick: str) -> None:
+        if nick == self.user_nick:
+            return
+        self.stored.user_nick = nick
+        self.commit()
 
     def add_user_resource(self, resource: str) -> None:
-        self._user_resources.add(resource)
-        assert self.pk is not None
-        self.__store.set_resource(self.pk, self._user_resources)
+        stored_set = self.get_user_resources()
+        if resource in stored_set:
+            return
+        stored_set.add(resource)
+        self.stored.user_resources = (
+            json.dumps(list(stored_set)) if stored_set else None
+        )
+        self.commit()
 
     def get_user_resources(self) -> set[str]:
-        return self._user_resources
+        stored_str = self.stored.user_resources
+        if stored_str is None:
+            return set()
+        return set(json.loads(stored_str))
 
     def remove_user_resource(self, resource: str) -> None:
-        self._user_resources.remove(resource)
-        assert self.pk is not None
-        self.__store.set_resource(self.pk, self._user_resources)
-
-    async def __fill_participants(self):
-        if self._participants_filled:
-            return
-        assert self.pk is not None
-        async with self.lock("fill participants"):
-            self._participants_filled = True
-            async for p in self.fill_participants():
-                self.__participants_store.update(p)
-            self.__store.set_participants_filled(self.pk)
-
-    async def get_participants(self) -> AsyncIterator[LegacyParticipant]:
-        assert self.pk is not None
-        if self._participants_filled:
-            for db_participant in self.xmpp.store.participants.get_all(
-                self.pk, user_included=True
-            ):
-                participant = self.Participant.from_store(
-                    self.session, db_participant, muc=self
-                )
-                yield participant
+        stored_set = self.get_user_resources()
+        if resource not in stored_set:
             return
+        stored_set.remove(resource)
+        self.stored.user_resources = (
+            json.dumps(list(stored_set)) if stored_set else None
+        )
+        self.commit()
 
+    @asynccontextmanager
+    async def lock(self, id_: str) -> AsyncIterator[None]:
+        async with self.session.lock((self.legacy_id, id_)):
+            yield
+
+    def get_lock(self, id_: str) -> Lock | None:
+        return self.session.get_lock((self.legacy_id, id_))
+
+    async def __fill_participants(self) -> None:
         async with self.lock("fill participants"):
-            self._participants_filled = True
-            # We only fill the participants list if/when the MUC is first
-            # joined by an XMPP client. But we may have instantiated some before.
+            with self.xmpp.store.session(expire_on_commit=False) as orm:
+                orm.add(self.stored)
+                with orm.no_autoflush:
+                    orm.refresh(self.stored, ["participants_filled"])
+            if self.participants_filled:
+                return
+            parts: list[Participant] = []
             resources = set[str]()
+            # During fill_participants(), self.get_participant*() methods may
+            # return a participant with a conflicting nick/resource.
             async for participant in self.fill_participants():
-                # TODO: batch SQL update at the end of this function for perf?
-                self.__store_participant(participant)
-                yield participant
-                resources.add(participant.jid.resource)
-            for db_participant in self.xmpp.store.participants.get_all(
-                self.pk, user_included=True
-            ):
-                participant = self.Participant.from_store(
-                    self.session, db_participant, muc=self
-                )
-                if participant.jid.resource not in resources:
-                    yield participant
-            self.__store.set_participants_filled(self.pk)
-            return
+                if participant.stored.resource in resources:
+                    self.log.warning(
+                        "Participant '%s' was yielded more than once by fill_participants()",
+                        participant.stored.resource,
+                    )
+                    continue
+                parts.append(participant.stored)
+                resources.add(participant.stored.resource)
+        with self.xmpp.store.session(expire_on_commit=False) as orm:
+            orm.add(self.stored)
+            # because self.fill_participants() is async, self.stored may be stale at
+            # this point, and the only thing we want to update is the participant list
+            # and the participant_filled attribute.
+            with orm.no_autoflush:
+                orm.refresh(self.stored)
+                for part in parts:
+                    orm.merge(part)
+            self.stored.participants_filled = True
+            orm.commit()
+
+    async def get_participants(
+        self, affiliation: Optional[MucAffiliation] = None
+    ) -> AsyncIterator[LegacyParticipantType]:
+        await self.__fill_participants()
+        with self.xmpp.store.session(expire_on_commit=False) as orm:
+            orm.add(self.stored)
+            for db_participant in self.stored.participants:
+                if (
+                    affiliation is not None
+                    and db_participant.affiliation != affiliation
+                ):
+                    continue
+                yield self.participant_from_store(db_participant)
 
-    async def __fill_history(self):
+    async def __fill_history(self) -> None:
         async with self.lock("fill history"):
-            if self._history_filled:
-                log.debug("History has already been fetched %s", self)
+            with self.xmpp.store.session(expire_on_commit=False) as orm:
+                orm.add(self.stored)
+                with orm.no_autoflush:
+                    orm.refresh(self.stored, ["history_filled"])
+            if self.stored.history_filled:
+                self.log.debug("History has already been fetched.")
                 return
             log.debug("Fetching history for %s", self)
             try:
@@ -288,43 +329,40 @@ class LegacyMUC(
             except NotImplementedError:
                 return
             except Exception as e:
-                log.exception("Could not backfill: %s", e)
-            assert self.pk is not None
-            self.__store.set_history_filled(self.pk, True)
-            self._history_filled = True
+                self.log.exception("Could not backfill", exc_info=e)
+
+            self.stored.history_filled = True
+            self.commit(merge=True)
+
+    def _get_disco_name(self) -> str | None:
+        return self.name
 
     @property
-    def name(self):
-        return self.DISCO_NAME
+    def name(self) -> str | None:
+        return self.stored.name
 
     @name.setter
-    def name(self, n: str):
-        if self.DISCO_NAME == n:
+    def name(self, n: str | None) -> None:
+        if self.name == n:
             return
-        self.DISCO_NAME = n
-        self._set_logger_name()
+        self.stored.name = n
+        self.commit()
+        self._set_logger()
         self.__send_configuration_change((104,))
-        if self._updating_info:
-            return
-        assert self.pk is not None
-        self.__store.update_name(self.pk, n)
 
     @property
     def description(self):
-        return self._description
+        return self.stored.description or ""
 
     @description.setter
-    def description(self, d: str):
-        if self._description == d:
+    def description(self, d: str) -> None:
+        if self.description == d:
             return
-        self._description = d
+        self.stored.description = d
+        self.commit()
         self.__send_configuration_change((104,))
-        if self._updating_info:
-            return
-        assert self.pk is not None
-        self.__store.update_description(self.pk, d)
 
-    def on_presence_unavailable(self, p: Presence):
+    def on_presence_unavailable(self, p: Presence) -> None:
         pto = p.get_to()
         if pto.bare != self.jid.bare:
             return
@@ -332,7 +370,7 @@ class LegacyMUC(
         pfrom = p.get_from()
         if pfrom.bare != self.user_jid.bare:
             return
-        if (resource := pfrom.resource) in self._user_resources:
+        if (resource := pfrom.resource) in self.get_user_resources():
             if pto.resource != self.user_nick:
                 self.log.debug(
                     "Received 'leave group' request but with wrong nickname. %s", p
@@ -381,7 +419,7 @@ class LegacyMUC(
         """
         raise NotImplementedError
 
-    async def fill_participants(self) -> AsyncIterator[LegacyParticipant]:
+    async def fill_participants(self) -> AsyncIterator[LegacyParticipantType]:
         """
         This method should yield the list of all members of this group.
 
@@ -393,30 +431,27 @@ class LegacyMUC(
         yield
 
     @property
-    def subject(self):
-        return self._subject
+    def subject(self) -> str:
+        return self.stored.subject or ""
 
     @subject.setter
-    def subject(self, s: str):
-        if s == self._subject:
+    def subject(self, s: str) -> None:
+        if s == self.subject:
             return
+
+        self.stored.subject = s
+        self.commit()
         self.__get_subject_setter_participant().set_room_subject(
             s, None, self.subject_date, False
         )
 
-        self._subject = s
-        if self._updating_info:
-            return
-        assert self.pk is not None
-        self.__store.update_subject(self.pk, s)
-
     @property
     def is_anonymous(self):
         return self.type == MucType.CHANNEL
 
     @property
     def subject_setter(self) -> Optional[str]:
-        return self._subject_setter
+        return self.stored.subject_setter
 
     @subject_setter.setter
     def subject_setter(self, subject_setter: SubjectSetterType) -> None:
@@ -425,19 +460,16 @@ class LegacyMUC(
         elif isinstance(subject_setter, LegacyParticipant):
             subject_setter = subject_setter.nickname
 
-        if subject_setter == self._subject_setter:
+        if subject_setter == self.subject_setter:
             return
         assert isinstance(subject_setter, str | None)
-        self._subject_setter = subject_setter
-        if self._updating_info:
-            return
-        assert self.pk is not None
-        self.__store.update_subject_setter(self.pk, subject_setter)
+        self.stored.subject_setter = subject_setter
+        self.commit()
 
     def __get_subject_setter_participant(self) -> LegacyParticipant:
-        if self._subject_setter is None:
+        if self.subject_setter is None:
             return self.get_system_participant()
-        return self.Participant(self, self._subject_setter)
+        return self._participant_cls(self, Participant(nickname=self.subject_setter))
 
     def features(self):
         features = [
@@ -475,11 +507,13 @@ class LegacyMUC(
         form.add_field("muc#maxhistoryfetch", value=str(self.max_history_fetch))
         form.add_field("muc#roominfo_subjectmod", "boolean", value=False)
 
-        if self._ALL_INFO_FILLED_ON_STARTUP or self._participants_filled:
-            assert self.pk is not None
-            n: Optional[int] = self.__participants_store.get_count(self.pk)
+        if self._ALL_INFO_FILLED_ON_STARTUP or self.stored.participants_filled:
+            with self.xmpp.store.session() as orm:
+                n = orm.scalar(
+                    sa.select(sa.func.count(Participant.id)).filter_by(room=self.stored)
+                )
         else:
-            n = self._n_participants
+            n = self.n_participants
         if n is not None:
             form.add_field("muc#roominfo_occupants", value=str(n))
 
@@ -489,14 +523,14 @@ class LegacyMUC(
         if s := self.subject:
             form.add_field("muc#roominfo_subject", value=s)
 
-        if self._set_avatar_task:
+        if self._set_avatar_task is not None:
             await self._set_avatar_task
-            avatar = self.get_avatar()
-            if avatar and (h := avatar.id):
-                form.add_field(
-                    "{http://modules.prosody.im/mod_vcard_muc}avatar#sha1", value=h
-                )
-                form.add_field("muc#roominfo_avatarhash", "text-multi", value=[h])
+        avatar = self.get_avatar()
+        if avatar and (h := avatar.id):
+            form.add_field(
+                "{http://modules.prosody.im/mod_vcard_muc}avatar#sha1", value=h
+            )
+            form.add_field("muc#roominfo_avatarhash", "text-multi", value=[h])
 
         form.add_field("muc#roomconfig_membersonly", "boolean", value=is_group)
         form.add_field(
@@ -514,7 +548,7 @@ class LegacyMUC(
 
         return r
 
-    def shutdown(self):
+    def shutdown(self) -> None:
         _, user_jid = escape_nickname(self.jid, self.user_nick)
         for user_full_jid in self.user_full_jids():
             presence = self.xmpp.make_presence(
@@ -526,7 +560,7 @@ class LegacyMUC(
             presence.send()
 
     def user_full_jids(self):
-        for r in self._user_resources:
+        for r in self.get_user_resources():
             j = JID(self.user_jid)
             j.resource = r
             yield j
@@ -536,14 +570,9 @@ class LegacyMUC(
         _, user_muc_jid = escape_nickname(self.jid, self.user_nick)
         return user_muc_jid
 
-    def _legacy_to_xmpp(self, legacy_id: LegacyMessageType):
-        return self.xmpp.store.sent.get_group_xmpp_id(
-            self.session.user_pk, str(legacy_id)
-        ) or self.session.legacy_to_xmpp_msg_id(legacy_id)
-
     async def echo(
         self, msg: Message, legacy_msg_id: Optional[LegacyMessageType] = None
-    ):
+    ) -> None:
         origin_id = msg.get_origin_id()
 
         msg.set_from(self.user_muc_jid)
@@ -568,24 +597,11 @@ class LegacyMUC(
 
             msg.send()
 
-    def _get_cached_avatar_id(self):
-        if self.pk is None:
-            return None
-        return self.xmpp.store.rooms.get_avatar_legacy_id(self.pk)
-
-    def _post_avatar_update(self) -> None:
-        if self.pk is None:
-            return
-        assert self.pk is not None
-        self.xmpp.store.rooms.set_avatar(
-            self.pk,
-            self._avatar_pk,
-            None if self.avatar_id is None else str(self.avatar_id),
-        )
+    def _post_avatar_update(self, cached_avatar) -> None:
         self.__send_configuration_change((104,))
         self._send_room_presence()
 
-    def _send_room_presence(self, user_full_jid: Optional[JID] = None):
+    def _send_room_presence(self, user_full_jid: Optional[JID] = None) -> None:
         if user_full_jid is None:
             tos = self.user_full_jids()
         else:
@@ -599,20 +615,19 @@ class LegacyMUC(
             p.send()
 
     @timeit
-    @with_session
     async def join(self, join_presence: Presence):
         user_full_jid = join_presence.get_from()
         requested_nickname = join_presence.get_to().resource
         client_resource = user_full_jid.resource
 
-        if client_resource in self._user_resources:
+        if client_resource in self.get_user_resources():
             self.log.debug("Received join from a resource that is already joined.")
 
-        self.add_user_resource(client_resource)
-
         if not requested_nickname or not client_resource:
             raise XMPPError("jid-malformed", by=self.jid)
 
+        self.add_user_resource(client_resource)
+
         self.log.debug(
             "Resource %s of %s wants to join room %s with nickname %s",
             client_resource,
@@ -631,9 +646,13 @@ class LegacyMUC(
 
         if user_participant is None:
             user_participant = await self.get_user_participant()
-        if not user_participant.is_user:  # type:ignore
+            with self.xmpp.store.session() as orm:
+                orm.add(self.stored)
+                with orm.no_autoflush:
+                    orm.refresh(self.stored, ["participants"])
+        if not user_participant.is_user:
             self.log.warning("is_user flag not set participant on user_participant")
-            user_participant.is_user = True  # type:ignore
+            user_participant.is_user = True
         user_participant.send_initial_presence(
             user_full_jid,
             presence_id=join_presence["id"],
@@ -661,8 +680,12 @@ class LegacyMUC(
                 maxstanzas=maxstanzas,
                 since=since,
             )
+        if self.HAS_SUBJECT:
+            subject = self.subject or ""
+        else:
+            subject = self.description or self.name or ""
         self.__get_subject_setter_participant().set_room_subject(
-            self._subject if self.HAS_SUBJECT else (self.description or self.name),
+            subject,
             user_full_jid,
             self.subject_date,
         )
@@ -683,22 +706,17 @@ class LegacyMUC(
         return p
 
     def __store_participant(self, p: "LegacyParticipantType") -> None:
-        # we don't want to update the participant list when we're filling history
-        if not self.KEEP_BACKFILLED_PARTICIPANTS and self.get_lock("fill history"):
+        if self.get_lock("fill participants"):
             return
-        assert self.pk is not None
-        p.pk = self.__participants_store.add(self.pk, p.nickname)
-        self.__participants_store.update(p)
-        if p._hats:
-            self.__participants_store.set_hats(p.pk, p._hats)
+        p.commit(merge=True)
 
     async def get_participant(
         self,
         nickname: str,
-        raise_if_not_found=False,
-        fill_first=False,
-        store=True,
-        **kwargs,
+        raise_if_not_found: bool = False,
+        fill_first: bool = False,
+        store: bool = True,
+        is_user: bool = False,
     ) -> "LegacyParticipantType":
         """
         Get a participant by their nickname.
@@ -713,30 +731,34 @@ class LegacyMUC(
         :param fill_first: Ensure :meth:`.LegacyMUC.fill_participants()` has been called first
              (internal use by slidge, plugins should not need that)
         :param store: persistently store the user in the list of MUC participants
-        :param kwargs: additional parameters for the :class:`.Participant`
-            construction (optional)
         :return:
         """
-        if fill_first and not self._participants_filled:
-            async for _ in self.get_participants():
-                pass
-        if self.pk is not None:
-            with self.xmpp.store.session():
-                stored = self.__participants_store.get_by_nickname(
-                    self.pk, nickname
-                ) or self.__participants_store.get_by_resource(self.pk, nickname)
-                if stored is not None:
-                    return self.Participant.from_store(self.session, stored)
+        if fill_first:
+            await self.__fill_participants()
+        with self.xmpp.store.session() as orm:
+            stored = (
+                orm.query(Participant)
+                .filter(
+                    Participant.room == self.stored,
+                    (Participant.nickname == nickname)
+                    | (Participant.resource == nickname),
+                )
+                .one_or_none()
+            )
+            if stored is not None:
+                return self.participant_from_store(stored)
 
         if raise_if_not_found:
             raise XMPPError("item-not-found")
-        p = self.Participant(self, nickname, **kwargs)
-        if store and not self._updating_info:
+        p = self._participant_cls(
+            self, Participant(room=self.stored, nickname=nickname, is_user=is_user)
+        )
+        if store:
             self.__store_participant(p)
         if (
             not self.get_lock("fill participants")
             and not self.get_lock("fill history")
-            and self._participants_filled
+            and self.stored.participants_filled
             and not p.is_user
             and not p.is_system
         ):
@@ -752,11 +774,26 @@ class LegacyMUC(
         service
         :return:
         """
-        return self.Participant(self, is_system=True)
+        return self._participant_cls(self, Participant(), is_system=True)
 
+    @overload
     async def get_participant_by_contact(
-        self, c: "LegacyContact", **kwargs
-    ) -> "LegacyParticipantType":
+        self, c: "LegacyContact"
+    ) -> "LegacyParticipantType": ...
+
+    @overload
+    async def get_participant_by_contact(
+        self, c: "LegacyContact", create: Literal[False]
+    ) -> "LegacyParticipantType | None": ...
+
+    @overload
+    async def get_participant_by_contact(
+        self, c: "LegacyContact", create: Literal[True]
+    ) -> "LegacyParticipantType": ...
+
+    async def get_participant_by_contact(
+        self, c: "LegacyContact", create: bool = True
+    ) -> "LegacyParticipantType | None":
         """
         Get a non-anonymous participant.
 
@@ -764,37 +801,42 @@ class LegacyMUC(
         that the Contact jid is associated to this participant
 
         :param c: The :class:`.LegacyContact` instance corresponding to this contact
-        :param kwargs: additional parameters for the :class:`.Participant`
-            construction (optional)
+        :param create: Creates the participant if it does not exist.
         :return:
         """
         await self.session.contacts.ready
 
-        if self.pk is not None:
-            c._LegacyContact__ensure_pk()  # type: ignore
-            assert c.contact_pk is not None
-            with self.__store.session():
-                stored = self.__participants_store.get_by_contact(self.pk, c.contact_pk)
-                if stored is not None:
-                    return self.Participant.from_store(
-                        self.session, stored, muc=self, contact=c
-                    )
+        with self.xmpp.store.session() as orm:
+            self.stored = orm.merge(self.stored)
+            stored = (
+                orm.query(Participant)
+                .filter_by(contact=c.stored, room=self.stored)
+                .one_or_none()
+            )
+            if stored is None:
+                if not create:
+                    return None
+            else:
+                return self.participant_from_store(stored=stored, contact=c)
 
-        nickname = c.name or unescape_node(c.jid_username)
+        nickname = c.name or unescape_node(c.jid.node)
 
-        if self.pk is None:
+        if self.stored.id is None:
             nick_available = True
         else:
-            nick_available = self.__store.nickname_is_available(self.pk, nickname)
+            with self.xmpp.store.session() as orm:
+                nick_available = (
+                    orm.query(Participant.id).filter_by(
+                        room=self.stored, nickname=nickname
+                    )
+                ).one_or_none() is None
 
         if not nick_available:
             self.log.debug("Nickname conflict")
-            nickname = f"{nickname} ({c.jid_username})"
-        p = self.Participant(self, nickname, **kwargs)
-        p.contact = c
-
-        if self._updating_info:
-            return p
+            nickname = f"{nickname} ({c.jid.node})"
+        p = self._participant_cls(
+            self, Participant(nickname=nickname, room=self.stored), contact=c
+        )
 
         self.__store_participant(p)
         # FIXME: this is not great but given the current design,
@@ -803,7 +845,7 @@ class LegacyMUC(
         #        and role afterwards.
         # We need a refactor of the MUC class… later™
         if (
-            self._participants_filled
+            self.stored.participants_filled
             and not self.get_lock("fill participants")
             and not self.get_lock("fill history")
         ):
@@ -811,19 +853,19 @@ class LegacyMUC(
         return p
 
     async def get_participant_by_legacy_id(
-        self, legacy_id: LegacyUserIdType, **kwargs
+        self, legacy_id: LegacyUserIdType
     ) -> "LegacyParticipantType":
         try:
             c = await self.session.contacts.by_legacy_id(legacy_id)
         except ContactIsUser:
-            return await self.get_user_participant(**kwargs)
-        return await self.get_participant_by_contact(c, **kwargs)
+            return await self.get_user_participant()
+        return await self.get_participant_by_contact(c)
 
     def remove_participant(
         self,
         p: "LegacyParticipantType",
-        kick=False,
-        ban=False,
+        kick: bool = False,
+        ban: bool = False,
         reason: str | None = None,
     ):
         """
@@ -836,7 +878,9 @@ class LegacyMUC(
         """
         if kick and ban:
             raise TypeError("Either kick or ban")
-        self.__participants_store.delete(p.pk)
+        with self.xmpp.store.session() as orm:
+            orm.delete(p.stored)
+            orm.commit()
         if kick:
             codes = {307}
         elif ban:
@@ -844,20 +888,23 @@ class LegacyMUC(
         else:
             codes = None
         presence = p._make_presence(ptype="unavailable", status_codes=codes)
-        p._affiliation = "outcast" if ban else "none"
-        p._role = "none"
+        p.stored.affiliation = "outcast" if ban else "none"
+        p.stored.role = "none"
         if reason:
             presence["muc"].set_item_attr("reason", reason)
         p._send(presence)
 
-    def rename_participant(self, old_nickname: str, new_nickname: str):
-        assert self.pk is not None
-        with self.xmpp.store.session():
-            stored = self.__participants_store.get_by_nickname(self.pk, old_nickname)
+    def rename_participant(self, old_nickname: str, new_nickname: str) -> None:
+        with self.xmpp.store.session() as orm:
+            stored = (
+                orm.query(Participant)
+                .filter_by(room=self.stored, nickname=old_nickname)
+                .one_or_none()
+            )
             if stored is None:
                 self.log.debug("Tried to rename a participant that we didn't know")
                 return
-            p = self.Participant.from_store(self.session, stored)
+            p = self.participant_from_store(stored)
             if p.nickname == old_nickname:
                 p.nickname = new_nickname
 
@@ -868,7 +915,7 @@ class LegacyMUC(
         maxstanzas: Optional[int] = None,
         seconds: Optional[int] = None,
         since: Optional[datetime] = None,
-    ):
+    ) -> None:
         """
         Old-style history join (internal slidge use)
 
@@ -895,7 +942,7 @@ class LegacyMUC(
             msg.set_to(full_jid)
             self.xmpp.send(msg, False)
 
-    async def send_mam(self, iq: Iq):
+    async def send_mam(self, iq: Iq) -> None:
         await self.__fill_history()
 
         form_values = iq["mam"]["form"].get_values()
@@ -922,8 +969,13 @@ class LegacyMUC(
         after_id = after_id_rsm or after_id
 
         before_rsm = iq["mam"]["rsm"]["before"]
-        if before_rsm is True and max_results is not None:
+        if before_rsm is not None and max_results is not None:
             last_page_n = max_results
+            # - before_rsm is True means the empty element <before />, which means
+            #   "last page in chronological order", cf https://xmpp.org/extensions/xep-0059.html#backwards
+            # - before_rsm == "an ID" means <before>an ID</before>
+            if before_rsm is not True:
+                before_id = before_rsm
         else:
             last_page_n = None
 
@@ -978,11 +1030,11 @@ class LegacyMUC(
         reply["mam_fin"]["rsm"]["count"] = str(count)
         reply.send()
 
-    async def send_mam_metadata(self, iq: Iq):
+    async def send_mam_metadata(self, iq: Iq) -> None:
         await self.__fill_history()
         await self.archive.send_metadata(iq)
 
-    async def kick_resource(self, r: str):
+    async def kick_resource(self, r: str) -> None:
         """
         Kick a XMPP client of the user. (slidge internal use)
 
@@ -1030,12 +1082,11 @@ class LegacyMUC(
 
     async def add_to_bookmarks(
         self,
-        auto_join=True,
-        invite=False,
-        preserve=True,
+        auto_join: bool = True,
+        preserve: bool = True,
         pin: bool | None = None,
         notify: WhenLiteral | None = None,
-    ):
+    ) -> None:
         """
         Add the MUC to the user's XMPP bookmarks (:xep:`0402')
 
@@ -1046,11 +1097,6 @@ class LegacyMUC(
             this MUC on startup. In theory, XMPP clients will receive
             a "push" notification when this is called, and they will
             join if they are online.
-        :param invite: send an invitation to join this MUC emanating from
-            the gateway. While this should not be strictly necessary,
-            it can help for clients that do not support :xep:`0402`, or
-            that have 'do not honor bookmarks auto-join' turned on in their
-            settings.
         :param preserve: preserve auto-join and bookmarks extensions
             set by the user outside slidge
         :param pin: Pin the group chat bookmark :xep:`0469`. Requires privileged entity.
@@ -1131,20 +1177,32 @@ class LegacyMUC(
                     "IQ privileges (XEP0356) are not set, we cannot add bookmarks for the user"
                 )
                 # fallback by forcing invitation
-                invite = True
+                bookmark_add_fail = True
             except IqError as e:
                 warnings.warn(
                     f"Something went wrong while trying to set the bookmarks: {e}"
                 )
                 # fallback by forcing invitation
-                invite = True
+                bookmark_add_fail = True
+            else:
+                bookmark_add_fail = False
         else:
             self.log.debug("Bookmark does not need updating.")
             return
 
-        if invite or (config.ALWAYS_INVITE_WHEN_ADDING_BOOKMARKS and existing is None):
+        if bookmark_add_fail:
             self.session.send_gateway_invite(
-                self, reason="This group could not be added automatically for you"
+                self,
+                reason="This group could not be added automatically for you, most"
+                "likely because this gateway is not configured as a privileged entity. "
+                "Contact your administrator.",
+            )
+        elif existing is None and self.session.user.preferences.get(
+            "always_invite_when_adding_bookmarks", True
+        ):
+            self.session.send_gateway_invite(
+                self,
+                reason="The gateway is configured to always send invitations for groups.",
             )
 
     async def on_avatar(
@@ -1233,12 +1291,10 @@ class LegacyMUC(
         raise NotImplementedError
 
     async def parse_mentions(self, text: str) -> list[Mention]:
-        with self.__store.session():
+        with self.xmpp.store.session() as orm:
             await self.__fill_participants()
-            assert self.pk is not None
-            participants = {
-                p.nickname: p for p in self.__participants_store.get_all(self.pk)
-            }
+            orm.add(self.stored)
+            participants = {p.nickname: p for p in self.stored.participants}
 
             if len(participants) == 0:
                 return []
@@ -1259,8 +1315,8 @@ class LegacyMUC(
                 if span[0] != 0 and text[span[0] - 1] not in _WHITESPACE_OR_PUNCTUATION:
                     continue
                 if span[1] == len(text) or text[span[1]] in _WHITESPACE_OR_PUNCTUATION:
-                    participant = self.Participant.from_store(
-                        self.session, participants[nick]
+                    participant = self.participant_from_store(
+                        stored=participants[nick],
                     )
                     if contact := participant.contact:
                         result.append(
@@ -1279,45 +1335,12 @@ class LegacyMUC(
         """
         raise NotImplementedError
 
-    @classmethod
-    def from_store(cls, session, stored: Room, *args, **kwargs) -> Self:
-        muc = cls(
-            session,
-            cls.xmpp.LEGACY_ROOM_ID_TYPE(stored.legacy_id),
-            stored.jid,
-            *args,  # type: ignore
-            **kwargs,  # type: ignore
-        )
-        muc.pk = stored.id
-        muc.type = stored.muc_type  # type: ignore
-        muc._user_nick = stored.user_nick
-        if stored.name:
-            muc.DISCO_NAME = stored.name
-        if stored.description:
-            muc._description = stored.description
-        if (data := stored.extra_attributes) is not None:
-            muc.deserialize_extra_attributes(data)
-        muc._subject = stored.subject or ""
-        if stored.subject_date is not None:
-            muc._subject_date = stored.subject_date.replace(tzinfo=timezone.utc)
-        muc._participants_filled = stored.participants_filled
-        muc._n_participants = stored.n_participants
-        muc._history_filled = stored.history_filled
-        if stored.user_resources is not None:
-            muc._user_resources = set(json.loads(stored.user_resources))
-        muc._subject_setter = stored.subject_setter
-        muc.archive = MessageArchive(muc.pk, session.xmpp.store.mam)
-        muc._set_logger_name()
-        muc._AvatarMixin__avatar_unique_id = (  # type:ignore
-            None
-            if stored.avatar_legacy_id is None
-            else session.xmpp.AVATAR_ID_TYPE(stored.avatar_legacy_id)
-        )
-        muc._avatar_pk = stored.avatar_id
-        return muc
+    @property
+    def participants_filled(self) -> bool:
+        return self.stored.participants_filled
 
 
-def set_origin_id(msg: Message, origin_id: str):
+def set_origin_id(msg: Message, origin_id: str) -> None:
     sub = ET.Element("{urn:xmpp:sid:0}origin-id")
     sub.attrib["id"] = origin_id
     msg.xml.append(sub)