@shaykec/app-agent 1.0.5 → 1.0.6

package/templates/shared/ios/SupabaseBackend/Screens/SupabaseProfileScreen.swift

@@ -0,0 +1,102 @@
+import SwiftUI
+
+/// Supabase profile screen showing user email, provider badge, sign out, and delete account options.
+struct SupabaseProfileScreen: View {
+    @StateObject private var authService = SupabaseAuthService.shared
+    @State private var showingDeleteConfirmation = false
+    @State private var isDeleting = false
+    
+    var body: some View {
+        NavigationView {
+            List {
+                // User info section
+                Section {
+                    if let user = authService.currentUser {
+                        HStack {
+                            // Avatar
+                            Circle()
+                                .fill(Color.blue.opacity(0.2))
+                                .frame(width: 60, height: 60)
+                                .overlay {
+                                    Text(user.email?.prefix(1).uppercased() ?? "?")
+                                        .font(.title2)
+                                        .foregroundStyle(.blue)
+                                }
+                                .accessibilityIdentifier("supabase_profile_avatar")
+                            
+                            VStack(alignment: .leading, spacing: AppConfig.Theme.Spacing.xs) {
+                                // Email
+                                Text(user.email ?? Strings.Supabase.noEmail)
+                                    .font(AppConfig.Theme.Typography.body)
+                                    .accessibilityIdentifier("supabase_profile_email")
+                                
+                                // Provider badge
+                                if let provider = user.appMetadata?["provider"] as? String {
+                                    Text(Strings.Supabase.providerBadge(provider: provider))
+                                        .font(AppConfig.Theme.Typography.caption)
+                                        .foregroundStyle(.secondary)
+                                        .accessibilityIdentifier("supabase_profile_provider")
+                                }
+                            }
+                        }
+                        .padding(.vertical, AppConfig.Theme.Spacing.xs)
+                    }
+                }
+                
+                // Actions section
+                Section {
+                    // Sign out button
+                    Button {
+                        Task {
+                            try? await authService.signOut()
+                        }
+                    } label: {
+                        HStack {
+                            Image(systemName: "arrow.right.square")
+                            Text(Strings.Supabase.signOut)
+                        }
+                        .foregroundStyle(.red)
+                    }
+                    .accessibilityIdentifier("supabase_profile_sign_out_button")
+                    
+                    // Delete account button
+                    Button {
+                        showingDeleteConfirmation = true
+                    } label: {
+                        HStack {
+                            Image(systemName: "trash")
+                            Text(Strings.Supabase.deleteAccount)
+                        }
+                        .foregroundStyle(.red)
+                    }
+                    .disabled(isDeleting)
+                    .accessibilityIdentifier("supabase_profile_delete_account_button")
+                }
+            }
+            .navigationTitle(Strings.Supabase.profile)
+            .alert(Strings.Supabase.deleteAccountTitle, isPresented: $showingDeleteConfirmation) {
+                Button(Strings.Supabase.cancel, role: .cancel) {}
+                Button(Strings.Supabase.delete, role: .destructive) {
+                    Task {
+                        await handleDeleteAccount()
+                    }
+                }
+            } message: {
+                Text(Strings.Supabase.deleteAccountMessage)
+            }
+        }
+    }
+    
+    // MARK: - Private Methods
+    
+    private func handleDeleteAccount() async {
+        isDeleting = true
+        do {
+            try await authService.deleteAccount()
+        } catch {
+            // Error handling - could show alert here
+            print("Failed to delete account: \(error)")
+        }
+        isDeleting = false
+    }
+}

package/templates/shared/ios/SupabaseBackend/Screens/SupabaseSignUpScreen.swift

