Skip to content

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

TypeScript fluxerfluxerapp

feat(constants): add verification levels, gated actions, traits

Hampus2ce77f7413ed
diff --git a/packages/constants/src/AccountTierConstants.ts b/packages/constants/src/AccountTierConstants.ts
new file mode 100644
index 000000000..dbfec9f1a
--- /dev/null
+++ b/packages/constants/src/AccountTierConstants.ts
@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+import {APIErrorCodes} from '@fluxer/constants/src/ApiErrorCodes';
+import {ValidationErrorCodes} from '@fluxer/constants/src/ValidationErrorCodes';
+import type {ValueOf} from '@fluxer/constants/src/ValueOf';
+
+export const AccountTiers = {
+ UNCLAIMED: 'unclaimed',
+ UNVERIFIED: 'unverified',
+ VERIFIED: 'verified',
+} as const;
+
+export type AccountTier = ValueOf<typeof AccountTiers>;
+
+export type RestrictedAccountTier = Exclude<AccountTier, typeof AccountTiers.VERIFIED>;
+
+export const AccountVerificationNeeds = {
+ ADD_EMAIL: 'add_email',
+ CONFIRM_EMAIL: 'confirm_email',
+ SET_PASSWORD: 'password',
+} as const;
+
+export type AccountVerificationNeed = ValueOf<typeof AccountVerificationNeeds>;
+
+export const TierGatedActions = {
+ MESSAGE: 'message',
+ TYPING: 'typing',
+ REACTION: 'reaction',
+ DIRECT_MESSAGE: 'direct_message',
+ DIRECT_MESSAGE_OPEN: 'direct_message_open',
+ GROUP_DM: 'group_dm',
+ FRIEND_REQUEST: 'friend_request',
+ FRIEND_ACCEPT: 'friend_accept',
+ INVITE_CREATE: 'invite_create',
+ GUILD_JOIN: 'guild_join',
+ GUILD_CREATE: 'guild_create',
+ VOICE: 'voice',
+ CALL: 'call',
+ GROUP_CALL: 'group_call',
+ THREAD_JOIN: 'thread_join',
+ CHANNEL_FOLLOW: 'channel_follow',
+ OWNERSHIP_TRANSFER: 'ownership_transfer',
+ APPLICATION_CREATE: 'application_create',
+ GIFT_REDEEM: 'gift_redeem',
+ PROFILE_CUSTOMIZE: 'profile_customize',
+ REPORT: 'report',
+ MFA: 'mfa',
+ GUILD_VERIFICATION: 'guild_verification',
+} as const;
+
+export type TierGatedAction = ValueOf<typeof TierGatedActions>;
+
+export const TierExemptions = {
+ GUILD_OWNER: 'guild_owner',
+} as const;
+
+export type TierExemption = ValueOf<typeof TierExemptions>;
+
+export const LocalCredentialKinds = {
+ NONE: 'none',
+ PASSWORD: 'password',
+ PASSKEY: 'passkey',
+ PASSWORD_AND_PASSKEY: 'password_and_passkey',
+} as const;
+
+export type LocalCredentialKind = ValueOf<typeof LocalCredentialKinds>;
+
+export function localCredentialKindOf(params: {hasPassword: boolean; hasPasskey: boolean}): LocalCredentialKind {
+ if (params.hasPassword && params.hasPasskey) return LocalCredentialKinds.PASSWORD_AND_PASSKEY;
+ if (params.hasPassword) return LocalCredentialKinds.PASSWORD;
+ if (params.hasPasskey) return LocalCredentialKinds.PASSKEY;
+ return LocalCredentialKinds.NONE;
+}
+
+export const TierDenialErrors = {
+ ACCOUNT_VERIFICATION_REQUIRED: APIErrorCodes.ACCOUNT_VERIFICATION_REQUIRED,
+ EMAIL_VERIFICATION_REQUIRED: APIErrorCodes.EMAIL_VERIFICATION_REQUIRED,
+ DIRECT_MESSAGE_EMAIL_VERIFICATION_REQUIRED: APIErrorCodes.DIRECT_MESSAGE_EMAIL_VERIFICATION_REQUIRED,
+ FRIEND_REQUEST_EMAIL_VERIFICATION_REQUIRED: APIErrorCodes.FRIEND_REQUEST_EMAIL_VERIFICATION_REQUIRED,
+ GUILD_CREATION_EMAIL_VERIFICATION_REQUIRED: APIErrorCodes.GUILD_CREATION_EMAIL_VERIFICATION_REQUIRED,
+ GUILD_EMAIL_VERIFICATION_REQUIRED: APIErrorCodes.GUILD_EMAIL_VERIFICATION_REQUIRED,
+ GUILD_VERIFICATION_REQUIRED: APIErrorCodes.GUILD_VERIFICATION_REQUIRED,
+ MFA_EMAIL_VERIFICATION_REQUIRED: APIErrorCodes.MFA_EMAIL_VERIFICATION_REQUIRED,
+ PROFILE_EMAIL_VERIFICATION_REQUIRED: APIErrorCodes.PROFILE_EMAIL_VERIFICATION_REQUIRED,
+ REACTION_EMAIL_VERIFICATION_REQUIRED: APIErrorCodes.REACTION_EMAIL_VERIFICATION_REQUIRED,
+ REPORT_EMAIL_VERIFICATION_REQUIRED: APIErrorCodes.REPORT_EMAIL_VERIFICATION_REQUIRED,
+ UNCLAIMED_ACCOUNT_CANNOT_ACCEPT_FRIEND_REQUESTS: APIErrorCodes.UNCLAIMED_ACCOUNT_CANNOT_ACCEPT_FRIEND_REQUESTS,
+ UNCLAIMED_ACCOUNT_CANNOT_ADD_REACTIONS: APIErrorCodes.UNCLAIMED_ACCOUNT_CANNOT_ADD_REACTIONS,
+ UNCLAIMED_ACCOUNT_CANNOT_CREATE_APPLICATIONS: APIErrorCodes.UNCLAIMED_ACCOUNT_CANNOT_CREATE_APPLICATIONS,
+ UNCLAIMED_ACCOUNT_CANNOT_CREATE_GUILDS: APIErrorCodes.UNCLAIMED_ACCOUNT_CANNOT_CREATE_GUILDS,
+ UNCLAIMED_ACCOUNT_CANNOT_JOIN_GROUP_DMS: APIErrorCodes.UNCLAIMED_ACCOUNT_CANNOT_JOIN_GROUP_DMS,
+ UNCLAIMED_ACCOUNT_CANNOT_JOIN_ONE_ON_ONE_VOICE_CALLS:
+ APIErrorCodes.UNCLAIMED_ACCOUNT_CANNOT_JOIN_ONE_ON_ONE_VOICE_CALLS,
+ UNCLAIMED_ACCOUNT_CANNOT_JOIN_VOICE_CHANNELS: APIErrorCodes.UNCLAIMED_ACCOUNT_CANNOT_JOIN_VOICE_CHANNELS,
+ UNCLAIMED_ACCOUNT_CANNOT_SEND_DIRECT_MESSAGES: APIErrorCodes.UNCLAIMED_ACCOUNT_CANNOT_SEND_DIRECT_MESSAGES,
+ UNCLAIMED_ACCOUNT_CANNOT_SEND_FRIEND_REQUESTS: APIErrorCodes.UNCLAIMED_ACCOUNT_CANNOT_SEND_FRIEND_REQUESTS,
+ UNCLAIMED_ACCOUNT_CANNOT_SEND_MESSAGES: APIErrorCodes.UNCLAIMED_ACCOUNT_CANNOT_SEND_MESSAGES,
+ UNCLAIMED_ACCOUNT_CANNOT_SUBMIT_REPORTS: APIErrorCodes.UNCLAIMED_ACCOUNT_CANNOT_SUBMIT_REPORTS,
+ UNCLAIMED_ACCOUNTS_CAN_ONLY_SET_EMAIL_VIA_TOKEN: ValidationErrorCodes.UNCLAIMED_ACCOUNTS_CAN_ONLY_SET_EMAIL_VIA_TOKEN,
+} as const;
+
+export type TierDenialError = ValueOf<typeof TierDenialErrors>;
+
+export const PurchaseBlockedReasons = {
+ UNCLAIMED: 'unclaimed',
+ EMAIL_UNVERIFIED: 'email_unverified',
+ NO_RECEIPT_EMAIL: 'no_receipt_email',
+} as const;
+
+export type PurchaseBlockedReason = ValueOf<typeof PurchaseBlockedReasons>;
diff --git a/packages/constants/src/AccountTierRules.ts b/packages/constants/src/AccountTierRules.ts
new file mode 100644
index 000000000..a52752e45
--- /dev/null
+++ b/packages/constants/src/AccountTierRules.ts
@@ -0,0 +1,359 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+import {
+ type EffectiveVerificationBasis,
+ EmailCodeAvailability,
+ type EmailDeliveryMode,
+ EmailDeliveryModes,
+ type EmailDeliveryState,
+ EmailDeliveryStates,
+ type IdentifierFirstMode,
+ IdentifierFirstModes,
+ InstantAccountAvailability,
+ type InteractionTierMode,
+ InteractionTierModes,
+ type RegistrationMode,
+ RegistrationModes,
+ VerificationBases,
+ type VerificationBasis,
+} from '@fluxer/constants/src/AccountConfigConstants';
+import {type AccountIdentityMode, AccountIdentityModes} from '@fluxer/constants/src/AccountIdentityConstants';
+import {
+ type AccountTier,
+ AccountTiers,
+ type AccountVerificationNeed,
+ AccountVerificationNeeds,
+ type LocalCredentialKind,
+ LocalCredentialKinds,
+ type PurchaseBlockedReason,
+ PurchaseBlockedReasons,
+ type RestrictedAccountTier,
+ type TierDenialError,
+ TierDenialErrors,
+ type TierExemption,
+ TierExemptions,
+ type TierGatedAction,
+ TierGatedActions,
+} from '@fluxer/constants/src/AccountTierConstants';
+import {type CaptchaProvider, CaptchaProviders} from '@fluxer/constants/src/CaptchaConstants';
+import {hasUserTrait, type UserTraitSet, UserTraits} from '@fluxer/constants/src/UserTraitConstants';
+
+export function resolveEffectiveVerificationBasis(params: {
+ identityMode: AccountIdentityMode;
+ basis: VerificationBasis;
+ deliveryState: EmailDeliveryState;
+}): EffectiveVerificationBasis {
+ if (params.identityMode === AccountIdentityModes.USERNAME) return VerificationBases.LOCAL_CREDENTIAL;
+ if (params.deliveryState !== EmailDeliveryStates.ON) return VerificationBases.LOCAL_CREDENTIAL;
+ return params.basis === VerificationBases.AUTO ? VerificationBases.CONFIRMED_EMAIL : params.basis;
+}
+
+export interface AccountTierInput {
+ isBot: boolean;
+ isSystem: boolean;
+ traits: UserTraitSet;
+ identityMode: AccountIdentityMode;
+ effectiveBasis: EffectiveVerificationBasis;
+ hasEmail: boolean;
+ emailVerified: boolean;
+ localCredential: LocalCredentialKind;
+}
+
+export function resolveAccountTier(input: AccountTierInput): AccountTier {
+ if (input.isBot || input.isSystem || hasUserTrait(input.traits, UserTraits.SSO)) return AccountTiers.VERIFIED;
+ const hasCredential = input.localCredential !== LocalCredentialKinds.NONE;
+ if (input.identityMode === AccountIdentityModes.USERNAME) {
+ return hasCredential ? AccountTiers.VERIFIED : AccountTiers.UNCLAIMED;
+ }
+ if (!input.hasEmail) return AccountTiers.UNCLAIMED;
+ if (input.effectiveBasis === VerificationBases.LOCAL_CREDENTIAL) {
+ return hasCredential ? AccountTiers.VERIFIED : AccountTiers.UNCLAIMED;
+ }
+ return input.emailVerified ? AccountTiers.VERIFIED : AccountTiers.UNVERIFIED;
+}
+
+export function resolveVerificationNeed(params: {
+ tier: AccountTier;
+ identityMode: AccountIdentityMode;
+ hasEmail: boolean;
+}): AccountVerificationNeed | null {
+ switch (params.tier) {
+ case AccountTiers.VERIFIED:
+ return null;
+ case AccountTiers.UNVERIFIED:
+ return AccountVerificationNeeds.CONFIRM_EMAIL;
+ case AccountTiers.UNCLAIMED:
+ return params.identityMode === AccountIdentityModes.USERNAME || params.hasEmail
+ ? AccountVerificationNeeds.SET_PASSWORD
+ : AccountVerificationNeeds.ADD_EMAIL;
+ }
+}
+
+interface TierRule {
+ unclaimed: TierDenialError | null;
+ unverified: TierDenialError | null;
+ exemptions?: ReadonlyArray<TierExemption>;
+ onlyWhenGuildJoinGateApplies?: true;
+}
+
+const ALLOWED: TierRule = {unclaimed: null, unverified: null};
+const VERIFICATION_REQUIRED: TierRule = {
+ unclaimed: TierDenialErrors.ACCOUNT_VERIFICATION_REQUIRED,
+ unverified: TierDenialErrors.ACCOUNT_VERIFICATION_REQUIRED,
+};
+
+const SHARED_RULES = {
+ [TierGatedActions.REACTION]: {
+ unclaimed: TierDenialErrors.UNCLAIMED_ACCOUNT_CANNOT_ADD_REACTIONS,
+ unverified: TierDenialErrors.REACTION_EMAIL_VERIFICATION_REQUIRED,
+ },
+ [TierGatedActions.FRIEND_REQUEST]: {
+ unclaimed: TierDenialErrors.UNCLAIMED_ACCOUNT_CANNOT_SEND_FRIEND_REQUESTS,
+ unverified: TierDenialErrors.FRIEND_REQUEST_EMAIL_VERIFICATION_REQUIRED,
+ },
+ [TierGatedActions.GUILD_CREATE]: {
+ unclaimed: TierDenialErrors.UNCLAIMED_ACCOUNT_CANNOT_CREATE_GUILDS,
+ unverified: TierDenialErrors.GUILD_CREATION_EMAIL_VERIFICATION_REQUIRED,
+ },
+ [TierGatedActions.GIFT_REDEEM]: {unclaimed: TierDenialErrors.ACCOUNT_VERIFICATION_REQUIRED, unverified: null},
+ [TierGatedActions.REPORT]: {
+ unclaimed: TierDenialErrors.UNCLAIMED_ACCOUNT_CANNOT_SUBMIT_REPORTS,
+ unverified: TierDenialErrors.REPORT_EMAIL_VERIFICATION_REQUIRED,
+ },
+ [TierGatedActions.MFA]: {
+ unclaimed: TierDenialErrors.MFA_EMAIL_VERIFICATION_REQUIRED,
+ unverified: TierDenialErrors.MFA_EMAIL_VERIFICATION_REQUIRED,
+ },
+ [TierGatedActions.GUILD_VERIFICATION]: {
+ unclaimed: TierDenialErrors.GUILD_VERIFICATION_REQUIRED,
+ unverified: TierDenialErrors.GUILD_EMAIL_VERIFICATION_REQUIRED,
+ },
+} as const satisfies Partial<Record<TierGatedAction, TierRule>>;
+
+const LEGACY_RULES: Record<TierGatedAction, TierRule> = {
+ ...SHARED_RULES,
+ [TierGatedActions.MESSAGE]: {unclaimed: TierDenialErrors.UNCLAIMED_ACCOUNT_CANNOT_SEND_MESSAGES, unverified: null},
+ [TierGatedActions.TYPING]: ALLOWED,
+ [TierGatedActions.DIRECT_MESSAGE]: {
+ unclaimed: TierDenialErrors.UNCLAIMED_ACCOUNT_CANNOT_SEND_DIRECT_MESSAGES,
+ unverified: null,
+ },
+ [TierGatedActions.DIRECT_MESSAGE_OPEN]: {
+ unclaimed: TierDenialErrors.UNCLAIMED_ACCOUNT_CANNOT_SEND_DIRECT_MESSAGES,
+ unverified: TierDenialErrors.DIRECT_MESSAGE_EMAIL_VERIFICATION_REQUIRED,
+ },
+ [TierGatedActions.GROUP_DM]: {unclaimed: TierDenialErrors.UNCLAIMED_ACCOUNT_CANNOT_JOIN_GROUP_DMS, unverified: null},
+ [TierGatedActions.FRIEND_ACCEPT]: {
+ unclaimed: TierDenialErrors.UNCLAIMED_ACCOUNT_CANNOT_ACCEPT_FRIEND_REQUESTS,
+ unverified: null,
+ },
+ [TierGatedActions.INVITE_CREATE]: ALLOWED,
+ [TierGatedActions.GUILD_JOIN]: ALLOWED,
+ [TierGatedActions.VOICE]: {
+ unclaimed: TierDenialErrors.UNCLAIMED_ACCOUNT_CANNOT_JOIN_VOICE_CHANNELS,
+ unverified: null,
+ exemptions: [TierExemptions.GUILD_OWNER],
+ },
+ [TierGatedActions.CALL]: {
+ unclaimed: TierDenialErrors.UNCLAIMED_ACCOUNT_CANNOT_JOIN_ONE_ON_ONE_VOICE_CALLS,
+ unverified: null,
+ },
+ [TierGatedActions.GROUP_CALL]: ALLOWED,
+ [TierGatedActions.THREAD_JOIN]: ALLOWED,
+ [TierGatedActions.CHANNEL_FOLLOW]: ALLOWED,
+ [TierGatedActions.OWNERSHIP_TRANSFER]: ALLOWED,
+ [TierGatedActions.APPLICATION_CREATE]: {
+ unclaimed: TierDenialErrors.UNCLAIMED_ACCOUNT_CANNOT_CREATE_APPLICATIONS,
+ unverified: null,
+ },
+ [TierGatedActions.PROFILE_CUSTOMIZE]: {
+ unclaimed: TierDenialErrors.UNCLAIMED_ACCOUNTS_CAN_ONLY_SET_EMAIL_VIA_TOKEN,
+ unverified: TierDenialErrors.PROFILE_EMAIL_VERIFICATION_REQUIRED,
+ },
+};
+
+const ENFORCED_CALL_RULE: TierRule = {
+ unclaimed: TierDenialErrors.UNCLAIMED_ACCOUNT_CANNOT_JOIN_ONE_ON_ONE_VOICE_CALLS,
+ unverified: TierDenialErrors.ACCOUNT_VERIFICATION_REQUIRED,
+};
+
+const ENFORCED_MESSAGE_RULE: TierRule = {
+ unclaimed: TierDenialErrors.UNCLAIMED_ACCOUNT_CANNOT_SEND_MESSAGES,
+ unverified: TierDenialErrors.EMAIL_VERIFICATION_REQUIRED,
+};
+
+const ENFORCED_DIRECT_MESSAGE_RULE: TierRule = {
+ unclaimed: TierDenialErrors.UNCLAIMED_ACCOUNT_CANNOT_SEND_DIRECT_MESSAGES,
+ unverified: TierDenialErrors.DIRECT_MESSAGE_EMAIL_VERIFICATION_REQUIRED,
+};
+
+const ENFORCED_RULES: Record<TierGatedAction, TierRule> = {
+ ...SHARED_RULES,
+ [TierGatedActions.MESSAGE]: ENFORCED_MESSAGE_RULE,
+ [TierGatedActions.TYPING]: ENFORCED_MESSAGE_RULE,
+ [TierGatedActions.DIRECT_MESSAGE]: ENFORCED_DIRECT_MESSAGE_RULE,
+ [TierGatedActions.DIRECT_MESSAGE_OPEN]: ENFORCED_DIRECT_MESSAGE_RULE,
+ [TierGatedActions.GROUP_DM]: {
+ unclaimed: TierDenialErrors.UNCLAIMED_ACCOUNT_CANNOT_JOIN_GROUP_DMS,
+ unverified: TierDenialErrors.DIRECT_MESSAGE_EMAIL_VERIFICATION_REQUIRED,
+ },
+ [TierGatedActions.FRIEND_ACCEPT]: {
+ unclaimed: TierDenialErrors.UNCLAIMED_ACCOUNT_CANNOT_ACCEPT_FRIEND_REQUESTS,
+ unverified: TierDenialErrors.FRIEND_REQUEST_EMAIL_VERIFICATION_REQUIRED,
+ },
+ [TierGatedActions.INVITE_CREATE]: VERIFICATION_REQUIRED,
+ [TierGatedActions.GUILD_JOIN]: {...VERIFICATION_REQUIRED, onlyWhenGuildJoinGateApplies: true},
+ [TierGatedActions.VOICE]: {
+ unclaimed: TierDenialErrors.UNCLAIMED_ACCOUNT_CANNOT_JOIN_VOICE_CHANNELS,
+ unverified: TierDenialErrors.ACCOUNT_VERIFICATION_REQUIRED,
+ },
+ [TierGatedActions.CALL]: ENFORCED_CALL_RULE,
+ [TierGatedActions.GROUP_CALL]: ENFORCED_CALL_RULE,
+ [TierGatedActions.THREAD_JOIN]: VERIFICATION_REQUIRED,
+ [TierGatedActions.CHANNEL_FOLLOW]: VERIFICATION_REQUIRED,
+ [TierGatedActions.OWNERSHIP_TRANSFER]: VERIFICATION_REQUIRED,
+ [TierGatedActions.APPLICATION_CREATE]: {
+ unclaimed: TierDenialErrors.UNCLAIMED_ACCOUNT_CANNOT_CREATE_APPLICATIONS,
+ unverified: TierDenialErrors.ACCOUNT_VERIFICATION_REQUIRED,
+ },
+ [TierGatedActions.PROFILE_CUSTOMIZE]: ALLOWED,
+};
+
+const TIER_RULES: Readonly<Record<InteractionTierMode, Readonly<Record<TierGatedAction, TierRule>>>> = {
+ [InteractionTierModes.LEGACY]: LEGACY_RULES,
+ [InteractionTierModes.ENFORCED]: ENFORCED_RULES,
+};
+
+export interface TierGateInput {
+ tier: AccountTier;
+ mode: InteractionTierMode;
+ action: TierGatedAction;
+ identityMode: AccountIdentityMode;
+ hasEmail: boolean;
+ guildJoinGateApplies: boolean;
+ exemptions: ReadonlyArray<TierExemption>;
+}
+
+export interface TierGateDenial {
+ allowed: false;
+ action: TierGatedAction;
+ tier: RestrictedAccountTier;
+ need: AccountVerificationNeed;
+ errorCode: TierDenialError;
+}
+
+export type TierGateResult = {allowed: true} | TierGateDenial;
+
+const TIER_GATE_ALLOWED: TierGateResult = {allowed: true};
+
+export function evaluateTierGate(input: TierGateInput): TierGateResult {
+ const {tier} = input;
+ if (tier === AccountTiers.VERIFIED) return TIER_GATE_ALLOWED;
+ const rule = TIER_RULES[input.mode][input.action];
+ if (rule.onlyWhenGuildJoinGateApplies && !input.guildJoinGateApplies) return TIER_GATE_ALLOWED;
+ if (rule.exemptions?.some((exemption) => input.exemptions.includes(exemption))) return TIER_GATE_ALLOWED;
+ const denial = tier === AccountTiers.UNCLAIMED ? rule.unclaimed : rule.unverified;
+ if (denial === null) return TIER_GATE_ALLOWED;
+ const need = resolveVerificationNeed({tier, identityMode: input.identityMode, hasEmail: input.hasEmail});
+ if (need === null) return TIER_GATE_ALLOWED;
+ return {
+ allowed: false,
+ action: input.action,
+ tier,
+ need,
+ errorCode: need === AccountVerificationNeeds.SET_PASSWORD ? TierDenialErrors.ACCOUNT_VERIFICATION_REQUIRED : denial,
+ };
+}
+
+export function resolveEmailDeliveryState(params: {
+ identityMode: AccountIdentityMode;
+ delivery: EmailDeliveryMode;
+ smtpComplete: boolean;
+ fromAddress: string | null;
+}): EmailDeliveryState {
+ if (params.identityMode === AccountIdentityModes.USERNAME) return EmailDeliveryStates.OFF_USERNAME_MODE;
+ if (params.delivery === EmailDeliveryModes.OFF) return EmailDeliveryStates.OFF_DISABLED;
+ if (!params.smtpComplete || !params.fromAddress?.trim()) return EmailDeliveryStates.OFF_INCOMPLETE;
+ return EmailDeliveryStates.ON;
+}
+
+export function resolveEmailCodeAvailability(params: {
+ identityMode: AccountIdentityMode;
+ deliveryState: EmailDeliveryState;
+ hasEmail: boolean;
+ emailVerified: boolean;
+}): EmailCodeAvailability {
+ if (params.identityMode === AccountIdentityModes.USERNAME) return EmailCodeAvailability.IDENTITY_MODE_USERNAME;
+ if (params.deliveryState !== EmailDeliveryStates.ON) return EmailCodeAvailability.DELIVERY_OFF;
+ if (!params.hasEmail || !params.emailVerified) return EmailCodeAvailability.NO_OWNED_EMAIL;
+ return EmailCodeAvailability.AVAILABLE;
+}
+
+export function resolveIdentifierFirst(params: {
+ mode: IdentifierFirstMode;
+ identityMode: AccountIdentityMode;
+ deliveryState: EmailDeliveryState;
+}): {identifierFirst: boolean; emailCodes: boolean} {
+ const emailMode = params.identityMode === AccountIdentityModes.EMAIL;
+ const deliveryOn = params.deliveryState === EmailDeliveryStates.ON;
+ let identifierFirst: boolean;
+ switch (params.mode) {
+ case IdentifierFirstModes.OFF:
+ identifierFirst = false;
+ break;
+ case IdentifierFirstModes.ON:
+ identifierFirst = emailMode;
+ break;
+ case IdentifierFirstModes.AUTO:
+ identifierFirst = emailMode && deliveryOn;
+ break;
+ }
+ return {identifierFirst, emailCodes: identifierFirst && deliveryOn};
+}
+
+export function resolveInstantAccountAvailability(params: {
+ enabled: boolean;
+ captchaProvider: CaptchaProvider;
+ registrationMode: RegistrationMode;
+ registrationUrl: {approvalRequired: boolean} | null;
+}): InstantAccountAvailability {
+ if (!params.enabled) return InstantAccountAvailability.DISABLED;
+ if (params.captchaProvider === CaptchaProviders.NONE) return InstantAccountAvailability.CAPTCHA_OFF;
+ if (params.registrationUrl !== null) {
+ return params.registrationUrl.approvalRequired
+ ? InstantAccountAvailability.APPROVAL_REQUIRED
+ : InstantAccountAvailability.AVAILABLE;
+ }
+ switch (params.registrationMode) {
+ case RegistrationModes.OPEN:
+ return InstantAccountAvailability.AVAILABLE;
+ case RegistrationModes.APPROVAL:
+ return InstantAccountAvailability.APPROVAL_REQUIRED;
+ case RegistrationModes.CLOSED:
+ return InstantAccountAvailability.REGISTRATION_CLOSED;
+ }
+}
+
+export function requiresLocalCredential(params: {
+ identityMode: AccountIdentityMode;
+ deliveryState: EmailDeliveryState;
+ emailProven: boolean;
+}): boolean {
+ if (params.identityMode === AccountIdentityModes.USERNAME) return true;
+ if (params.deliveryState === EmailDeliveryStates.ON) return false;
+ return !params.emailProven;
+}
+
+export function resolvePurchaseBlockedReason(params: {
+ tier: AccountTier;
+ hasEmail: boolean;
+}): PurchaseBlockedReason | null {
+ switch (params.tier) {
+ case AccountTiers.UNCLAIMED:
+ return PurchaseBlockedReasons.UNCLAIMED;
+ case AccountTiers.UNVERIFIED:
+ return PurchaseBlockedReasons.EMAIL_UNVERIFIED;
+ case AccountTiers.VERIFIED:
+ return params.hasEmail ? null : PurchaseBlockedReasons.NO_RECEIPT_EMAIL;
+ }
+}
diff --git a/packages/constants/src/Headers.ts b/packages/constants/src/Headers.ts
index ea49415dd..f886d3a9d 100644
--- a/packages/constants/src/Headers.ts
+++ b/packages/constants/src/Headers.ts
@@ -3,7 +3,6 @@
export const Headers = {
CONTENT_TYPE: 'Content-Type',
CONTENT_LENGTH: 'Content-Length',
- CONTENT_DISPOSITION: 'Content-Disposition',
AUTHORIZATION: 'Authorization',
ACCEPT: 'Accept',
ORIGIN: 'Origin',
@@ -14,17 +13,11 @@ export const Headers = {
IF_NONE_MATCH: 'If-None-Match',
IF_MODIFIED_SINCE: 'If-Modified-Since',
USER_AGENT: 'User-Agent',
- X_FORWARDED_FOR: 'X-Forwarded-For',
- X_FORWARDED_PROTO: 'X-Forwarded-Proto',
- X_FORWARDED_HOST: 'X-Forwarded-Host',
X_REQUEST_ID: 'X-Request-ID',
X_REQUESTED_WITH: 'X-Requested-With',
- X_RATELIMIT_LIMIT: 'X-RateLimit-Limit',
- X_RATELIMIT_REMAINING: 'X-RateLimit-Remaining',
- X_RATELIMIT_RESET: 'X-RateLimit-Reset',
X_CONTENT_TYPE_OPTIONS: 'X-Content-Type-Options',
X_FRAME_OPTIONS: 'X-Frame-Options',
- X_XSS_PROTECTION: 'X-XSS-Protection',
+ X_FLUXER_CAPABILITIES: 'X-Fluxer-Capabilities',
X_FLUXER_CLIENT_INSTALLATION_ID: 'X-Fluxer-Client-Installation-ID',
X_FLUXER_FEATURES: 'X-Fluxer-Features',
X_FLUXER_PLATFORM: 'X-Fluxer-Platform',
@@ -33,8 +26,4 @@ export const Headers = {
X_CAPTCHA_ID: 'X-Captcha-Id',
X_CAPTCHA_TOKEN: 'X-Captcha-Token',
X_AUDIT_LOG_REASON: 'X-Audit-Log-Reason',
- X_INTERNAL_API_KEY: 'X-Internal-API-Key',
- X_AMZ_REQUEST_ID: 'x-amz-request-id',
- X_AMZ_ID_2: 'x-amz-id-2',
- X_ACCEL_BUFFERING: 'X-Accel-Buffering',
} as const;
diff --git a/packages/constants/src/UserTraitConstants.ts b/packages/constants/src/UserTraitConstants.ts
new file mode 100644
index 000000000..33eddd2b0
--- /dev/null
+++ b/packages/constants/src/UserTraitConstants.ts
@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+import type {ValueOf} from '@fluxer/constants/src/ValueOf';
+
+export const UserTraits = {
+ SSO: 'sso',
+ PASSKEY: 'passkey',
+ DOB_DEFERRED: 'dob_deferred',
+ BELOW_MINIMUM_AGE: 'below_minimum_age',
+} as const;
+
+export type UserTrait = ValueOf<typeof UserTraits>;
+
+export type UserTraitSet = ReadonlySet<string> | ReadonlyArray<string>;
+
+export function hasUserTrait(traits: UserTraitSet, trait: UserTrait): boolean {
+ return 'has' in traits ? traits.has(trait) : traits.includes(trait);
+}