A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
feat(constants): add verification levels, gated actions, traits
Hampus2ce77f7413ed
diff --git a/packages/constants/src/AccountTierConstants.ts b/packages/constants/src/AccountTierConstants.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsnew file mode 100644index 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);+}