@@ -0,0 +1,159 @@
+import SwiftUI
+
+/// Supabase sign-up screen with email, password, confirm password, and create account button.
+struct SupabaseSignUpScreen: View {
+    @StateObject private var authService = SupabaseAuthService.shared
+    @State private var email = ""
+    @State private var password = ""
+    @State private var confirmPassword = ""
+    @State private var errorMessage: String?
+    
+    let onSuccess: (() -> Void)?
+    let onSignIn: (() -> Void)?
+    
+    init(
+        onSuccess: (() -> Void)? = nil,
+        onSignIn: (() -> Void)? = nil
+    ) {
+        self.onSuccess = onSuccess
+        self.onSignIn = onSignIn
+    }
+    
+    var body: some View {
+        NavigationView {
+            ScrollView {
+                VStack(spacing: AppConfig.Theme.Spacing.lg) {
+                    // Title
+                    Text(Strings.Supabase.signUp)
+                        .font(AppConfig.Theme.Typography.title)
+                        .multilineTextAlignment(.center)
+                        .accessibilityIdentifier("supabase_signup_title")
+                    
+                    // Email field
+                    VStack(alignment: .leading, spacing: AppConfig.Theme.Spacing.xs) {
+                        Text(Strings.Supabase.email)
+                            .font(AppConfig.Theme.Typography.caption)
+                            .foregroundStyle(.secondary)
+                        TextField(Strings.Supabase.email, text: $email)
+                            .textFieldStyle(.roundedBorder)
+                            .autocapitalization(.none)
+                            .keyboardType(.emailAddress)
+                            .textContentType(.emailAddress)
+                            .accessibilityIdentifier("supabase_signup_email_field")
+                    }
+                    
+                    // Password field
+                    VStack(alignment: .leading, spacing: AppConfig.Theme.Spacing.xs) {
+                        Text(Strings.Supabase.password)
+                            .font(AppConfig.Theme.Typography.caption)
+                            .foregroundStyle(.secondary)
+                        SecureField(Strings.Supabase.password, text: $password)
+                            .textFieldStyle(.roundedBorder)
+                            .textContentType(.newPassword)
+                            .accessibilityIdentifier("supabase_signup_password_field")
+                    }
+                    
+                    // Confirm password field
+                    VStack(alignment: .leading, spacing: AppConfig.Theme.Spacing.xs) {
+                        Text(Strings.Supabase.confirmPassword)
+                            .font(AppConfig.Theme.Typography.caption)
+                            .foregroundStyle(.secondary)
+                        SecureField(Strings.Supabase.confirmPassword, text: $confirmPassword)
+                            .textFieldStyle(.roundedBorder)
+                            .textContentType(.newPassword)
+                            .accessibilityIdentifier("supabase_signup_confirm_password_field")
+                    }
+                    
+                    // Password mismatch warning
+                    if !confirmPassword.isEmpty && password != confirmPassword {
+                        Text(Strings.Supabase.passwordMismatch)
+                            .font(AppConfig.Theme.Typography.caption)
+                            .foregroundStyle(.orange)
+                            .accessibilityIdentifier("supabase_signup_password_mismatch_warning")
+                    }
+                    
+                    // Error message
+                    if let errorMessage = errorMessage {
+                        Text(errorMessage)
+                            .font(AppConfig.Theme.Typography.caption)
+                            .foregroundStyle(.red)
+                            .multilineTextAlignment(.center)
+                            .accessibilityIdentifier("supabase_signup_error_message")
+                    }
+                    
+                    // Create account button
+                    Button {
+                        Task {
+                            await handleSignUp()
+                        }
+                    } label: {
+                        Text(Strings.Supabase.createAccount)
+                            .font(AppConfig.Theme.Typography.body)
+                            .frame(maxWidth: .infinity)
+                            .frame(height: 50)
+                    }
+                    .buttonStyle(.borderedProminent)
+                    .disabled(
+                        authService.authState == .authenticating ||
+                        email.isEmpty ||
+                        password.isEmpty ||
+                        confirmPassword.isEmpty ||
+                        password != confirmPassword
+                    )
+                    .accessibilityIdentifier("supabase_signup_create_account_button")
+                    
+                    // Sign in link
+                    if let onSignIn = onSignIn {
+                        HStack {
+                            Text(Strings.Supabase.alreadyHaveAccount)
+                            Button(Strings.Supabase.signIn) {
+                                onSignIn()
+                            }
+                        }
+                        .font(AppConfig.Theme.Typography.body)
+                        .accessibilityIdentifier("supabase_signup_sign_in_link")
+                    }
+                }
+                .padding(AppConfig.Theme.Spacing.lg)
+            }
+            .navigationBarTitleDisplayMode(.inline)
+            .onChange(of: authService.authState) { oldValue, newValue in
+                handleAuthStateChange(newValue)
+            }
+        }
+    }
+    
+    // MARK: - Private Methods
+    
+    private func handleSignUp() async {
+        errorMessage = nil
+        
+        // Validation
+        guard password == confirmPassword else {
+            errorMessage = Strings.Supabase.passwordMismatch
+            return
+        }
+        
+        guard password.count >= 6 else {
+            errorMessage = Strings.Supabase.weakPassword
+            return
+        }
+        
+        do {
+            try await authService.signUp(email: email, password: password)
+        } catch {
+            errorMessage = error.localizedDescription
+        }
+    }
+    
+    private func handleAuthStateChange(_ state: SupabaseAuthService.AuthState) {
+        switch state {
+        case .loggedIn:
+            onSuccess?()
+        case .error(let message):
+            errorMessage = message
+        default:
+            break
+        }
+    }
+}

