happy2 0.0.5 → 0.0.9

package/packages/happy2-server/dist/routes/collaboration.js

@@ -1,22 +1,91 @@
-import { CollaborationError } from "../modules/collaboration/types.js";
+import { userSetBanned } from "../modules/user/userSetBanned.js";
+import { userDelete } from "../modules/user/userDelete.js";
+import { userAdministrationUpdate } from "../modules/user/userAdministrationUpdate.js";
+import { userAdministrationList } from "../modules/user/userAdministrationList.js";
+import { threadFollowSet } from "../modules/thread/threadFollowSet.js";
+import { threadGet } from "../modules/thread/threadGet.js";
+import { threadCreate } from "../modules/thread/threadCreate.js";
+import { threadListMine } from "../modules/thread/threadListMine.js";
+import { serverProfileUpdate } from "../modules/server-profile/serverProfileUpdate.js";
+import { serverProfileGet } from "../modules/server-profile/serverProfileGet.js";
+import { searchPageGet } from "../modules/search/searchPageGet.js";
+import { presenceSettingUpdate } from "../modules/presence/presenceSettingUpdate.js";
+import { presenceSettingList } from "../modules/presence/presenceSettingList.js";
+import { notificationPreferenceUpdate } from "../modules/notification/notificationPreferenceUpdate.js";
+import { notificationPreferenceGet } from "../modules/notification/notificationPreferenceGet.js";
+import { notificationMarkRead } from "../modules/notification/notificationMarkRead.js";
+import { notificationList } from "../modules/notification/notificationList.js";
+import { messageSendAutomated } from "../modules/message/messageSendAutomated.js";
+import { messageSend } from "../modules/message/messageSend.js";
+import { messageRevisionList } from "../modules/message/messageRevisionList.js";
+import { messageReactionSet } from "../modules/message/messageReactionSet.js";
+import { messagePinSet } from "../modules/message/messagePinSet.js";
+import { messageList } from "../modules/message/messageList.js";
+import { messageGet } from "../modules/message/messageGet.js";
+import { messageForward } from "../modules/message/messageForward.js";
+import { messageEdit } from "../modules/message/messageEdit.js";
+import { messageDelete } from "../modules/message/messageDelete.js";
+import { fileList } from "../modules/file/fileList.js";
+import { directMessageCreateGroup } from "../modules/chat/directMessageCreateGroup.js";
+import { directMessageCreate } from "../modules/chat/directMessageCreate.js";
+import { customEmojiList } from "../modules/emoji/customEmojiList.js";
+import { customEmojiDelete } from "../modules/emoji/customEmojiDelete.js";
+import { customEmojiCreate } from "../modules/emoji/customEmojiCreate.js";
+import { contactList } from "../modules/user/contactList.js";
+import { chatStarSet } from "../modules/chat/chatStarSet.js";
+import { chatStarReorder } from "../modules/chat/chatStarReorder.js";
+import { chatPinList } from "../modules/chat/chatPinList.js";
+import { chatNotificationPreferenceSet } from "../modules/notification/chatNotificationPreferenceSet.js";
+import { chatMembershipList } from "../modules/chat/chatMembershipList.js";
+import { chatMarkRead } from "../modules/chat/chatMarkRead.js";
+import { chatList } from "../modules/chat/chatList.js";
+import { chatGet } from "../modules/chat/chatGet.js";
+import { chatBookmarkList } from "../modules/chat/chatBookmarkList.js";
+import { chatBookmarkDelete } from "../modules/chat/chatBookmarkDelete.js";
+import { chatBookmarkCreate } from "../modules/chat/chatBookmarkCreate.js";
+import { channelUpdate } from "../modules/chat/channelUpdate.js";
+import { channelTopicUpdate } from "../modules/chat/channelTopicUpdate.js";
+import { channelSetArchived } from "../modules/chat/channelSetArchived.js";
+import { channelPolicyUpdate } from "../modules/chat/channelPolicyUpdate.js";
+import { channelMemberSetRole } from "../modules/chat/channelMemberSetRole.js";
+import { channelMemberRemove } from "../modules/chat/channelMemberRemove.js";
+import { channelMemberAdd } from "../modules/chat/channelMemberAdd.js";
+import { channelLeave } from "../modules/chat/channelLeave.js";
+import { channelJoinPublic } from "../modules/chat/channelJoinPublic.js";
+import { channelDirectoryList } from "../modules/chat/channelDirectoryList.js";
+import { channelDelete } from "../modules/chat/channelDelete.js";
+import { channelCreate } from "../modules/chat/channelCreate.js";
+import { channelDefaultAgentUpdate } from "../modules/chat/channelDefaultAgentUpdate.js";
+import { callParticipationUpdate } from "../modules/call/callParticipationUpdate.js";
+import { callList } from "../modules/call/callList.js";
+import { callGet } from "../modules/call/callGet.js";
+import { callEnd } from "../modules/call/callEnd.js";
+import { callCreate } from "../modules/call/callCreate.js";
+import { agentChatGetContext } from "../modules/agent/agentChatGetContext.js";
+import {} from "../modules/drizzle.js";
+import { CollaborationError } from "../modules/chat/types.js";
 import { realtimeTopics, } from "../modules/realtime/index.js";
 const MAX_ID_LENGTH = 128;
 const MAX_MESSAGE_LENGTH = 40_000;
 const MAX_ATTACHMENTS = 20;
 const MAX_FORWARD_TARGETS = 20;
 const MAX_SELF_DESTRUCT_SECONDS = 31_536_000;
