Feat: Gather user's behaviors during onboarding

[austinkimchi]

Describe the solution you'd like
During on-boarding (after asking user for name and email), ask user for behaviors.
Behaviors include (but limited to): alcohol consumption, caffiene consumption, smoke regularly, medication, late exercise, late screen time.
Pharse the questions in a easy way for users to answer.
e.g., "Do you regularly consume alcohol? (more than 2 times a week)

[erik-keifer]

This is what I want to add. Let me know what you think.

AuthModels.swift

import Foundation

nonisolated struct ConfirmableProfile: Codable {
var name: String
var email: String
}

nonisolated struct AppleLoginRequest: Encodable {
let appleUserId: String
let identityToken: String
let authorizationCode: String?
let profile: ConfirmableProfile
}

nonisolated struct AppleStatusRequest: Encodable {
let appleUserId: String
let identityToken: String
}

nonisolated struct RefreshSessionRequest: Encodable {
let refreshToken: String
}

nonisolated struct AppleStatusResponse: Decodable {
let status: String
let exists: Bool
let user: AuthenticatedUser?
let tokens: SessionTokens?
}

nonisolated struct AppleLoginResponse: Decodable {
let status: String
let user: AuthenticatedUser
let tokens: SessionTokens
}

nonisolated struct UserProfileResponse: Decodable {
let status: String
let user: AuthenticatedUser
}

nonisolated struct AuthenticatedUser: Decodable {
let userId: String
let name: String
let email: String
let apple: AppleAccountMetadata
let healthSync: HealthSyncProfile?
}

nonisolated struct AppleAccountMetadata: Decodable {
let userId: String
let email: String?
let emailVerified: Bool
let isPrivateEmail: Bool
}

nonisolated struct HealthSyncProfile: Decodable {
let lastFetchedAt: String?
let lastFetchedRangeStart: String?
let lastFetchedRangeEnd: String?
let lastIngestIdempotencyKey: String?
let updatedAt: String?
}

nonisolated struct SessionTokens: Decodable {
let accessToken: String
let accessTokenExpiresAt: String
let accessTokenExpiresIn: Int
let refreshToken: String
let refreshTokenExpiresAt: String
}

nonisolated struct LogoutResponse: Decodable {
let status: String
}

// MARK: - Behavior Onboarding

enum BehaviorFrequency: String, Codable, CaseIterable {
case never
case sometimes
case regularly

var label: String {
    switch self {
    case .never: return "No"
    case .sometimes: return "Sometimes"
    case .regularly: return "Yes"
    }
}

}

nonisolated struct UserBehaviors: Codable {
var alcoholFrequency: BehaviorFrequency
var caffeineLate: BehaviorFrequency
var smokingFrequency: BehaviorFrequency
var sleepMedication: BehaviorFrequency
var lateExercise: BehaviorFrequency
var lateScreenTime: BehaviorFrequency

static let empty = UserBehaviors(
    alcoholFrequency: .never,
    caffeineLate: .never,
    smokingFrequency: .never,
    sleepMedication: .never,
    lateExercise: .never,
    lateScreenTime: .never
)

}

nonisolated struct UserBehaviorsRequest: Encodable {
let behaviors: UserBehaviors
}

nonisolated struct UserBehaviorsResponse: Decodable {
let status: String
}

AuthenticationManager.swift

import Foundation
import Combine
import AuthenticationServices