package/templates/shared/ios/SupabaseBackend/Strings.swift

@@ -0,0 +1,73 @@
+import Foundation
+
+// MARK: - Supabase Strings
+extension Strings {
+    enum Supabase {
+        // MARK: - Auth Actions
+        static let signIn = "Sign In"
+        static let signUp = "Sign Up"
+        static let signOut = "Sign Out"
+        static let createAccount = "Create Account"
+        
+        // MARK: - Form Fields
+        static let email = "Email"
+        static let password = "Password"
+        static let confirmPassword = "Confirm Password"
+        
+        // MARK: - Magic Link
+        static let useMagicLink = "Use Magic Link"
+        static let sendMagicLink = "Send Magic Link"
+        static let magicLinkSentTitle = "Check Your Email"
+        static func magicLinkSentMessage(email: String) -> String {
+            "We sent a magic link to \(email). Click the link to sign in."
+        }
+        static let magicLinkInstructions = "The link will expire in 1 hour."
+        static let openEmail = "Open Email"
+        static let resendMagicLink = "Resend Magic Link"
+        static func resendMagicLinkCountdown(seconds: Int) -> String {
+            "Resend in \(seconds)s"
+        }
+        
+        // MARK: - Password Reset
+        static let forgotPassword = "Forgot Password?"
+        static let forgotPasswordTitle = "Reset Password"
+        static let forgotPasswordMessage = "Enter your email address and we'll send you a link to reset your password."
+        static let sendResetLink = "Send Reset Link"
+        static let passwordResetSent = "Password Reset Sent"
+        static let passwordResetInstructions = "Check your email for instructions on how to reset your password."
+        static let backToSignIn = "Back to Sign In"
+        
+        // MARK: - Social Login
+        static let orContinueWith = "or continue with"
+        static let signInWithGoogle = "Sign in with Google"
+        static let signInWithApple = "Sign in with Apple"
+        static let signInWithGithub = "Sign in with GitHub"
+        static let signInWithFacebook = "Sign in with Facebook"
+        
+        // MARK: - Navigation Links
+        static let noAccount = "Don't have an account?"
+        static let alreadyHaveAccount = "Already have an account?"
+        
+        // MARK: - Profile
+        static let profile = "Profile"
+        static let noEmail = "No email"
+        static func providerBadge(provider: String) -> String {
+            "Signed in with \(provider.capitalized)"
+        }
+        static let deleteAccount = "Delete Account"
+        static let deleteAccountTitle = "Delete Account"
+        static let deleteAccountMessage = "Are you sure you want to delete your account? This action cannot be undone."
+        static let delete = "Delete"
+        static let cancel = "Cancel"
+        
+        // MARK: - Errors
+        static let invalidEmail = "Invalid email address"
+        static let weakPassword = "Password must be at least 6 characters"
+        static let passwordMismatch = "Passwords do not match"
+        static let userNotFound = "No account found with this email"
+        static let wrongPassword = "Incorrect password"
+        static let emailAlreadyInUse = "This email is already registered"
+        static let networkError = "Network error. Please check your connection"
+        static let sessionExpired = "Session expired. Please sign in again"
+    }
+}

package/templates/shared/ios/SupabaseBackend/SupabaseAuthService.swift

