@moifort/stack 0.0.0-stage → 0.1.0

package/templates/ios/ios/{{APP_NAME}}/Features/Onboarding/OnboardingAPI.swift

@@ -0,0 +1,28 @@
+import Foundation
+
+enum OnboardingAPI {
+    static func launch() async throws -> LaunchState {
+        #if DEBUG
+        if Showcase.isOn {
+            return LaunchState(firstName: Showcase.firstName, onboardingCompleted: true)
+        }
+        #endif
+        let data = try await GraphQLHelpers.fetch(
+            GraphQLClient.shared.apollo,
+            query: {{APP_NAME}}GraphQL.LaunchQuery()
+        )
+        return LaunchState(
+            firstName: data.me.firstName,
+            onboardingCompleted: data.me.onboardingCompleted
+        )
+    }
+
+    static func completeOnboarding(firstName: String) async throws {
+        let input = {{APP_NAME}}GraphQL.CompleteOnboardingInput(firstName: firstName)
+        _ = try await GraphQLHelpers.perform(
+            GraphQLClient.shared.apollo,
+            mutation: {{APP_NAME}}GraphQL.CompleteOnboardingMutation(input: input),
+            changesData: false
+        )
+    }
+}

package/templates/ios/ios/{{APP_NAME}}/Features/Onboarding/OnboardingClient.swift

@@ -0,0 +1,26 @@
+import Foundation
+
+/// What a signed-in launch reads, in one request.
+struct LaunchState: Sendable {
+    let firstName: String?
+    let onboardingCompleted: Bool
+}
+
+/// What the onboarding asks of the server, as closures: `.live` goes through the
+/// API, `.preview` answers at once, a test builds the one it needs inline.
+struct OnboardingClient: Sendable {
+    var launch: @Sendable () async throws -> LaunchState
+    var complete: @Sendable (_ firstName: String) async throws -> Void
+}
+
+extension OnboardingClient {
+    static let live = OnboardingClient(
+        launch: { try await OnboardingAPI.launch() },
+        complete: { try await OnboardingAPI.completeOnboarding(firstName: $0) }
+    )
+
+    static let preview = OnboardingClient(
+        launch: { LaunchState(firstName: "Ada", onboardingCompleted: true) },
+        complete: { _ in }
+    )
+}

package/templates/ios/ios/{{APP_NAME}}/Features/Onboarding/OnboardingGate.swift

@@ -0,0 +1,50 @@
+import Observation
+
+/// Decides, once a user is signed in, whether to show the onboarding or the app.
+/// Reads `me` at launch; `onboardingCompleted` drives the choice. Lives at
+/// `AuthRoot` scope and is refreshed on sign-in and account switch.
+@MainActor
+@Observable
+final class OnboardingGate {
+    enum State: Equatable {
+        case loading
+        case required
+        case ready
+        case failed(String)
+    }
+
+    private(set) var state: State = .loading
+    /// The user's first name, riding the same launch request: the profile settings
+    /// draw it from here rather than asking the server again.
+    private(set) var firstName: String?
+
+    private let client: OnboardingClient
+
+    init(client: OnboardingClient = .live) {
+        self.client = client
+    }
+
+    func refresh() async {
+        state = .loading
+        do {
+            let launch = try await client.launch()
+            firstName = launch.firstName
+            state = launch.onboardingCompleted ? .ready : .required
+        } catch {
+            state = .failed(reportError(error))
+        }
+    }
+
+    /// Called by the onboarding on success, to enter the app without a re-fetch.
+    func markCompleted(firstName: String) {
+        self.firstName = firstName
+        state = .ready
+    }
+
+    /// Clears the resolved state on sign-out, so the next account never sees the
+    /// previous one's state for a frame.
+    func reset() {
+        state = .loading
+        firstName = nil
+    }
+}

package/templates/ios/ios/{{APP_NAME}}/Features/Onboarding/OnboardingScreen.swift