@mainactor
final class AuthenticationManager: NSObject, ObservableObject {
@published var isAuthenticated = false
@published var isRestoringSession = false
@published var requiresProfileConfirmation = false
@published var requiresBehaviorOnboarding = false
@published var userName: String?
@published var userEmail: String?
@published var userID: String?
@published var appleEmail: String?
@published var isPrivateEmail = false

private let tokenStore = TokenStore()
private var pendingAppleSignIn: PendingAppleSignIn?

override init() {
    super.init()
    restoreStoredProfile()

    Task {
        await restoreSessionIfPossible()
    }
}

func prepareAppleSignIn(authorization: ASAuthorization) async throws {
    guard let credential = authorization.credential as? ASAuthorizationAppleIDCredential else {
        throw AuthManagerError.invalidAppleCredential
    }

    guard let identityTokenData = credential.identityToken,
          let identityToken = String(data: identityTokenData, encoding: .utf8) else {
        throw AuthManagerError.missingIdentityToken
    }

    let authorizationCode = credential.authorizationCode.flatMap {
        String(data: $0, encoding: .utf8)
    }

    let suggestedName = preferredName(
        from: credential,
        fallback: userName
    )
    let suggestedEmail = preferredEmail(
        from: credential,
        identityToken: identityToken,
        fallback: userEmail
    )

    pendingAppleSignIn = PendingAppleSignIn(
        appleUserId: credential.user,
        identityToken: identityToken,
        authorizationCode: authorizationCode,
        suggestedName: suggestedName,
        suggestedEmail: suggestedEmail
    )

    userID = credential.user
    appleEmail = decodeIdentityTokenEmail(identityToken) ?? credential.email ?? appleEmail
    isPrivateEmail = decodeIdentityTokenIsPrivateEmail(identityToken) ?? isPrivateEmail

    let accountStatus: AppleStatusResponse = try await APIWrapper.shared.post(
        "auth/apple/status",
        body: AppleStatusRequest(
            appleUserId: credential.user,
            identityToken: identityToken
        ),
        responseType: AppleStatusResponse.self
    )

    if accountStatus.exists,
       let user = accountStatus.user,
       let tokens = accountStatus.tokens {
        try storeAuthenticatedSession(
            AppleLoginResponse(
                status: accountStatus.status,
                user: user,
                tokens: tokens
            )
        )
        requiresProfileConfirmation = false
        pendingAppleSignIn = nil
        return
    }

    requiresProfileConfirmation = true
}

func pendingProfileDefaults() -> ConfirmableProfile {
    ConfirmableProfile(
        name: pendingAppleSignIn?.suggestedName ?? "",
        email: pendingAppleSignIn?.suggestedEmail ?? ""
    )
}

func completeProfileConfirmation(name: String, email: String) async throws {
    guard let pendingSignIn = pendingAppleSignIn else {
        throw AuthManagerError.missingPendingSignIn
    }

    let request = AppleLoginRequest(
        appleUserId: pendingSignIn.appleUserId,
        identityToken: pendingSignIn.identityToken,
        authorizationCode: pendingSignIn.authorizationCode,
        profile: ConfirmableProfile(
            name: name.trimmingCharacters(in: .whitespacesAndNewlines),
            email: email.trimmingCharacters(in: .whitespacesAndNewlines)
        )
    )

    let response: AppleLoginResponse = try await APIWrapper.shared.post(
        "auth/apple/login",
        body: request,
        responseType: AppleLoginResponse.self
    )

    try storeAuthenticatedSession(response)
    requiresProfileConfirmation = false
    pendingAppleSignIn = nil

    // Route to behavior onboarding instead of directly to the main app
    requiresBehaviorOnboarding = true
}

func completeBehaviorOnboarding() {
    requiresBehaviorOnboarding = false
    isAuthenticated = true
}

func signInFailed(error: Error) {
    print("Sign in with Apple failed: \(error.localizedDescription)")
    requiresProfileConfirmation = false
    requiresBehaviorOnboarding = false
    pendingAppleSignIn = nil
    isAuthenticated = false
}

func validAccessToken() async throws -> String {
    if let token = try tokenStore.readAccessToken(), !token.isEmpty {
        return token
    }

    try await refreshSession()

    guard let token = try tokenStore.readAccessToken(), !token.isEmpty else {
        throw AuthManagerError.missingAccessToken
    }

    return token
}

func updateProfile(name: String, email: String) async throws {
    let token = try await validAccessToken()
    let response: UserProfileResponse = try await APIWrapper.shared.post(
        "me",
        body: ConfirmableProfile(
            name: name.trimmingCharacters(in: .whitespacesAndNewlines),
            email: email.trimmingCharacters(in: .whitespacesAndNewlines)
        ),
        headers: ["Authorization": "Bearer \(token)"],
        responseType: UserProfileResponse.self
    )

    applyAuthenticatedUser(response.user)
}

func signOut() {
    Task {
        if let refreshToken = try? tokenStore.readRefreshToken(), !refreshToken.isEmpty {
            let accessToken = try? tokenStore.readAccessToken()
            let headers = accessToken.map { ["Authorization": "Bearer \($0)"] } ?? [:]
            _ = try? await APIWrapper.shared.post(
                "auth/logout",
                body: RefreshSessionRequest(refreshToken: refreshToken),
                headers: headers,
                responseType: LogoutResponse.self
            )
        }

        clearLocalSession()
    }
}

private func restoreSessionIfPossible() async {
    guard !isAuthenticated else { return }
    guard (try? tokenStore.readRefreshToken())?.isEmpty == false else { return }

    isRestoringSession = true
    defer { isRestoringSession = false }

    do {
        try await refreshSession()
    } catch {
        clearLocalSession()
    }
}

private func refreshSession() async throws {
    guard let refreshToken = try tokenStore.readRefreshToken(), !refreshToken.isEmpty else {
        throw AuthManagerError.missingRefreshToken
    }

    let response: AppleLoginResponse = try await APIWrapper.shared.post(
        "auth/refresh",
        body: RefreshSessionRequest(refreshToken: refreshToken),
        responseType: AppleLoginResponse.self
    )

    try storeAuthenticatedSession(response)
}

private func storeAuthenticatedSession(_ response: AppleLoginResponse) throws {
    try tokenStore.storeAccessToken(response.tokens.accessToken)
    try tokenStore.storeRefreshToken(response.tokens.refreshToken)
    applyAuthenticatedUser(response.user)
    // Note: isAuthenticated is NOT set here during new sign-up flow.
    // completeBehaviorOnboarding() sets it after onboarding finishes.
    // For session restores (refresh), set it directly.
    if requiresBehaviorOnboarding == false && requiresProfileConfirmation == false {
        isAuthenticated = true
    }
}

private func applyAuthenticatedUser(_ user: AuthenticatedUser) {
    userID = user.userId
    userName = user.name
    userEmail = user.email
    appleEmail = user.apple.email
    isPrivateEmail = user.apple.isPrivateEmail
    persistProfile()
}

private func restoreStoredProfile() {
    userID = UserDefaults.standard.string(forKey: "userID")
    userName = UserDefaults.standard.string(forKey: "userName")
    userEmail = UserDefaults.standard.string(forKey: "userEmail")
    appleEmail = UserDefaults.standard.string(forKey: "appleEmail")
    isPrivateEmail = UserDefaults.standard.bool(forKey: "isPrivateEmail")
}

private func persistProfile() {
    UserDefaults.standard.set(userID, forKey: "userID")
    UserDefaults.standard.set(userName, forKey: "userName")
    UserDefaults.standard.set(userEmail, forKey: "userEmail")
    UserDefaults.standard.set(appleEmail, forKey: "appleEmail")
    UserDefaults.standard.set(isPrivateEmail, forKey: "isPrivateEmail")
}

private func clearLocalSession() {
    isAuthenticated = false
    requiresProfileConfirmation = false
    requiresBehaviorOnboarding = false
    userName = nil
    userEmail = nil
    userID = nil
    appleEmail = nil
    isPrivateEmail = false
    pendingAppleSignIn = nil

    UserDefaults.standard.removeObject(forKey: "userID")
    UserDefaults.standard.removeObject(forKey: "userName")
    UserDefaults.standard.removeObject(forKey: "userEmail")
    UserDefaults.standard.removeObject(forKey: "appleEmail")
    UserDefaults.standard.removeObject(forKey: "isPrivateEmail")

    try? tokenStore.clear()
}

private func preferredName(from credential: ASAuthorizationAppleIDCredential, fallback: String?) -> String {
    let components = [credential.fullName?.givenName, credential.fullName?.familyName]
        .compactMap { $0?.trimmingCharacters(in: .whitespacesAndNewlines) }
        .filter { !$0.isEmpty }
    let fullName = components.joined(separator: " ")

    if !fullName.isEmpty { return fullName }
    if let fallback, !fallback.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
        return fallback
    }
    return ""
}

