happy2 0.0.5 → 0.0.11

package/packages/happy2-server/dist/modules/operations/{repository.test.js → actions.test.js}

@@ -1,37 +1,67 @@
+import { userAccessList } from "../user/userAccessList.js";
+import { retentionRunStart } from "../retention/retentionRunStart.js";
+import { retentionRunFinish } from "../retention/retentionRunFinish.js";
+import { moderationReportUpdate } from "../moderation/moderationReportUpdate.js";
+import { moderationReportList } from "../moderation/moderationReportList.js";
+import { moderationReportCreate } from "../moderation/moderationReportCreate.js";
+import { moderationActionTake } from "../moderation/moderationActionTake.js";
+import { moderationActionRevoke } from "../moderation/moderationActionRevoke.js";
+import { dataExportUpdate } from "../data-export/dataExportUpdate.js";
+import { dataExportRequest } from "../data-export/dataExportRequest.js";
+import { backupUpdate } from "../backup/backupUpdate.js";
+import { backupCreate } from "../backup/backupCreate.js";
+import { auditLogList } from "../audit/auditLogList.js";
+import { accountBanRevoke } from "../moderation/accountBanRevoke.js";
+import { accountBanList } from "../moderation/accountBanList.js";
+import { accountBanExpireDue } from "../moderation/accountBanExpireDue.js";
+import { accountBanApply } from "../moderation/accountBanApply.js";
+import { userCreateProfile } from "../user/userCreateProfile.js";
+import { sessionFindActive } from "../auth/sessionFindActive.js";
+import { sessionCreate } from "../auth/sessionCreate.js";
+import { fileCreate } from "../file/fileCreate.js";
+import { accountCreatePassword } from "../auth/accountCreatePassword.js";
+import { createDatabase } from "../drizzle.js";
 import { createClient } from "@libsql/client";
+import { serverSchemaMigrate } from "../server/serverSchemaMigrate.js";
 import { createId } from "@paralleldrive/cuid2";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { Database } from "../database.js";