@@ -0,0 +1,69 @@
+import FirebaseCore
+import SwiftUI
+
+/// Shown once, before the app: a welcome that says what the app is for, then the
+/// first name, the one thing it asks.
+struct OnboardingScreen: View {
+    /// Handed the first name the user gave, so the app knows it without asking.
+    var onCompleted: (String) -> Void
+    var client: OnboardingClient = .live
+
+    @Environment(AuthSession.self) private var session
+    @State private var step: Step = .welcome
+    @State private var firstName = ""
+    @State private var isSaving = false
+    @State private var errorMessage: String?
+
+    private enum Step {
+        case welcome
+        case firstName
+    }
+
+    var body: some View {
+        NavigationStack {
+            switch step {
+            case .welcome:
+                WelcomePage(onNext: { withAnimation { step = .firstName } })
+            case .firstName:
+                FirstNamePage(
+                    firstName: $firstName,
+                    isSaving: isSaving,
+                    onNext: { Task { await complete() } },
+                    onBack: { withAnimation { step = .welcome } }
+                )
+            }
+        }
+        .alert(
+            "Impossible de terminer",
+            isPresented: .init(get: { errorMessage != nil }, set: { if !$0 { errorMessage = nil } })
+        ) {
+            Button("OK", role: .cancel) {}
+        } message: {
+            Text(errorMessage ?? "")
+        }
+        .onAppear {
+            // Proposed, not imposed: the field stays editable.
+            if firstName.isEmpty, let suggested = session.suggestedFirstName {
+                firstName = suggested
+            }
+        }
+    }
+
+    private func complete() async {
+        let name = firstName.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !name.isEmpty else { return }
+        isSaving = true
+        defer { isSaving = false }
+        do {
+            try await client.complete(name)
+            onCompleted(name)
+        } catch {
+            errorMessage = reportError(error)
+        }
+    }
+}
+
+#Preview {
+    if FirebaseApp.app() == nil { FirebaseApp.configure() }
+    return OnboardingScreen(onCompleted: { _ in }, client: .preview).environment(AuthSession())
+}

package/templates/ios/ios/{{APP_NAME}}/Features/Onboarding/components/pages/FirstNamePage.swift

@@ -0,0 +1,66 @@
+import SwiftUI
+
+struct FirstNamePage: View {
+    @Binding var firstName: String
+    var isSaving: Bool
+    var onNext: () -> Void
+    var onBack: () -> Void
+
+    @FocusState private var focused: Bool
+
+    private var trimmed: String {
+        firstName.trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 24) {
+            VStack(alignment: .leading, spacing: 8) {
+                Text("Comment vous appelez-vous ?")
+                    .font(.title.bold())
+                Text("Votre prénom sert à personnaliser l'application.")
+                    .font(.subheadline)
+                    .foregroundStyle(.secondary)
+            }
+
+            TextField("Prénom", text: $firstName)
+                .textContentType(.givenName)
+                .textInputAutocapitalization(.words)
+                .submitLabel(.next)
+                .focused($focused)
+                .onSubmit { if !trimmed.isEmpty { onNext() } }
+                .padding()
+                .background(Color(.systemGray6))
+                .clipShape(RoundedRectangle(cornerRadius: 12))
+                .accessibilityIdentifier("onboarding-firstname-field")
+
+            Spacer()
+
+            Button(action: onNext) {
+                ZStack {
+                    Text("Continuer").opacity(isSaving ? 0 : 1)
+                    if isSaving { ProgressView() }
+                }
+                .frame(maxWidth: .infinity)
+            }
+            .buttonStyle(.borderedProminent)
+            .controlSize(.large)
+            .disabled(trimmed.isEmpty || isSaving)
+            .accessibilityIdentifier("onboarding-firstname-next")
+        }
+        .padding()
+        .navigationTitle("Prénom")
+        .navigationBarTitleDisplayMode(.inline)
+        .toolbar {
+            ToolbarItem(placement: .topBarLeading) {
+                ToolbarIconButton(title: "Retour", systemImage: "chevron.left", action: onBack)
+            }
+        }
+        .onAppear { focused = true }
+    }
+}
+
+#Preview {
+    NavigationStack {
+        FirstNamePage(firstName: .constant("Ada"), isSaving: false, onNext: {}, onBack: {})
+    }
+}

package/templates/ios/ios/{{APP_NAME}}/Features/Onboarding/components/pages/WelcomePage.swift

@@ -0,0 +1,37 @@
+import SwiftUI
+
+struct WelcomePage: View {
+    var onNext: () -> Void
+
+    var body: some View {
+        VStack(spacing: 24) {
+            Spacer()
+            Image(systemName: "sparkles")
+                .font(.system(size: 72))
+                .foregroundStyle(.tint)
+            VStack(spacing: 12) {
+                Text("Bienvenue dans {{APP_NAME}}")
+                    .font(.largeTitle.bold())
+                    .multilineTextAlignment(.center)
+                Text("{{APP_TAGLINE}}")
+                    .font(.body)
+                    .foregroundStyle(.secondary)
+                    .multilineTextAlignment(.center)
+            }
+            .padding(.horizontal)
+            Spacer()
+            Button(action: onNext) {
+                Text("Commencer")
+                    .frame(maxWidth: .infinity)
+            }
+            .buttonStyle(.borderedProminent)
+            .controlSize(.large)
+            .accessibilityIdentifier("onboarding-start")
+        }
+        .padding()
+    }
+}
+
+#Preview {
+    WelcomePage(onNext: {})
+}