private func preferredEmail(
    from credential: ASAuthorizationAppleIDCredential,
    identityToken: String,
    fallback: String?
) -> String {
    if let email = credential.email?.trimmingCharacters(in: .whitespacesAndNewlines), !email.isEmpty {
        return email
    }
    if let tokenEmail = decodeIdentityTokenEmail(identityToken), !tokenEmail.isEmpty {
        return tokenEmail
    }
    return fallback ?? ""
}

private func decodeIdentityTokenEmail(_ identityToken: String) -> String? {
    decodeJWTBody(identityToken)?["email"] as? String
}

private func decodeIdentityTokenIsPrivateEmail(_ identityToken: String) -> Bool? {
    if let value = decodeJWTBody(identityToken)?["is_private_email"] as? Bool {
        return value
    }
    if let value = decodeJWTBody(identityToken)?["is_private_email"] as? String {
        return value == "true"
    }
    return nil
}

private func decodeJWTBody(_ token: String) -> [String: Any]? {
    let parts = token.split(separator: ".")
    guard parts.count == 3 else { return nil }

    var payload = String(parts[1])
        .replacingOccurrences(of: "-", with: "+")
        .replacingOccurrences(of: "_", with: "/")

    let padding = payload.count % 4
    if padding > 0 {
        payload += String(repeating: "=", count: 4 - padding)
    }

    guard let data = Data(base64Encoded: payload),
          let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
        return nil
    }

    return object
}

}

