Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp

feat(api): add friends switch, gate requests, end pass offers

Hampus91bb29f70168
diff --git a/fluxer_api/src/api/admin/services/AdminUserRelationshipService.ts b/fluxer_api/src/api/admin/services/AdminUserRelationshipService.ts
index e749a6f67..6ac059cdd 100644
--- a/fluxer_api/src/api/admin/services/AdminUserRelationshipService.ts
+++ b/fluxer_api/src/api/admin/services/AdminUserRelationshipService.ts
@@ -5,6 +5,7 @@ import {resolveAdminUsers} from '@app/api/admin/models/UserTypes';
import type {AdminAuditService} from '@app/api/admin/services/AdminAuditService';
import {createUserID, type UserID} from '@app/api/BrandedTypes';
import type {Relationship} from '@app/api/models/Relationship';
+import type {UserRelationshipService} from '@app/api/user/services/UserRelationshipService';
import {RelationshipTypes} from '@fluxer/constants/src/UserConstants';
import {UnknownUserError} from '@fluxer/errors/src/domains/user/UnknownUserError';
import type {
@@ -20,6 +21,7 @@ import type {
interface AdminUserRelationshipServiceDeps {
apiContext: ApiContext;
auditService: AdminAuditService;
+ userRelationshipService: Pick<UserRelationshipService, 'endFriendship'>;
}
const CATEGORY_TO_TYPE: Record<RelationshipCategory, number> = {
@@ -164,8 +166,7 @@ export class AdminUserRelationshipService {
const {users: userRepository, gateway: gatewayService} = this.deps.apiContext.services;
switch (category) {
case 'friend': {
- await userRepository.deleteRelationship(userId, targetUserId, RelationshipTypes.FRIEND);
- await userRepository.deleteRelationship(targetUserId, userId, RelationshipTypes.FRIEND);
+ await this.deps.userRelationshipService.endFriendship(userId, targetUserId);
await gatewayService.dispatchPresence({
userId,
event: 'RELATIONSHIP_REMOVE',
diff --git a/fluxer_api/src/api/admin/tests/InstancePolicyFriends.test.ts b/fluxer_api/src/api/admin/tests/InstancePolicyFriends.test.ts
new file mode 100644
index 000000000..5bcf5b9fb
--- /dev/null
+++ b/fluxer_api/src/api/admin/tests/InstancePolicyFriends.test.ts
@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+import type {TestAccount} from '@app/api/auth/tests/AuthTestUtils';
+import {createTestAccount, setUserACLs} from '@app/api/auth/tests/AuthTestUtils';
+import type {ApiTestHarness} from '@app/api/test/ApiTestHarness';
+import {createApiTestHarness} from '@app/api/test/ApiTestHarness';
+import {HTTP_STATUS} from '@app/api/test/TestConstants';
+import {createBuilder} from '@app/api/test/TestRequestBuilder';
+import {AdminACLs} from '@fluxer/constants/src/AdminACLs';
+import {APIErrorCodes} from '@fluxer/constants/src/ApiErrorCodes';
+import type {InstanceConfigResponse} from '@fluxer/schema/src/domains/admin/AdminSchemas';
+import {afterAll, beforeAll, beforeEach, describe, expect, it} from 'vitest';
+
+describe('instance policy friends and direct messages', () => {
+ let harness: ApiTestHarness;
+ let admin: TestAccount;
+ let alice: TestAccount;
+ let bob: TestAccount;
+
+ beforeAll(async () => {
+ harness = await createApiTestHarness();
+ });
+
+ beforeEach(async () => {
+ await harness.reset();
+ admin = await setUserACLs(harness, await createTestAccount(harness), [
+ AdminACLs.AUTHENTICATE,
+ AdminACLs.INSTANCE_CONFIG_VIEW,
+ AdminACLs.INSTANCE_CONFIG_UPDATE,
+ ]);
+ alice = await createTestAccount(harness);
+ bob = await createTestAccount(harness);
+ });
+
+ afterAll(async () => {
+ await harness.shutdown();
+ });
+
+ const patchPolicy = (policy: Record<string, unknown>) =>
+ createBuilder<InstanceConfigResponse>(harness, admin.token)
+ .patch('/admin/instance/config')
+ .body({policy})
+ .execute();
+
+ const friendRequest = (from: TestAccount, to: TestAccount) =>
+ createBuilder(harness, from.token).post(`/users/@me/relationships/${to.userId}`).body({});
+
+ const openDm = (from: TestAccount, to: TestAccount) =>
+ createBuilder(harness, from.token).post('/users/@me/channels').body({recipient_id: to.userId});
+
+ it('turns friend requests off on their own', async () => {
+ const config = await patchPolicy({friends_disabled: true});
+ expect(config.policy).toMatchObject({friends_disabled: true, direct_messages_disabled: false});
+ await friendRequest(alice, bob).expect(HTTP_STATUS.BAD_REQUEST, APIErrorCodes.FRIENDS_DISABLED).execute();
+ });
+
+ it('keeps friend requests working while direct messages are off', async () => {
+ const config = await patchPolicy({direct_messages_disabled: true, friends_disabled: false});
+ expect(config.policy).toMatchObject({friends_disabled: false, direct_messages_disabled: true});
+ await friendRequest(alice, bob).expect(HTTP_STATUS.OK).execute();
+ await createBuilder(harness, bob.token)
+ .put(`/users/@me/relationships/${alice.userId}`)
+ .body({})
+ .expect(HTTP_STATUS.OK)
+ .execute();
+ await openDm(alice, bob).expect(HTTP_STATUS.BAD_REQUEST, APIErrorCodes.DIRECT_MESSAGES_DISABLED).execute();
+ });
+
+ it('turns friend requests off and on with direct messages when the friends switch is not sent', async () => {
+ const off = await patchPolicy({direct_messages_disabled: true});
+ expect(off.policy).toMatchObject({friends_disabled: true, direct_messages_disabled: true});
+ await friendRequest(alice, bob).expect(HTTP_STATUS.BAD_REQUEST, APIErrorCodes.FRIENDS_DISABLED).execute();
+ const on = await patchPolicy({direct_messages_disabled: false});
+ expect(on.policy).toMatchObject({friends_disabled: false, direct_messages_disabled: false});
+ await friendRequest(alice, bob).expect(HTTP_STATUS.OK).execute();
+ });
+
+ it('refuses accepting a pending request once friends are turned off', async () => {
+ await friendRequest(alice, bob).expect(HTTP_STATUS.OK).execute();
+ await patchPolicy({friends_disabled: true});
+ await createBuilder(harness, bob.token)
+ .put(`/users/@me/relationships/${alice.userId}`)
+ .body({})
+ .expect(HTTP_STATUS.BAD_REQUEST, APIErrorCodes.FRIENDS_DISABLED)
+ .execute();
+ });
+
+ it('refuses a notice link that is not http or https', async () => {
+ await createBuilder(harness, admin.token)
+ .patch('/admin/instance/config')
+ .body({notice: {message: 'Hello', url: 'javascript:alert(1)'}})
+ .expect(HTTP_STATUS.BAD_REQUEST, APIErrorCodes.INVALID_FORM_BODY)
+ .execute();
+ });
+});
diff --git a/fluxer_api/src/api/user/services/UserRelationshipService.ts b/fluxer_api/src/api/user/services/UserRelationshipService.ts
index 632df7f68..21d5a7d15 100644
--- a/fluxer_api/src/api/user/services/UserRelationshipService.ts
+++ b/fluxer_api/src/api/user/services/UserRelationshipService.ts
@@ -1,39 +1,41 @@
// SPDX-License-Identifier: AGPL-3.0-or-later
import type {ApiContext} from '@app/api/ApiContext';
-import {requireEmailVerified} from '@app/api/auth/EmailVerificationUtils';
import type {UserID} from '@app/api/BrandedTypes';
import {emitActivity} from '@app/api/infrastructure/activity/ActivityEvents';
import type {IGatewayService} from '@app/api/infrastructure/IGatewayService';
import type {UserCacheService} from '@app/api/infrastructure/UserCacheService';
+import {usesUniqueUsernames} from '@app/api/instance/AccountIdentityModeCache';
import type {LimitConfigService} from '@app/api/limits/LimitConfigService';
import {resolveLimitSafe} from '@app/api/limits/LimitConfigUtils';
import {createLimitMatchContext} from '@app/api/limits/LimitMatchContextBuilder';
+import type {OperatorPassServices} from '@app/api/middleware/OperatorPassServiceFactory';
import type {RequestCache} from '@app/api/middleware/RequestCacheMiddleware';
import {getInstanceConfigRepository} from '@app/api/middleware/ServiceSingletons';
import type {Relationship} from '@app/api/models/Relationship';
import type {User} from '@app/api/models/User';
+import {assertTierAllows, NO_TIER_CONTEXT} from '@app/api/user/AccountTier';
import {assertMayStartConversation} from '@app/api/user/NewConversationLimit';
import type {UserRepository} from '@app/api/user/repositories/UserRepository';
+import {findPersonByLoginHandle} from '@app/api/user/UniqueUsernames';
import {isDirectDeliverySuppressed} from '@app/api/user/UserHelpers';
import {mapRelationshipToResponse} from '@app/api/user/UserMappers';
import type {UserPermissionUtils} from '@app/api/utils/UserPermissionUtils';
+import {TierGatedActions} from '@fluxer/constants/src/AccountTierConstants';
import type {LimitKey} from '@fluxer/constants/src/LimitConfigMetadata';
import {MAX_RELATIONSHIPS} from '@fluxer/constants/src/LimitConstants';
import {RelationshipTypes, UserFlags} from '@fluxer/constants/src/UserConstants';
-import {DirectMessagesDisabledError} from '@fluxer/errors/src/domains/channel/DirectMessagesDisabledError';
import {BotsCannotSendFriendRequestsError} from '@fluxer/errors/src/domains/oauth/BotsCannotSendFriendRequestsError';
import {AlreadyFriendsError} from '@fluxer/errors/src/domains/user/AlreadyFriendsError';
import {CannotBlockSystemUserError} from '@fluxer/errors/src/domains/user/CannotBlockSystemUserError';
import {CannotSendFriendRequestToBlockedUserError} from '@fluxer/errors/src/domains/user/CannotSendFriendRequestToBlockedUserError';
import {CannotSendFriendRequestToSelfError} from '@fluxer/errors/src/domains/user/CannotSendFriendRequestToSelfError';
import {FriendRequestBlockedError} from '@fluxer/errors/src/domains/user/FriendRequestBlockedError';
+import {FriendsDisabledError} from '@fluxer/errors/src/domains/user/FriendsDisabledError';
import {InvalidDiscriminatorError} from '@fluxer/errors/src/domains/user/InvalidDiscriminatorError';
import {MaxRelationshipsError} from '@fluxer/errors/src/domains/user/MaxRelationshipsError';
import {NoUsersWithFluxertagError} from '@fluxer/errors/src/domains/user/NoUsersWithFluxertagError';
-import {UnclaimedAccountCannotAcceptFriendRequestsError} from '@fluxer/errors/src/domains/user/UnclaimedAccountCannotAcceptFriendRequestsError';
-import {UnclaimedAccountCannotSendFriendRequestsError} from '@fluxer/errors/src/domains/user/UnclaimedAccountCannotSendFriendRequestsError';
import {UnknownUserError} from '@fluxer/errors/src/domains/user/UnknownUserError';
import type {
BulkIgnoreFriendRequestsRequest,
@@ -64,6 +66,7 @@ export class UserRelationshipService {
apiContext: ApiContext,
private userPermissionUtils: UserPermissionUtils,
private readonly limitConfigService: LimitConfigService,
+ private readonly operatorPassServices: Pick<OperatorPassServices, 'holdingService'> | null,
) {
const {users, gateway} = apiContext.services;
this.userRepository = users;
@@ -90,11 +93,7 @@ export class UserRelationshipService {
requestCache: RequestCache;
}): Promise<Relationship> {
const {username, discriminator} = data;
- const discrimValue = discriminator;
- if (!Number.isInteger(discrimValue) || discrimValue < 0 || discrimValue > 9999) {
- throw new InvalidDiscriminatorError();
- }
- const targetUser = await this.userRepository.findByUsernameDiscriminator(username, discrimValue);
+ const targetUser = await this.findFriendRequestTarget(username, discriminator);
if (!targetUser) {
throw new NoUsersWithFluxertagError();
}
@@ -112,6 +111,19 @@ export class UserRelationshipService {
return this.sendFriendRequest({userId, targetId: targetUser.id, userCacheService, requestCache});
}
+ private async findFriendRequestTarget(username: string, discriminator: number | undefined): Promise<User | null> {
+ if (discriminator === undefined) {
+ if (!usesUniqueUsernames()) {
+ throw new InvalidDiscriminatorError();
+ }
+ return await findPersonByLoginHandle(this.userRepository, {username, discriminator: null});
+ }
+ if (!Number.isInteger(discriminator) || discriminator < 0 || discriminator > 9999) {
+ throw new InvalidDiscriminatorError();
+ }
+ return await this.userRepository.findByUsernameDiscriminator(username, discriminator);
+ }
+
async sendFriendRequest({
userId,
targetId,
@@ -127,8 +139,8 @@ export class UserRelationshipService {
}): Promise<Relationship> {
const requesterUser = await this.userRepository.findUnique(userId);
const requesterIsStaff = requesterUser != null && (requesterUser.flags & UserFlags.STAFF) === UserFlags.STAFF;
- if (!requesterIsStaff && (await getInstanceConfigRepository().getInstancePolicyConfig()).direct_messages_disabled) {
- throw new DirectMessagesDisabledError();
+ if (!requesterIsStaff && (await getInstanceConfigRepository().getInstancePolicyConfig()).friends_disabled) {
+ throw new FriendsDisabledError();
}
if (staffForceAccept && requesterIsStaff) {
return await this.forceCreateFriendship({userId, targetId, userCacheService, requestCache});
@@ -209,8 +221,8 @@ export class UserRelationshipService {
userCacheService: UserCacheService;
requestCache: RequestCache;
}): Promise<Relationship> {
- if ((await getInstanceConfigRepository().getInstancePolicyConfig()).direct_messages_disabled) {
- throw new DirectMessagesDisabledError();
+ if ((await getInstanceConfigRepository().getInstancePolicyConfig()).friends_disabled) {
+ throw new FriendsDisabledError();
}
const user = await this.userRepository.findUnique(userId);
if (!user) {
@@ -219,9 +231,7 @@ export class UserRelationshipService {
if (this.isDeletedUser(user)) {
throw new FriendRequestBlockedError();
}
- if (user?.isUnclaimedAccount()) {
- throw new UnclaimedAccountCannotAcceptFriendRequestsError();
- }
+ assertTierAllows(user, TierGatedActions.FRIEND_ACCEPT, NO_TIER_CONTEXT);
const requesterUser = await this.userRepository.findUnique(targetId);
if (!requesterUser) {
throw new UnknownUserError();
@@ -312,8 +322,7 @@ export class UserRelationshipService {
RelationshipTypes.OUTGOING_REQUEST,
);
if (existingFriend) {
- await this.userRepository.deleteRelationship(userId, targetId, RelationshipTypes.FRIEND);
- await this.userRepository.deleteRelationship(targetId, userId, RelationshipTypes.FRIEND);
+ await this.endFriendship(userId, targetId);
await this.dispatchRelationshipRemove({userId: targetId, targetId: userId.toString()});
} else if (existingOutgoingRequest) {
await this.userRepository.deleteRelationship(userId, targetId, RelationshipTypes.OUTGOING_REQUEST);
@@ -368,8 +377,7 @@ export class UserRelationshipService {
return;
}
if (relationshipType === RelationshipTypes.FRIEND) {
- await this.userRepository.deleteRelationship(userId, targetId, RelationshipTypes.FRIEND);
- await this.userRepository.deleteRelationship(targetId, userId, RelationshipTypes.FRIEND);
+ await this.endFriendship(userId, targetId);
await this.dispatchRelationshipRemove({userId, targetId: targetId.toString()});
await this.dispatchRelationshipRemove({userId: targetId, targetId: userId.toString()});
return;
@@ -378,6 +386,12 @@ export class UserRelationshipService {
await this.dispatchRelationshipRemove({userId, targetId: targetId.toString()});
}
+ async endFriendship(userId: UserID, targetId: UserID): Promise<void> {
+ await this.userRepository.deleteRelationship(userId, targetId, RelationshipTypes.FRIEND);
+ await this.userRepository.deleteRelationship(targetId, userId, RelationshipTypes.FRIEND);
+ await this.operatorPassServices?.holdingService.cancelOffersBetween(userId, targetId);
+ }
+
async updateFriendNickname({
userId,
targetId,
@@ -467,10 +481,7 @@ export class UserRelationshipService {
if (this.isDeletedUser(requesterUser)) {
throw new FriendRequestBlockedError();
}
- if (requesterUser.isUnclaimedAccount()) {
- throw new UnclaimedAccountCannotSendFriendRequestsError();
- }
- requireEmailVerified(requesterUser, 'friend_request');
+ assertTierAllows(requesterUser, TierGatedActions.FRIEND_REQUEST, NO_TIER_CONTEXT);
if (requesterUser.isBot) {
throw new BotsCannotSendFriendRequestsError();
}
@@ -581,10 +592,7 @@ export class UserRelationshipService {
if (this.isDeletedUser(requesterUser)) {
throw new FriendRequestBlockedError();
}
- if (requesterUser?.isUnclaimedAccount()) {
- throw new UnclaimedAccountCannotSendFriendRequestsError();
- }
- requireEmailVerified(requesterUser, 'friend_request');
+ assertTierAllows(requesterUser, TierGatedActions.FRIEND_REQUEST, NO_TIER_CONTEXT);
if (requesterUser?.isBot) {
throw new BotsCannotSendFriendRequestsError();
}
@@ -699,10 +707,7 @@ export class UserRelationshipService {
if (this.isDeletedUser(requesterUser)) {
throw new FriendRequestBlockedError();
}
- if (requesterUser.isUnclaimedAccount()) {
- throw new UnclaimedAccountCannotSendFriendRequestsError();
- }
- requireEmailVerified(requesterUser, 'friend_request');
+ assertTierAllows(requesterUser, TierGatedActions.FRIEND_REQUEST, NO_TIER_CONTEXT);
if (requesterUser.isBot) {
throw new BotsCannotSendFriendRequestsError();
}
@@ -747,7 +752,7 @@ export class UserRelationshipService {
return userRelationship;
}
- async dispatchRelationshipCreate({
+ private async dispatchRelationshipCreate({
userId,
relationship,
userCacheService,
@@ -766,7 +771,7 @@ export class UserRelationshipService {
});
}
- async dispatchRelationshipUpdate({
+ private async dispatchRelationshipUpdate({
userId,
relationship,
userCacheService,
@@ -785,7 +790,7 @@ export class UserRelationshipService {
});
}
- async dispatchRelationshipRemove({userId, targetId}: {userId: UserID; targetId: string}): Promise<void> {
+ private async dispatchRelationshipRemove({userId, targetId}: {userId: UserID; targetId: string}): Promise<void> {
await this.gatewayService.dispatchPresence({
userId,
event: 'RELATIONSHIP_REMOVE',
diff --git a/fluxer_api/src/api/user/services/UserService.ts b/fluxer_api/src/api/user/services/UserService.ts
index 7a59a4026..407c6119e 100644
--- a/fluxer_api/src/api/user/services/UserService.ts
+++ b/fluxer_api/src/api/user/services/UserService.ts
@@ -12,6 +12,7 @@ import type {KVAccountDeletionQueueService} from '@app/api/infrastructure/KVAcco
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 {OperatorPassServices} from '@app/api/middleware/OperatorPassServiceFactory';
import {UserAccountService} from '@app/api/user/services/UserAccountService';
import {UserChannelService} from '@app/api/user/services/UserChannelService';
import type {UserContactChangeLogService} from '@app/api/user/services/UserContactChangeLogService';
@@ -40,6 +41,7 @@ export class UserService {
contactChangeLogService: UserContactChangeLogService,
connectionRepository: ConnectionRepository,
limitConfigService: LimitConfigService,
+ operatorPassServices: Pick<OperatorPassServices, 'holdingService'> | null,
) {
this.accountService = new UserAccountService(
apiContext,
@@ -53,7 +55,12 @@ export class UserService {
connectionRepository,
limitConfigService,
);
- this.relationshipService = new UserRelationshipService(apiContext, userPermissionUtils, limitConfigService);
+ this.relationshipService = new UserRelationshipService(
+ apiContext,
+ userPermissionUtils,
+ limitConfigService,
+ operatorPassServices,
+ );
this.channelService = new UserChannelService(
apiContext,
channelService,