package/templates/ios/ios/{{APP_NAME}}/Features/Settings/ChangelogScreen.swift

@@ -0,0 +1,25 @@
+import SwiftUI
+
+/// The release notes, connected.
+struct ChangelogScreen: View {
+    @State private var viewModel: ChangelogViewModel
+
+    init(client: SettingsClient = .live) {
+        _viewModel = State(initialValue: ChangelogViewModel(client: client))
+    }
+
+    var body: some View {
+        ChangelogPage(
+            entries: viewModel.entries,
+            isLoading: viewModel.isLoading,
+            errorMessage: viewModel.errorMessage
+        ) {
+            await viewModel.load()
+        }
+        .task { await viewModel.load() }
+    }
+}
+
+#Preview {
+    NavigationStack { ChangelogScreen(client: .preview) }
+}

package/templates/ios/ios/{{APP_NAME}}/Features/Settings/ChangelogViewModel.swift

@@ -0,0 +1,27 @@
+import Foundation
+
+/// The release notes, served by the backend in the user's language.
+@MainActor
+@Observable
+final class ChangelogViewModel {
+    private(set) var entries: [ChangelogEntry] = []
+    private(set) var isLoading = true
+    private(set) var errorMessage: String?
+
+    private let client: SettingsClient
+
+    init(client: SettingsClient) {
+        self.client = client
+    }
+
+    func load() async {
+        isLoading = true
+        errorMessage = nil
+        do {
+            entries = try await client.changelog()
+        } catch {
+            errorMessage = reportError(error)
+        }
+        isLoading = false
+    }
+}

package/templates/ios/ios/{{APP_NAME}}/Features/Settings/GraphQL/Settings.graphql

@@ -0,0 +1,11 @@
+query Changelog {
+  changelog {
+    version
+    date
+    notes
+  }
+}
+
+mutation DeleteAccount {
+  deleteAccount
+}

package/templates/ios/ios/{{APP_NAME}}/Features/Settings/ProfileSettingsScreen.swift

@@ -0,0 +1,30 @@
+import SwiftUI
+
+/// The account, connected: who it is from the auth session, and the two ways out
+/// through `ProfileSettingsViewModel`.
+struct ProfileSettingsScreen: View {
+    @Environment(AuthSession.self) private var authSession
+    /// Read at launch with the routing flags: this screen asks the server nothing.
+    @Environment(\.accountFirstName) private var firstName
+    @State private var viewModel: ProfileSettingsViewModel
+
+    init(client: SettingsClient = .live) {
+        _viewModel = State(initialValue: ProfileSettingsViewModel(client: client))
+    }
+
+    var body: some View {
+        ProfileSettingsPage(
+            firstName: firstName,
+            displayName: authSession.user?.displayName,
+            email: authSession.user?.email,
+            shortUid: String((authSession.user?.uid ?? "").prefix(8)),
+            isDeletingAccount: viewModel.isDeletingAccount,
+            errorMessage: viewModel.errorMessage
+        ) { action in
+            switch action {
+            case .signOut: await viewModel.signOut(endSession: authSession.signOut)
+            case .deleteAccount: await viewModel.deleteAccount(endSession: authSession.signOut)
+            }
+        }
+    }
+}

package/templates/ios/ios/{{APP_NAME}}/Features/Settings/ProfileSettingsViewModel.swift