-export function registerCollaborationRoutes(app, auth, repository, pubsub, agents) {
+export function registerCollaborationRoutes(app, auth, executor, pubsub, agents) {
     app.get("/v0/chats", authenticated(auth, async (request, _reply, userId) => {
         emptyQuery(request);
-        return { chats: await repository.listChats(userId) };
+        return {
+            chats: await chatList(executor, userId),
+        };
     }));
     app.get("/v0/chats/:chatId", authenticated(auth, async (request, _reply, userId) => {
         emptyQuery(request);
-        return { chat: await repository.getChat(userId, pathId(request, "chatId")) };
+        return {
+            chat: await chatGet(executor, userId, pathId(request, "chatId")),
+        };
     }));
     app.get("/v0/chats/:chatId/members", authenticated(auth, async (request, _reply, userId) => {
         emptyQuery(request);
-        const memberships = await repository.listChatMemberships(userId, pathId(request, "chatId"));
+        const memberships = await chatMembershipList(executor, userId, pathId(request, "chatId"));
         return {
             users: memberships.map(({ user }) => user),
             memberships,
@@ -25,31 +94,39 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
     app.get("/v0/chats/:chatId/messages", authenticated(auth, async (request, _reply, userId) => {
         const chatId = pathId(request, "chatId");
         const page = messagePage(request, ["beforeSequence", "afterSequence", "limit"]);
-        return repository.listMessages({ userId, chatId, ...page });
+        return messageList(executor, {
+            userId,
+            chatId,
+            ...page,
+        });
     }));
     app.get("/v0/messages/:messageId", authenticated(auth, async (request, _reply, userId) => {
         emptyQuery(request);
         return {
-            message: await repository.getMessage(userId, pathId(request, "messageId")),
+            message: await messageGet(executor, userId, pathId(request, "messageId")),
         };
     }));
     app.get("/v0/messages/:messageId/thread", authenticated(auth, async (request, _reply, userId) => {
-        const selected = await repository.getMessage(userId, pathId(request, "messageId"));
-        const root = selected.threadRootMessageId
-            ? await repository.getMessage(userId, selected.threadRootMessageId)
-            : selected;
-        const page = messagePage(request, ["beforeSequence", "afterSequence", "limit"]);
-        const result = await repository.listMessages({
-            userId,
-            chatId: root.chatId,
-            threadRootMessageId: root.id,
-            ...page,
+        emptyQuery(request);
+        return {
+            chat: await threadGet(executor, userId, pathId(request, "messageId")),
+        };
+    }));
+    app.post("/v0/messages/:messageId/createThread", authenticated(auth, async (request, reply, userId) => {
+        emptyBody(request);
+        const result = await threadCreate(executor, {
+            actorUserId: userId,
+            parentMessageId: pathId(request, "messageId"),
+        });
+        await publishHints(request, pubsub, result.hints);
+        return reply.code(result.created ? 201 : 200).send({
+            chat: result.chat,
+            sync: result.hints.at(-1),
         });
-        return { root, ...result };
     }));
     app.get("/v0/threads", authenticated(auth, async (request, _reply, userId) => {
         const query = requestQuery(request, ["before", "unreadOnly", "limit"]);
-        return repository.listMyThreads({
+        return threadListMine(executor, {
             userId,
             before: optionalQueryString(query, "before", MAX_ID_LENGTH),
             unreadOnly: optionalQueryBoolean(query, "unreadOnly"),
@@ -58,7 +135,7 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
     }));
     app.get("/v0/notifications", authenticated(auth, async (request, _reply, userId) => {
         const query = requestQuery(request, ["before", "unreadOnly", "limit"]);
-        return repository.listNotifications({
+        return notificationList(executor, {
             userId,
             before: optionalQueryString(query, "before", MAX_ID_LENGTH),
             unreadOnly: optionalQueryBoolean(query, "unreadOnly"),
@@ -67,20 +144,24 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
     }));
     app.post("/v0/notifications/markRead", authenticated(auth, async (request, _reply, userId) => {
         const body = requestBody(request, ["notificationIds", "all"]);
-        const result = await repository.markNotificationsRead({
+        const result = await notificationMarkRead(executor, {
             actorUserId: userId,
             notificationIds: has(body, "notificationIds")
                 ? idArrayField(body, "notificationIds", 500, true)
                 : undefined,
             all: has(body, "all") ? booleanField(body, "all") : undefined,
         });
-        await publishHints(request, pubsub, [result.hint], { userIds: [userId] });
-        return { sync: result.hint };
+        await publishHints(request, pubsub, [result.hint], {
+            userIds: [userId],
+        });
+        return {
+            sync: result.hint,
+        };
     }));
     app.post("/v0/chats/createDirectMessage", authenticated(auth, async (request, reply, userId) => {
         const body = requestBody(request, ["userId"]);
         const otherUserId = idField(body, "userId");
-        const result = await repository.createDirectMessage(userId, otherUserId);
+        const result = await directMessageCreate(executor, userId, otherUserId);
         if (result.hint)
             await publishHints(request, pubsub, [result.hint], {
                 userIds: [userId, otherUserId],
@@ -92,7 +173,7 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
     }));
     app.post("/v0/chats/createGroupDirectMessage", authenticated(auth, async (request, reply, userId) => {
         const body = requestBody(request, ["userIds", "name"]);
-        const result = await repository.createGroupDirectMessage({
+        const result = await directMessageCreateGroup(executor, {
             actorUserId: userId,
             userIds: idArrayField(body, "userIds", 49, false),
             name: has(body, "name") ? trimmedString(body, "name", 100) : undefined,
@@ -118,31 +199,70 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
             name: trimmedString(body, "name", 100),
             username: agentUsername(body),
         });
+        await publishHints(request, pubsub, [result.hint], {
+            userIds: [userId],
+        });
+        return reply.code(201).send({
+            chat: result.chat,
+            sync: result.hint,
+        });
+    }));
+    app.post("/v0/chats/createAgentConversation", authenticated(auth, async (request, reply, userId) => {
+        if (!agents)
+            return reply.code(503).send({
+                error: "agents_unavailable",
+                message: "AI agents are not enabled on this Happy (2) server.",
+            });
+        const body = requestBody(request, ["agentUserId"]);
+        const result = await agents.createAgentConversation({
+            actorUserId: userId,
+            agentUserId: idField(body, "agentUserId"),
+        });
         await publishHints(request, pubsub, [result.hint], { userIds: [userId] });
         return reply.code(201).send({ chat: result.chat, sync: result.hint });
     }));
     app.post("/v0/chats/createChannel", authenticated(auth, async (request, reply, userId) => {
-        const body = requestBody(request, ["kind", "name", "slug", "topic"]);
+        const body = requestBody(request, ["kind", "name", "slug", "topic", "autoJoin"]);
         const kind = enumField(body, "kind", ["public_channel", "private_channel"]);
-        const result = await repository.createChannel({
+        const result = await channelCreate(executor, {
             actorUserId: userId,
             kind,
             name: trimmedString(body, "name", 100),
             slug: channelSlug(body),
             topic: nullableTrimmedString(body, "topic", 500),
+            autoJoin: has(body, "autoJoin") ? booleanField(body, "autoJoin") : undefined,
         });
         await publishHints(request, pubsub, [result.hint], {
-            server: kind === "public_channel",
+            server: kind === "public_channel" || result.chat.autoJoin,
             userIds: [userId],
         });
-        return reply.code(201).send({ chat: result.chat, sync: result.hint });
+        return reply.code(201).send({
+            chat: result.chat,
+            sync: result.hint,
+        });
+    }));
+    app.post("/v0/chats/:chatId/updateDefaultAgent", authenticated(auth, async (request, _reply, userId) => {
+        const body = requestBody(request, ["agentUserId"]);
+        const result = await channelDefaultAgentUpdate(executor, {
+            actorUserId: userId,
+            chatId: pathId(request, "chatId"),
+            agentUserId: idField(body, "agentUserId"),
+        });
+        await publishHints(request, pubsub, [result.hint]);
+        return {
+            chat: result.chat,
+            sync: result.hint,
+        };
     }));
     app.post("/v0/chats/:chatId/updateTopic", authenticated(auth, async (request, _reply, userId) => {
         const body = requestBody(request, ["topic"]);
         requireField(body, "topic");
-        const result = await repository.updateTopic(userId, pathId(request, "chatId"), nullableTrimmedString(body, "topic", 500));
+        const result = await channelTopicUpdate(executor, userId, pathId(request, "chatId"), nullableTrimmedString(body, "topic", 500));
         await publishHints(request, pubsub, [result.hint]);
-        return { chat: result.chat, sync: result.hint };
+        return {
+            chat: result.chat,
+            sync: result.hint,
+        };
     }));
     app.post("/v0/chats/:chatId/updateChannel", authenticated(auth, async (request, _reply, userId) => {
         const body = requestBody(request, [
@@ -152,10 +272,11 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
             "kind",
             "photoFileId",
             "isListed",
+            "autoJoin",
         ]);
         if (Object.keys(body).length === 0)
             throw new InvalidRequest("At least one channel field is required");
-        const result = await repository.updateChannel({
+        const result = await channelUpdate(executor, {
             actorUserId: userId,
             chatId: pathId(request, "chatId"),
             name: has(body, "name") ? trimmedString(body, "name", 100) : undefined,
@@ -175,11 +296,15 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
                     : id(body.photoFileId, "photoFileId")
                 : undefined,
             isListed: has(body, "isListed") ? booleanField(body, "isListed") : undefined,
+            autoJoin: has(body, "autoJoin") ? booleanField(body, "autoJoin") : undefined,
         });
         await publishHints(request, pubsub, [result.hint], {
-            server: result.chat.kind === "public_channel",
+            server: result.chat.kind === "public_channel" || result.chat.autoJoin,
         });
-        return { chat: result.chat, sync: result.hint };
+        return {
+            chat: result.chat,
+            sync: result.hint,
+        };
     }));
     app.post("/v0/chats/:chatId/updatePolicies", authenticated(auth, async (request, _reply, userId) => {
         const body = requestBody(request, [
@@ -191,7 +316,7 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
         ]);
         if (Object.keys(body).length === 0)
             throw new InvalidRequest("At least one policy field is required");
-        const result = await repository.updateChannelPolicies({
+        const result = await channelPolicyUpdate(executor, {
             actorUserId: userId,
             chatId: pathId(request, "chatId"),
             retentionMode: optionalEnumField(body, "retentionMode", [
@@ -212,7 +337,10 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
             ]),
         });
         await publishHints(request, pubsub, [result.hint]);
-        return { chat: result.chat, sync: result.hint };
+        return {
+            chat: result.chat,
+            sync: result.hint,
+        };
     }));
     for (const [path, archived] of [
         ["archiveChannel", true],
@@ -222,7 +350,7 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
             const body = request.body === undefined || request.body === null
                 ? {}
                 : requestBody(request, ["reason"]);
-            const result = await repository.setChannelArchived({
+            const result = await channelSetArchived(executor, {
                 actorUserId: userId,
                 chatId: pathId(request, "chatId"),
                 archived,
@@ -233,11 +361,14 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
             await publishHints(request, pubsub, [result.hint], {
                 server: result.chat.kind === "public_channel",
             });
-            return { chat: result.chat, sync: result.hint };
+            return {
+                chat: result.chat,
+                sync: result.hint,
+            };
         }));
     app.post("/v0/chats/:chatId/deleteChannel", authenticated(auth, async (request, _reply, userId) => {
         const body = requestBody(request, ["reason"]);
-        const result = await repository.deleteChannel({
+        const result = await channelDelete(executor, {
             actorUserId: userId,
             chatId: pathId(request, "chatId"),
             reason: has(body, "reason")
@@ -247,70 +378,102 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
         await publishHints(request, pubsub, [result.hint], {
             userIds: result.memberUserIds,
         });
-        return { sync: result.hint };
+        return {
+            sync: result.hint,
+        };
     }));
     app.post("/v0/chats/:chatId/join", authenticated(auth, async (request, _reply, userId) => {
         emptyBody(request);
-        const result = await repository.joinPublicChannel(userId, pathId(request, "chatId"));
-        await publishHints(request, pubsub, [result.hint], { userIds: [userId] });
-        return { chat: result.chat, sync: result.hint };
+        const result = await channelJoinPublic(executor, userId, pathId(request, "chatId"));
+        await publishHints(request, pubsub, [result.hint], {
+            userIds: [userId],
+        });
+        return {
+            chat: result.chat,
+            sync: result.hint,
+        };
     }));
     app.post("/v0/chats/:chatId/leave", authenticated(auth, async (request, _reply, userId) => {
         emptyBody(request);
-        const result = await repository.leaveChannel(userId, pathId(request, "chatId"));
-        await publishHints(request, pubsub, [result.hint], { userIds: [userId] });
-        return { sync: result.hint };
+        const result = await channelLeave(executor, userId, pathId(request, "chatId"));
+        await publishHints(request, pubsub, [result.hint], {
+            userIds: [userId],
+        });
+        return {
+            sync: result.hint,
+        };
     }));
     app.post("/v0/chats/:chatId/addMember", authenticated(auth, async (request, _reply, userId) => {
         const body = requestBody(request, ["userId", "role"]);
         const addedUserId = idField(body, "userId");
-        const result = await repository.addChannelMember({
+        const result = await channelMemberAdd(executor, {
             actorUserId: userId,
             chatId: pathId(request, "chatId"),
             userId: addedUserId,
             role: optionalEnumField(body, "role", ["owner", "admin", "member"]),
         });
-        await publishHints(request, pubsub, [result.hint], { userIds: [addedUserId] });
-        return { sync: result.hint };
+        await publishHints(request, pubsub, [result.hint], {
+            userIds: [addedUserId],
+        });
+        return {
+            sync: result.hint,
+        };
     }));
     app.post("/v0/chats/:chatId/removeMember", authenticated(auth, async (request, _reply, userId) => {
         const body = requestBody(request, ["userId"]);
         const removedUserId = idField(body, "userId");
-        const result = await repository.removeChannelMember({
+        const result = await channelMemberRemove(executor, {
             actorUserId: userId,
             chatId: pathId(request, "chatId"),
             userId: removedUserId,
         });
-        await publishHints(request, pubsub, [result.hint], { userIds: [removedUserId] });
-        return { sync: result.hint };
+        await publishHints(request, pubsub, [result.hint], {
+            userIds: [removedUserId],
+        });
+        return {
+            sync: result.hint,
+        };
     }));
     app.post("/v0/chats/:chatId/setMemberRole", authenticated(auth, async (request, _reply, userId) => {
         const body = requestBody(request, ["userId", "role"]);
         const targetUserId = idField(body, "userId");
-        const result = await repository.setChannelMemberRole({
+        const result = await channelMemberSetRole(executor, {
             actorUserId: userId,
             chatId: pathId(request, "chatId"),
             userId: targetUserId,
             role: enumField(body, "role", ["owner", "admin", "member"]),
         });
-        await publishHints(request, pubsub, [result.hint], { userIds: [targetUserId] });
-        return { sync: result.hint };
+        await publishHints(request, pubsub, [result.hint], {
+            userIds: [targetUserId],
+        });
+        return {
+            sync: result.hint,
+        };
     }));
     app.post("/v0/chats/:chatId/setStar", authenticated(auth, async (request, _reply, userId) => {
         const body = requestBody(request, ["starred"]);
-        const result = await repository.setStar(userId, pathId(request, "chatId"), booleanField(body, "starred"));
-        await publishHints(request, pubsub, [result.hint], { userIds: [userId] });
-        return { sync: result.hint };
+        const result = await chatStarSet(executor, userId, pathId(request, "chatId"), booleanField(body, "starred"));
+        await publishHints(request, pubsub, [result.hint], {
+            userIds: [userId],
+        });
+        return {
+            sync: result.hint,
+        };
     }));
     app.post("/v0/chats/:chatId/markRead", authenticated(auth, async (request, _reply, userId) => {
         const body = requestBody(request, ["messageId"]);
-        const result = await repository.markChatRead({
+        const result = await chatMarkRead(executor, {
             actorUserId: userId,
             chatId: pathId(request, "chatId"),
             messageId: optionalIdField(body, "messageId"),
         });
-        await publishHints(request, pubsub, [result.hint], { userIds: [userId] });
-        return { chat: result.chat, sync: result.hint };
+        await publishHints(request, pubsub, [result.hint], {
+            userIds: [userId],
+        });
+        return {
+            chat: result.chat,
+            sync: result.hint,
+        };
     }));
     app.post("/v0/chats/:chatId/updateNotificationPreferences", authenticated(auth, async (request, _reply, userId) => {
         const body = requestBody(request, [
@@ -321,7 +484,7 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
         ]);
         if (Object.keys(body).length === 0)
             throw new InvalidRequest("At least one preference is required");
-        const result = await repository.setChatNotificationPreferences({
+        const result = await chatNotificationPreferenceSet(executor, {
             actorUserId: userId,
             chatId: pathId(request, "chatId"),
             notificationLevel: optionalEnumField(body, "notificationLevel", [
@@ -337,46 +500,60 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
                 ? booleanField(body, "showMessagePreviews")
                 : undefined,
         });
-        await publishHints(request, pubsub, [result.hint], { userIds: [userId] });
-        return { chat: result.chat, sync: result.hint };
+        await publishHints(request, pubsub, [result.hint], {
+            userIds: [userId],
+        });
+        return {
+            chat: result.chat,
+            sync: result.hint,
+        };
     }));
     app.post("/v0/chats/reorderStarred", authenticated(auth, async (request, _reply, userId) => {
         const body = requestBody(request, ["chatIds"]);
-        const result = await repository.reorderStarred(userId, idArrayField(body, "chatIds", 1_000, true));
-        await publishHints(request, pubsub, [result.hint], { userIds: [userId] });
-        return { sync: result.hint };
+        const result = await chatStarReorder(executor, userId, idArrayField(body, "chatIds", 1_000, true));
+        await publishHints(request, pubsub, [result.hint], {
+            userIds: [userId],
+        });
+        return {
+            sync: result.hint,
+        };
     }));
     app.post("/v0/chats/:chatId/sendMessage", authenticated(auth, async (request, reply, userId) => {
         const chatId = pathId(request, "chatId");
-        const agentContext = await repository.getDirectAgentChatContext(userId, chatId);
-        if (agentContext && !agents)
-            return reply.code(503).send({
-                error: "agents_unavailable",
-                message: "AI agents are not enabled on this Happy (2) server.",
-            });
         const body = requestBody(request, [
             "text",
             "attachmentFileIds",
             "quotedMessageId",
-            "threadRootMessageId",
             "expiryMode",
             "selfDestructSeconds",
             "afterReadScope",
             "clientMutationId",
+            "audience",
+            "agentUserIds",
         ]);
         const attachmentFileIds = optionalIdArrayField(body, "attachmentFileIds", MAX_ATTACHMENTS);
         const text = messageText(body, attachmentFileIds?.length ?? 0);
-        const agentTurn = agentContext && text
-            ? await agents.prepareTurn({ actorUserId: userId, chatId })
-            : undefined;
+        const directContext = await agentChatGetContext(executor, userId, chatId);
+        const audience = optionalEnumField(body, "audience", ["people", "agents"]) ??
+            (directContext ? "agents" : "people");
+        const agentUserIds = optionalIdArrayField(body, "agentUserIds", 8) ?? [];
+        if (audience === "people" && agentUserIds.length)
+            throw new InvalidRequest("agentUserIds require the agents audience");
+        if (audience === "agents" && !agents)
+            return reply.code(503).send({
+                error: "agents_unavailable",
+                message: "AI agents are not enabled on this Happy (2) server.",
+            });
+        const agentTurns = audience === "agents"
+            ? await agents.prepareTurns({ actorUserId: userId, agentUserIds, chatId })
+            : [];
         const selfDestructSeconds = optionalPositiveIntegerField(body, "selfDestructSeconds", MAX_SELF_DESTRUCT_SECONDS);
-        const result = await repository.sendMessage({
+        const result = await messageSend(executor, {
             actorUserId: userId,
             chatId,
             text,
             attachmentFileIds,
             quotedMessageId: optionalIdField(body, "quotedMessageId"),
-            threadRootMessageId: optionalIdField(body, "threadRootMessageId"),
             expiryMode: optionalEnumField(body, "expiryMode", [
                 "none",
                 "after_send",
@@ -388,87 +565,43 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
                 "all_readers",
             ]),
             clientMutationId: optionalTokenField(body, "clientMutationId"),
-            agentTurn,
+            audience,
+            agentTurns,
         });
-        if (agentTurn)
+        if (agentTurns.length)
             agents.startTurn(chatId);
         await publishHints(request, pubsub, [result.hint]);
-        return reply.code(201).send({ message: result.message, sync: result.hint });
-    }));
-    app.post("/v0/messages/:messageId/sendThreadMessage", authenticated(auth, async (request, reply, userId) => {
-        const selected = await repository.getMessage(userId, pathId(request, "messageId"));
-        const rootMessageId = selected.threadRootMessageId ?? selected.id;
-        const body = requestBody(request, [
-            "text",
-            "attachmentFileIds",
-            "quotedMessageId",
-            "expiryMode",
-            "selfDestructSeconds",
-            "afterReadScope",
-            "clientMutationId",
-        ]);
-        const attachmentFileIds = optionalIdArrayField(body, "attachmentFileIds", MAX_ATTACHMENTS);
-        const selfDestructSeconds = optionalPositiveIntegerField(body, "selfDestructSeconds", MAX_SELF_DESTRUCT_SECONDS);
-        const result = await repository.sendMessage({
-            actorUserId: userId,
-            chatId: selected.chatId,
-            text: messageText(body, attachmentFileIds?.length ?? 0),
-            attachmentFileIds,
-            quotedMessageId: optionalIdField(body, "quotedMessageId"),
-            threadRootMessageId: rootMessageId,
-            expiryMode: optionalEnumField(body, "expiryMode", [
-                "none",
-                "after_send",
-                "after_read",
-            ]) ?? (selfDestructSeconds ? "after_send" : undefined),
-            selfDestructSeconds,
-            afterReadScope: optionalEnumField(body, "afterReadScope", [
-                "any_reader",
-                "all_readers",
-            ]),
-            clientMutationId: optionalTokenField(body, "clientMutationId"),
+        return reply.code(201).send({
+            message: result.message,
+            sync: result.hint,
         });
-        await publishHints(request, pubsub, [result.hint]);
-        return reply.code(201).send({ message: result.message, sync: result.hint });
     }));
-    app.post("/v0/messages/:messageId/updateThreadSubscription", authenticated(auth, async (request, _reply, userId) => {
-        const body = requestBody(request, ["subscribed", "notificationLevel"]);
-        const selected = await repository.getMessage(userId, pathId(request, "messageId"));
-        const rootMessageId = selected.threadRootMessageId ?? selected.id;
-        const result = await repository.setThreadSubscription({
+    app.post("/v0/chats/:chatId/updateThreadFollow", authenticated(auth, async (request, _reply, userId) => {
+        const body = requestBody(request, ["followed"]);
+        const result = await threadFollowSet(executor, {
             actorUserId: userId,
-            threadRootMessageId: rootMessageId,
-            subscribed: booleanField(body, "subscribed"),
-            notificationLevel: optionalEnumField(body, "notificationLevel", [
-                "all",
-                "mentions",
-                "none",
-            ]),
+            chatId: pathId(request, "chatId"),
+            followed: booleanField(body, "followed"),
         });
-        await publishHints(request, pubsub, [result.hint], { userIds: [userId] });
-        return { sync: result.hint };
-    }));
-    app.post("/v0/messages/:messageId/markThreadRead", authenticated(auth, async (request, _reply, userId) => {
-        const body = requestBody(request, ["throughMessageId"]);
-        const selected = await repository.getMessage(userId, pathId(request, "messageId"));
-        const rootMessageId = selected.threadRootMessageId ?? selected.id;
-        const result = await repository.markThreadRead({
-            actorUserId: userId,
-            threadRootMessageId: rootMessageId,
-            messageId: optionalIdField(body, "throughMessageId"),
+        await publishHints(request, pubsub, [result.hint], {
+            userIds: [userId],
         });
-        await publishHints(request, pubsub, [result.hint], { userIds: [userId] });
-        return { sync: result.hint };
+        return {
+            sync: result.hint,
+        };
     }));
     app.post("/v0/messages/:messageId/deleteMessage", authenticated(auth, async (request, _reply, userId) => {
         emptyBody(request);
-        const result = await repository.deleteMessage(userId, pathId(request, "messageId"));
+        const result = await messageDelete(executor, userId, pathId(request, "messageId"));
         await publishHints(request, pubsub, [result.hint]);
-        return { message: result.message, sync: result.hint };
+        return {
+            message: result.message,
+            sync: result.hint,
+        };
     }));
     app.post("/v0/messages/:messageId/editMessage", authenticated(auth, async (request, _reply, userId) => {
         const body = requestBody(request, ["text", "reason", "expectedRevision"]);
-        const result = await repository.editMessage({
+        const result = await messageEdit(executor, {
             actorUserId: userId,
             messageId: pathId(request, "messageId"),
             text: messageText(body, 0),
@@ -478,77 +611,93 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
             expectedRevision: optionalPositiveIntegerField(body, "expectedRevision", Number.MAX_SAFE_INTEGER),
         });
         await publishHints(request, pubsub, [result.hint]);
-        return { message: result.message, sync: result.hint };
+        return {
+            message: result.message,
+            sync: result.hint,
+        };
     }));
     app.get("/v0/messages/:messageId/revisions", authenticated(auth, async (request, _reply, userId) => {
         emptyQuery(request);
         return {
-            revisions: await repository.listMessageRevisions(userId, pathId(request, "messageId")),
+            revisions: await messageRevisionList(executor, userId, pathId(request, "messageId")),
         };
     }));
     app.post("/v0/messages/:messageId/forwardMessage", authenticated(auth, async (request, reply, userId) => {
         const body = requestBody(request, ["targetChatIds", "clientMutationId"]);
-        const result = await repository.forwardMessage({
+        const result = await messageForward(executor, {
             actorUserId: userId,
             messageId: pathId(request, "messageId"),
             targetChatIds: idArrayField(body, "targetChatIds", MAX_FORWARD_TARGETS, false),
             clientMutationId: optionalTokenField(body, "clientMutationId"),
         });
         await publishHints(request, pubsub, result.hints);
-        return reply.code(201).send({ messages: result.messages, sync: result.hints });
+        return reply.code(201).send({
+            messages: result.messages,
+            sync: result.hints,
+        });
     }));
     app.post("/v0/messages/:messageId/addReaction", authenticated(auth, async (request, _reply, userId) => {
         const reaction = reactionBody(request);
-        const result = await repository.setReaction({
+        const result = await messageReactionSet(executor, {
             actorUserId: userId,
             messageId: pathId(request, "messageId"),
             ...reaction,
             active: true,
         });
         await publishHints(request, pubsub, [result.hint]);
-        return { message: result.message, sync: result.hint };
+        return {
+            message: result.message,
+            sync: result.hint,
+        };
     }));
     app.post("/v0/messages/:messageId/removeReaction", authenticated(auth, async (request, _reply, userId) => {
         const reaction = reactionBody(request);
-        const result = await repository.setReaction({
+        const result = await messageReactionSet(executor, {
             actorUserId: userId,
             messageId: pathId(request, "messageId"),
             ...reaction,
             active: false,
         });
         await publishHints(request, pubsub, [result.hint]);
-        return { message: result.message, sync: result.hint };
+        return {
+            message: result.message,
+            sync: result.hint,
+        };
     }));
     app.post("/v0/messages/:messageId/pinMessage", authenticated(auth, async (request, _reply, userId) => {
         emptyBody(request);
-        const result = await repository.setMessagePinned({
+        const result = await messagePinSet(executor, {
             actorUserId: userId,
             messageId: pathId(request, "messageId"),
             pinned: true,
         });
         await publishHints(request, pubsub, [result.hint]);
-        return { sync: result.hint };
+        return {
+            sync: result.hint,
+        };
     }));
     app.post("/v0/messages/:messageId/unpinMessage", authenticated(auth, async (request, _reply, userId) => {
         emptyBody(request);
-        const result = await repository.setMessagePinned({
+        const result = await messagePinSet(executor, {
             actorUserId: userId,
             messageId: pathId(request, "messageId"),
             pinned: false,
         });
         await publishHints(request, pubsub, [result.hint]);
-        return { sync: result.hint };
+        return {
+            sync: result.hint,
+        };
     }));
     app.get("/v0/chats/:chatId/pins", authenticated(auth, async (request, _reply, userId) => {
         emptyQuery(request);
         return {
-            pins: await repository.listChatPins(userId, pathId(request, "chatId")),
+            pins: await chatPinList(executor, userId, pathId(request, "chatId")),
         };
     }));
     app.get("/v0/chats/:chatId/bookmarks", authenticated(auth, async (request, _reply, userId) => {
         emptyQuery(request);
         return {
-            bookmarks: await repository.listChatBookmarks(userId, pathId(request, "chatId")),
+            bookmarks: await chatBookmarkList(executor, userId, pathId(request, "chatId")),
         };
     }));
     app.post("/v0/chats/:chatId/createBookmark", authenticated(auth, async (request, reply, userId) => {
@@ -568,7 +717,7 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
             (kind === "message" && (!messageId || url || fileId)) ||
             (kind === "file" && (!fileId || url || messageId)))
             throw new InvalidRequest("Bookmark target does not match its kind");
-        const result = await repository.createChatBookmark({
+        const result = await chatBookmarkCreate(executor, {
             actorUserId: userId,
             chatId: pathId(request, "chatId"),
             kind,
@@ -581,43 +730,48 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
                 : undefined,
         });
         await publishHints(request, pubsub, [result.hint]);
-        return reply.code(201).send({ bookmark: result.bookmark, sync: result.hint });
+        return reply.code(201).send({
+            bookmark: result.bookmark,
+            sync: result.hint,
+        });
     }));
     app.post("/v0/chats/:chatId/deleteBookmark", authenticated(auth, async (request, _reply, userId) => {
         const body = requestBody(request, ["bookmarkId"]);
-        const result = await repository.deleteChatBookmark({
+        const result = await chatBookmarkDelete(executor, {
             actorUserId: userId,
             chatId: pathId(request, "chatId"),
             bookmarkId: idField(body, "bookmarkId"),
         });
         await publishHints(request, pubsub, [result.hint]);
-        return { sync: result.hint };
+        return {
+            sync: result.hint,
+        };
     }));
     app.get("/v0/contacts", authenticated(auth, async (request) => {
         emptyQuery(request);
-        const users = await repository.listContacts();
+        const users = await contactList(executor);
         return {
             users,
             presence: await pubsub.getPresenceSnapshot(users.map((user) => user.id)),
-            statuses: await repository.listPresenceSettings(users.map((user) => user.id)),
+            statuses: await presenceSettingList(executor, users.map((user) => user.id)),
         };
     }));
     app.get("/v0/directory/users", authenticated(auth, async (request) => {
         emptyQuery(request);
-        const users = await repository.listContacts();
+        const users = await contactList(executor);
         return {
             users,
             presence: await pubsub.getPresenceSnapshot(users.map((user) => user.id)),
-            statuses: await repository.listPresenceSettings(users.map((user) => user.id)),
+            statuses: await presenceSettingList(executor, users.map((user) => user.id)),
         };
     }));
     app.get("/v0/directory", authenticated(auth, async (request, _reply, userId) => {
         emptyQuery(request);
         const [users, channels, customEmoji, server] = await Promise.all([
-            repository.listContacts(),
-            repository.listDirectoryChannels(userId),
-            repository.listCustomEmoji(),
-            repository.getServerProfile(),
+            contactList(executor),
+            channelDirectoryList(executor, userId),
+            customEmojiList(executor),
+            serverProfileGet(executor),
         ]);
         return {
             server,
@@ -625,15 +779,15 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
             channels,
             customEmoji,
             presence: await pubsub.getPresenceSnapshot(users.map((user) => user.id)),
-            statuses: await repository.listPresenceSettings(users.map((user) => user.id)),
+            statuses: await presenceSettingList(executor, users.map((user) => user.id)),
         };
     }));
     app.get("/v0/presence", authenticated(auth, async (request) => {
         emptyQuery(request);
-        const users = await repository.listContacts();
+        const users = await contactList(executor);
         return {
             presence: await pubsub.getPresenceSnapshot(users.map((user) => user.id)),
-            statuses: await repository.listPresenceSettings(users.map((user) => user.id)),
+            statuses: await presenceSettingList(executor, users.map((user) => user.id)),
         };
     }));
     app.post("/v0/me/updateStatus", authenticated(auth, async (request, _reply, userId) => {
@@ -646,7 +800,7 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
         ]);
         if (Object.keys(body).length === 0)
             throw new InvalidRequest("At least one presence field is required");
-        const result = await repository.updatePresenceSettings({
+        const result = await presenceSettingUpdate(executor, {
             actorUserId: userId,
             availability: optionalEnumField(body, "availability", [
                 "automatic",
@@ -659,12 +813,19 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
             statusExpiresAt: optionalNullableDateField(body, "statusExpiresAt"),
             dndUntil: optionalNullableDateField(body, "dndUntil"),
         });
-        await publishHints(request, pubsub, [result.hint], { server: true });
-        return { status: result.presence, sync: result.hint };
+        await publishHints(request, pubsub, [result.hint], {
+            server: true,
+        });
+        return {
+            status: result.presence,
+            sync: result.hint,
+        };
     }));
     app.get("/v0/me/notificationPreferences", authenticated(auth, async (request, _reply, userId) => {
         emptyQuery(request);
-        return { preferences: await repository.getNotificationPreferences(userId) };
+        return {
+            preferences: await notificationPreferenceGet(executor, userId),
+        };
     }));
     app.post("/v0/me/updateNotificationPreferences", authenticated(auth, async (request, _reply, userId) => {
         const body = requestBody(request, [
@@ -681,7 +842,7 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
         ]);
         if (Object.keys(body).length === 0)
             throw new InvalidRequest("At least one notification preference is required");
-        const result = await repository.updateNotificationPreferences({
+        const result = await notificationPreferenceUpdate(executor, {
             actorUserId: userId,
             directMessages: optionalEnumField(body, "directMessages", ["all", "none"]),
             mentions: optionalEnumField(body, "mentions", ["all", "none"]),
@@ -702,19 +863,26 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
             dndEndMinutes: optionalNullableMinute(body, "dndEndMinutes"),
             timezone: nullableStringUpdate(body, "timezone", 100),
         });
-        await publishHints(request, pubsub, [result.hint], { userIds: [userId] });
-        return { preferences: result.preferences, sync: result.hint };
+        await publishHints(request, pubsub, [result.hint], {
+            userIds: [userId],
+        });
+        return {
+            preferences: result.preferences,
+            sync: result.hint,
+        };
     }));
     app.get("/v0/directory/channels", authenticated(auth, async (request, _reply, userId) => {
         emptyQuery(request);
-        return { channels: await repository.listDirectoryChannels(userId) };
+        return {
+            channels: await channelDirectoryList(executor, userId),
+        };
     }));
     app.get("/v0/search", authenticated(auth, async (request, _reply, userId) => {
         const query = requestQuery(request, ["q", "cursor", "limit"]);
         const search = queryString(query, "q", 200);
         if (search.trim().length === 0)
             throw new InvalidRequest("Search query is required");
-        return repository.searchPage({
+        return searchPageGet(executor, {
             userId,
             query: search.trim(),
             cursor: optionalQueryString(query, "cursor", 1_024),
@@ -723,7 +891,7 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
     }));
     app.get("/v0/files", authenticated(auth, async (request, _reply, userId) => {
         const query = requestQuery(request, ["kind", "before", "limit"]);
-        return repository.listFiles({
+        return fileList(executor, {
             userId,
             kind: optionalQueryEnum(query, "kind", ["file", "photo", "video", "gif"]),
             before: optionalQueryString(query, "before", 64),
@@ -733,7 +901,7 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
     app.get("/v0/calls", authenticated(auth, async (request, _reply, userId) => {
         const query = requestQuery(request, ["chatId", "limit"]);
         return {
-            calls: await repository.listCalls({
+            calls: await callList(executor, {
                 userId,
                 chatId: optionalQueryString(query, "chatId", MAX_ID_LENGTH),
                 limit: queryLimit(query, "limit", 50, 100),
@@ -742,11 +910,13 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
     }));
     app.get("/v0/calls/:callId", authenticated(auth, async (request, _reply, userId) => {
         emptyQuery(request);
-        return { call: await repository.getCall(userId, pathId(request, "callId")) };
+        return {
+            call: await callGet(executor, userId, pathId(request, "callId")),
+        };
     }));
     app.post("/v0/chats/:chatId/createCall", authenticated(auth, async (request, reply, userId) => {
         const body = requestBody(request, ["kind", "invitedUserIds"]);
-        const result = await repository.createCall({
+        const result = await callCreate(executor, {
             actorUserId: userId,
             chatId: pathId(request, "chatId"),
             kind: enumField(body, "kind", ["audio", "video"]),
@@ -757,7 +927,10 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
         await publishHints(request, pubsub, [result.hint], {
             userIds: [userId, ...result.invitedUserIds],
         });
-        return reply.code(201).send({ call: result.call, sync: result.hint });
+        return reply.code(201).send({
+            call: result.call,
+            sync: result.hint,
+        });
     }));
     for (const [path, action] of [
         ["joinCall", "join"],
@@ -766,7 +939,7 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
     ])
         app.post(`/v0/calls/:callId/${path}`, authenticated(auth, async (request, _reply, userId) => {
             emptyBody(request);
-            const result = await repository.updateCallParticipation({
+            const result = await callParticipationUpdate(executor, {
                 actorUserId: userId,
                 callId: pathId(request, "callId"),
                 action,
@@ -774,11 +947,14 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
             await publishHints(request, pubsub, [result.hint], {
                 userIds: result.call.participants.map((participant) => participant.userId),
             });
-            return { call: result.call, sync: result.hint };
+            return {
+                call: result.call,
+                sync: result.hint,
+            };
         }));
     app.post("/v0/calls/:callId/endCall", authenticated(auth, async (request, _reply, userId) => {
         const body = requestBody(request, ["reason"]);
-        const result = await repository.endCall({
+        const result = await callEnd(executor, {
             actorUserId: userId,
             callId: pathId(request, "callId"),
             reason: has(body, "reason")
@@ -788,35 +964,53 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
         await publishHints(request, pubsub, [result.hint], {
             userIds: result.call.participants.map((participant) => participant.userId),
         });
-        return { call: result.call, sync: result.hint };
+        return {
+            call: result.call,
+            sync: result.hint,
+        };
     }));
     app.get("/v0/customEmoji", authenticated(auth, async (request) => {
         emptyQuery(request);
-        return { emoji: await repository.listCustomEmoji() };
+        return {
+            emoji: await customEmojiList(executor),
+        };
     }));
     app.post("/v0/customEmoji/createCustomEmoji", authenticated(auth, async (request, reply, userId) => {
         const body = requestBody(request, ["name", "fileId"]);
-        const result = await repository.createCustomEmoji({
+        const result = await customEmojiCreate(executor, {
             actorUserId: userId,
             name: emojiName(body),
             fileId: idField(body, "fileId"),
         });
-        await publishHints(request, pubsub, [result.hint], { server: true });
-        return reply.code(201).send({ emoji: result.emoji, sync: result.hint });
+        await publishHints(request, pubsub, [result.hint], {
+            server: true,
+        });
+        return reply.code(201).send({
+            emoji: result.emoji,
+            sync: result.hint,
+        });
     }));
     app.post("/v0/customEmoji/:emojiId/deleteCustomEmoji", authenticated(auth, async (request, _reply, userId) => {
         emptyBody(request);
-        const result = await repository.deleteCustomEmoji(userId, pathId(request, "emojiId"));
-        await publishHints(request, pubsub, [result.hint], { server: true });
-        return { sync: result.hint };
+        const result = await customEmojiDelete(executor, userId, pathId(request, "emojiId"));
+        await publishHints(request, pubsub, [result.hint], {
+            server: true,
+        });
+        return {
+            sync: result.hint,
+        };
     }));
     app.get("/v0/server", authenticated(auth, async (request) => {
         emptyQuery(request);
-        return { server: await repository.getServerProfile() };
+        return {
+            server: await serverProfileGet(executor),
+        };
     }));
     app.get("/v0/admin/users", authenticated(auth, async (request, _reply, userId) => {
         emptyQuery(request);
-        return { users: await repository.listAdminUsers(userId) };
+        return {
+            users: await userAdministrationList(executor, userId),
+        };
     }));
     app.post("/v0/admin/users/:userId/updateUser", authenticated(auth, async (request, _reply, actorUserId) => {
         const body = requestBody(request, ["title", "role"]);
@@ -828,7 +1022,7 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
                 ? null
                 : (nullableTrimmedString(body, "title", 200) ?? null)
             : undefined;
-        const result = await repository.updateUserAdministration({
+        const result = await userAdministrationUpdate(executor, {
             actorUserId,
             userId: targetUserId,
             title,
@@ -838,12 +1032,15 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
             server: true,
             userIds: [targetUserId],
         });
-        return { user: result.user, sync: result.hint };
+        return {
+            user: result.user,
+            sync: result.hint,
+        };
     }));
     app.post("/v0/admin/users/:userId/banUser", authenticated(auth, async (request, _reply, actorUserId) => {
         emptyBody(request);
         const targetUserId = pathId(request, "userId");
-        const result = await repository.setUserBanned({
+        const result = await userSetBanned(executor, {
             actorUserId,
             userId: targetUserId,
             banned: true,
@@ -852,12 +1049,14 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
             server: true,
             userIds: [targetUserId],
         });
-        return { sync: result.hint };
+        return {
+            sync: result.hint,
+        };
     }));
     app.post("/v0/admin/users/:userId/unbanUser", authenticated(auth, async (request, _reply, actorUserId) => {
         emptyBody(request);
         const targetUserId = pathId(request, "userId");
-        const result = await repository.setUserBanned({
+        const result = await userSetBanned(executor, {
             actorUserId,
             userId: targetUserId,
             banned: false,
@@ -866,12 +1065,14 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
             server: true,
             userIds: [targetUserId],
         });
-        return { sync: result.hint };
+        return {
+            sync: result.hint,
+        };
     }));
     app.post("/v0/admin/users/:userId/deleteUser", authenticated(auth, async (request, _reply, actorUserId) => {
         emptyBody(request);
         const targetUserId = pathId(request, "userId");
-        const result = await repository.deleteUser({
+        const result = await userDelete(executor, {
             actorUserId,
             userId: targetUserId,
         });
@@ -879,7 +1080,9 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
             server: true,
             userIds: [targetUserId],
         });
-        return { sync: result.hint };
+        return {
+            sync: result.hint,
+        };
     }));
     app.post("/v0/admin/updateServer", authenticated(auth, async (request, _reply, actorUserId) => {
         const body = requestBody(request, [
@@ -891,7 +1094,7 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
         ]);
         if (Object.keys(body).length === 0)
             throw new InvalidRequest("At least one server field is required");
-        const result = await repository.updateServerProfile({
+        const result = await serverProfileUpdate(executor, {
             actorUserId,
             name: has(body, "name") ? trimmedString(body, "name", 100) : undefined,
             title: has(body, "title")
@@ -908,8 +1111,13 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
             ]),
             defaultRetentionSeconds: optionalNullablePositiveIntegerField(body, "defaultRetentionSeconds", MAX_SELF_DESTRUCT_SECONDS * 100),
         });
-        await publishHints(request, pubsub, [result.hint], { server: true });
-        return { server: result.server, sync: result.hint };
+        await publishHints(request, pubsub, [result.hint], {
+            server: true,
+        });
+        return {
+            server: result.server,
+            sync: result.hint,
+        };
     }));
     app.post("/v0/admin/sendAutomatedMessage", authenticated(auth, async (request, reply, actorUserId) => {
         const body = requestBody(request, [
@@ -920,7 +1128,7 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
             "clientMutationId",
         ]);
         const attachmentFileIds = optionalIdArrayField(body, "attachmentFileIds", MAX_ATTACHMENTS);
-        const result = await repository.sendAutomatedMessage({
+        const result = await messageSendAutomated(executor, {
             actorUserId,
             chatId: idField(body, "chatId"),
             text: messageText(body, attachmentFileIds?.length ?? 0),
@@ -929,23 +1137,34 @@ export function registerCollaborationRoutes(app, auth, repository, pubsub, agent
             clientMutationId: optionalTokenField(body, "clientMutationId"),
         });
         await publishHints(request, pubsub, [result.hint]);
-        return reply.code(201).send({ message: result.message, sync: result.hint });
+        return reply.code(201).send({
+            message: result.message,
+            sync: result.hint,
+        });
     }));
 }
 function authenticated(auth, handler) {
     return async (request, reply) => {
         const current = await auth.authenticate(request);
         if (!current)
-            return reply.code(401).send({ error: "unauthorized" });
+            return reply.code(401).send({
+                error: "unauthorized",
+            });
         try {
             return await handler(request, reply, current.user.id);
         }
         catch (error) {
             if (error instanceof InvalidRequest)
-                return reply.code(400).send({ error: "invalid_request", message: error.message });
+                return reply.code(400).send({
+                    error: "invalid_request",
+                    message: error.message,
+                });
             if (error instanceof CollaborationError) {
                 const status = collaborationStatus(error.code);
-                return reply.code(status).send({ error: error.code, message: error.message });
+                return reply.code(status).send({
+                    error: error.code,
+                    message: error.message,
+                });
             }
             throw error;
         }
@@ -968,7 +1187,10 @@ function collaborationStatus(code) {
 async function publishHints(request, pubsub, hints, audience = {}) {
     const publications = [];
     for (const hint of hints) {
-        const event = { type: "sync", ...hint };
+        const event = {
+            type: "sync",
+            ...hint,
+        };
         const topics = new Set();
         for (const chat of hint.chats)
             topics.add(realtimeTopics.chat(chat.chatId));
@@ -977,12 +1199,17 @@ async function publishHints(request, pubsub, hints, audience = {}) {
         if (audience.server || hint.areas.some((area) => area !== "preferences"))
             topics.add(realtimeTopics.server);
         for (const topic of topics)
-            publications.push({ topic, event });
+            publications.push({
+                topic,
+                event,
+            });
     }
     const results = await Promise.allSettled(publications.map(({ topic, event }) => pubsub.publish(topic, event)));
     for (const result of results) {
         if (result.status === "rejected")
-            request.log.warn({ err: result.reason }, "Could not publish realtime sync hint");
+            request.log.warn({
+                err: result.reason,
+            }, "Could not publish realtime sync hint");
     }
 }
 function requestBody(request, allowed) {
@@ -1163,14 +1390,18 @@ function reactionBody(request) {
     if (hasEmoji === hasCustom)
         throw new InvalidRequest("Exactly one of emoji or customEmojiId is required");
     if (hasCustom)
-        return { customEmojiId: id(body.customEmojiId, "customEmojiId") };
+        return {
+            customEmojiId: id(body.customEmojiId, "customEmojiId"),
+        };
     if (typeof body.emoji !== "string" ||
         body.emoji.length === 0 ||
         body.emoji.length > 32 ||
         body.emoji.trim() !== body.emoji ||
         hasControlCharacters(body.emoji))
         throw new InvalidRequest("emoji must be between 1 and 32 characters");
-    return { emoji: body.emoji };
+    return {
+        emoji: body.emoji,
+    };
 }
 function messagePage(request, allowed) {
     const query = requestQuery(request, allowed);