-import { OperationsRepository } from "./repository.js";
-describe("OperationsRepository", () => {
+describe("operations actions", () => {
     let directory;
-    let database;
+    let client;
+    let executor;
     let raw;
-    let repository;
     let admin;
     let member;
     beforeEach(async () => {
         directory = await mkdtemp(join(tmpdir(), "happy2-operations-"));
         const url = `file:${join(directory, "happy2.db")}`;
-        database = new Database(url);
-        await database.migrate();
-        raw = createClient({ url });
-        repository = new OperationsRepository(url);
-        admin = await createUser(database, "admin@example.com", "admin", "Ada");
-        member = await createUser(database, "member@example.com", "member", "Grace");
+        client = createClient({
+            url,
+        });
+        executor = createDatabase(client);
+        await serverSchemaMigrate(client);
+        raw = createClient({
+            url,
+        });
+        admin = await createUser(executor, "admin@example.com", "admin", "Ada");
+        member = await createUser(executor, "member@example.com", "member", "Grace");
     });
     afterEach(async () => {
-        repository.close();
         raw.close();
-        database.close();
-        await rm(directory, { recursive: true, force: true });
+        client.close();
+        await rm(directory, {
+            recursive: true,
+            force: true,
+        });
     });
     it("applies and revokes reasoned bans atomically with session revocation and audit telemetry", async () => {
-        const session = await database.createSession(member.account.id, new Date(Date.now() + 60_000), { ip: "203.0.113.9" });
-        const ban = await repository.applyBan({
+        const session = await sessionCreate(executor, member.account.id, new Date(Date.now() + 60_000), {
+            ip: "203.0.113.9",
+        });
+        const ban = await accountBanApply(executor, {
             actorUserId: admin.user.id,
             targetUserId: member.user.id,
             reason: "Repeated abuse",
@@ -50,24 +80,34 @@ describe("OperationsRepository", () => {
             reason: "Repeated abuse",
             status: "active",
         });
-        expect(await database.findActiveSession(session.id)).toBeUndefined();
-        await expect(database.createSession(member.account.id, new Date(Date.now() + 60_000), {})).rejects.toThrow("not allowed");
-        const audit = await repository.listAuditLog({ actorUserId: admin.user.id, limit: 20 });
+        expect(await sessionFindActive(executor, session.id)).toBeUndefined();
+        await expect(sessionCreate(executor, member.account.id, new Date(Date.now() + 60_000), {})).rejects.toThrow("not allowed");
+        const audit = await auditLogList(executor, {
+            actorUserId: admin.user.id,
+            limit: 20,
+        });
         expect(audit.items[0]).toMatchObject({
             action: "user.ban_applied",
             targetId: member.user.id,
             clientIp: "198.51.100.12",
             device: "Happy (2) Desktop",
         });
-        expect(audit.items[0]?.metadata).toMatchObject({ revokedSessionCount: 1 });
-        const revoked = await repository.revokeBan({
+        expect(audit.items[0]?.metadata).toMatchObject({
+            revokedSessionCount: 1,
+        });
+        const revoked = await accountBanRevoke(executor, {
             actorUserId: admin.user.id,
             targetUserId: member.user.id,
             reason: "Appeal accepted",
         });
-        expect(revoked).toMatchObject({ status: "revoked", revokeReason: "Appeal accepted" });
-        await expect(database.createSession(member.account.id, new Date(Date.now() + 60_000), {})).resolves.toMatchObject({ accountId: member.account.id });
-        const history = await repository.listBans({
+        expect(revoked).toMatchObject({
+            status: "revoked",
+            revokeReason: "Appeal accepted",
+        });
+        await expect(sessionCreate(executor, member.account.id, new Date(Date.now() + 60_000), {})).resolves.toMatchObject({
+            accountId: member.account.id,
+        });
+        const history = await accountBanList(executor, {
             actorUserId: admin.user.id,
             targetUserId: member.user.id,
             limit: 20,
@@ -75,7 +115,7 @@ describe("OperationsRepository", () => {
         expect(history.items).toHaveLength(1);
     });
     it("expires elapsed bans idempotently and records a system audit entry", async () => {
-        await repository.applyBan({
+        await accountBanApply(executor, {
             actorUserId: admin.user.id,
             targetUserId: member.user.id,
             expiresAt: new Date(Date.now() + 3_600_000).toISOString(),
@@ -88,57 +128,84 @@ describe("OperationsRepository", () => {
             sql: `UPDATE account_bans SET expires_at = ? WHERE account_id = ?`,
             args: [new Date(Date.now() - 1_000).toISOString(), member.account.id],
         });
-        await expect(repository.expireDueBans()).resolves.toBe(1);
-        await expect(repository.expireDueBans()).resolves.toBe(0);
-        await expect(database.createSession(member.account.id, new Date(Date.now() + 60_000), {})).resolves.toBeDefined();
-        const audit = await repository.listAuditLog({
+        await expect(accountBanExpireDue(executor)).resolves.toBe(1);
+        await expect(accountBanExpireDue(executor)).resolves.toBe(0);
+        await expect(sessionCreate(executor, member.account.id, new Date(Date.now() + 60_000), {})).resolves.toBeDefined();
+        const audit = await auditLogList(executor, {
             actorUserId: admin.user.id,
             action: "user.ban_expired",
             limit: 10,
         });
         expect(audit.items).toHaveLength(1);
-        expect(audit.items[0]).toMatchObject({ actorUserId: undefined, targetId: member.user.id });
+        expect(audit.items[0]).toMatchObject({
+            actorUserId: undefined,
+            targetId: member.user.id,
+        });
     });
     it("accepts privacy-checked reports and durably resolves them with moderation actions", async () => {
-        const report = await repository.createReport({
+        const report = await moderationReportCreate(executor, {
             actorUserId: member.user.id,
             targetUserId: admin.user.id,
             reason: "Inappropriate profile content",
             details: "Please review the title.",
         });
-        expect(report).toMatchObject({ status: "open", reportedByUserId: member.user.id });
-        await expect(repository.listReports({ actorUserId: member.user.id, limit: 20 })).rejects.toMatchObject({ code: "forbidden" });
-        const reviewing = await repository.updateReport({
+        expect(report).toMatchObject({
+            status: "open",
+            reportedByUserId: member.user.id,
+        });
+        await expect(moderationReportList(executor, {
+            actorUserId: member.user.id,
+            limit: 20,
+        })).rejects.toMatchObject({
+            code: "forbidden",
+        });
+        const reviewing = await moderationReportUpdate(executor, {
             actorUserId: admin.user.id,
             reportId: report.id,
             status: "reviewing",
             assignedToUserId: admin.user.id,
         });
-        expect(reviewing).toMatchObject({ status: "reviewing", assignedToUserId: admin.user.id });
-        const acted = await repository.takeModerationAction({
+        expect(reviewing).toMatchObject({
+            status: "reviewing",
+            assignedToUserId: admin.user.id,
+        });
+        const acted = await moderationActionTake(executor, {
             actorUserId: admin.user.id,
             reportId: report.id,
             action: "warn",
             reason: "Content policy reminder sent",
-            metadata: { template: "profile-content-v1" },
+            metadata: {
+                template: "profile-content-v1",
+            },
+        });
+        expect(acted.report).toMatchObject({
+            status: "resolved",
         });
-        expect(acted.report).toMatchObject({ status: "resolved" });
         expect(acted.action).toMatchObject({
             action: "warn",
-            metadata: { template: "profile-content-v1" },
+            metadata: {
+                template: "profile-content-v1",
+            },
+        });
+        expect(acted.sync).toMatchObject({
+            areas: ["notifications"],
         });
-        expect(acted.sync).toMatchObject({ areas: ["notifications"] });
         expect((await raw.execute({
             sql: `SELECT kind, user_id, sync_sequence FROM notifications
                            WHERE user_id = ? ORDER BY created_at`,
             args: [admin.user.id],
-        })).rows).toMatchObject([{ kind: "moderation", user_id: admin.user.id }]);
-        const restrictionReport = await repository.createReport({
+        })).rows).toMatchObject([
+            {
+                kind: "moderation",
+                user_id: admin.user.id,
+            },
+        ]);
+        const restrictionReport = await moderationReportCreate(executor, {
             actorUserId: admin.user.id,
             targetUserId: member.user.id,
             reason: "Repeated disruptive posting",
         });
-        const restriction = await repository.takeModerationAction({
+        const restriction = await moderationActionTake(executor, {
             actorUserId: admin.user.id,
             reportId: restrictionReport.id,
             action: "restrict",
@@ -149,22 +216,26 @@ describe("OperationsRepository", () => {
             action: "restrict",
             targetUserId: member.user.id,
         });
-        const revokedRestriction = await repository.revokeModerationAction({
+        const revokedRestriction = await moderationActionRevoke(executor, {
             actorUserId: admin.user.id,
             actionId: restriction.action.id,
             reason: "Review completed",
         });
         expect(revokedRestriction.action.revokedAt).toEqual(expect.any(String));
-        expect(revokedRestriction.sync).toMatchObject({ areas: ["notifications"] });
+        expect(revokedRestriction.sync).toMatchObject({
+            areas: ["notifications"],
+        });
         expect((await raw.execute({
             sql: `SELECT count(*) AS count FROM notifications WHERE user_id = ? AND kind = 'moderation'`,
             args: [member.user.id],
         })).rows[0]?.count).toBe(2);
-        await expect(repository.revokeModerationAction({
+        await expect(moderationActionRevoke(executor, {
             actorUserId: admin.user.id,
             actionId: restriction.action.id,
-        })).rejects.toMatchObject({ code: "conflict" });
-        const queue = await repository.listReports({
+        })).rejects.toMatchObject({
+            code: "conflict",
+        });
+        const queue = await moderationReportList(executor, {
             actorUserId: admin.user.id,
             status: "resolved",
             limit: 20,
@@ -211,13 +282,13 @@ describe("OperationsRepository", () => {
                 args: [chatId],
             },
         ]);
-        const messageReport = await repository.createReport({
+        const messageReport = await moderationReportCreate(executor, {
             actorUserId: admin.user.id,
             chatId,
             messageId: removedMessageId,
             reason: "Abusive message",
         });
-        const removedMessage = await repository.takeModerationAction({
+        const removedMessage = await moderationActionTake(executor, {
             actorUserId: admin.user.id,
             reportId: messageReport.id,
             action: "remove_message",
@@ -228,7 +299,12 @@ describe("OperationsRepository", () => {
             chatId,
             messageId: removedMessageId,
         });
-        expect(removedMessage.sync?.chats).toEqual([{ chatId, pts: "3" }]);
+        expect(removedMessage.sync?.chats).toEqual([
+            {
+                chatId,
+                pts: "3",
+            },
+        ]);
         const messageRow = (await raw.execute({
             sql: `SELECT text, content_json, deleted_at, deleted_by_user_id, delete_reason,
                              change_pts FROM messages WHERE id = ?`,
@@ -263,7 +339,7 @@ describe("OperationsRepository", () => {
             thumbhash: "",
             kind: "file",
         };
-        await database.createFile(file);
+        await fileCreate(executor, file);
         await raw.batch([
             {
                 sql: `INSERT INTO message_attachments (message_id, file_id, position)
@@ -277,21 +353,29 @@ describe("OperationsRepository", () => {
                 args: [createId(), file.id, chatId, admin.user.id],
             },
         ]);
-        const fileReport = await repository.createReport({
+        const fileReport = await moderationReportCreate(executor, {
             actorUserId: admin.user.id,
             chatId,
             fileId: file.id,
             reason: "Unsafe attachment",
         });
-        const removedFile = await repository.takeModerationAction({
+        const removedFile = await moderationActionTake(executor, {
             actorUserId: admin.user.id,
             reportId: fileReport.id,
             action: "remove_file",
             reason: "Quarantined by moderation",
         });
-        expect(removedFile.action).toMatchObject({ action: "remove_file", fileId: file.id });
+        expect(removedFile.action).toMatchObject({
+            action: "remove_file",
+            fileId: file.id,
+        });
         expect(removedFile.sync).toMatchObject({
-            chats: [{ chatId, pts: "4" }],
+            chats: [
+                {
+                    chatId,
+                    pts: "4",
+                },
+            ],
             areas: ["files"],
         });
         expect((await raw.execute({
@@ -311,112 +395,88 @@ describe("OperationsRepository", () => {
             args: [file.id],
         })).rows[0]?.count).toBe(0);
     });
-    it("recomputes thread projections when moderation removes a reply", async () => {
-        const chatId = await createChat(raw, admin.user.id, member.user.id, admin.user.id);
+    it("moderates a message in a child chat without mutating the parent timeline", async () => {
+        const parentChatId = await createChat(raw, admin.user.id, member.user.id, admin.user.id);
         const rootMessageId = createId();
-        const survivingReplyId = createId();
+        const childChatId = createId();
         const removedReplyId = createId();
         await raw.batch([
             {
                 sql: `INSERT INTO messages
                         (id, chat_id, sequence, change_pts, sender_user_id, text)
                       VALUES (?, ?, 1, 1, ?, 'thread root')`,
-                args: [rootMessageId, chatId, admin.user.id],
-            },
-            {
-                sql: `INSERT INTO messages
-                        (id, chat_id, sequence, change_pts, sender_user_id, text,
-                         thread_root_message_id)
-                      VALUES (?, ?, 2, 2, ?, 'surviving reply', ?)`,
-                args: [survivingReplyId, chatId, admin.user.id, rootMessageId],
+                args: [rootMessageId, parentChatId, admin.user.id],
             },
             {
-                sql: `INSERT INTO messages
-                        (id, chat_id, sequence, change_pts, sender_user_id, text,
-                         thread_root_message_id)
-                      VALUES (?, ?, 3, 3, ?, 'removed reply', ?)`,
-                args: [removedReplyId, chatId, member.user.id, rootMessageId],
-            },
-            {
-                sql: `INSERT INTO threads
-                        (root_message_id, chat_id, created_by_user_id, reply_count, last_pts,
-                         last_reply_message_id, last_reply_sequence, participant_count)
-                      VALUES (?, ?, ?, 2, 3, ?, 3, 2)`,
-                args: [rootMessageId, chatId, admin.user.id, removedReplyId],
+                sql: `INSERT INTO chats
+                        (id, kind, name, parent_message_id, created_by_user_id, owner_user_id,
+                         pts, last_message_sequence, last_change_sequence, is_listed)
+                      VALUES (?, 'private_channel', 'Moderated child', ?, ?, ?, 1, 1, 1, 0)`,
+                args: [childChatId, rootMessageId, admin.user.id, admin.user.id],
             },
             {
-                sql: `INSERT INTO thread_participants
-                        (thread_root_message_id, user_id, reply_count)
-                      VALUES (?, ?, 1), (?, ?, 1)`,
-                args: [rootMessageId, admin.user.id, rootMessageId, member.user.id],
+                sql: `INSERT INTO chat_members
+                        (chat_id, user_id, role, membership_epoch)
+                      VALUES (?, ?, 'owner', ?), (?, ?, 'member', ?)`,
+                args: [
+                    childChatId,
+                    admin.user.id,
+                    createId(),
+                    childChatId,
+                    member.user.id,
+                    createId(),
+                ],
             },
             {
-                sql: `INSERT INTO thread_user_states
-                        (thread_root_message_id, user_id, last_read_sequence, unread_count,
-                         mention_count)
-                      VALUES (?, ?, 0, 1, 1), (?, ?, 0, 1, 0)`,
-                args: [rootMessageId, admin.user.id, rootMessageId, member.user.id],
-            },
-            {
-                sql: `INSERT INTO message_mentions
-                        (id, message_id, kind, mentioned_user_id, start_offset, length, raw_text)
-                      VALUES (?, ?, 'user', ?, 0, 6, '@admin')`,
-                args: [createId(), removedReplyId, admin.user.id],
+                sql: `INSERT INTO messages
+                        (id, chat_id, sequence, change_pts, sender_user_id, text)
+                      VALUES (?, ?, 1, 1, ?, 'removed child reply')`,
+                args: [removedReplyId, childChatId, member.user.id],
             },
             {
-                sql: `UPDATE chats SET pts = 3, last_message_sequence = 3,
-                             last_change_sequence = 3 WHERE id = ?`,
-                args: [chatId],
+                sql: `UPDATE chats SET pts = 1, last_message_sequence = 1,
+                             last_change_sequence = 1 WHERE id = ?`,
+                args: [parentChatId],
             },
         ]);
-        const report = await repository.createReport({
+        const report = await moderationReportCreate(executor, {
             actorUserId: admin.user.id,
-            chatId,
+            chatId: childChatId,
             messageId: removedReplyId,
-            reason: "Thread reply violates policy",
+            reason: "Child-chat reply violates policy",
         });
-        const removed = await repository.takeModerationAction({
+        const removed = await moderationActionTake(executor, {
             actorUserId: admin.user.id,
             reportId: report.id,
             action: "remove_message",
         });
-        expect(removed.sync?.chats).toEqual([{ chatId, pts: "4" }]);
+        expect(removed.sync?.chats).toEqual([
+            {
+                chatId: childChatId,
+                pts: "2",
+            },
+        ]);
         expect((await raw.execute({
-            sql: `SELECT reply_count, participant_count, last_reply_message_id,
-                                 last_reply_sequence, last_pts
-                            FROM threads WHERE root_message_id = ?`,
-            args: [rootMessageId],
+            sql: `SELECT deleted_at, change_pts FROM messages WHERE id = ?`,
+            args: [removedReplyId],
         })).rows[0]).toMatchObject({
-            reply_count: 1,
-            participant_count: 1,
-            last_reply_message_id: survivingReplyId,
-            last_reply_sequence: 2,
-            last_pts: 4,
+            deleted_at: expect.any(String),
+            change_pts: 2,
         });
-        expect((await raw.execute({
-            sql: `SELECT user_id, reply_count FROM thread_participants
-                           WHERE thread_root_message_id = ?`,
-            args: [rootMessageId],
-        })).rows).toEqual([{ user_id: admin.user.id, reply_count: 1 }]);
-        expect((await raw.execute({
-            sql: `SELECT unread_count, mention_count FROM thread_user_states
-                           WHERE thread_root_message_id = ? AND user_id = ?`,
-            args: [rootMessageId, admin.user.id],
-        })).rows[0]).toMatchObject({ unread_count: 0, mention_count: 0 });
         expect((await raw.execute({
             sql: `SELECT change_pts FROM messages WHERE id = ?`,
             args: [rootMessageId],
-        })).rows[0]?.change_pts).toBe(4);
+        })).rows[0]?.change_pts).toBe(1);
     });
     it("deletes users by revoking sessions, anonymizing identity, and transferring ownership", async () => {
         const chatId = await createChat(raw, admin.user.id, member.user.id, member.user.id);
-        const session = await database.createSession(member.account.id, new Date(Date.now() + 60_000), {});
-        const report = await repository.createReport({
+        const session = await sessionCreate(executor, member.account.id, new Date(Date.now() + 60_000), {});
+        const report = await moderationReportCreate(executor, {
             actorUserId: admin.user.id,
             targetUserId: member.user.id,
             reason: "Account removal required",
         });
-        const deleted = await repository.takeModerationAction({
+        const deleted = await moderationActionTake(executor, {
             actorUserId: admin.user.id,
             reportId: report.id,
             action: "delete_user",
@@ -427,10 +487,15 @@ describe("OperationsRepository", () => {
             targetUserId: member.user.id,
         });
         expect(deleted.sync).toMatchObject({
-            chats: [{ chatId, pts: "1" }],
+            chats: expect.arrayContaining([
+                {
+                    chatId,
+                    pts: "1",
+                },
+            ]),
             areas: ["users"],
         });
-        expect(await database.findActiveSession(session.id)).toBeUndefined();
+        expect(await sessionFindActive(executor, session.id)).toBeUndefined();
         expect((await raw.execute({
             sql: `SELECT active, deleted_at, password_hash, email FROM accounts WHERE id = ?`,
             args: [member.account.id],
@@ -455,20 +520,25 @@ describe("OperationsRepository", () => {
                               ON cm.chat_id = c.id AND cm.user_id = ?
                            WHERE c.id = ?`,
             args: [admin.user.id, chatId],
-        })).rows[0]).toMatchObject({ owner_user_id: admin.user.id, role: "owner" });
+        })).rows[0]).toMatchObject({
+            owner_user_id: admin.user.id,
+            role: "owner",
+        });
     });
     it("manages safe export artifacts, backup records, retention runs, and paged audit history", async () => {
-        const requested = await repository.requestDataExport({
+        const requested = await dataExportRequest(executor, {
             actorUserId: member.user.id,
             kind: "user_data",
-            options: { includeFiles: true },
+            options: {
+                includeFiles: true,
+            },
         });
         expect(requested).toMatchObject({
             kind: "user_data",
             targetId: member.user.id,
             status: "pending",
         });
-        await repository.updateDataExport({
+        await dataExportUpdate(executor, {
             actorUserId: admin.user.id,
             jobId: requested.id,
             status: "running",
@@ -487,15 +557,18 @@ describe("OperationsRepository", () => {
             kind: "file",
             originalName: "happy2-export.zip",
         };
-        await database.createFile(output);
-        const complete = await repository.updateDataExport({
+        await fileCreate(executor, output);
+        const complete = await dataExportUpdate(executor, {
             actorUserId: admin.user.id,
             jobId: requested.id,
             status: "complete",
             outputFileId: output.id,
             expiresAt: new Date(Date.now() + 86_400_000).toISOString(),
         });
-        expect(complete).toMatchObject({ status: "complete", outputFileId: output.id });
+        expect(complete).toMatchObject({
+            status: "complete",
+            outputFileId: output.id,
+        });
         expect(complete).not.toHaveProperty("storageKey");
         const artifactGrant = await raw.execute({
             sql: `SELECT principal_id, expires_at FROM file_access_grants
@@ -504,42 +577,56 @@ describe("OperationsRepository", () => {
         });
         expect(artifactGrant.rows[0]?.principal_id).toBe(member.user.id);
         expect(artifactGrant.rows[0]?.expires_at).toBe(complete.expiresAt);
-        const backup = await repository.createBackup({
+        const backup = await backupCreate(executor, {
             actorUserId: admin.user.id,
             storageProvider: "local",
             storageKey: "backups/server-2026-07-12.db",
-            metadata: { encrypted: true },
+            metadata: {
+                encrypted: true,
+            },
         });
-        await repository.updateBackup({
+        await backupUpdate(executor, {
             actorUserId: admin.user.id,
             backupId: backup.id,
             status: "running",
         });
-        const completedBackup = await repository.updateBackup({
+        const completedBackup = await backupUpdate(executor, {
             actorUserId: admin.user.id,
             backupId: backup.id,
             status: "complete",
             checksumSha256: "a".repeat(64),
             size: 1_024,
         });
-        expect(completedBackup).toMatchObject({ status: "complete", size: 1_024 });
-        const run = await repository.startRetentionRun({
+        expect(completedBackup).toMatchObject({
+            status: "complete",
+            size: 1_024,
+        });
+        const run = await retentionRunStart(executor, {
             actorUserId: admin.user.id,
             scope: "audit",
-            details: { cutoffDays: 365 },
+            details: {
+                cutoffDays: 365,
+            },
         });
-        const finished = await repository.finishRetentionRun({
+        const finished = await retentionRunFinish(executor, {
             actorUserId: admin.user.id,
             runId: run.id,
             status: "complete",
             itemsExamined: 80,
             itemsDeleted: 12,
         });
-        expect(finished).toMatchObject({ status: "complete", itemsExamined: 80, itemsDeleted: 12 });
-        const firstPage = await repository.listAuditLog({ actorUserId: admin.user.id, limit: 2 });
+        expect(finished).toMatchObject({
+            status: "complete",
+            itemsExamined: 80,
+            itemsDeleted: 12,
+        });
+        const firstPage = await auditLogList(executor, {
+            actorUserId: admin.user.id,
+            limit: 2,
+        });
         expect(firstPage.items).toHaveLength(2);
         expect(firstPage.nextCursor).toEqual(expect.any(String));
-        const secondPage = await repository.listAuditLog({
+        const secondPage = await auditLogList(executor, {
             actorUserId: admin.user.id,
             before: firstPage.nextCursor,
             limit: 2,
@@ -548,14 +635,19 @@ describe("OperationsRepository", () => {
         expect(secondPage.items.map((item) => item.id)).not.toEqual(firstPage.items.map((item) => item.id));
     });
     it("keeps access telemetry admin-only", async () => {
-        await database.createSession(member.account.id, new Date(Date.now() + 60_000), {
+        await sessionCreate(executor, member.account.id, new Date(Date.now() + 60_000), {
             ip: "192.0.2.44",
             device: "MacBookPro",
             appVersion: "4.0.0",
             userAgent: "happy2/4.0.0",
         });
-        await expect(repository.listUserAccess({ actorUserId: member.user.id, limit: 20 })).rejects.toMatchObject({ code: "forbidden" });
-        const telemetry = await repository.listUserAccess({
+        await expect(userAccessList(executor, {
+            actorUserId: member.user.id,
+            limit: 20,
+        })).rejects.toMatchObject({
+            code: "forbidden",
+        });
+        const telemetry = await userAccessList(executor, {
             actorUserId: admin.user.id,
             limit: 20,
         });
@@ -565,12 +657,12 @@ describe("OperationsRepository", () => {
             lastClientIp: "192.0.2.44",
             lastDevice: "MacBookPro",
         });
-        const firstPage = await repository.listUserAccess({
+        const firstPage = await userAccessList(executor, {
             actorUserId: admin.user.id,
             limit: 1,
         });
         expect(firstPage.nextCursor).toEqual(expect.any(String));
-        const secondPage = await repository.listUserAccess({
+        const secondPage = await userAccessList(executor, {
             actorUserId: admin.user.id,
             before: firstPage.nextCursor,
             limit: 1,
@@ -578,11 +670,15 @@ describe("OperationsRepository", () => {
         expect(secondPage.items).toHaveLength(1);
         expect(secondPage.items[0]?.userId).not.toBe(firstPage.items[0]?.userId);
     });
-    it("does not close a shared extension client", async () => {
-        const sharedRepository = new OperationsRepository(raw);
-        sharedRepository.close();
+    it("does not own or close the executor's shared client", async () => {
+        const sharedExecutor = createDatabase(raw);
+        await auditLogList(sharedExecutor, { actorUserId: admin.user.id, limit: 1 });
         await expect(raw.execute("SELECT 1 AS alive")).resolves.toMatchObject({
-            rows: [{ alive: 1 }],
+            rows: [
+                {
+                    alive: 1,
+                },
+            ],
         });
     });
 });
@@ -602,9 +698,18 @@ async function createChat(client, adminUserId, memberUserId, ownerUserId) {
         });
     return chatId;
 }
-async function createUser(database, email, username, firstName) {
-    const account = await database.createPasswordAccount(email, "not-used-in-this-test");
-    const user = await database.createProfile(account.id, { firstName, username, email });
-    return { account, user };
+async function createUser(executor, email, username, firstName) {
+    const account = await accountCreatePassword(executor, email, "not-used-in-this-test");
+    const user = await userCreateProfile(executor, account.id, {
+        firstName,
+        username,
+        email,
+    }, {
+        provisioned: true,
+    });
+    return {
+        account,
+        user,
+    };
 }
-//# sourceMappingURL=repository.test.js.map
+//# sourceMappingURL=actions.test.js.map