private struct PendingAppleSignIn {
let appleUserId: String
let identityToken: String
let authorizationCode: String?
let suggestedName: String
let suggestedEmail: String
}

enum AuthManagerError: LocalizedError {
case invalidAppleCredential
case missingIdentityToken
case missingPendingSignIn
case missingAccessToken
case missingRefreshToken

var errorDescription: String? {
    switch self {
    case .invalidAppleCredential:
        return "Apple sign in did not return a valid credential."
    case .missingIdentityToken:
        return "Apple sign in did not return an identity token."
    case .missingPendingSignIn:
        return "No pending Apple sign in was found."
    case .missingAccessToken:
        return "No access token is available."
    case .missingRefreshToken:
        return "No refresh token is available."
    }
}

}

SleepFocusApp.swift

import SwiftUI

@main
struct SleepFocusApp: App {
@StateObject private var navigationManager = NavigationManager()
@StateObject private var authManager = AuthenticationManager()
@StateObject private var sleepPreferences = SleepPreferencesStore()
@StateObject private var notificationSettings = NotificationSettingsStore()
@StateObject private var appearanceStore = AppearanceStore()
private let healthAutoSyncService = HealthAutoSyncService.shared

var body: some Scene {
    WindowGroup {
        Group {
            if authManager.isAuthenticated {
                ContentView()
                    .environmentObject(navigationManager)
                    .environmentObject(authManager)
                    .environmentObject(sleepPreferences)
                    .environmentObject(notificationSettings)
                    .environmentObject(appearanceStore)
            } else if authManager.requiresBehaviorOnboarding {
                BehaviorOnboardingView(authManager: authManager)
            } else if authManager.requiresProfileConfirmation {
                ConfirmProfileView(authManager: authManager)
            } else {
                SignInView(authManager: authManager)
            }
        }
        .preferredColorScheme(appearanceStore.preferredColorScheme)
        .task {
            await notificationSettings.requestAlarmPermissionsAtLaunchIfNeeded()
        }
        .task(id: authManager.isAuthenticated) {
            guard authManager.isAuthenticated else { return }
            await healthAutoSyncService.startIfNeeded(authManager: authManager)
        }
        .onOpenURL { url in
            navigationManager.handleDeepLink(url)
        }
    }
}

}