@@ -0,0 +1,191 @@
+import Foundation
+import SwiftUI
+import Supabase
+
+/// Supabase Authentication service with ObservableObject state management.
+/// Supports email/password, magic link (OTP), OAuth, password reset, and account deletion.
+@MainActor
+class SupabaseAuthService: ObservableObject {
+    static let shared = SupabaseAuthService()
+    
+    // MARK: - Published State
+    
+    enum AuthState {
+        case loggedOut
+        case authenticating
+        case loggedIn(user: User)
+        case error(String)
+    }
+    
+    @Published var authState: AuthState = .loggedOut
+    @Published var currentUser: User?
+    @Published var isLoggedIn: Bool = false
+    
+    // MARK: - Private Properties
+    
+    private let client: SupabaseClient
+    
+    // MARK: - Initialization
+    
+    private init() {
+        let url = URL(string: SecretsConfig.supabaseUrl)!
+        let key = SecretsConfig.supabaseAnonKey
+        client = SupabaseClient(supabaseURL: url, supabaseKey: key)
+        checkSession()
+    }
+    
+    // MARK: - Session Management
+    
+    private func checkSession() {
+        Task {
+            do {
+                let session = try await client.auth.session
+                await MainActor.run {
+                    self.currentUser = session.user
+                    self.authState = .loggedIn(user: session.user)
+                    self.isLoggedIn = true
+                }
+            } catch {
+                await MainActor.run {
+                    self.currentUser = nil
+                    self.authState = .loggedOut
+                    self.isLoggedIn = false
+                }
+            }
+        }
+    }
+    
+    // MARK: - Email/Password Authentication
+    
+    func signInWithEmail(email: String, password: String) async throws {
+        authState = .authenticating
+        do {
+            let session = try await client.auth.signIn(email: email, password: password)
+            await MainActor.run {
+                self.currentUser = session.user
+                self.authState = .loggedIn(user: session.user)
+                self.isLoggedIn = true
+            }
+        } catch {
+            await MainActor.run {
+                self.authState = .error(error.localizedDescription)
+                self.isLoggedIn = false
+            }
+            throw error
+        }
+    }
+    
+    func signUp(email: String, password: String) async throws {
+        authState = .authenticating
+        do {
+            let session = try await client.auth.signUp(email: email, password: password)
+            await MainActor.run {
+                self.currentUser = session.user
+                self.authState = .loggedIn(user: session.user)
+                self.isLoggedIn = true
+            }
+        } catch {
+            await MainActor.run {
+                self.authState = .error(error.localizedDescription)
+                self.isLoggedIn = false
+            }
+            throw error
+        }
+    }
+    
+    // MARK: - Magic Link (OTP)
+    
+    func signInWithMagicLink(email: String) async throws {
+        authState = .authenticating
+        do {
+            try await client.auth.signInWithOTP(email: email)
+            await MainActor.run {
+                // Magic link sent - user needs to check email
+                self.authState = .loggedOut
+            }
+        } catch {
+            await MainActor.run {
+                self.authState = .error(error.localizedDescription)
+            }
+            throw error
+        }
+    }
+    
+    // MARK: - OAuth
+    
+    enum OAuthProvider: String {
+        case google = "google"
+        case apple = "apple"
+        case github = "github"
+        case facebook = "facebook"
+    }
+    
+    func signInWithOAuth(provider: OAuthProvider) async throws {
+        authState = .authenticating
+        do {
+            try await client.auth.signInWithOAuth(
+                provider: .init(rawValue: provider.rawValue)!,
+                redirectTo: URL(string: "\(SecretsConfig.supabaseUrl)/auth/v1/callback")
+            )
+            // OAuth flow continues in browser/deep link
+        } catch {
+            await MainActor.run {
+                self.authState = .error(error.localizedDescription)
+            }
+            throw error
+        }
+    }
+    
+    // MARK: - Password Reset
+    
+    func sendPasswordReset(email: String) async throws {
+        do {
+            try await client.auth.resetPasswordForEmail(email)
+        } catch {
+            await MainActor.run {
+                self.authState = .error(error.localizedDescription)
+            }
+            throw error
+        }
+    }
+    
+    // MARK: - Sign Out
+    
+    func signOut() async throws {
+        do {
+            try await client.auth.signOut()
+            await MainActor.run {
+                self.currentUser = nil
+                self.authState = .loggedOut
+                self.isLoggedIn = false
+            }
+        } catch {
+            await MainActor.run {
+                self.authState = .error(error.localizedDescription)
+            }
+            throw error
+        }
+    }
+    
+    // MARK: - Account Deletion
+    
+    func deleteAccount() async throws {
+        guard let user = currentUser else {
+            throw NSError(domain: "SupabaseAuthService", code: -1, userInfo: [NSLocalizedDescriptionKey: "No user logged in"])
+        }
+        
+        do {
+            try await client.auth.admin.deleteUser(id: user.id)
+            await MainActor.run {
+                self.currentUser = nil
+                self.authState = .loggedOut
+                self.isLoggedIn = false
+            }
+        } catch {
+            await MainActor.run {
+                self.authState = .error(error.localizedDescription)
+            }
+            throw error
+        }
+    }
+}

package/templates/shared/ios/SupabaseBackend/SupabaseConfigService.swift