@@ -0,0 +1,51 @@
+import Foundation
+
+/// The two ways out of the account: signing out, which keeps everything, and
+/// deleting, which keeps nothing. Ending the session is the caller's, handed
+/// in as `endSession`: the ViewModel never holds the auth session itself.
+@MainActor
+@Observable
+final class ProfileSettingsViewModel {
+    private(set) var isDeletingAccount = false
+    /// What went wrong, said under the buttons.
+    private(set) var errorMessage: String?
+
+    private let client: SettingsClient
+
+    init(client: SettingsClient) {
+        self.client = client
+    }
+
+    func signOut(endSession: () throws -> Void) async {
+        errorMessage = nil
+        do {
+            try endSession()
+        } catch {
+            errorMessage = reportError(error)
+        }
+    }
+
+    func deleteAccount(endSession: () throws -> Void) async {
+        isDeletingAccount = true
+        errorMessage = nil
+        do {
+            try await client.deleteAccount()
+        } catch {
+            // The server may have finished and only its answer been lost — a
+            // timeout, the app sent to the background. If the account is gone,
+            // the deletion happened: sign out as if the answer had arrived.
+            if await client.accountIsGone() { return }
+            errorMessage = reportError(error)
+            isDeletingAccount = false
+            return
+        }
+        // Everything is erased, the Firebase user last: drop the now-invalid
+        // session and route back to the login screen.
+        do {
+            try endSession()
+        } catch {
+            errorMessage = reportError(error)
+            isDeletingAccount = false
+        }
+    }
+}

package/templates/ios/ios/{{APP_NAME}}/Features/Settings/SettingsAPI.swift

@@ -0,0 +1,37 @@
+import Foundation
+
+/// One released version and what it changed, as the app shows it.
+struct ChangelogEntry: Identifiable, Sendable {
+    var id: String { version }
+    let version: String
+    let date: Date?
+    let notes: [String]
+}
+
+enum SettingsAPI {
+    /// The release notes, served in the caller's language by the backend.
+    static func changelog() async throws -> [ChangelogEntry] {
+        let data = try await GraphQLHelpers.fetch(
+            GraphQLClient.shared.apollo,
+            query: {{APP_NAME}}GraphQL.ChangelogQuery()
+        )
+        return data.changelog.map { entry in
+            ChangelogEntry(
+                version: entry.version,
+                date: entry.date.flatMap(GraphQLHelpers.parseISO8601),
+                notes: entry.notes
+            )
+        }
+    }
+
+    /// Erases the account and everything it owns, then the Firebase identity.
+    /// Irreversible, and required by App Review for any app that creates an
+    /// account. Does NOT cancel an App Store subscription: Apple owns that.
+    static func deleteAccount() async throws {
+        _ = try await GraphQLHelpers.perform(
+            GraphQLClient.shared.apollo,
+            mutation: {{APP_NAME}}GraphQL.DeleteAccountMutation(),
+            changesData: false
+        )
+    }
+}

package/templates/ios/ios/{{APP_NAME}}/Features/Settings/SettingsClient.swift

@@ -0,0 +1,40 @@
+import Foundation
+
+/// Everything the settings screens ask of the server, as closures: `.live` goes
+/// through the API, `.preview` answers at once, a test builds the one it needs.
+struct SettingsClient: Sendable {
+    var changelog: @Sendable () async throws -> [ChangelogEntry]
+    var deleteAccount: @Sendable () async throws -> Void
+    /// After a deletion that seemed to fail: true when the account is gone all the
+    /// same, and the session has been dropped.
+    var accountIsGone: @Sendable () async -> Bool
+}
+
+extension SettingsClient {
+    static let live = SettingsClient(
+        changelog: { try await SettingsAPI.changelog() },
+        deleteAccount: { try await SettingsAPI.deleteAccount() },
+        accountIsGone: { await AuthSession.dropSessionIfAccountIsGone() }
+    )
+
+    static let preview = SettingsClient(
+        changelog: { ChangelogEntry.previews },
+        deleteAccount: {},
+        accountIsGone: { false }
+    )
+}
+
+extension ChangelogEntry {
+    static let previews = [
+        ChangelogEntry(
+            version: "1.1",
+            date: .now.addingTimeInterval(-86400 * 3),
+            notes: ["Les listes s'ouvrent maintenant plus vite."]
+        ),
+        ChangelogEntry(
+            version: "1.0",
+            date: .now.addingTimeInterval(-86400 * 30),
+            notes: ["Première version."]
+        ),
+    ]
+}

package/templates/ios/ios/{{APP_NAME}}/Features/Settings/SettingsHomeScreen.swift