BehaviorOnboardingStore.swift

import Foundation

@mainactor
final class BehaviorOnboardingStore: ObservableObject {

struct BehaviorQuestion {
    let id: String
    let question: String
    let clarification: String
    let icon: String
    let keyPath: WritableKeyPath<UserBehaviors, BehaviorFrequency>
}

static let questions: [BehaviorQuestion] = [
    BehaviorQuestion(
        id: "alcohol",
        question: "Do you drink alcohol regularly?",
        clarification: "More than twice a week",
        icon: "wineglass",
        keyPath: \.alcoholFrequency
    ),
    BehaviorQuestion(
        id: "caffeine",
        question: "Do you have caffeine after 2 PM?",
        clarification: "Coffee, tea, energy drinks, or soda",
        icon: "cup.and.saucer.fill",
        keyPath: \.caffeineLate
    ),
    BehaviorQuestion(
        id: "smoking",
        question: "Do you smoke or vape regularly?",
        clarification: "Cigarettes, e-cigarettes, or similar",
        icon: "smoke.fill",
        keyPath: \.smokingFrequency
    ),
    BehaviorQuestion(
        id: "medication",
        question: "Do you take medication that affects sleep?",
        clarification: "Sleeping pills, antidepressants, stimulants, or similar",
        icon: "pills.fill",
        keyPath: \.sleepMedication
    ),
    BehaviorQuestion(
        id: "exercise",
        question: "Do you exercise close to bedtime?",
        clarification: "Within 3 hours of when you usually go to sleep",
        icon: "figure.run",
        keyPath: \.lateExercise
    ),
    BehaviorQuestion(
        id: "screens",
        question: "Do you use screens right before bed?",
        clarification: "Phone, TV, or tablet within 1 hour of sleeping",
        icon: "iphone",
        keyPath: \.lateScreenTime
    ),
]

@Published var behaviors = UserBehaviors.empty
@Published var isSaving = false
@Published var errorMessage: String?

func answer(_ keyPath: WritableKeyPath<UserBehaviors, BehaviorFrequency>, with frequency: BehaviorFrequency) {
    behaviors[keyPath: keyPath] = frequency
}

func submit(authManager: AuthenticationManager) async {
    isSaving = true
    errorMessage = nil

    do {
        let token = try await authManager.validAccessToken()
        let _: UserBehaviorsResponse = try await APIWrapper.shared.post(
            "me/behaviors",
            body: UserBehaviorsRequest(behaviors: behaviors),
            headers: ["Authorization": "Bearer \(token)"],
            responseType: UserBehaviorsResponse.self
        )
        authManager.completeBehaviorOnboarding()
    } catch {
        // If the backend call fails, don't block the user —
        // let them into the app and we'll retry later.
        authManager.completeBehaviorOnboarding()
    }

    isSaving = false
}

}

BehaviorOnboardingView.swift

import SwiftUI

