Skip to content

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

TypeScript fluxerfluxerapp

feat(api/sso): link SSO identities and sync group roles

Hampus2e0e79eed97b
diff --git a/fluxer_api/src/api/auth/services/SsoIdentityLinks.ts b/fluxer_api/src/api/auth/services/SsoIdentityLinks.ts
new file mode 100644
index 000000000..2af580303
--- /dev/null
+++ b/fluxer_api/src/api/auth/services/SsoIdentityLinks.ts
@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+import {createHash} from 'node:crypto';
+import {SsoIdentityRepository} from '@app/api/auth/services/SsoIdentityRepository';
+import type {UserSsoIdentityRow} from '@app/api/database/types/AuthTypes';
+import type {InstanceSsoConfig} from '@app/api/instance/InstanceConfigRepository';
+import type {User} from '@app/api/models/User';
+import type {UserRepository} from '@app/api/user/repositories/UserRepository';
+import {UserTraits} from '@app/api/user/UserTraits';
+import {UserFlags} from '@fluxer/constants/src/UserConstants';
+import {ValidationErrorCodes} from '@fluxer/constants/src/ValidationErrorCodes';
+import {InputValidationError} from '@fluxer/errors/src/domains/core/InputValidationError';
+
+const SSO_IDENTITY_TRAIT_PREFIXES = ['sso:', 'sso_provider:', 'sso_identity:'];
+
+export function ssoProviderIdOf(config: Pick<InstanceSsoConfig, 'issuer' | 'authorizationUrl'>): string {
+ return config.issuer || config.authorizationUrl || 'sso';
+}
+
+export function ssoIdentityTrait(providerId: string, sub: string): string {
+ const digest = createHash('sha256').update(providerId).update('\0').update(sub).digest('hex');
+ return `sso_identity:${digest}`;
+}
+
+export function ssoIdentityTraits(providerId: string, sub: string): Array<string> {
+ const providerDigest = createHash('sha256').update(providerId).digest('hex').slice(0, 32);
+ return [UserTraits.SSO, `sso:${providerId}`, `sso_provider:${providerDigest}`, ssoIdentityTrait(providerId, sub)];
+}
+
+function withoutSsoIdentityTraits(traits: Iterable<string>): Set<string> {
+ return new Set(
+ Array.from(traits).filter(
+ (trait) => trait !== UserTraits.SSO && !SSO_IDENTITY_TRAIT_PREFIXES.some((prefix) => trait.startsWith(prefix)),
+ ),
+ );
+}
+
+function isLiveAccount(user: User | null): user is User {
+ return user !== null && (user.flags & UserFlags.DELETED) === 0n;
+}
+
+export class SsoIdentityLinkService {
+ private readonly identities = new SsoIdentityRepository();
+
+ constructor(private readonly users: UserRepository) {}
+
+ async unlink(user: User, providerId: string): Promise<Array<UserSsoIdentityRow>> {
+ await this.releaseAll(user, providerId);
+ await this.users.patchUpsert(user.id, {traits: withoutSsoIdentityTraits(user.traits)}, user.toRow());
+ return this.identities.listForUser(user.id);
+ }
+
+ async link(user: User, providerId: string, subject: string): Promise<Array<UserSsoIdentityRow>> {
+ const holder = await this.identities.findIdentity(providerId, subject);
+ if (holder && holder.user_id !== user.id) {
+ if (isLiveAccount(await this.users.findUnique(holder.user_id))) {
+ throw InputValidationError.fromCode('subject', ValidationErrorCodes.SSO_IDENTITY_LINKED_TO_ANOTHER_ACCOUNT);
+ }
+ await this.identities.releaseIdentity(providerId, subject);
+ }
+ await this.releaseAll(user, providerId);
+ await this.identities.tryClaimIdentity({providerId, subject, userId: user.id, claimedAt: new Date()});
+ const traits = withoutSsoIdentityTraits(user.traits);
+ for (const trait of ssoIdentityTraits(providerId, subject)) {
+ traits.add(trait);
+ }
+ await this.users.patchUpsert(user.id, {traits}, user.toRow());
+ return this.identities.listForUser(user.id);
+ }
+
+ async migrate(fromProviderId: string, toProviderId: string): Promise<{moved: number; skipped: number}> {
+ let moved = 0;
+ let skipped = 0;
+ for (const identity of await this.identities.listForProvider(fromProviderId)) {
+ const user = await this.users.findUnique(identity.user_id);
+ if (!user || !(await this.claimFor(toProviderId, identity))) {
+ skipped += 1;
+ continue;
+ }
+ await this.identities.releaseIdentity(fromProviderId, identity.subject);
+ const traits = new Set(user.traits);
+ for (const trait of ssoIdentityTraits(fromProviderId, identity.subject)) {
+ traits.delete(trait);
+ }
+ for (const trait of ssoIdentityTraits(toProviderId, identity.subject)) {
+ traits.add(trait);
+ }
+ await this.users.patchUpsert(user.id, {traits}, user.toRow());
+ moved += 1;
+ }
+ return {moved, skipped};
+ }
+
+ private async releaseAll(user: User, providerId: string): Promise<void> {
+ if ((await this.identities.releaseIdentitiesForUser(user.id)) > 0) return;
+ for (const identity of await this.identities.listForProvider(providerId)) {
+ if (identity.user_id === user.id) {
+ await this.identities.releaseIdentity(identity.provider_id, identity.subject);
+ }
+ }
+ }
+
+ private async claimFor(providerId: string, identity: UserSsoIdentityRow): Promise<boolean> {
+ const claimed = await this.identities.tryClaimIdentity({
+ providerId,
+ subject: identity.subject,
+ userId: identity.user_id,
+ claimedAt: identity.claimed_at,
+ });
+ return claimed || (await this.identities.findUserId(providerId, identity.subject)) === identity.user_id;
+ }
+}
diff --git a/fluxer_api/src/api/auth/services/SsoIdentityRepository.ts b/fluxer_api/src/api/auth/services/SsoIdentityRepository.ts
index 6288ac3a7..47fcf510e 100644
--- a/fluxer_api/src/api/auth/services/SsoIdentityRepository.ts
+++ b/fluxer_api/src/api/auth/services/SsoIdentityRepository.ts
@@ -1,9 +1,9 @@
// SPDX-License-Identifier: AGPL-3.0-or-later
import type {UserID} from '@app/api/BrandedTypes';
-import {deleteOneOrMany, executeQuery, fetchOne} from '@app/api/database/CassandraQueryExecution';
+import {deleteOneOrMany, executeQuery, fetchMany, fetchOne, upsertOne} from '@app/api/database/CassandraQueryExecution';
import type {UserSsoIdentityRow} from '@app/api/database/types/AuthTypes';
-import {UserSsoIdentities} from '@app/api/Tables';
+import {UserSsoIdentities, UserSsoIdentitiesByUser} from '@app/api/Tables';
interface ConditionalInsertResult {
'[applied]': boolean;
@@ -14,12 +14,21 @@ const FIND_SSO_IDENTITY_QUERY = UserSsoIdentities.select({
limit: 1,
});
+const LIST_PROVIDER_IDENTITIES_QUERY = UserSsoIdentities.select({
+ where: UserSsoIdentities.where.eq('provider_id'),
+});
+
+const LIST_USER_IDENTITIES_QUERY = UserSsoIdentitiesByUser.select({
+ where: UserSsoIdentitiesByUser.where.eq('user_id'),
+});
+
export class SsoIdentityRepository {
+ async findIdentity(providerId: string, subject: string): Promise<UserSsoIdentityRow | null> {
+ return fetchOne<UserSsoIdentityRow>(FIND_SSO_IDENTITY_QUERY.bind({provider_id: providerId, subject}));
+ }
+
async findUserId(providerId: string, subject: string): Promise<UserID | null> {
- const row = await fetchOne<Pick<UserSsoIdentityRow, 'user_id'>>(
- FIND_SSO_IDENTITY_QUERY.bind({provider_id: providerId, subject}),
- );
- return row?.user_id ?? null;
+ return (await this.findIdentity(providerId, subject))?.user_id ?? null;
}
async tryClaimIdentity(params: {
@@ -28,21 +37,73 @@ export class SsoIdentityRepository {
userId: UserID;
claimedAt: Date;
}): Promise<boolean> {
- const [result] = await executeQuery<ConditionalInsertResult>(
- UserSsoIdentities.insertIfNotExists({
- provider_id: params.providerId,
- subject: params.subject,
- user_id: params.userId,
- claimed_at: params.claimedAt,
- }),
- );
+ const row: UserSsoIdentityRow = {
+ provider_id: params.providerId,
+ subject: params.subject,
+ user_id: params.userId,
+ claimed_at: params.claimedAt,
+ };
+ const [result] = await executeQuery<ConditionalInsertResult>(UserSsoIdentities.insertIfNotExists(row));
if (!result || typeof result['[applied]'] !== 'boolean') {
throw new Error('Unexpected database response for SSO identity claim');
}
+ if (result['[applied]']) {
+ await this.indexIdentity(row);
+ }
return result['[applied]'];
}
+ async indexIdentity(row: UserSsoIdentityRow): Promise<void> {
+ await upsertOne(UserSsoIdentitiesByUser.insert(row));
+ }
+
async releaseIdentity(providerId: string, subject: string): Promise<void> {
+ const identity = await this.findIdentity(providerId, subject);
await deleteOneOrMany(UserSsoIdentities.deleteByPk({provider_id: providerId, subject}));
+ if (identity) {
+ await this.unindexIdentity(identity);
+ }
+ }
+
+ async listForUser(userId: UserID): Promise<Array<UserSsoIdentityRow>> {
+ const indexed = await fetchMany<UserSsoIdentityRow>(LIST_USER_IDENTITIES_QUERY.bind({user_id: userId}));
+ const identities: Array<UserSsoIdentityRow> = [];
+ for (const entry of indexed) {
+ const identity = await this.findIdentity(entry.provider_id, entry.subject);
+ if (identity?.user_id === userId) {
+ identities.push(identity);
+ }
+ }
+ return identities;
+ }
+
+ async listForProvider(providerId: string): Promise<Array<UserSsoIdentityRow>> {
+ return fetchMany<UserSsoIdentityRow>(LIST_PROVIDER_IDENTITIES_QUERY.bind({provider_id: providerId}));
+ }
+
+ async releaseIdentitiesForUser(userId: UserID): Promise<number> {
+ const indexed = await fetchMany<UserSsoIdentityRow>(LIST_USER_IDENTITIES_QUERY.bind({user_id: userId}));
+ let released = 0;
+ for (const entry of indexed) {
+ const identity = await this.findIdentity(entry.provider_id, entry.subject);
+ if (identity?.user_id === userId) {
+ await deleteOneOrMany(
+ UserSsoIdentities.deleteByPk({provider_id: identity.provider_id, subject: identity.subject}),
+ );
+ released += 1;
+ }
+ await this.unindexIdentity({...entry, user_id: userId});
+ }
+ return released;
+ }
+
+ private async unindexIdentity(identity: UserSsoIdentityRow): Promise<void> {
+ await deleteOneOrMany(
+ UserSsoIdentitiesByUser.deleteByPk({
+ user_id: identity.user_id,
+ provider_id: identity.provider_id,
+ subject: identity.subject,
+ }),
+ );
}
}
diff --git a/fluxer_api/src/api/auth/services/SsoService.ts b/fluxer_api/src/api/auth/services/SsoService.ts
index 330f62422..6376ee24b 100644
--- a/fluxer_api/src/api/auth/services/SsoService.ts
+++ b/fluxer_api/src/api/auth/services/SsoService.ts
@@ -2,28 +2,34 @@
import {createHash, randomBytes} from 'node:crypto';
import type {ApiContext} from '@app/api/ApiContext';
-import {maybeAutoJoinInvite} from '@app/api/auth/AuthRegistration';
+import {createMfaTicketResponse, type LoginMfaResult} from '@app/api/auth/AuthLogin';
+import * as AuthMfa from '@app/api/auth/AuthMfa';
+import {assertAccountCreationPastSetup, maybeAutoJoinInvite} from '@app/api/auth/AuthRegistration';
import * as AuthSession from '@app/api/auth/AuthSession';
import * as AuthUtility from '@app/api/auth/AuthUtility';
-import {assertEmailNotBlocklisted} from '@app/api/auth/EmailBlocklist';
+import {assertEmailNotBlocklisted, isEmailBlocklisted} from '@app/api/auth/EmailBlocklist';
+import {ssoIdentityTrait, ssoIdentityTraits, ssoProviderIdOf} from '@app/api/auth/services/SsoIdentityLinks';
import {SsoIdentityRepository} from '@app/api/auth/services/SsoIdentityRepository';
import {
parseTokenEndpointResponse,
sanitizeSsoRedirectTo,
tryDiscoverOidcProviderMetadata,
} from '@app/api/auth/services/SsoUtils';
-import type {UserID} from '@app/api/BrandedTypes';
+import {userHasMfa} from '@app/api/auth/services/SudoMethods';
+import {resolveWebAuthnSecondFactor} from '@app/api/auth/services/WebAuthnSecondFactor';
+import {createRoleID, type UserID} from '@app/api/BrandedTypes';
import {EMPTY_USER_ROW, type UserRow} from '@app/api/database/types/UserTypes';
+import type {GuildMemberService} from '@app/api/guild/services/GuildMemberService';
import {emitActivity} from '@app/api/infrastructure/activity/ActivityEvents';
import type {DiscriminatorService} from '@app/api/infrastructure/DiscriminatorService';
import type {KVActivityTracker} from '@app/api/infrastructure/KVActivityTracker';
-import {usesUsernameSignIn} from '@app/api/instance/AccountIdentityModeCache';
+import {instanceCollectsDateOfBirth} from '@app/api/instance/DateOfBirthCollectionCache';
import {
type InstanceConfigRepository,
type InstanceSsoConfig,
REGISTRATION_PENDING_APPROVAL_TRAIT,
} from '@app/api/instance/InstanceConfigRepository';
-import type {SingleCommunityService} from '@app/api/instance/SingleCommunityService';
+import {canJoinSingleCommunity, type SingleCommunityService} from '@app/api/instance/SingleCommunityService';
import {
deriveSsoRedirectUri,
getSsoRequestUrlPolicy,
@@ -33,11 +39,15 @@ import {
import type {InviteService} from '@app/api/invite/InviteService';
import {Logger} from '@app/api/Logger';
import {profileSubstringBlocklistCache} from '@app/api/middleware/ProfileSubstringBlocklistCache';
-import type {RequestCache} from '@app/api/middleware/RequestCacheMiddleware';
+import {createRequestCache, type RequestCache} from '@app/api/middleware/RequestCacheMiddleware';
import type {User} from '@app/api/models/User';
import {UserSettings} from '@app/api/models/UserSettings';
+import {enqueueStripeCustomerEmailSync} from '@app/api/stripe/StripeCustomer';
import {deriveAvailableUsername, reserveUsername, type UsernameReservation} from '@app/api/user/UniqueUsernames';
+import {isEnforcementDeletion} from '@app/api/user/UserHelpers';
+import {dispatchUserUpdate} from '@app/api/user/UserMappers';
import {USERNAME_MODE_DISCRIMINATOR} from '@app/api/user/UserTag';
+import {DOB_DEFERRED_TRAIT} from '@app/api/user/UserTraits';
import {EXTERNAL_RESPONSE_LIMITS} from '@app/api/utils/ExternalResponseLimits';
import * as FetchUtils from '@app/api/utils/FetchUtils';
import {isJsonRecord, parseJsonRecord, parseJsonWithGuard} from '@app/api/utils/JsonBoundaryUtils';
@@ -46,11 +56,10 @@ import {generateRandomUsername} from '@app/api/utils/UsernameGenerator';
import {deriveUsernameFromDisplayName} from '@app/api/utils/UsernameSuggestionUtils';
import {AccountIdentityModes, TagStyles} from '@fluxer/constants/src/AccountIdentityConstants';
import {SSO_MOBILE_CALLBACK_URI, SSO_MOBILE_STATE_PREFIX} from '@fluxer/constants/src/SsoConstants';
-import {ProfileFieldPrivacyFlags} from '@fluxer/constants/src/UserConstants';
+import {ProfileFieldPrivacyFlags, UserFlags} from '@fluxer/constants/src/UserConstants';
import {ValidationErrorCodes} from '@fluxer/constants/src/ValidationErrorCodes';
-import {RegistrationClosedError} from '@fluxer/errors/src/domains/auth/RegistrationClosedError';
import {RegistrationPendingApprovalError} from '@fluxer/errors/src/domains/auth/RegistrationPendingApprovalError';
-import {SsoRequiredError} from '@fluxer/errors/src/domains/auth/SsoRequiredError';
+import {SsoRequiredError, SsoRequiredReasons} from '@fluxer/errors/src/domains/auth/SsoRequiredError';
import {ContentBlockedError} from '@fluxer/errors/src/domains/content/ContentBlockedError';
import {FeatureTemporarilyDisabledError} from '@fluxer/errors/src/domains/core/FeatureTemporarilyDisabledError';
import {InputValidationError} from '@fluxer/errors/src/domains/core/InputValidationError';
@@ -78,10 +87,26 @@ interface SsoStatePayload {
createdAt: number;
}
+interface PendingSsoLink {
+ userId: string;
+ providerId: string;
+ subject: string;
+ groups: Array<string> | null;
+}
+
+interface SsoSignIn {
+ token: string;
+ user_id: string;
+ redirect_to: string;
+}
+
+type SsoCompletion = SsoSignIn | (LoginMfaResult & {redirect_to: string});
+
interface PublicSsoStatus {
enabled: boolean;
enforced: boolean;
display_name: string | null;
+ button_label: string | null;
redirect_uri: string;
}
@@ -95,10 +120,12 @@ interface ResolvedSsoConfig extends InstanceSsoConfig {
}
interface ResolvedSsoClaims {
- email: string;
+ email: string | null;
emailVerified: boolean;
- name?: string | null;
+ preferredUsername: string | null;
+ name: string | null;
sub: string;
+ groups: Array<string> | null;
}
interface RemoteJwkSetResolver {
@@ -138,7 +165,11 @@ function buildStateCacheKey(state: string): string {
return `sso:state:${state}`;
}
-function buildDiscoveryCacheKey(issuer: string): string {
+function pendingSsoLinkKey(ticket: string): string {
+ return `sso:pending-link:${ticket}`;
+}
+
+export function ssoDiscoveryCacheKey(issuer: string): string {
const key = createHash('sha256').update(issuer).digest('hex').slice(0, 32);
return `sso:oidc-discovery:${key}`;
}
@@ -169,16 +200,6 @@ function validateEmailAgainstAllowlist(email: string, domains: Array<string>): v
}
}
-function buildSsoProviderTrait(providerId: string): string {
- const digest = createHash('sha256').update(providerId).digest('hex').slice(0, 32);
- return `sso_provider:${digest}`;
-}
-
-function buildSsoIdentityTrait(providerId: string, sub: string): string {
- const digest = createHash('sha256').update(providerId).update('\0').update(sub).digest('hex');
- return `sso_identity:${digest}`;
-}
-
function normalizeSsoEmail(rawEmail: string): string {
const email = rawEmail.trim().toLowerCase();
if (!EmailType.safeParse(email).success) {
@@ -202,17 +223,84 @@ function readStringClaim(
return typeof value === 'string' ? value : undefined;
}
-function parseTestProviderClaims(rawPayload: string): ResolvedSsoClaims {
+function readTrimmedClaim(record: Record<string, unknown> | JWTPayload | null | undefined, key: string): string | null {
+ return readStringClaim(record, key)?.trim() || null;
+}
+
+function readDisplayName(record: Record<string, unknown> | JWTPayload | null | undefined): string | null {
+ const name = readTrimmedClaim(record, 'name');
+ if (name) return name;
+ const parts = [readTrimmedClaim(record, 'given_name'), readTrimmedClaim(record, 'family_name')];
+ return parts.filter((part): part is string => part !== null).join(' ') || null;
+}
+
+const DEFAULT_GROUPS_CLAIM = 'groups';
+
+function readGroupsClaim(
+ record: Record<string, unknown> | JWTPayload | null | undefined,
+ key: string,
+): Array<string> | null {
+ const value = record?.[key];
+ if (typeof value === 'string') return [value];
+ if (!Array.isArray(value)) return null;
+ return value.filter((group): group is string => typeof group === 'string');
+}
+
+function parseTestProviderClaims(rawPayload: string, groupsClaim: string): ResolvedSsoClaims {
const parsed = rawPayload.trim().startsWith('{') ? parseJsonRecord(rawPayload) : null;
- const rawEmail = parsed ? readStringClaim(parsed, 'email') : rawPayload;
- if (!rawEmail) {
+ if (!parsed) {
+ const email = normalizeSsoEmail(rawPayload);
+ return {
+ email,
+ emailVerified: true,
+ preferredUsername: null,
+ name: 'Test SSO User',
+ sub: normalizeSsoSubject(email),
+ groups: null,
+ };
+ }
+ const rawEmail = readStringClaim(parsed, 'email');
+ const email = rawEmail ? normalizeSsoEmail(rawEmail) : null;
+ const sub = readStringClaim(parsed, 'sub') ?? email;
+ if (!sub) {
throw InputValidationError.fromCode('code', ValidationErrorCodes.SSO_TEST_CODE_MISSING_EMAIL);
}
- const email = normalizeSsoEmail(rawEmail);
- const sub = normalizeSsoSubject(parsed ? (readStringClaim(parsed, 'sub') ?? email) : email);
- const emailVerified = parsed ? (coerceEmailVerified(parsed['email_verified']) ?? true) : true;
- const name = parsed ? (readStringClaim(parsed, 'name') ?? 'Test SSO User') : 'Test SSO User';
- return {email, emailVerified, name, sub};
+ return {
+ email,
+ emailVerified: email !== null && (coerceEmailVerified(parsed['email_verified']) ?? true),
+ preferredUsername: readTrimmedClaim(parsed, 'preferred_username'),
+ name: readDisplayName(parsed),
+ sub: normalizeSsoSubject(sub),
+ groups: readGroupsClaim(parsed, groupsClaim),
+ };
+}
+
+function deriveSsoUsernameBase(claims: ResolvedSsoClaims): string | null {
+ const preferredUsername = claims.preferredUsername?.split('@')[0];
+ for (const candidate of [preferredUsername, claims.name, claims.email?.split('@')[0]]) {
+ const username = candidate ? deriveUsernameFromDisplayName(candidate) : null;
+ if (username) return username;
+ }
+ return null;
+}
+
+function resolveUsableSsoEmail(
+ claims: ResolvedSsoClaims,
+ allowedEmailDomains: Array<string>,
+ usernameMode: boolean,
+): string | null {
+ const emailRequired = !usernameMode || allowedEmailDomains.length > 0;
+ if (!emailRequired) {
+ return claims.emailVerified ? claims.email : null;
+ }
+ if (!claims.email) {
+ throw InputValidationError.fromCode('email', ValidationErrorCodes.SSO_PROVIDER_DID_NOT_RETURN_EMAIL);
+ }
+ if (!claims.emailVerified) {
+ throw InputValidationError.fromCode('email_verified', ValidationErrorCodes.SSO_EMAIL_NOT_VERIFIED);
+ }
+ validateEmailAgainstAllowlist(claims.email, allowedEmailDomains);
+ return claims.email;
}
function readMatchingEmailVerified(
@@ -269,6 +357,7 @@ export class SsoService {
private readonly kvActivityTracker: KVActivityTracker,
private readonly singleCommunityService: SingleCommunityService,
private readonly inviteService: InviteService,
+ private readonly guildMemberService: GuildMemberService,
) {}
async getPublicStatus(): Promise<PublicSsoStatus> {
@@ -278,6 +367,7 @@ export class SsoService {
enabled,
enforced: enabled && config.enforced,
display_name: config.displayName ?? null,
+ button_label: config.buttonLabel,
redirect_uri: config.redirectUri,
};
}
@@ -340,16 +430,14 @@ export class SsoService {
state,
request,
requestCache,
+ clientIp,
}: {
code: string;
state: string;
request: Request;
requestCache: RequestCache;
- }): Promise<{
- token: string;
- user_id: string;
- redirect_to: string;
- }> {
+ clientIp: string;
+ }): Promise<SsoCompletion> {
const config = await this.requireReadyConfig();
const {cache} = this.apiContext.services;
const statePayload = await cache.getAndDelete<SsoStatePayload>(buildStateCacheKey(state));
@@ -363,56 +451,131 @@ export class SsoService {
config,
});
const claims = await this.resolveClaims(tokenResponse, config, statePayload.nonce);
- const user = await this.resolveUserFromClaims(claims, config, requestCache);
+ const redirectTo = statePayload.redirectTo ?? '';
+ const resolved = await this.resolveUserFromClaims(claims, config, requestCache, clientIp);
+ if (resolved.secondFactorRequired) {
+ return {...(await this.challengeSecondFactor(resolved.user, claims, config)), redirect_to: redirectTo};
+ }
+ const {user} = resolved;
+ await this.joinCommunityAndSyncRoles(user, claims.groups, config, requestCache);
const [token] = await AuthSession.createAuthSession(this.apiContext, {
user,
origin: AuthSession.resolveSessionOrigin(this.apiContext, request),
});
- return {token, user_id: user.id.toString(), redirect_to: statePayload.redirectTo ?? ''};
+ if (config.enforced && claims.email && claims.emailVerified) {
+ await this.syncEnforcedEmail(user, claims.email);
+ }
+ return {token, user_id: user.id.toString(), redirect_to: redirectTo};
}
- private async resolveUserFromClaims(
+ async isPendingLinkTicket(ticket: string): Promise<boolean> {
+ return this.apiContext.services.cache.exists(pendingSsoLinkKey(ticket));
+ }
+
+ async completePendingLink(user: User, ticket: string): Promise<User> {
+ const {cache} = this.apiContext.services;
+ const pending = await cache.getAndDelete<PendingSsoLink>(pendingSsoLinkKey(ticket));
+ if (!pending) {
+ return user;
+ }
+ try {
+ const config = await this.requireReadyConfig();
+ if (pending.userId !== user.id.toString() || pending.providerId !== config.providerId) {
+ throw InputValidationError.fromCode('ticket', ValidationErrorCodes.SESSION_TIMEOUT);
+ }
+ const linkedUser = await this.bindSsoIdentity(user, pending.subject, config);
+ await this.joinCommunityAndSyncRoles(linkedUser, pending.groups, config, createRequestCache());
+ return linkedUser;
+ } catch (error) {
+ await cache.delete(`mfa-ticket:${ticket}`);
+ throw error;
+ }
+ }
+
+ private async challengeSecondFactor(
+ user: User,
claims: ResolvedSsoClaims,
config: ResolvedSsoConfig,
+ ): Promise<LoginMfaResult> {
+ AuthUtility.assertMfaTicketAllowed(this.apiContext, user);
+ const challenge = await createMfaTicketResponse(
+ this.apiContext,
+ user,
+ await resolveWebAuthnSecondFactor(this.apiContext, user),
+ );
+ const pending: PendingSsoLink = {
+ userId: user.id.toString(),
+ providerId: config.providerId,
+ subject: claims.sub,
+ groups: claims.groups,
+ };
+ await this.apiContext.services.cache.set(pendingSsoLinkKey(challenge.ticket), pending, seconds('5 minutes'));
+ return challenge;
+ }
+
+ private async hasSecondFactor(user: User): Promise<boolean> {
+ return (
+ userHasMfa(user) ||
+ (await resolveWebAuthnSecondFactor(this.apiContext, user)) ||
+ (await AuthMfa.hasUnconsumedBackupCodes(this.apiContext, user.id))
+ );
+ }
+
+ private async joinCommunityAndSyncRoles(
+ user: User,
+ groups: Array<string> | null,
+ config: ResolvedSsoConfig,
requestCache: RequestCache,
- ): Promise<User> {
- if (!claims.emailVerified) {
- throw InputValidationError.fromCode('email_verified', ValidationErrorCodes.INVALID_SSO_TOKEN);
+ ): Promise<void> {
+ if (canJoinSingleCommunity(user)) {
+ await this.singleCommunityService.joinStockCommunity(user.id, requestCache);
}
- const emailLower = claims.email.toLowerCase();
- getLogger().info(
- usesUsernameSignIn() ? {has_sub: true} : {email: emailLower, has_sub: true},
- 'SSO login with sub claim',
- );
- const identityUserId = await this.ssoIdentityRepository.findUserId(config.providerId, claims.sub);
- if (identityUserId) {
- const user = await this.apiContext.services.users.findUnique(identityUserId);
- if (!user) {
- getLogger().error(
- {user_id: identityUserId.toString()},
- 'SSO identity mapping points at a missing user; refusing reassignment',
- );
- throw InputValidationError.fromCode('sub', ValidationErrorCodes.SSO_IDENTITY_MISMATCH);
- }
- return this.bindSsoIdentity(user, claims.sub, config);
+ await this.syncGroupRoles(user, groups, config, requestCache);
+ }
+
+ private async resolveUserFromClaims(
+ claims: ResolvedSsoClaims,
+ config: ResolvedSsoConfig,
+ requestCache: RequestCache,
+ clientIp: string,
+ ): Promise<{user: User; secondFactorRequired: boolean}> {
+ const accountIdentity = await this.instanceConfigRepository.getAccountIdentity();
+ const usernameMode = accountIdentity.mode === AccountIdentityModes.USERNAME;
+ const email = resolveUsableSsoEmail(claims, config.allowedEmailDomains, usernameMode);
+ getLogger().info(usernameMode ? {has_sub: true} : {email, has_sub: true}, 'SSO login with sub claim');
+ const mappedUser = await this.findMappedUser(claims.sub, config, usernameMode ? null : email);
+ if (mappedUser) {
+ return {user: await this.bindSsoIdentity(mappedUser, claims.sub, config), secondFactorRequired: false};
}
const {users} = this.apiContext.services;
- const existingUser = await users.findByEmail(emailLower);
+ const existingUser = email ? await users.findByEmail(email) : null;
if (existingUser) {
- return this.bindSsoIdentity(existingUser, claims.sub, config);
+ this.assertLinkable(existingUser, claims.sub, config);
+ if (
+ !existingUser.traits.has(ssoIdentityTrait(config.providerId, claims.sub)) &&
+ (await this.hasSecondFactor(existingUser))
+ ) {
+ return {user: existingUser, secondFactorRequired: true};
+ }
+ return {user: await this.bindSsoIdentity(existingUser, claims.sub, config), secondFactorRequired: false};
}
AuthUtility.assertNetworkAllowed(this.apiContext);
if (!config.autoProvision) {
- throw new SsoRequiredError();
+ throw new SsoRequiredError(SsoRequiredReasons.NO_ACCOUNT);
}
+ await assertAccountCreationPastSetup(this.apiContext, this.instanceConfigRepository, clientIp);
const registrationConfig = await this.instanceConfigRepository.getRegistrationConfig();
- if (registrationConfig.mode === 'closed') {
- throw new RegistrationClosedError();
+ if (email) {
+ await assertEmailNotBlocklisted(email, 'email');
}
- await assertEmailNotBlocklisted(emailLower, 'email');
const pendingApproval = registrationConfig.mode === 'approval';
const autoJoinInviteCode = this.apiContext.services.config.instance.autoJoinInviteCode?.trim() || null;
- const user = await this.provisionUserFromClaims(claims, config, {pendingApproval, autoJoinInviteCode});
+ const user = await this.provisionUserFromClaims({...claims, email}, config, {
+ usernameMode,
+ uniqueUsernames: accountIdentity.tagStyle === TagStyles.NONE,
+ pendingApproval,
+ autoJoinInviteCode,
+ });
if (pendingApproval) {
throw new RegistrationPendingApprovalError();
}
@@ -421,8 +584,84 @@ export class SsoService {
inviteCode: autoJoinInviteCode,
requestCache,
});
- await this.singleCommunityService.joinStockCommunity(user.id, requestCache);
- return user;
+ return {user, secondFactorRequired: false};
+ }
+
+ private async syncGroupRoles(
+ user: User,
+ groups: Array<string> | null,
+ config: ResolvedSsoConfig,
+ requestCache: RequestCache,
+ ): Promise<void> {
+ if (groups === null || config.groupRoleMappings.length === 0) return;
+ const guildId = await this.singleCommunityService.getStockCommunityId();
+ if (guildId === null) return;
+ const memberOf = new Set(groups);
+ try {
+ await this.guildMemberService.systemSyncManagedRoles({
+ targetId: user.id,
+ guildId,
+ managedRoleIds: new Set(config.groupRoleMappings.map(({roleId}) => createRoleID(BigInt(roleId)))),
+ grantedRoleIds: new Set(
+ config.groupRoleMappings
+ .filter(({group}) => memberOf.has(group))
+ .map(({roleId}) => createRoleID(BigInt(roleId))),
+ ),
+ requestCache,
+ });
+ } catch (error) {
+ getLogger().error({error, user_id: user.id.toString()}, 'Failed to sync community roles from SSO groups');
+ }
+ }
+
+ private async findMappedUser(sub: string, config: ResolvedSsoConfig, email: string | null): Promise<User | null> {
+ const identityUserId = await this.ssoIdentityRepository.findUserId(config.providerId, sub);
+ if (!identityUserId) {
+ return null;
+ }
+ const user = await this.apiContext.services.users.findUnique(identityUserId);
+ if (!user) {
+ getLogger().error(
+ {user_id: identityUserId.toString()},
+ 'SSO identity mapping points at a missing user; refusing reassignment',
+ );
+ throw InputValidationError.fromCode('sub', ValidationErrorCodes.SSO_IDENTITY_LINKED_TO_ANOTHER_ACCOUNT);
+ }
+ if ((user.flags & UserFlags.DELETED) === 0n) {
+ return user;
+ }
+ if (isEnforcementDeletion(user) && (email === null || (await isEmailBlocklisted(email)))) {
+ return user;
+ }
+ await this.ssoIdentityRepository.releaseIdentity(config.providerId, sub);
+ getLogger().info({user_id: user.id.toString()}, 'Released SSO identity of a deleted account');
+ return null;
+ }
+
+ private async syncEnforcedEmail(user: User, email: string): Promise<void> {
+ if (user.email?.toLowerCase() === email) {
+ return;
+ }
+ const accountIdentity = await this.instanceConfigRepository.getAccountIdentity();
+ if (accountIdentity.mode === AccountIdentityModes.USERNAME) {
+ return;
+ }
+ const {users, gateway, worker} = this.apiContext.services;
+ const holder = await users.findByEmail(email);
+ if (holder) {
+ getLogger().warn(
+ {user_id: user.id.toString(), holder_user_id: holder.id.toString()},
+ 'SSO provider email belongs to another account; keeping the current email',
+ );
+ return;
+ }
+ const updatedUser = await users.patchUpsert(
+ user.id,
+ {email, email_verified: true, email_bounced: false},
+ user.toRow(),
+ );
+ await enqueueStripeCustomerEmailSync(worker, user, updatedUser);
+ await dispatchUserUpdate(gateway, updatedUser);
}
private async claimSsoIdentity(userId: UserID, sub: string, config: ResolvedSsoConfig): Promise<void> {
@@ -435,33 +674,38 @@ export class SsoService {
if (claimed) {
return;
}
- const ownerId = await this.ssoIdentityRepository.findUserId(config.providerId, sub);
- if (ownerId?.toString() === userId.toString()) {
+ const owned = await this.ssoIdentityRepository.findIdentity(config.providerId, sub);
+ if (owned?.user_id === userId) {
+ await this.ssoIdentityRepository.indexIdentity(owned);
return;
}
getLogger().error(
- {user_id: userId.toString(), owner_user_id: ownerId?.toString() ?? null},
+ {user_id: userId.toString(), owner_user_id: owned?.user_id.toString() ?? null},
'SSO identity is already linked to another account',
);
- throw InputValidationError.fromCode('sub', ValidationErrorCodes.SSO_IDENTITY_MISMATCH);
+ throw InputValidationError.fromCode('sub', ValidationErrorCodes.SSO_IDENTITY_LINKED_TO_ANOTHER_ACCOUNT);
}
- private async bindSsoIdentity(user: User, sub: string, config: ResolvedSsoConfig): Promise<User> {
- const identityTrait = buildSsoIdentityTrait(config.providerId, sub);
- const traits = user.traits;
- const existingIdentities = Array.from(traits).filter((trait) => trait.startsWith('sso_identity:'));
- if (existingIdentities.length > 0 && !traits.has(identityTrait)) {
+ private assertLinkable(user: User, sub: string, config: ResolvedSsoConfig): void {
+ const identityTrait = ssoIdentityTrait(config.providerId, sub);
+ const existingIdentities = Array.from(user.traits).filter((trait) => trait.startsWith('sso_identity:'));
+ if (existingIdentities.length > 0 && !user.traits.has(identityTrait)) {
getLogger().error({user_id: user.id.toString()}, 'SSO identity claim did not match linked account');
- throw InputValidationError.fromCode('sub', ValidationErrorCodes.SSO_IDENTITY_MISMATCH);
+ throw InputValidationError.fromCode('sub', ValidationErrorCodes.SSO_ACCOUNT_LINKED_TO_ANOTHER_IDENTITY);
}
+ }
+
+ private async bindSsoIdentity(user: User, sub: string, config: ResolvedSsoConfig): Promise<User> {
+ const identityTrait = ssoIdentityTrait(config.providerId, sub);
+ const traits = user.traits;
+ this.assertLinkable(user, sub, config);
await this.claimSsoIdentity(user.id, sub, config);
if (traits.has(identityTrait)) {
return user;
}
- traits.add('sso');
- traits.add(`sso:${config.providerId}`);
- traits.add(buildSsoProviderTrait(config.providerId));
- traits.add(identityTrait);
+ for (const trait of ssoIdentityTraits(config.providerId, sub)) {
+ traits.add(trait);
+ }
const {users} = this.apiContext.services;
return users.patchUpsert(user.id, {traits}, user.toRow());
}
@@ -477,30 +721,27 @@ export class SsoService {
private async provisionUserFromClaims(
claims: ResolvedSsoClaims,
config: ResolvedSsoConfig,
- options?: {
- pendingApproval?: boolean;
- autoJoinInviteCode?: string | null;
+ options: {
+ usernameMode: boolean;
+ uniqueUsernames: boolean;
+ pendingApproval: boolean;
+ autoJoinInviteCode: string | null;
},
): Promise<User> {
const {users, snowflake, cache} = this.apiContext.services;
- const accountIdentity = await this.instanceConfigRepository.getAccountIdentity();
- const usernameMode = accountIdentity.mode === AccountIdentityModes.USERNAME;
- const uniqueUsernames = accountIdentity.tagStyle === TagStyles.NONE;
+ const {usernameMode, uniqueUsernames} = options;
const userId = (await snowflake.generate()) as UserID;
- const baseName = claims.name?.trim() || claims.email.split('@')[0] || generateRandomUsername();
- const derivedUsername = deriveUsernameFromDisplayName(baseName) ?? generateRandomUsername();
+ const derivedUsername = deriveSsoUsernameBase(claims) ?? generateRandomUsername();
const username = uniqueUsernames ? await deriveAvailableUsername(users, derivedUsername) : derivedUsername;
const discriminator = uniqueUsernames ? USERNAME_MODE_DISCRIMINATOR : await this.allocateDiscriminator(username);
const now = new Date();
- const traits = new Set<string>([
- 'sso',
- `sso:${config.providerId}`,
- buildSsoProviderTrait(config.providerId),
- buildSsoIdentityTrait(config.providerId, claims.sub),
- ]);
- if (options?.pendingApproval) {
+ const traits = new Set<string>(ssoIdentityTraits(config.providerId, claims.sub));
+ if (options.pendingApproval) {
traits.add(REGISTRATION_PENDING_APPROVAL_TRAIT);
}
+ if (instanceCollectsDateOfBirth()) {
+ traits.add(DOB_DEFERRED_TRAIT);
+ }
const globalName = claims.name?.substring(0, 256) ?? username;
if (
profileSubstringBlocklistCache.containsBannedSubstring('username', username) ||
@@ -516,28 +757,27 @@ export class SsoService {
global_name: globalName,
bot: false,
system: false,
- email: usernameMode ? null : claims.email.toLowerCase(),
- email_verified: claims.emailVerified,
+ email: usernameMode ? null : claims.email,
+ email_verified: claims.email !== null && claims.emailVerified,
email_bounced: false,
timezone_privacy_flags: ProfileFieldPrivacyFlags.EVERYONE,
flags: 0n,
has_ever_purchased: false,
- terms_agreed_at: now,
- privacy_agreed_at: now,
+ terms_agreed_at: null,
+ privacy_agreed_at: null,
last_active_at: now,
acls: new Set<string>(),
traits,
version: 1,
};
await this.claimSsoIdentity(userId, claims.sub, config);
- let createAttempted = false;
- let userCreated = false;
+ let creationStage: 'unattempted' | 'attempted' | 'created' = 'unattempted';
let usernameReservation: UsernameReservation | null = null;
try {
if (uniqueUsernames) {
usernameReservation = await reserveUsername({users, cache}, username);
}
- if (options?.pendingApproval) {
+ if (options.pendingApproval) {
await this.instanceConfigRepository.addPendingRegistration({
user_id: userId.toString(),
username,
@@ -547,17 +787,17 @@ export class SsoService {
requested_at: now.toISOString(),
registration_url_id: null,
client_ip: null,
- invite_code: options.autoJoinInviteCode ?? null,
+ invite_code: options.autoJoinInviteCode,
});
}
- createAttempted = true;
+ creationStage = 'attempted';
const user = await users.create(userRow);
- userCreated = true;
+ creationStage = 'created';
await users.upsertSettings(
UserSettings.getDefaultUserSettings({
userId,
locale: 'en-US',
- isAdult: true,
+ isAdult: !instanceCollectsDateOfBirth(),
}),
);
void this.kvActivityTracker.updateActivity(user.id, now).catch((error: unknown) => {
@@ -569,6 +809,7 @@ export class SsoService {
{
user_id: user.id.toString(),
method: 'oauth',
+ source: 'app',
email: user.email,
username: user.username,
username_user_chosen: false,
@@ -584,11 +825,11 @@ export class SsoService {
);
return user;
} catch (error) {
- if (!userCreated) {
+ if (creationStage !== 'created') {
await this.ssoIdentityRepository.releaseIdentity(config.providerId, claims.sub).catch((releaseError) => {
getLogger().error({releaseError}, 'Failed to release SSO identity after user provisioning failed');
});
- if (options?.pendingApproval && !createAttempted) {
+ if (options.pendingApproval && creationStage === 'unattempted') {
await this.instanceConfigRepository
.removePendingRegistration(userId.toString())
.catch((removeError: unknown) => {
@@ -618,9 +859,7 @@ export class SsoService {
if (!rawEmail) {
throw InputValidationError.fromCode('code', ValidationErrorCodes.SSO_TEST_CODE_MISSING_EMAIL);
}
- const testClaims = parseTestProviderClaims(rawEmail);
- validateEmailAgainstAllowlist(testClaims.email, config.allowedEmailDomains);
- return testClaims;
+ return parseTestProviderClaims(rawEmail, config.groupsClaim ?? DEFAULT_GROUPS_CLAIM);
}
let claims: JWTPayload | null = null;
if (tokenResponse.id_token) {
@@ -658,27 +897,27 @@ export class SsoService {
getLogger().error('SSO email mismatch between id_token and userinfo');
throw InputValidationError.fromCode('email', ValidationErrorCodes.SSO_IDENTITY_MISMATCH);
}
- const email =
- normalizedIdTokenEmail ??
- normalizedUserInfoEmail ??
- (() => {
- throw InputValidationError.fromCode('email', ValidationErrorCodes.SSO_PROVIDER_DID_NOT_RETURN_EMAIL);
- })();
- const primaryClaims = normalizedIdTokenEmail ? claims : userInfo;
- const emailVerified = resolveEmailVerified({
- claims,
- userInfo,
- idTokenEmail: normalizedIdTokenEmail,
- userInfoEmail: normalizedUserInfoEmail,
+ const email = normalizedIdTokenEmail ?? normalizedUserInfoEmail ?? null;
+ const emailVerified =
+ email !== null &&
+ resolveEmailVerified({
+ claims,
+ userInfo,
+ idTokenEmail: normalizedIdTokenEmail,
+ userInfoEmail: normalizedUserInfoEmail,
+ email,
+ });
+ return {
email,
- });
- if (!emailVerified) {
- throw InputValidationError.fromCode('email_verified', ValidationErrorCodes.INVALID_SSO_TOKEN);
- }
- const name = readStringClaim(primaryClaims, 'name') ?? null;
- validateEmailAgainstAllowlist(email, config.allowedEmailDomains);
- const resolvedClaims: ResolvedSsoClaims = {email, emailVerified, name, sub};
- return resolvedClaims;
+ emailVerified,
+ preferredUsername:
+ readTrimmedClaim(claims, 'preferred_username') ?? readTrimmedClaim(userInfo, 'preferred_username'),
+ name: readDisplayName(claims) ?? readDisplayName(userInfo),
+ sub,
+ groups:
+ readGroupsClaim(claims, config.groupsClaim ?? DEFAULT_GROUPS_CLAIM) ??
+ readGroupsClaim(userInfo, config.groupsClaim ?? DEFAULT_GROUPS_CLAIM),
+ };
}
private async verifyIdToken(idToken: string, config: ResolvedSsoConfig, expectedNonce: string): Promise<JWTPayload> {
@@ -906,7 +1145,7 @@ export class SsoService {
const stored = await this.instanceConfigRepository.getSsoConfig({includeSecret: true});
const redirectUri = deriveSsoRedirectUri(config.endpoints.webApp);
const scope = stored.scope?.trim() || 'openid email profile';
- const providerId = stored.issuer || stored.authorizationUrl || 'sso';
+ const providerId = ssoProviderIdOf(stored);
let authorizationUrl = stored.authorizationUrl;
let tokenUrl = stored.tokenUrl;
let userInfoUrl = stored.userInfoUrl;
@@ -924,7 +1163,7 @@ export class SsoService {
? await this.validateOptionalPublicOutboundUrl(stored.issuer, 'issuer')
: stored.issuer;
if (validatedIssuer) {
- const cacheKey = buildDiscoveryCacheKey(validatedIssuer);
+ const cacheKey = ssoDiscoveryCacheKey(validatedIssuer);
const {cache} = this.apiContext.services;
let discovered = await cache.get<{
issuer: string;
diff --git a/fluxer_api/src/api/guild/services/GuildMemberService.ts b/fluxer_api/src/api/guild/services/GuildMemberService.ts
index 9d69f895e..cea77ab64 100644
--- a/fluxer_api/src/api/guild/services/GuildMemberService.ts
+++ b/fluxer_api/src/api/guild/services/GuildMemberService.ts
@@ -18,6 +18,7 @@ import type {LimitConfigService} from '@app/api/limits/LimitConfigService';
import type {RequestCache} from '@app/api/middleware/RequestCacheMiddleware';
import type {Guild} from '@app/api/models/Guild';
import type {GuildMember} from '@app/api/models/GuildMember';
+import type {TierContext} from '@app/api/user/AccountTier';
import type {UserRepository} from '@app/api/user/repositories/UserRepository';
import {AuditLogActionType} from '@fluxer/constants/src/AuditLogActionType';
import type {JoinSourceType} from '@fluxer/constants/src/GuildConstants';
@@ -215,6 +216,58 @@ export class GuildMemberService {
});
}
+ async systemSyncManagedRoles(params: {
+ targetId: UserID;
+ guildId: GuildID;
+ managedRoleIds: ReadonlySet<RoleID>;
+ grantedRoleIds: ReadonlySet<RoleID>;
+ requestCache: RequestCache;
+ }): Promise<void> {
+ const {targetId, guildId, managedRoleIds, grantedRoleIds, requestCache} = params;
+ const member = await this.guildRepository.getMember(guildId, targetId);
+ if (!member) return;
+ const existingRoleIds = new Set((await this.guildRepository.listRoles(guildId)).map((role) => role.id));
+ const nextRoleIds = new Set([...member.roleIds].filter((roleId) => !managedRoleIds.has(roleId)));
+ for (const roleId of grantedRoleIds) {
+ if (managedRoleIds.has(roleId) && existingRoleIds.has(roleId)) nextRoleIds.add(roleId);
+ }
+ if (nextRoleIds.size === member.roleIds.size && [...nextRoleIds].every((roleId) => member.roleIds.has(roleId))) {
+ return;
+ }
+ const previousSnapshot = this.auditService.serializeMemberForAudit(member);
+ await this.guildRepository.upsertMember({...member.toRow(), role_ids: nextRoleIds});
+ const updatedMember = await this.guildRepository.getMember(guildId, targetId);
+ if (!updatedMember) return;
+ await this.eventService.dispatchGuildMemberUpdate({guildId, member: updatedMember, requestCache});
+ await this.refreshMemberSearchIndex(updatedMember);
+ await this.guildAuditLogService.record({
+ guildId,
+ userId: SYSTEM_USER_ID,
+ action: AuditLogActionType.MEMBER_ROLE_UPDATE,
+ targetId,
+ auditLogReason: null,
+ changes: this.guildAuditLogService.computeChanges(
+ previousSnapshot,
+ this.auditService.serializeMemberForAudit(updatedMember),
+ ),
+ });
+ }
+
+ async systemRemoveMemberRole(params: {
+ targetId: UserID;
+ guildId: GuildID;
+ roleId: RoleID;
+ initiatorId: UserID;
+ requestCache: RequestCache;
+ }): Promise<void> {
+ await this.applyRoleChange({
+ ...params,
+ actorId: params.initiatorId,
+ auditLogReason: null,
+ mutate: () => this.roleService.systemRemoveMemberRole(params),
+ });
+ }
+
async removeMemberRole(
params: {
userId: UserID;
@@ -286,6 +339,7 @@ export class GuildMemberService {
inviterId?: UserID;
requestCache: RequestCache;
initiatorId?: UserID;
+ tierContext?: TierContext;
}): Promise<GuildMember> {
return this.operationsService.addUserToGuild(params, this.eventService);
}
diff --git a/fluxer_api/src/api/guild/services/member/GuildMemberRoleService.ts b/fluxer_api/src/api/guild/services/member/GuildMemberRoleService.ts
index 874642790..2f371fb5d 100644
--- a/fluxer_api/src/api/guild/services/member/GuildMemberRoleService.ts
+++ b/fluxer_api/src/api/guild/services/member/GuildMemberRoleService.ts
@@ -44,6 +44,16 @@ export class GuildMemberRoleService {
await this.applyAddMemberRole(targetMember, guildId, targetId, roleId);
}
+ async systemRemoveMemberRole(params: {targetId: UserID; guildId: GuildID; roleId: RoleID}): Promise<void> {
+ const {targetId, guildId, roleId} = params;
+ const targetMember = await this.guildRepository.getMember(guildId, targetId);
+ if (!targetMember) throw new UnknownGuildMemberError();
+ if (!targetMember.roleIds.has(roleId)) return;
+ const updatedRoleIds = new Set(targetMember.roleIds);
+ updatedRoleIds.delete(roleId);
+ await this.guildRepository.upsertMember({...targetMember.toRow(), role_ids: updatedRoleIds});
+ }
+
async addMemberRole(params: {userId: UserID; targetId: UserID; guildId: GuildID; roleId: RoleID}): Promise<void> {
const {userId, targetId, guildId, roleId} = params;
const {guildData, hasPermission, canManageRoles} = await getGuildAuth(this.gatewayService, this.userRepository, {