@@ -0,0 +1,39 @@
+import SwiftUI
+
+/// The settings, connected: the account from the auth session, and every sheet
+/// and push of `SettingsHomePage`.
+struct SettingsHomeScreen: View {
+    var client: SettingsClient = .live
+
+    @Environment(AuthSession.self) private var authSession
+    @Environment(\.dismiss) private var dismiss
+    @State private var feedbackShown = false
+
+    var body: some View {
+        NavigationStack {
+            SettingsHomePage(
+                profileSubtitle: authSession.user?.displayName ?? authSession.user?.email,
+                appVersion: Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "?",
+                buildNumber: Bundle.main.infoDictionary?["CFBundleVersion"] as? String ?? "?"
+            ) { action in
+                switch action {
+                case .showFeedback: feedbackShown = true
+                }
+            }
+            .navigationDestination(for: SettingsDestination.self) { destination in
+                switch destination {
+                case .profile: ProfileSettingsScreen(client: client)
+                case .changelog: ChangelogScreen(client: client)
+                }
+            }
+            .sheet(isPresented: $feedbackShown) {
+                FeedbackSheet(onSend: sendFeedback)
+            }
+            .toolbar {
+                ToolbarItem(placement: .cancellationAction) {
+                    ToolbarIconButton(title: "Fermer", systemImage: "xmark", role: .cancel) { dismiss() }
+                }
+            }
+        }
+    }
+}

package/templates/ios/ios/{{APP_NAME}}/Features/Settings/components/organisms/DeleteAccountButton.swift

@@ -0,0 +1,30 @@
+import SwiftUI
+
+struct DeleteAccountButton: View {
+    var isDeleting: Bool
+    let action: () -> Void
+
+    var body: some View {
+        Button(role: .destructive, action: action) {
+            if isDeleting {
+                ProgressView()
+            } else {
+                Label {
+                    Text("Supprimer mon compte")
+                } icon: {
+                    Image(systemName: "trash")
+                        .foregroundStyle(.red)
+                }
+            }
+        }
+        .disabled(isDeleting)
+        .accessibilityIdentifier("delete-account")
+    }
+}
+
+#Preview {
+    List {
+        DeleteAccountButton(isDeleting: false) {}
+        DeleteAccountButton(isDeleting: true) {}
+    }
+}

package/templates/ios/ios/{{APP_NAME}}/Features/Settings/components/organisms/SettingsRow.swift

@@ -0,0 +1,56 @@
+import SwiftUI
+
+/// One entry of the settings list: a tinted badge, a title, and under it a
+/// value read at runtime — an email, a version, a store — which the caller
+/// localizes since it is data, not a key.
+struct SettingsRow: View {
+    let icon: String
+    let title: LocalizedStringKey
+    let subtitle: String?
+    let tint: Color
+
+    /// The badge box scales with Dynamic Type; the glyph is sized to a fixed
+    /// fraction of it, so its inset stays constant at every text size.
+    @ScaledMetric(relativeTo: .body) private var iconBadgeSize: CGFloat = 28
+    private var glyphSize: CGFloat { iconBadgeSize * 0.5 }
+
+    init(icon: String, title: LocalizedStringKey, subtitle: String? = nil, tint: Color = .accentColor) {
+        self.icon = icon
+        self.title = title
+        self.subtitle = subtitle
+        self.tint = tint
+    }
+
+    var body: some View {
+        Label {
+            VStack(alignment: .leading, spacing: 2) {
+                Text(title)
+                if let subtitle {
+                    Text(verbatim: subtitle)
+                        .font(.footnote)
+                        .foregroundStyle(.secondary)
+                }
+            }
+        } icon: {
+            Image(systemName: icon)
+                .font(.system(size: glyphSize))
+                .foregroundStyle(.white)
+                .frame(width: iconBadgeSize, height: iconBadgeSize)
+                .background(
+                    tint,
+                    in: RoundedRectangle(cornerRadius: iconBadgeSize * 6 / 28, style: .continuous)
+                )
+        }
+        // A plain button only answers where something is drawn: stretched and
+        // shaped, the whole row is the target, not just its title.
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .contentShape(.rect)
+    }
+}
+
+#Preview {
+    List {
+        SettingsRow(icon: "person.crop.circle.fill", title: "Profil", subtitle: "ada@example.com", tint: .blue)
+        SettingsRow(icon: "doc.text.fill", title: "Version et nouveautés", tint: .indigo)
+    }
+}

package/templates/ios/ios/{{APP_NAME}}/Features/Settings/components/organisms/SignOutButton.swift

@@ -0,0 +1,23 @@
+import SwiftUI
+
+struct SignOutButton: View {
+    let action: () -> Void
+
+    var body: some View {
+        Button(role: .destructive, action: action) {
+            Label {
+                Text("Se déconnecter")
+            } icon: {
+                Image(systemName: "rectangle.portrait.and.arrow.right")
+                    .foregroundStyle(.red)
+            }
+        }
+        .accessibilityIdentifier("sign-out")
+    }
+}
+
+#Preview {
+    List {
+        SignOutButton {}
+    }
+}