@@ -0,0 +1,31 @@
+import Foundation
+import Supabase
+
+/// Supabase Configuration service that initializes and provides access to the Supabase client.
+/// Reads configuration from SecretsConfig (supabaseUrl and supabaseAnonKey).
+class SupabaseConfigService {
+    static let shared = SupabaseConfigService()
+    
+    /// The configured Supabase client instance.
+    var client: SupabaseClient {
+        _client
+    }
+    
+    private let _client: SupabaseClient
+    
+    private init() {
+        guard let url = URL(string: SecretsConfig.supabaseUrl),
+              !SecretsConfig.supabaseUrl.isEmpty else {
+            fatalError("Supabase URL is not configured. Set SUPABASE_URL in SecretsConfig.")
+        }
+        
+        guard !SecretsConfig.supabaseAnonKey.isEmpty else {
+            fatalError("Supabase anon key is not configured. Set SUPABASE_ANON_KEY in SecretsConfig.")
+        }
+        
+        _client = SupabaseClient(
+            supabaseURL: url,
+            supabaseKey: SecretsConfig.supabaseAnonKey
+        )
+    }
+}

package/templates/shared/ios/SupabaseBackend/SupabaseDatabaseService.swift

@@ -0,0 +1,133 @@
+import Foundation
+import Supabase
+
+/// Supabase Database service wrapping PostgREST for querying PostgreSQL tables.
+/// Provides a fluent query builder API with type-safe Codable models.
+class SupabaseDatabaseService {
+    static let shared = SupabaseDatabaseService()
+    
+    private let client: SupabaseClient
+    
+    private init() {
+        let url = URL(string: SecretsConfig.supabaseUrl)!
+        let key = SecretsConfig.supabaseAnonKey
+        client = SupabaseClient(supabaseURL: url, supabaseKey: key)
+    }
+    
+    // MARK: - Query Builder
+    
+    /// Starts a query builder for the specified table.
+    /// Usage: `database.from("items").select().execute()`
+    func from(_ table: String) -> QueryBuilder {
+        QueryBuilder(client: client, table: table)
+    }
+    
+    // MARK: - Query Builder Class
+    
+    class QueryBuilder {
+        private let client: SupabaseClient
+        private let table: String
+        private var filters: [Filter] = []
+        private var orderBy: (column: String, ascending: Bool)?
+        private var limitValue: Int?
+        
+        init(client: SupabaseClient, table: String) {
+            self.client = client
+            self.table = table
+        }
+        
+        // MARK: - Filter Methods
+        
+        func eq(column: String, value: Any) -> QueryBuilder {
+            filters.append(.eq(column: column, value: value))
+            return self
+        }
+        
+        func like(column: String, pattern: String) -> QueryBuilder {
+            filters.append(.like(column: column, pattern: pattern))
+            return self
+        }
+        
+        func order(column: String, ascending: Bool = true) -> QueryBuilder {
+            orderBy = (column: column, ascending: ascending)
+            return self
+        }
+        
+        func limit(_ count: Int) -> QueryBuilder {
+            limitValue = count
+            return self
+        }
+        
+        // MARK: - Execute Methods
+        
+        func select<T: Codable>() async throws -> [T] {
+            var query = client.database.from(table).select()
+            
+            // Apply filters
+            for filter in filters {
+                switch filter {
+                case .eq(let column, let value):
+                    query = query.eq(column, value: value)
+                case .like(let column, let pattern):
+                    query = query.like(column, pattern: pattern)
+                }
+            }
+            
+            // Apply ordering
+            if let orderBy = orderBy {
+                query = query.order(orderBy.column, ascending: orderBy.ascending)
+            }
+            
+            // Apply limit
+            if let limit = limitValue {
+                query = query.limit(limit)
+            }
+            
+            let response: [T] = try await query.execute().value
+            return response
+        }
+        
+        func insert<T: Encodable>(_ data: T) async throws {
+            try await client.database.from(table).insert(data).execute()
+        }
+        
+        func update(_ data: [String: Any]) async throws {
+            var query = client.database.from(table).update(data)
+            
+            // Apply filters
+            for filter in filters {
+                switch filter {
+                case .eq(let column, let value):
+                    query = query.eq(column, value: value)
+                case .like(let column, let pattern):
+                    query = query.like(column, pattern: pattern)
+                }
+            }
+            
+            try await query.execute()
+        }
+        
+        func delete() async throws {
+            var query = client.database.from(table).delete()
+            
+            // Apply filters
+            for filter in filters {
+                switch filter {
+                case .eq(let column, let value):
+                    query = query.eq(column, value: value)
+                case .like(let column, let pattern):
+                    query = query.like(column, pattern: pattern)
+                }
+            }
+            
+            try await query.execute()
+        }
+    }
+    
+    // MARK: - Filter Types
+    
+    private enum Filter {
+        case eq(column: String, value: Any)
+        case like(column: String, pattern: String)
+    }
+}