A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
test(api): exercise user content through real routes
Hampusf68d0f552e42
diff --git a/fluxer_api/src/api/user/services/UserContentService.test.ts b/fluxer_api/src/api/user/services/UserContentService.test.tsindex ca332edfa..3a2677e37 100644--- a/fluxer_api/src/api/user/services/UserContentService.test.ts+++ b/fluxer_api/src/api/user/services/UserContentService.test.ts@@ -1,762 +1,338 @@// SPDX-License-Identifier: AGPL-3.0-or-later-import type {ApiContext} from '@app/api/ApiContext';-import type {ChannelID, GuildID, MessageID, UserID} from '@app/api/BrandedTypes';+import assert from 'node:assert/strict';+import {createTestAccount, type TestAccount} from '@app/api/auth/tests/AuthTestUtils';import {createChannelID, createGuildID, createMessageID, createUserID} from '@app/api/BrandedTypes';-import type {ChannelRepository} from '@app/api/channel/ChannelRepository';-import type {ChannelService} from '@app/api/channel/services/ChannelService';-import {SYSTEM_THREAD_VIEWER} from '@app/api/experiment/ChannelThreadsGate';-import type {KVBulkMessageDeletionQueueService} from '@app/api/infrastructure/KVBulkMessageDeletionQueueService';-import type {UserCacheService} from '@app/api/infrastructure/UserCacheService';-import type {LimitConfigService} from '@app/api/limits/LimitConfigService';-import type {RequestCache} from '@app/api/middleware/RequestCacheMiddleware';-import type {Channel} from '@app/api/models/Channel';-import {Message} from '@app/api/models/Message';-import {UserContentService} from '@app/api/user/services/UserContentService';-import {APIErrorCodes} from '@fluxer/constants/src/ApiErrorCodes';-import {ChannelTypes, MessageTypes} from '@fluxer/constants/src/ChannelConstants';+import {resetApiServicesForTesting} from '@app/api/CreateApiContext';+import {ChannelRepository} from '@app/api/channel/ChannelRepository';+import {+ createChannel,+ createDmChannel,+ createFriendship,+ createPermissionOverwrite,+ setupTestGuildWithMembers,+} from '@app/api/channel/tests/ChannelTestUtils';+import {threadsRequest} from '@app/api/channel/tests/ThreadTestUtils';+import type {MessageRow} from '@app/api/database/types/MessageTypes';+import {setInjectedGatewayService} from '@app/api/middleware/ServiceRegistry';+import {type ApiTestHarness, createApiTestHarness} from '@app/api/test/ApiTestHarness';+import {NoopGatewayService} from '@app/api/test/NoopGatewayService';+import {UserRepository} from '@app/api/user/repositories/UserRepository';+import {ChannelTypes, MessageReferenceTypes, MessageTypes, Permissions} from '@fluxer/constants/src/ChannelConstants';+import {HttpStatus} from '@fluxer/constants/src/HttpConstants';import {ServerMessageFlags} from '@fluxer/constants/src/ThreadConstants';-import {UnknownChannelError} from '@fluxer/errors/src/domains/channel/UnknownChannelError';-import {BadGatewayError} from '@fluxer/errors/src/domains/core/BadGatewayError';-import {MaxBookmarksError} from '@fluxer/errors/src/domains/core/MaxBookmarksError';-import {MissingPermissionsError} from '@fluxer/errors/src/domains/core/MissingPermissionsError';-import {UnknownGuildError} from '@fluxer/errors/src/domains/guild/UnknownGuildError';-import type {LimitConfigSnapshot} from '@fluxer/limits/src/LimitTypes';+import type {ThreadChannelResponse} from '@fluxer/schema/src/domains/channel/ThreadRequestSchemas';+import type {MessageRequestSchemaType} from '@fluxer/schema/src/domains/message/MessageRequestSchemas';import type {MessageResponse} from '@fluxer/schema/src/domains/message/MessageResponseSchemas';-import {describe, expect, it, vi} from 'vitest';+import type {SavedMessageEntryListResponse} from '@fluxer/schema/src/domains/user/UserResponseSchemas';+import {afterEach, beforeEach, describe, expect, it} from 'vitest';-const VIEWER_ID = createUserID(7n);+type PresenceDispatch = Parameters<NoopGatewayService['dispatchPresence']>[0];-interface ChannelBatchCall {- channelId: string;- messageIds: Array<string>;-}+class RecordingGateway extends NoopGatewayService {+ readonly dispatches: Array<PresenceDispatch> = [];-function makeMessage(channelId: ChannelID, messageId: MessageID): Message {- return new Message({- channel_id: channelId,- bucket: 0,- message_id: messageId,- author_id: createUserID(3n),- type: MessageTypes.DEFAULT,- webhook_id: null,- webhook_name: null,- webhook_avatar_hash: null,- content: '',- edited_timestamp: null,- pinned_timestamp: null,- flags: 0,- mention_everyone: false,- mention_users: null,- mention_roles: null,- mention_channels: null,- attachments: null,- embeds: null,- sticker_items: null,- message_reference: null,- message_snapshots: null,- call: null,- has_reaction: null,- version: 1,- });-}+ override async dispatchPresence(params: PresenceDispatch): Promise<void> {+ this.dispatches.push(params);+ }-function createUserContentService({- entries,- readable,- stored,- failures = new Map<string, Error>(),- channels = [],-}: {- entries: Array<{channelId: ChannelID; messageId: MessageID}>;- readable: Array<{channelId: ChannelID; messageId: MessageID}>;- stored?: Array<{channelId: ChannelID; messageId: MessageID}>;- failures?: Map<string, Error>;- channels?: Array<{id: ChannelID; type: number; guildId: GuildID | null}>;-}) {- const batchCalls: Array<ChannelBatchCall> = [];- const deletedSavedMessageIds: Array<string> = [];- const savedMessageListCalls: Array<{limit?: number; before?: MessageID}> = [];- const recentMentionListCalls: Array<{limit: number; before?: MessageID}> = [];- const readableByChannel = new Map<string, Map<string, Message>>();- for (const entry of readable) {- const key = entry.channelId.toString();- const messages = readableByChannel.get(key) ?? new Map<string, Message>();- messages.set(entry.messageId.toString(), makeMessage(entry.channelId, entry.messageId));- readableByChannel.set(key, messages);+ savedPayloads(): Array<unknown> {+ return this.dispatches.filter((entry) => entry.event === 'SAVED_MESSAGE_CREATE').map((entry) => entry.data);}- const userRepository = {- listRecentMentions: async (- _userId: UserID,- _everyone: boolean,- _roles: boolean,- _guilds: boolean,- limit: number,- before?: MessageID,- ) => {- recentMentionListCalls.push({limit, before});- return entries.filter((entry) => before === undefined || entry.messageId < before).slice(0, limit);- },- listSavedMessages: async (_userId: UserID, limit?: number, before?: MessageID) => {- savedMessageListCalls.push({limit, before});- return entries.filter((entry) => before === undefined || entry.messageId < before).slice(0, limit);- },- deleteSavedMessage: async (_userId: UserID, messageId: MessageID) => {- deletedSavedMessageIds.push(messageId.toString());- },- };- const channelService = {- messages: {- retrieval: {- getMessagesByIds: async ({channelId, messageIds}: {channelId: ChannelID; messageIds: Array<MessageID>}) => {- batchCalls.push({- channelId: channelId.toString(),- messageIds: messageIds.map((messageId) => messageId.toString()),- });- const failure = failures.get(channelId.toString());- if (failure) throw failure;- return readableByChannel.get(channelId.toString()) ?? new Map<string, Message>();- },- },- },- };- const storedKeys = new Set(- (stored ?? readable).map((entry) => `${entry.channelId.toString()}:${entry.messageId.toString()}`),- );- const channelRepository = {- channelData: {- listChannels: async (channelIds: Array<ChannelID>) =>- channels.filter((channel) => channelIds.some((channelId) => channelId === channel.id)),- },- messages: {- getMessage: async (channelId: ChannelID, messageId: MessageID) =>- storedKeys.has(`${channelId.toString()}:${messageId.toString()}`) ? makeMessage(channelId, messageId) : null,- },- };- const service = new UserContentService(- {services: {users: userRepository, gateway: {}, worker: {}, snowflake: {}}} as unknown as ApiContext,- channelService as unknown as ChannelService,- channelRepository as unknown as ChannelRepository,- {} as unknown as KVBulkMessageDeletionQueueService,- {} as unknown as LimitConfigService,- );- return {service, batchCalls, deletedSavedMessageIds, savedMessageListCalls, recentMentionListCalls};}-const CHANNEL_A = createChannelID(100n);-const CHANNEL_B = createChannelID(200n);-const CHANNEL_C = createChannelID(300n);--describe('getRecentMentions', () => {- it('authenticates each distinct channel once no matter how many mentions it holds', async () => {- const entries = [- {channelId: CHANNEL_A, messageId: createMessageID(11n)},- {channelId: CHANNEL_B, messageId: createMessageID(12n)},- {channelId: CHANNEL_A, messageId: createMessageID(13n)},- {channelId: CHANNEL_A, messageId: createMessageID(14n)},- ];- const {service, batchCalls} = createUserContentService({entries, readable: entries});-- const messages = await service.getRecentMentions({- viewer: SYSTEM_THREAD_VIEWER,- userId: VIEWER_ID,- limit: 50,- everyone: true,- roles: true,- guilds: true,- });-- expect(messages.map((message) => message.id.toString())).toEqual(['14', '13', '12', '11']);- expect(batchCalls).toEqual([- {channelId: '100', messageIds: ['11', '13', '14']},- {channelId: '200', messageIds: ['12']},- ]);+describe('user content routes', () => {+ let harness: ApiTestHarness;+ let gateway: RecordingGateway;+ let users: UserRepository;+ let channels: ChannelRepository;++ beforeEach(async () => {+ harness = await createApiTestHarness();+ gateway = new RecordingGateway();+ setInjectedGatewayService(gateway);+ resetApiServicesForTesting();+ users = new UserRepository();+ channels = new ChannelRepository();});- it('drops only the mentions from the channels the viewer can no longer reach', async () => {- const entries = [- {channelId: CHANNEL_A, messageId: createMessageID(11n)},- {channelId: CHANNEL_B, messageId: createMessageID(12n)},- {channelId: CHANNEL_C, messageId: createMessageID(13n)},- {channelId: CHANNEL_B, messageId: createMessageID(14n)},- ];- const {service} = createUserContentService({- entries,- readable: [entries[0], entries[2]],- failures: new Map<string, Error>([- [CHANNEL_B.toString(), new MissingPermissionsError()],- [CHANNEL_C.toString(), new UnknownChannelError()],- ]),- });-- const messages = await service.getRecentMentions({- viewer: SYSTEM_THREAD_VIEWER,- userId: VIEWER_ID,- limit: 50,- everyone: true,- roles: true,- guilds: true,- });-- expect(messages.map((message) => message.id.toString())).toEqual(['11']);+ afterEach(async () => {+ await harness.shutdown();});- it('drops a mention whose message the batch read did not return', async () => {- const entries = [- {channelId: CHANNEL_A, messageId: createMessageID(11n)},- {channelId: CHANNEL_A, messageId: createMessageID(12n)},- ];- const {service} = createUserContentService({entries, readable: [entries[1]]});-- const messages = await service.getRecentMentions({- viewer: SYSTEM_THREAD_VIEWER,- userId: VIEWER_ID,- limit: 50,- everyone: true,- roles: true,- guilds: true,- });+ async function world() {+ const {owner, members, guild, systemChannel} = await setupTestGuildWithMembers(harness, 1);+ const [member] = members;+ assert(member, 'Expected a guild member');+ const other = await createChannel(harness, owner.token, guild.id, 'other');+ return {owner, member, guild, channel: systemChannel, other};+ }- expect(messages.map((message) => message.id.toString())).toEqual(['12']);- });+ async function send(account: TestAccount, channelId: string, body: MessageRequestSchemaType = {}) {+ return threadsRequest<MessageResponse>(harness, account.token)+ .post(`/channels/${channelId}/messages`)+ .body({content: 'Stored message', ...body})+ .expect(HttpStatus.OK)+ .execute();+ }- describe('thread channels', () => {- const GUILD = createGuildID(900n);- const THREAD = createChannelID(400n);- const viewer = {kind: 'user', userId: VIEWER_ID, bot: false, capable: false} as const;+ async function thread(account: TestAccount, channelId: string, messageId?: string) {+ const path = `/channels/${channelId}${messageId ? `/messages/${messageId}` : ''}/threads`;+ return threadsRequest<ThreadChannelResponse>(harness, account.token)+ .post(path)+ .body({name: 'Saved thread', type: ChannelTypes.PUBLIC_THREAD})+ .expect(HttpStatus.CREATED)+ .execute();+ }- const entries = [- {channelId: THREAD, messageId: createMessageID(15n)},- {channelId: THREAD, messageId: createMessageID(14n)},- {channelId: CHANNEL_A, messageId: createMessageID(13n)},- {channelId: CHANNEL_B, messageId: createMessageID(12n)},- {channelId: CHANNEL_A, messageId: createMessageID(11n)},- {channelId: CHANNEL_A, messageId: createMessageID(10n)},- ];+ async function mentionRows(account: TestAccount, guildId: string, messages: Array<MessageResponse>) {+ await users.createRecentMentions(+ messages.map((message) => ({+ user_id: createUserID(BigInt(account.userId)),+ channel_id: createChannelID(BigInt(message.channel_id)),+ message_id: createMessageID(BigInt(message.id)),+ guild_id: createGuildID(BigInt(guildId)),+ is_everyone: false,+ is_role: false,+ })),+ );+ }- function build() {- return createUserContentService({- entries,- readable: entries.filter((entry) => entry.channelId === CHANNEL_A),- failures: new Map<string, Error>([- [THREAD.toString(), new UnknownChannelError()],- [CHANNEL_B.toString(), new UnknownChannelError()],- ]),- channels: [- {id: THREAD, type: ChannelTypes.PUBLIC_THREAD, guildId: GUILD},- {id: CHANNEL_B, type: ChannelTypes.GUILD_TEXT, guildId: GUILD},- ],- });+ async function savedRows(account: TestAccount, messages: Array<{id: string; channel_id: string}>) {+ for (const message of messages) {+ await users.createSavedMessage(+ createUserID(BigInt(account.userId)),+ createChannelID(BigInt(message.channel_id)),+ createMessageID(BigInt(message.id)),+ );}+ }- it('refills the page when the newest mentions sit in threads a non-viewer cannot see', async () => {- const {service, recentMentionListCalls} = build();+ function save(account: TestAccount, message: MessageResponse) {+ return threadsRequest(harness, account.token)+ .post('/users/@me/saved-messages')+ .body({channel_id: message.channel_id, message_id: message.id});+ }- const messages = await service.getRecentMentions({- viewer,- userId: VIEWER_ID,- limit: 4,- everyone: true,- roles: true,- guilds: true,- });+ function listPath(path: string, options: {limit?: number}) {+ const query = new URLSearchParams();+ if (options.limit !== undefined) {+ query.set('limit', String(options.limit));+ }+ return `${path}?${query.toString()}`;+ }- expect(messages.map((message) => message.id.toString())).toEqual(['13', '11', '10']);- expect(recentMentionListCalls).toEqual([- {limit: 4, before: undefined},- {limit: 2, before: createMessageID(12n)},- ]);- });+ async function mentions(account: TestAccount, options: {limit?: number; capable?: boolean} = {}) {+ return threadsRequest<Array<MessageResponse>>(harness, account.token, options)+ .get(listPath('/users/@me/mentions', options))+ .expect(HttpStatus.OK)+ .execute();+ }- it('stops refilling after a bounded number of pages of hidden mentions', async () => {- const hiddenEntries = Array.from({length: 50}, (_, index) => ({- channelId: THREAD,- messageId: createMessageID(BigInt(100 - index)),- }));- const {service, recentMentionListCalls} = createUserContentService({- entries: hiddenEntries,- readable: [],- failures: new Map<string, Error>([[THREAD.toString(), new UnknownChannelError()]]),- channels: [{id: THREAD, type: ChannelTypes.PUBLIC_THREAD, guildId: GUILD}],- });+ async function saved(account: TestAccount, options: {limit?: number; capable?: boolean} = {}) {+ return threadsRequest<SavedMessageEntryListResponse>(harness, account.token, options)+ .get(listPath('/users/@me/saved-messages', options))+ .expect(HttpStatus.OK)+ .execute();+ }- const messages = await service.getRecentMentions({- viewer,- userId: VIEWER_ID,- limit: 4,- everyone: true,- roles: true,- guilds: true,- });+ async function storedSavedIds(account: TestAccount) {+ return (await users.listSavedMessages(createUserID(BigInt(account.userId)))).map((entry) =>+ String(entry.messageId),+ );+ }- expect(messages).toEqual([]);- expect(recentMentionListCalls).toHaveLength(4);+ async function deny(+ account: TestAccount,+ channelId: string,+ member: TestAccount,+ permission = Permissions.VIEW_CHANNEL,+ ) {+ await createPermissionOverwrite(harness, account.token, channelId, member.userId, {+ type: 1,+ allow: '0',+ deny: permission.toString(),});- });+ }- it('still lets an unexpected channel failure surface', async () => {- const entries = [{channelId: CHANNEL_A, messageId: createMessageID(11n)}];- const {service} = createUserContentService({- entries,- readable: [],- failures: new Map<string, Error>([[CHANNEL_A.toString(), new Error('database is on fire')]]),- });+ async function updateStoredMessage(+ message: MessageResponse,+ patch: Partial<Pick<MessageRow, 'flags' | 'type' | 'message_reference'>>,+ ) {+ const stored = await channels.messages.getMessage(+ createChannelID(BigInt(message.channel_id)),+ createMessageID(BigInt(message.id)),+ );+ assert(stored, 'Expected a stored message');+ await channels.messages.upsertMessage({...stored.toRow(), ...patch}, stored.toRow());+ }- await expect(- service.getRecentMentions({- viewer: SYSTEM_THREAD_VIEWER,- userId: VIEWER_ID,- limit: 50,- everyone: true,- roles: true,- guilds: true,- }),- ).rejects.toThrow('database is on fire');+ it('omits mentions from denied and deleted channels while retaining accessible mentions', async () => {+ const w = await world();+ const gone = await createChannel(harness, w.owner.token, w.guild.id, 'removed');+ const visible = await send(w.owner, w.channel.id);+ const denied = await send(w.owner, w.other.id);+ const deleted = await send(w.owner, gone.id);+ await deny(w.owner, w.other.id, w.member);+ await threadsRequest(harness, w.owner.token).delete(`/channels/${gone.id}`).expect(HttpStatus.NO_CONTENT).execute();+ await mentionRows(w.member, w.guild.id, [visible, denied, deleted]);+ expect((await mentions(w.member)).map((message) => message.id)).toEqual([visible.id]);});-});--describe('getSavedMessages', () => {- it('passes the page cursor to the repository', async () => {- const entries = [{channelId: CHANNEL_A, messageId: createMessageID(11n)}];- const {service, savedMessageListCalls} = createUserContentService({entries, readable: entries});- await service.getSavedMessages({- viewer: SYSTEM_THREAD_VIEWER,- userId: VIEWER_ID,- limit: 50,- before: createMessageID(20n),- });-- expect(savedMessageListCalls).toEqual([{limit: 50, before: createMessageID(20n)}]);+ it('refills hidden thread mentions without replacing ordinary denied mentions', async () => {+ const w = await world();+ const t = await thread(w.owner, w.channel.id);+ const first = await send(w.owner, w.channel.id);+ const second = await send(w.owner, w.channel.id);+ const denied = await send(w.owner, w.other.id);+ const third = await send(w.owner, w.channel.id);+ const hidden1 = await send(w.owner, t.id);+ const hidden2 = await send(w.owner, t.id);+ await deny(w.owner, w.other.id, w.member);+ await mentionRows(w.member, w.guild.id, [first, second, denied, third, hidden1, hidden2]);+ expect((await mentions(w.member, {limit: 4, capable: false})).map((message) => message.id)).toEqual([+ third.id,+ second.id,+ first.id,+ ]);});- it('marks every entry of an unreachable channel as missing permissions without deleting it', async () => {- const entries = [- {channelId: CHANNEL_A, messageId: createMessageID(11n)},- {channelId: CHANNEL_B, messageId: createMessageID(12n)},- {channelId: CHANNEL_B, messageId: createMessageID(13n)},- ];- const {service, batchCalls, deletedSavedMessageIds} = createUserContentService({- entries,- readable: [entries[0]],- failures: new Map<string, Error>([[CHANNEL_B.toString(), new UnknownGuildError()]]),- });-- const saved = await service.getSavedMessages({viewer: SYSTEM_THREAD_VIEWER, userId: VIEWER_ID, limit: 50});-- expect(- saved.map((entry) => ({id: entry.messageId.toString(), status: entry.status, hasMessage: entry.message != null})),- ).toEqual([- {id: '13', status: 'missing_permissions', hasMessage: false},- {id: '12', status: 'missing_permissions', hasMessage: false},- {id: '11', status: 'available', hasMessage: true},- ]);- expect(deletedSavedMessageIds).toEqual([]);- expect(batchCalls).toEqual([- {channelId: '100', messageIds: ['11']},- {channelId: '200', messageIds: ['12', '13']},+ it('keeps every saved reference to an unreachable channel', async () => {+ const w = await world();+ const visible = await send(w.owner, w.channel.id);+ const first = await send(w.owner, w.other.id);+ const second = await send(w.owner, w.other.id);+ await savedRows(w.member, [visible, first, second]);+ await deny(w.owner, w.other.id, w.member);+ const result = await saved(w.member);+ expect(result.map((entry) => [entry.message_id, entry.status, entry.message !== null])).toEqual([+ [second.id, 'missing_permissions', false],+ [first.id, 'missing_permissions', false],+ [visible.id, 'available', true],]);+ expect(await storedSavedIds(w.member)).toEqual([second.id, first.id, visible.id]);});- it('keeps a saved message the batch read could not return while the message still exists', async () => {- const entries = [- {channelId: CHANNEL_A, messageId: createMessageID(11n)},- {channelId: CHANNEL_A, messageId: createMessageID(12n)},- ];- const {service, deletedSavedMessageIds} = createUserContentService({- entries,- readable: [entries[0]],- stored: entries,- });-- const saved = await service.getSavedMessages({viewer: SYSTEM_THREAD_VIEWER, userId: VIEWER_ID, limit: 50});-+ it('refills saved thread entries and includes ordinary missing-permission entries', async () => {+ const w = await world();+ const t = await thread(w.owner, w.channel.id);+ const first = await send(w.owner, w.channel.id);+ const denied = await send(w.owner, w.other.id);+ const second = await send(w.owner, w.channel.id);+ const hidden1 = await send(w.owner, t.id);+ const hidden2 = await send(w.owner, t.id);+ const third = await send(w.owner, w.channel.id);+ await savedRows(w.member, [first, denied, second, hidden1, hidden2, third]);+ await deny(w.owner, w.other.id, w.member);expect(- saved.map((entry) => ({id: entry.messageId.toString(), status: entry.status, hasMessage: entry.message != null})),+ (await saved(w.member, {limit: 4, capable: false})).map((entry) => [entry.message_id, entry.status]),).toEqual([- {id: '12', status: 'missing_permissions', hasMessage: false},- {id: '11', status: 'available', hasMessage: true},+ [third.id, 'available'],+ [second.id, 'available'],+ [denied.id, 'missing_permissions'],+ [first.id, 'available'],]);- expect(deletedSavedMessageIds).toEqual([]);- });-- describe('thread channels', () => {- const GUILD = createGuildID(900n);- const THREAD = createChannelID(400n);- const viewer = {kind: 'user', userId: VIEWER_ID, bot: false, capable: false} as const;-- it('stops refilling saved messages after a bounded number of hidden pages', async () => {- const {service, savedMessageListCalls} = createUserContentService({- entries: Array.from({length: 50}, (_, index) => ({- channelId: THREAD,- messageId: createMessageID(BigInt(100 - index)),- })),- readable: [],- failures: new Map<string, Error>([[THREAD.toString(), new UnknownChannelError()]]),- channels: [{id: THREAD, type: ChannelTypes.PUBLIC_THREAD, guildId: GUILD}],- });-- expect(await service.getSavedMessages({viewer, userId: VIEWER_ID, limit: 4})).toEqual([]);- expect(savedMessageListCalls).toHaveLength(4);- });-- it('drops saved thread messages for a non-viewer and refills the page', async () => {- const entries = [- {channelId: CHANNEL_A, messageId: createMessageID(15n)},- {channelId: THREAD, messageId: createMessageID(14n)},- {channelId: THREAD, messageId: createMessageID(13n)},- {channelId: CHANNEL_A, messageId: createMessageID(12n)},- {channelId: CHANNEL_B, messageId: createMessageID(11n)},- {channelId: CHANNEL_A, messageId: createMessageID(10n)},- ];- const {service, savedMessageListCalls} = createUserContentService({- entries,- readable: entries.filter((entry) => entry.channelId === CHANNEL_A),- failures: new Map<string, Error>([- [THREAD.toString(), new UnknownChannelError()],- [CHANNEL_B.toString(), new UnknownChannelError()],- ]),- channels: [- {id: THREAD, type: ChannelTypes.PUBLIC_THREAD, guildId: GUILD},- {id: CHANNEL_B, type: ChannelTypes.GUILD_TEXT, guildId: GUILD},- ],- });-- const saved = await service.getSavedMessages({viewer, userId: VIEWER_ID, limit: 4});-- expect(saved.map((entry) => [entry.messageId.toString(), entry.status])).toEqual([- ['15', 'available'],- ['12', 'available'],- ['11', 'missing_permissions'],- ['10', 'available'],- ]);- expect(savedMessageListCalls).toEqual([- {limit: 4, before: undefined},- {limit: 2, before: createMessageID(12n)},- ]);- });- });-- it('deletes a saved message the repository no longer holds', async () => {- const entries = [- {channelId: CHANNEL_A, messageId: createMessageID(11n)},- {channelId: CHANNEL_A, messageId: createMessageID(12n)},- ];- const {service, deletedSavedMessageIds} = createUserContentService({- entries,- readable: [entries[0]],- stored: [entries[0]],- });-- const saved = await service.getSavedMessages({viewer: SYSTEM_THREAD_VIEWER, userId: VIEWER_ID, limit: 50});-- expect(saved.map((entry) => entry.messageId.toString())).toEqual(['11']);- expect(deletedSavedMessageIds).toEqual(['12']);- });-});--describe('gateway dispatches after the write', () => {- function createDispatchingService(- dispatchPresence: (params: {event: string; data: unknown}) => Promise<void>,- channel: {type: number; guildId: GuildID | null} = {type: ChannelTypes.GUILD_TEXT, guildId: null},- ) {- const createdSavedMessageIds: Array<string> = [];- const deletedSavedMessageIds: Array<string> = [];- const deletedRecentMentionIds: Array<string> = [];- const message = makeMessage(CHANNEL_A, createMessageID(31n));- const userRepository = {- findUnique: async () => ({- isBot: false,- premiumType: 0,- premiumUntil: null,- premiumGiftExtensionEndsAt: null,- premiumWillCancel: false,- premiumGraceEndsAt: null,- flags: 0n,- premiumFlags: 0,- traits: null,- }),- listSavedMessages: async () => [],- countSavedMessages: async () => 0,- createSavedMessage: async (_userId: UserID, _channelId: ChannelID, messageId: MessageID) => {- createdSavedMessageIds.push(messageId.toString());- },- deleteSavedMessage: async (_userId: UserID, messageId: MessageID) => {- deletedSavedMessageIds.push(messageId.toString());- },- getRecentMention: async (_userId: UserID, messageId: MessageID) => ({messageId}),- deleteRecentMention: async (mention: {messageId: MessageID}) => {- deletedRecentMentionIds.push(mention.messageId.toString());- },- };- const channelService = {- channelData: {auth: {getChannelAuthenticated: async () => ({channel})}},- messages: {retrieval: {getMessage: async () => message}},- };- const service = new UserContentService(- {- services: {users: userRepository, gateway: {dispatchPresence}, worker: {}, snowflake: {}},- } as unknown as ApiContext,- channelService as unknown as ChannelService,- {} as unknown as ChannelRepository,- {} as unknown as KVBulkMessageDeletionQueueService,- {getConfigSnapshot: () => null} as unknown as LimitConfigService,- );- return {service, message, createdSavedMessageIds, deletedSavedMessageIds, deletedRecentMentionIds};- }-- function saveMessageArgs(messageId: MessageID) {- return {- userId: VIEWER_ID,- viewer: SYSTEM_THREAD_VIEWER,- channelId: CHANNEL_A,- messageId,- userCacheService: {} as unknown as UserCacheService,- requestCache: {} as unknown as RequestCache,- };- }-- it('keeps the saved message when SAVED_MESSAGE_CREATE fails to publish', async () => {- const {service, message, createdSavedMessageIds} = createDispatchingService(async () => {- throw new BadGatewayError();- });- vi.spyOn(service, 'buildUnmaskedResponses').mockResolvedValue({responses: [], channelById: new Map()});-- await expect(service.saveMessage(saveMessageArgs(message.id))).resolves.toBeUndefined();-- expect(createdSavedMessageIds).toEqual([message.id.toString()]);});- it('still surfaces a failure of the message response build', async () => {- const {service, message} = createDispatchingService(async () => {});- vi.spyOn(service, 'buildUnmaskedResponses').mockRejectedValue(new Error('database is on fire'));-- await expect(service.saveMessage(saveMessageArgs(message.id))).rejects.toThrow('database is on fire');- });-- describe('thread scoping', () => {- const GUILD = createGuildID(900n);-- function capture() {- const sent: Array<unknown> = [];- return {- sent,- dispatch: async (params: {data: unknown}) => {- sent.push(params.data);- },- };- }-- function response(overrides: Partial<MessageResponse>): MessageResponse {- return {id: '31', channel_id: '100', type: MessageTypes.DEFAULT, flags: 0, ...overrides} as MessageResponse;- }-- it('sends a plain guild message unchanged', async () => {- const {sent, dispatch} = capture();- const {service, message} = createDispatchingService(dispatch, {type: ChannelTypes.GUILD_TEXT, guildId: GUILD});- const data = response({});- vi.spyOn(service, 'buildUnmaskedResponses').mockResolvedValue({responses: [data], channelById: new Map()});-- await service.saveMessage(saveMessageArgs(message.id));-- expect(sent).toEqual([data]);- });-- it('scopes a thread message to thread viewers only', async () => {- const {sent, dispatch} = capture();- const {service, message} = createDispatchingService(dispatch, {- type: ChannelTypes.PUBLIC_THREAD,- guildId: GUILD,- });- const data = response({channel_id: '400'});- vi.spyOn(service, 'buildUnmaskedResponses').mockResolvedValue({responses: [data], channelById: new Map()});-- await service.saveMessage(saveMessageArgs(message.id));-- expect(sent).toEqual([{...data, __thread_scoped: '900'}]);- });-- it('scopes a thread created message without an unscoped copy', async () => {- const {sent, dispatch} = capture();- const {service, message} = createDispatchingService(dispatch, {type: ChannelTypes.GUILD_TEXT, guildId: GUILD});- const data = response({type: MessageTypes.THREAD_CREATED});- vi.spyOn(service, 'buildUnmaskedResponses').mockResolvedValue({responses: [data], channelById: new Map()});-- await service.saveMessage(saveMessageArgs(message.id));-- expect(sent).toEqual([{...data, __thread_scoped: '900'}]);- });-- it('sends viewers the thread flag and everyone else a masked copy', async () => {- const {sent, dispatch} = capture();- const {service, message} = createDispatchingService(dispatch, {type: ChannelTypes.GUILD_TEXT, guildId: GUILD});- const data = response({flags: ServerMessageFlags.HAS_THREAD | 4});- vi.spyOn(service, 'buildUnmaskedResponses').mockResolvedValue({responses: [data], channelById: new Map()});-- await service.saveMessage(saveMessageArgs(message.id));-- expect(sent).toEqual([- {...data, __thread_scoped: '900'},- {...data, flags: 4, __thread_unscoped: '900'},- ]);- });+ it('publishes a plain saved guild message without thread scoping', async () => {+ const w = await world();+ const message = await send(w.owner, w.channel.id);+ gateway.dispatches.length = 0;+ await save(w.owner, message).expect(HttpStatus.NO_CONTENT).execute();+ expect(gateway.savedPayloads()).toEqual([expect.objectContaining({id: message.id, flags: 0})]);+ const [payload] = gateway.savedPayloads();+ expect(payload).not.toHaveProperty('__thread_scoped');+ expect(payload).not.toHaveProperty('__thread_unscoped');});- it('keeps the deletion when SAVED_MESSAGE_DELETE fails to publish', async () => {- const {service, deletedSavedMessageIds} = createDispatchingService(async () => {- throw new BadGatewayError();- });-- await expect(service.unsaveMessage({userId: VIEWER_ID, messageId: createMessageID(31n)})).resolves.toBeUndefined();-- expect(deletedSavedMessageIds).toEqual(['31']);+ it('publishes a saved thread message only to thread viewers', async () => {+ const w = await world();+ const t = await thread(w.owner, w.channel.id);+ const message = await send(w.owner, t.id);+ gateway.dispatches.length = 0;+ await save(w.owner, message).expect(HttpStatus.NO_CONTENT).execute();+ expect(gateway.savedPayloads()).toEqual([+ expect.objectContaining({id: message.id, channel_id: t.id, __thread_scoped: w.guild.id}),+ ]);});- it('keeps the deletion when RECENT_MENTION_DELETE fails to publish', async () => {- const {service, deletedRecentMentionIds} = createDispatchingService(async () => {- throw new BadGatewayError();- });-- await expect(- service.deleteRecentMention({userId: VIEWER_ID, messageId: createMessageID(31n)}),- ).resolves.toBeUndefined();-- expect(deletedRecentMentionIds).toEqual(['31']);- });-});--describe('buildMessageResponsesForUser thread masking', () => {- const GUILD = createGuildID(900n);- const HAS_THREAD = ServerMessageFlags.HAS_THREAD;-- function build() {- const {service} = createUserContentService({entries: [], readable: []});- const threadCreated = {id: '40', channel_id: '100', type: MessageTypes.THREAD_CREATED, flags: 0};- const responses = [- {id: '41', channel_id: '100', type: MessageTypes.DEFAULT, flags: HAS_THREAD | 4},- {id: '42', channel_id: '100', type: MessageTypes.REPLY, flags: 0, referenced_message: threadCreated},- {id: '43', channel_id: '300', type: MessageTypes.DEFAULT, flags: HAS_THREAD},- ] as Array<MessageResponse>;- const channelById = new Map([- ['100', {id: CHANNEL_A, guildId: GUILD}],- ['300', {id: CHANNEL_C, guildId: null}],- ]) as unknown as Map<string, Channel>;- vi.spyOn(service, 'buildUnmaskedResponses').mockResolvedValue({responses, channelById});- return {service, responses};- }-- const viewer = {kind: 'user', userId: VIEWER_ID, bot: false, capable: true} as const;-- it('masks the parent flag and a thread created reply for a non-viewer', async () => {- const {service} = build();-- const out = await service.buildMessageResponsesForUser(VIEWER_ID, {...viewer, capable: false}, []);-- expect(out.map((response) => [response.id, response.flags, response.referenced_message])).toEqual([- ['41', 4, undefined],- ['42', 0, null],- ['43', 0, undefined],+ it('publishes a thread-created message without an unscoped copy', async () => {+ const w = await world();+ await thread(w.owner, w.channel.id);+ const parentMessages = await channels.messages.listMessages(createChannelID(BigInt(w.channel.id)));+ const created = parentMessages.find((message) => message.type === MessageTypes.THREAD_CREATED);+ assert(created, 'Expected the thread-created parent message');+ const message = await threadsRequest<MessageResponse>(harness, w.owner.token)+ .get(`/channels/${w.channel.id}/messages/${created.id}`)+ .execute();+ gateway.dispatches.length = 0;+ await save(w.owner, message).expect(HttpStatus.NO_CONTENT).execute();+ expect(gateway.savedPayloads()).toEqual([+ expect.objectContaining({id: message.id, type: MessageTypes.THREAD_CREATED, __thread_scoped: w.guild.id}),]);});- it('leaves guild responses untouched for an active viewer and still masks a DM', async () => {- const {service, responses} = build();-- const out = await service.buildMessageResponsesForUser(VIEWER_ID, viewer, []);-- expect(out.slice(0, 2)).toEqual(responses.slice(0, 2));- expect(out[2]?.flags).toBe(0);+ it('publishes a thread parent flag to viewers and a masked copy to other sessions', async () => {+ const w = await world();+ const message = await send(w.owner, w.channel.id, {flags: 4});+ await thread(w.owner, w.channel.id, message.id);+ gateway.dispatches.length = 0;+ await save(w.owner, message).expect(HttpStatus.NO_CONTENT).execute();+ expect(gateway.savedPayloads()).toEqual([+ expect.objectContaining({id: message.id, flags: ServerMessageFlags.HAS_THREAD | 4, __thread_scoped: w.guild.id}),+ expect.objectContaining({id: message.id, flags: 4, __thread_unscoped: w.guild.id}),+ ]);});-});-describe('bookmark ceiling', () => {- function createBookmarkLimitedService({- savedMessageCount,- maxBookmarks,- }: {- savedMessageCount: number;- maxBookmarks: number;- }) {- const createdSavedMessageIds: Array<string> = [];- const message = makeMessage(CHANNEL_A, createMessageID(41n));- const userRepository = {- findUnique: async () => ({- isBot: false,- premiumType: 0,- premiumUntil: null,- premiumGiftExtensionEndsAt: null,- premiumWillCancel: false,- premiumGraceEndsAt: null,- flags: 0n,- premiumFlags: 0,- traits: null,- }),- countSavedMessages: async () => savedMessageCount,- listSavedMessages: async () => {- throw new Error('the ceiling check must not page through saved messages');- },- createSavedMessage: async (_userId: UserID, _channelId: ChannelID, messageId: MessageID) => {- createdSavedMessageIds.push(messageId.toString());- },- };- const channelService = {- channelData: {- auth: {getChannelAuthenticated: async () => ({channel: {type: ChannelTypes.GUILD_TEXT, guildId: null}})},- },- messages: {retrieval: {getMessage: async () => message}},- };- const snapshot: LimitConfigSnapshot = {- traitDefinitions: [],- rules: [{id: 'default', limits: {max_bookmarks: maxBookmarks}}],- };- const service = new UserContentService(- {- services: {users: userRepository, gateway: {dispatchPresence: async () => {}}, worker: {}, snowflake: {}},- } as unknown as ApiContext,- channelService as unknown as ChannelService,- {} as unknown as ChannelRepository,- {} as unknown as KVBulkMessageDeletionQueueService,- {getConfigSnapshot: () => snapshot} as unknown as LimitConfigService,+ async function maskingWorld() {+ const w = await world();+ const parent = await send(w.owner, w.channel.id, {flags: 4});+ await thread(w.owner, w.channel.id, parent.id);+ await thread(w.owner, w.other.id);+ const created = (await channels.messages.listMessages(createChannelID(BigInt(w.other.id)))).find(+ (message) => message.type === MessageTypes.THREAD_CREATED,);- return {service, message, createdSavedMessageIds};- }-- function saveMessageArgs(messageId: MessageID) {- return {- userId: VIEWER_ID,- viewer: SYSTEM_THREAD_VIEWER,- channelId: CHANNEL_A,- messageId,- userCacheService: {} as unknown as UserCacheService,- requestCache: {} as unknown as RequestCache,- };- }-- it('enforces a configured max_bookmarks above 1000', async () => {- const {service, message, createdSavedMessageIds} = createBookmarkLimitedService({- savedMessageCount: 1002,- maxBookmarks: 1002,+ assert(created, 'Expected a thread-created message to reference');+ const reply = await send(w.owner, w.other.id);+ await updateStoredMessage(reply, {+ type: MessageTypes.REPLY,+ message_reference: {+ message_id: created.id,+ channel_id: createChannelID(BigInt(w.other.id)),+ guild_id: createGuildID(BigInt(w.guild.id)),+ type: MessageReferenceTypes.DEFAULT,+ },});- vi.spyOn(service, 'buildUnmaskedResponses').mockResolvedValue({responses: [], channelById: new Map()});-- const error = await service.saveMessage(saveMessageArgs(message.id)).catch((thrown: unknown) => thrown);+ const friend = await createTestAccount(harness);+ await createFriendship(harness, w.member, friend);+ const dm = await createDmChannel(harness, w.member.token, friend.userId);+ const direct = await send(w.member, dm.id);+ await updateStoredMessage(direct, {flags: ServerMessageFlags.HAS_THREAD});+ await savedRows(w.member, [parent, reply, direct]);+ return {w, parent, reply, direct};+ }- expect(error).toBeInstanceOf(MaxBookmarksError);- expect((error as MaxBookmarksError).status).toBe(400);- expect((error as MaxBookmarksError).code).toBe(APIErrorCodes.MAX_BOOKMARKS);- expect((error as MaxBookmarksError).data?.max_bookmarks).toBe(1002);- expect(createdSavedMessageIds).toEqual([]);+ it('masks a parent thread flag and thread-created reply for a non-viewer', async () => {+ const {w, parent, reply, direct} = await maskingWorld();+ const result = await saved(w.member, {capable: false});+ expect(result.map((entry) => [entry.message_id, entry.message?.flags])).toEqual([+ [direct.id, 0],+ [reply.id, 0],+ [parent.id, 4],+ ]);+ expect(result.find((entry) => entry.message_id === reply.id)?.message?.referenced_message).toBeNull();});- it('still saves below a configured max_bookmarks above 1000', async () => {- const {service, message, createdSavedMessageIds} = createBookmarkLimitedService({- savedMessageCount: 1001,- maxBookmarks: 1002,+ it('preserves guild thread artifacts for a capable viewer and still masks a direct message', async () => {+ const {w, parent, reply, direct} = await maskingWorld();+ const result = await saved(w.member);+ expect(result.map((entry) => [entry.message_id, entry.message?.flags])).toEqual([+ [direct.id, 0],+ [reply.id, 0],+ [parent.id, ServerMessageFlags.HAS_THREAD | 4],+ ]);+ expect(result.find((entry) => entry.message_id === reply.id)?.message?.referenced_message).toMatchObject({+ type: MessageTypes.THREAD_CREATED,});- vi.spyOn(service, 'buildUnmaskedResponses').mockResolvedValue({responses: [], channelById: new Map()});-- await expect(service.saveMessage(saveMessageArgs(message.id))).resolves.toBeUndefined();-- expect(createdSavedMessageIds).toEqual([message.id.toString()]);});});