@meith/accounts 0.31.0 → 0.32.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meith/accounts",
-  "version": "0.31.0",
+  "version": "0.32.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -20,6 +20,7 @@
   },
   "dependencies": {
     "hash-wasm": "^4.12.0",
-    "@meith/i18n": "0.31.0"
+    "@meith/i18n": "0.32.0",
+    "@meith/subscriptions": "0.32.0"
   }
 }

package/src/federation/service.ts

@@ -33,6 +33,12 @@ export type FederationOutcome =
       readonly login: LoginResult
       readonly created: boolean
     }
+  | {
+      readonly status: 'second-factor'
+      readonly account: AccountRecord
+      readonly token: string
+      readonly expiresAt: Date
+    }
   | {
       readonly status: 'pending'
       readonly account: AccountRecord
@@ -67,9 +73,8 @@ export class FederationService {
         )
       }
 
-      const login = await this.identity.startSessionFor(account, context)
       await this.identities.markUsed(linked.id, this.now())
-      return { status: 'signed-in', account, login, created: false }
+      return this.begin(account, context, false)
     }
 
     const email = normalisedEmail(input.profile)
@@ -85,13 +90,12 @@ export class FederationService {
         )
       }
 
-      const login = await this.identity.startSessionFor(existing, context)
       await this.link({
         userId: existing.id,
         provider: input.provider,
         profile: input.profile,
       })
-      return { status: 'signed-in', account: existing, login, created: false }
+      return this.begin(existing, context, false)
     }
 
     if (email === null) {
@@ -126,12 +130,26 @@ export class FederationService {
       }
     }
 
-    return {
-      status: 'signed-in',
-      account: provisioned.account,
-      login: await this.identity.startSessionFor(provisioned.account, context),
-      created: true,
+    return this.begin(provisioned.account, context, true)
+  }
+
+  private async begin(
+    account: AccountRecord,
+    context: RequestContext,
+    created: boolean,
+  ): Promise<FederationOutcome> {
+    const outcome = await this.identity.beginSessionFor(account, context)
+
+    if (outcome.status === 'second-factor') {
+      return {
+        status: 'second-factor',
+        account,
+        token: outcome.token,
+        expiresAt: outcome.expiresAt,
+      }
     }
+
+    return { status: 'signed-in', account, login: outcome.login, created }
   }
 
   async linkToViewer(input: {

package/src/member-settings.ts

@@ -1,5 +1,6 @@
 import { ValidationError } from '@meith/core'
 import { msg, normaliseLocale } from '@meith/i18n'
+import { parseSubscriptionMode, type SubscriptionMode } from '@meith/subscriptions'
 
 import { foldIdentifier } from './case-fold'
 import { hashPassword, needsRehash, verifyPassword } from './crypto/password'
@@ -33,6 +34,9 @@ export interface MemberSettings {
   readonly bio: string | null
   readonly displayGroupId: number | null
   readonly massMailOptInAt: Date | null
+  readonly boardDigestCadence: string
+  readonly autoWatchOwnThreads: SubscriptionMode
+  readonly autoWatchRepliedThreads: SubscriptionMode
 }
 
 export interface MemberGroupChoice {
@@ -66,10 +70,17 @@ export interface MemberSettingsRepository {
     readonly postsPerPage: number | null
     readonly threadsPerPage: number | null
     readonly invisible: boolean
+    readonly autoWatchOwnThreads: SubscriptionMode
+    readonly autoWatchRepliedThreads: SubscriptionMode
   }): Promise<void>
 
   saveMassMailOptIn(input: { readonly userId: number; readonly optIn: boolean }): Promise<void>
 
+  saveBoardDigestCadence(input: {
+    readonly userId: number
+    readonly cadence: string
+  }): Promise<void>
+
   adoptEmail(input: {
     readonly userId: number
     readonly email: string
@@ -102,6 +113,12 @@ export function isLocalePreference(value: string): boolean {
   return value === AUTOMATIC_LOCALE || normaliseLocale(value) !== null
 }
 
+function parseAutoWatchPreference(value: string): SubscriptionMode {
+  const mode = parseSubscriptionMode(value.trim())
+  if (mode === null) throw new ValidationError(msg('error.accounts.auto-watch-preference'))
+  return mode
+}
+
 export class MemberSettingsService {
   private readonly settings: MemberSettingsRepository
   private readonly accounts: AccountRepository
@@ -201,6 +218,8 @@ export class MemberSettingsService {
     readonly postsPerPage: string
     readonly threadsPerPage: string
     readonly invisible: boolean
+    readonly autoWatchOwnThreads: string
+    readonly autoWatchRepliedThreads: string
   }): Promise<void> {
     const timezone = input.timezone.trim()
     if (!isTimezonePreference(timezone)) {
@@ -212,6 +231,9 @@ export class MemberSettingsService {
       throw new ValidationError(msg('error.accounts.language-board-recognises'))
     }
 
+    const autoWatchOwnThreads = parseAutoWatchPreference(input.autoWatchOwnThreads)
+    const autoWatchRepliedThreads = parseAutoWatchPreference(input.autoWatchRepliedThreads)
+
     await this.settings.saveOptions({
       userId: input.userId,
       timezone,
@@ -219,9 +241,23 @@ export class MemberSettingsService {
       postsPerPage: parsePageSize(input.postsPerPage, 'Posts per page'),
       threadsPerPage: parsePageSize(input.threadsPerPage, 'Threads per page'),
       invisible: input.invisible,
+      autoWatchOwnThreads,
+      autoWatchRepliedThreads,
     })
   }
 
+  async saveBoardDigestCadence(input: {
+    readonly userId: number
+    readonly cadence: string
+  }): Promise<void> {
+    const cadence = input.cadence.trim()
+    if (cadence !== 'weekly' && cadence !== 'monthly') {
+      throw new ValidationError(msg('error.accounts.digest-cadence-weekly-monthly'))
+    }
+
+    await this.settings.saveBoardDigestCadence({ userId: input.userId, cadence })
+  }
+
   async changePassword(input: {
     readonly userId: number
     readonly currentPassword: string

package/src/service.ts

@@ -505,6 +505,30 @@ export class IdentityService {
     return this.startSession(account, this.now(), context)
   }
 
+  async beginSessionFor(
+    account: AccountRecord,
+    context: RequestContext = {},
+    options: { readonly remember?: boolean } = {},
+  ): Promise<LoginOutcome> {
+    await this.assertSignInAllowed(account)
+
+    const at = this.now()
+    const prefix = prefixOf(context)
+    if (prefix !== null) {
+      await this.store.accounts.recordLastIpPrefix(account.id, prefix)
+    }
+
+    if (await this.secondFactor?.isEnrolled(account.id)) {
+      return {
+        status: 'second-factor',
+        account,
+        ...(await this.holdForSecondFactor(account.id, options.remember === true, at)),
+      }
+    }
+
+    return { status: 'signed-in', login: await this.startSession(account, at, context) }
+  }
+
   private async assertNotFiltered(subject: BanFilterSubject): Promise<void> {
     const match = matchBanFilter(await this.banFilters.listAll(), subject)
     if (match) {