struct BehaviorOnboardingView: View {
@ObservedObject var authManager: AuthenticationManager
@StateObject private var store = BehaviorOnboardingStore()

var body: some View {
    ZStack {
        Color.appBackground
            .ignoresSafeArea()

        ScrollView {
            VStack(spacing: 24) {

                // Header
                VStack(spacing: 10) {
                    ZStack {
                        Circle()
                            .fill(
                                LinearGradient(
                                    colors: [Color(hex: "5856D6"), Color(hex: "007AFF")],
                                    startPoint: .topLeading,
                                    endPoint: .bottomTrailing
                                )
                            )
                            .frame(width: 72, height: 72)

                        Image(systemName: "list.clipboard.fill")
                            .font(.system(size: 34))
                            .foregroundColor(.white)
                    }
                    .padding(.top, 40)

                    Text("A few quick questions")
                        .font(.system(size: 28, weight: .bold))
                        .foregroundColor(.appPrimaryText)
                        .multilineTextAlignment(.center)

                    Text("Your answers help us personalize your sleep and focus insights. There are no wrong answers.")
                        .font(.system(size: 15))
                        .foregroundColor(.appSecondaryText)
                        .multilineTextAlignment(.center)
                        .padding(.horizontal, 32)
                }

                // Questions
                VStack(spacing: 12) {
                    ForEach(BehaviorOnboardingStore.questions, id: \.id) { question in
                        BehaviorQuestionCard(
                            question: question,
                            selected: store.behaviors[keyPath: question.keyPath],
                            onSelect: { frequency in
                                store.answer(question.keyPath, with: frequency)
                            }
                        )
                    }
                }
                .padding(.horizontal, 16)

                // Error
                if let errorMessage = store.errorMessage {
                    Text(errorMessage)
                        .font(.system(size: 13))
                        .foregroundColor(Color(hex: "FF3B30"))
                        .multilineTextAlignment(.center)
                        .padding(.horizontal, 32)
                }

                // Continue button
                Button {
                    Task { await store.submit(authManager: authManager) }
                } label: {
                    ZStack {
                        RoundedRectangle(cornerRadius: 14)
                            .fill(Color(hex: "007AFF"))
                            .frame(height: 54)

                        if store.isSaving {
                            ProgressView()
                                .tint(.white)
                        } else {
                            Text("Continue")
                                .font(.system(size: 17, weight: .semibold))
                                .foregroundColor(.white)
                        }
                    }
                }
                .buttonStyle(PlainButtonStyle())
                .disabled(store.isSaving)
                .padding(.horizontal, 16)
                .padding(.bottom, 40)
            }
        }
    }
}

}

// MARK: - Question Card

private struct BehaviorQuestionCard: View {
let question: BehaviorOnboardingStore.BehaviorQuestion
let selected: BehaviorFrequency
let onSelect: (BehaviorFrequency) -> Void

var body: some View {
    VStack(alignment: .leading, spacing: 14) {

        // Question text
        HStack(alignment: .top, spacing: 12) {
            Image(systemName: question.icon)
                .font(.system(size: 20))
                .foregroundColor(Color(hex: "5856D6"))
                .frame(width: 28)

            VStack(alignment: .leading, spacing: 3) {
                Text(question.question)
                    .font(.system(size: 16, weight: .semibold))
                    .foregroundColor(.appPrimaryText)

                Text(question.clarification)
                    .font(.system(size: 13))
                    .foregroundColor(.appSecondaryText)
            }
        }

        // Answer chips
        HStack(spacing: 8) {
            ForEach(BehaviorFrequency.allCases, id: \.self) { frequency in
                BehaviorChip(
                    label: frequency.label,
                    isSelected: selected == frequency,
                    onTap: { onSelect(frequency) }
                )
            }
        }
    }
    .padding(16)
    .frame(maxWidth: .infinity, alignment: .leading)
    .background(Color.appCardBackground)
    .cornerRadius(14)
    .shadow(color: Color.black.opacity(0.05), radius: 2, x: 0, y: 1)
}

}

// MARK: - Answer Chip

private struct BehaviorChip: View {
let label: String
let isSelected: Bool
let onTap: () -> Void

var body: some View {
    Button(action: onTap) {
        Text(label)
            .font(.system(size: 14, weight: isSelected ? .semibold : .regular))
            .foregroundColor(isSelected ? .white : .appPrimaryText)
            .padding(.horizontal, 16)
            .padding(.vertical, 8)
            .background(isSelected ? Color(hex: "5856D6") : Color.appCardSecondaryBackground)
            .cornerRadius(20)
    }
    .buttonStyle(PlainButtonStyle())
    .animation(.easeInOut(duration: 0.15), value: isSelected)
}

}

[austinkimchi]

@erik-keifer
Can you instead create a commit in the pull request, and I'll review it there?
The changes should be minimal. I already put comments on what needs to be changed in pull request #12.

[erik-keifer]

I did that.