@shaykec/app-agent 1.0.5 → 1.0.6

package/templates/shared/ios/SupabaseBackend/SETUP.md

@@ -0,0 +1,232 @@
+# Supabase Dashboard Setup Guide
+
+This guide walks through setting up your Supabase project for use with the SupabaseBackend module.
+
+## 1. Create Supabase Project
+
+1. Go to https://supabase.com
+2. Sign up or sign in
+3. Click **New Project**
+4. Fill in:
+   - **Name:** Your project name
+   - **Database Password:** Choose a strong password (save it!)
+   - **Region:** Choose closest to your users
+5. Click **Create new project**
+
+Wait 2-3 minutes for the project to initialize.
+
+## 2. Get API Credentials
+
+1. Go to **Project Settings → API**
+2. Copy:
+   - **Project URL** (e.g., `https://yourproject.supabase.co`)
+   - **anon/public key** (starts with `eyJ...`)
+
+Add these to your app's `Secrets.xcconfig`:
+
+```xcconfig
+SUPABASE_URL = https://yourproject.supabase.co
+SUPABASE_ANON_KEY = eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
+```
+
+## 3. Configure Authentication
+
+### Email/Password
+
+Email/password authentication is enabled by default. No configuration needed.
+
+### Magic Link (OTP)
+
+1. Go to **Authentication → Providers**
+2. Ensure **Email** provider is enabled
+3. Under **Email Auth**, enable **Enable email confirmations** (optional)
+4. Configure email templates in **Authentication → Email Templates**
+
+### OAuth Providers
+
+#### Google
+
+1. Go to **Authentication → Providers**
+2. Enable **Google**
+3. Get credentials from [Google Cloud Console](https://console.cloud.google.com):
+   - Create OAuth 2.0 Client ID
+   - Add authorized redirect URI: `https://yourproject.supabase.co/auth/v1/callback`
+4. Paste **Client ID** and **Client Secret** into Supabase
+
+#### Apple
+
+1. Go to **Authentication → Providers**
+2. Enable **Apple**
+3. Get credentials from [Apple Developer Portal](https://developer.apple.com):
+   - Create Services ID
+   - Configure Sign in with Apple
+   - Add redirect URI: `https://yourproject.supabase.co/auth/v1/callback`
+4. Paste **Services ID**, **Team ID**, **Key ID**, and **Private Key** into Supabase
+
+#### GitHub
+
+1. Go to **Authentication → Providers**
+2. Enable **GitHub**
+3. Create OAuth app in [GitHub Settings](https://github.com/settings/developers):
+   - Authorization callback URL: `https://yourproject.supabase.co/auth/v1/callback`
+4. Paste **Client ID** and **Client Secret** into Supabase
+
+## 4. Configure Deep Links
+
+### iOS URL Scheme
+
+1. In Xcode, open `Info.plist`
+2. Add URL Types:
+
+```xml
+<key>CFBundleURLTypes</key>
+<array>
+    <dict>
+        <key>CFBundleURLSchemes</key>
+        <array>
+            <string>com.yourapp</string>
+        </array>
+    </dict>
+</array>
+```
+
+### Supabase Redirect URLs
+
+1. Go to **Authentication → URL Configuration**
+2. Add **Redirect URLs**:
+   - `com.yourapp://auth/callback` (for OAuth)
+   - `com.yourapp://auth/magic-link` (for magic link)
+3. Set **Site URL**: `com.yourapp://`
+
+## 5. Create Database Tables
+
+1. Go to **SQL Editor**
+2. Create your tables:
+
+```sql
+-- Example: Items table
+CREATE TABLE items (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    title TEXT NOT NULL,
+    description TEXT,
+    "userId" UUID REFERENCES auth.users(id),
+    "createdAt" TIMESTAMPTZ DEFAULT now()
+);
+```
+
+3. Enable Row Level Security:
+
+```sql
+ALTER TABLE items ENABLE ROW LEVEL SECURITY;
+```
+
+4. Create policies:
+
+```sql
+-- Users can view their own items
+CREATE POLICY "Users can view own items"
+    ON items FOR SELECT
+    USING (auth.uid() = "userId");
+
+-- Users can insert their own items
+CREATE POLICY "Users can insert own items"
+    ON items FOR INSERT
+    WITH CHECK (auth.uid() = "userId");
+
+-- Users can update their own items
+CREATE POLICY "Users can update own items"
+    ON items FOR UPDATE
+    USING (auth.uid() = "userId");
+
+-- Users can delete their own items
+CREATE POLICY "Users can delete own items"
+    ON items FOR DELETE
+    USING (auth.uid() = "userId");
+```
+
+## 6. Create Storage Buckets
+
+1. Go to **Storage**
+2. Click **New bucket**
+3. Configure:
+   - **Name:** e.g., `avatars`, `uploads`
+   - **Public bucket:** Enable if files should be publicly accessible
+   - **File size limit:** Set max file size (e.g., 5MB)
+   - **Allowed MIME types:** e.g., `image/*`, `application/pdf`
+
+4. Create storage policies:
+
+```sql
+-- Allow authenticated users to upload
+CREATE POLICY "Authenticated users can upload"
+    ON storage.objects FOR INSERT
+    WITH CHECK (
+        bucket_id = 'avatars' AND
+        auth.role() = 'authenticated'
+    );
+
+-- Allow public read access
+CREATE POLICY "Public can read"
+    ON storage.objects FOR SELECT
+    USING (bucket_id = 'avatars');
+```
+
+## 7. Enable Realtime (Optional)
+
+Realtime is enabled by default. To use it:
+
+1. Go to **Database → Replication**
+2. Enable replication for tables you want real-time updates:
+   - Toggle **Enable Realtime** for each table
+
+## 8. Test Configuration
+
+### Test Authentication
+
+1. Run your app
+2. Try signing up with email/password
+3. Check **Authentication → Users** in Supabase Dashboard
+4. Verify user appears in the list
+
+### Test Database
+
+1. Insert a test record via your app
+2. Go to **Table Editor → items**
+3. Verify record appears
+
+### Test Storage
+
+1. Upload a file via your app
+2. Go to **Storage → [your bucket]**
+3. Verify file appears
+
+## Troubleshooting
+
+### "Invalid API key"
+
+- Check that `SUPABASE_ANON_KEY` matches the anon key from Project Settings → API
+- Ensure no extra spaces or quotes in `Secrets.xcconfig`
+
+### "Row Level Security policy violation"
+
+- Ensure RLS is enabled on the table
+- Create policies that allow your operations
+- Check that `auth.uid()` matches the `userId` column
+
+### OAuth redirect fails
+
+- Verify redirect URL matches exactly in Supabase Dashboard
+- Check URL scheme is configured in `Info.plist`
+- Ensure deep link handler is set up in app delegate/scene delegate
+
+### Magic link doesn't work
+
+- Check email template in Authentication → Email Templates
+- Verify redirect URL is configured
+- Check spam folder for magic link email
+
+## Next Steps
+
+- Read `INTEGRATION.md` for code integration instructions
+- Check Supabase documentation: https://supabase.com/docs
+- Join Supabase Discord for support: https://discord.supabase.com

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

@@ -0,0 +1,123 @@
+import SwiftUI
+
+/// Supabase forgot password screen with email input and send reset link button.
+struct SupabaseForgotPasswordScreen: View {
+    @StateObject private var authService = SupabaseAuthService.shared
+    @State private var email = ""
+    @State private var isSent = false
+    @State private var errorMessage: String?
+    @Environment(\.dismiss) private var dismiss
+    
+    var body: some View {
+        NavigationView {
+            ScrollView {
+                VStack(spacing: AppConfig.Theme.Spacing.lg) {
+                    if isSent {
+                        // Success state
+                        VStack(spacing: AppConfig.Theme.Spacing.md) {
+                            Image(systemName: "checkmark.circle.fill")
+                                .font(.system(size: 60))
+                                .foregroundStyle(.green)
+                                .accessibilityIdentifier("supabase_forgot_password_success_icon")
+                            
+                            Text(Strings.Supabase.passwordResetSent)
+                                .font(AppConfig.Theme.Typography.title)
+                                .multilineTextAlignment(.center)
+                                .accessibilityIdentifier("supabase_forgot_password_success_title")
+                            
+                            Text(Strings.Supabase.passwordResetInstructions)
+                                .font(AppConfig.Theme.Typography.body)
+                                .foregroundStyle(.secondary)
+                                .multilineTextAlignment(.center)
+                                .accessibilityIdentifier("supabase_forgot_password_success_message")
+                            
+                            Button {
+                                dismiss()
+                            } label: {
+                                Text(Strings.Supabase.backToSignIn)
+                                    .font(AppConfig.Theme.Typography.body)
+                                    .frame(maxWidth: .infinity)
+                                    .frame(height: 50)
+                            }
+                            .buttonStyle(.borderedProminent)
+                            .accessibilityIdentifier("supabase_forgot_password_back_button")
+                        }
+                    } else {
+                        // Email input form
+                        VStack(spacing: AppConfig.Theme.Spacing.lg) {
+                            Text(Strings.Supabase.forgotPasswordTitle)
+                                .font(AppConfig.Theme.Typography.title)
+                                .multilineTextAlignment(.center)
+                                .accessibilityIdentifier("supabase_forgot_password_title")
+                            
+                            Text(Strings.Supabase.forgotPasswordMessage)
+                                .font(AppConfig.Theme.Typography.body)
+                                .foregroundStyle(.secondary)
+                                .multilineTextAlignment(.center)
+                                .accessibilityIdentifier("supabase_forgot_password_message")
+                            
+                            // 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_forgot_password_email_field")
+                            }
+                            
+                            // Error message
+                            if let errorMessage = errorMessage {
+                                Text(errorMessage)
+                                    .font(AppConfig.Theme.Typography.caption)
+                                    .foregroundStyle(.red)
+                                    .multilineTextAlignment(.center)
+                                    .accessibilityIdentifier("supabase_forgot_password_error_message")
+                            }
+                            
+                            // Send reset link button
+                            Button {
+                                Task {
+                                    await handleSendReset()
+                                }
+                            } label: {
+                                Text(Strings.Supabase.sendResetLink)
+                                    .font(AppConfig.Theme.Typography.body)
+                                    .frame(maxWidth: .infinity)
+                                    .frame(height: 50)
+                            }
+                            .buttonStyle(.borderedProminent)
+                            .disabled(authService.authState == .authenticating || email.isEmpty)
+                            .accessibilityIdentifier("supabase_forgot_password_send_button")
+                        }
+                    }
+                }
+                .padding(AppConfig.Theme.Spacing.lg)
+            }
+            .navigationBarTitleDisplayMode(.inline)
+            .toolbar {
+                ToolbarItem(placement: .cancellationAction) {
+                    Button(Strings.Supabase.cancel) {
+                        dismiss()
+                    }
+                    .accessibilityIdentifier("supabase_forgot_password_cancel_button")
+                }
+            }
+        }
+    }
+    
+    // MARK: - Private Methods
+    
+    private func handleSendReset() async {
+        errorMessage = nil
+        do {
+            try await authService.sendPasswordReset(email: email)
+            isSent = true
+        } catch {
+            errorMessage = error.localizedDescription
+        }
+    }
+}

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

@@ -0,0 +1,207 @@
+import SwiftUI
+
+/// Supabase login screen with email/password, magic link toggle, social login, and forgot password.
+struct SupabaseLoginScreen: View {
+    @StateObject private var authService = SupabaseAuthService.shared
+    @State private var email = ""
+    @State private var password = ""
+    @State private var useMagicLink = false
+    @State private var showingForgotPassword = false
+    @State private var errorMessage: String?
+    
+    let onSuccess: (() -> Void)?
+    let onSignUp: (() -> Void)?
+    
+    init(
+        onSuccess: (() -> Void)? = nil,
+        onSignUp: (() -> Void)? = nil
+    ) {
+        self.onSuccess = onSuccess
+        self.onSignUp = onSignUp
+    }
+    
+    var body: some View {
+        NavigationView {
+            ScrollView {
+                VStack(spacing: AppConfig.Theme.Spacing.lg) {
+                    // Title
+                    Text(Strings.Supabase.signIn)
+                        .font(AppConfig.Theme.Typography.title)
+                        .multilineTextAlignment(.center)
+                        .accessibilityIdentifier("supabase_login_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_login_email_field")
+                    }
+                    
+                    // Password field (if not using magic link)
+                    if !useMagicLink {
+                        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(.password)
+                                .accessibilityIdentifier("supabase_login_password_field")
+                        }
+                    }
+                    
+                    // Magic link toggle
+                    Toggle(Strings.Supabase.useMagicLink, isOn: $useMagicLink)
+                        .accessibilityIdentifier("supabase_login_magic_link_toggle")
+                    
+                    // Error message
+                    if let errorMessage = errorMessage {
+                        Text(errorMessage)
+                            .font(AppConfig.Theme.Typography.caption)
+                            .foregroundStyle(.red)
+                            .multilineTextAlignment(.center)
+                            .accessibilityIdentifier("supabase_login_error_message")
+                    }
+                    
+                    // Sign in button
+                    Button {
+                        Task {
+                            await handleSignIn()
+                        }
+                    } label: {
+                        Text(useMagicLink ? Strings.Supabase.sendMagicLink : Strings.Supabase.signIn)
+                            .font(AppConfig.Theme.Typography.body)
+                            .frame(maxWidth: .infinity)
+                            .frame(height: 50)
+                    }
+                    .buttonStyle(.borderedProminent)
+                    .disabled(authService.authState == .authenticating || email.isEmpty)
+                    .accessibilityIdentifier("supabase_login_sign_in_button")
+                    
+                    // Forgot password
+                    Button {
+                        showingForgotPassword = true
+                    } label: {
+                        Text(Strings.Supabase.forgotPassword)
+                            .font(AppConfig.Theme.Typography.body)
+                            .foregroundStyle(.secondary)
+                    }
+                    .accessibilityIdentifier("supabase_login_forgot_password_button")
+                    
+                    // Social login divider
+                    HStack {
+                        Rectangle()
+                            .frame(height: 1)
+                            .foregroundStyle(.secondary.opacity(0.3))
+                        Text(Strings.Supabase.orContinueWith)
+                            .font(AppConfig.Theme.Typography.caption)
+                            .foregroundStyle(.secondary)
+                        Rectangle()
+                            .frame(height: 1)
+                            .foregroundStyle(.secondary.opacity(0.3))
+                    }
+                    
+                    // Social login buttons
+                    VStack(spacing: AppConfig.Theme.Spacing.sm) {
+                        Button {
+                            Task {
+                                try? await authService.signInWithOAuth(provider: .google)
+                            }
+                        } label: {
+                            HStack {
+                                Image(systemName: "globe")
+                                Text(Strings.Supabase.signInWithGoogle)
+                            }
+                            .frame(maxWidth: .infinity)
+                            .frame(height: 50)
+                        }
+                        .buttonStyle(.bordered)
+                        .accessibilityIdentifier("supabase_login_google_button")
+                        
+                        Button {
+                            Task {
+                                try? await authService.signInWithOAuth(provider: .apple)
+                            }
+                        } label: {
+                            HStack {
+                                Image(systemName: "applelogo")
+                                Text(Strings.Supabase.signInWithApple)
+                            }
+                            .frame(maxWidth: .infinity)
+                            .frame(height: 50)
+                        }
+                        .buttonStyle(.bordered)
+                        .accessibilityIdentifier("supabase_login_apple_button")
+                        
+                        Button {
+                            Task {
+                                try? await authService.signInWithOAuth(provider: .github)
+                            }
+                        } label: {
+                            HStack {
+                                Image(systemName: "chevron.left.forwardslash.chevron.right")
+                                Text(Strings.Supabase.signInWithGithub)
+                            }
+                            .frame(maxWidth: .infinity)
+                            .frame(height: 50)
+                        }
+                        .buttonStyle(.bordered)
+                        .accessibilityIdentifier("supabase_login_github_button")
+                    }
+                    
+                    // Sign up link
+                    if let onSignUp = onSignUp {
+                        HStack {
+                            Text(Strings.Supabase.noAccount)
+                            Button(Strings.Supabase.signUp) {
+                                onSignUp()
+                            }
+                        }
+                        .font(AppConfig.Theme.Typography.body)
+                        .accessibilityIdentifier("supabase_login_sign_up_link")
+                    }
+                }
+                .padding(AppConfig.Theme.Spacing.lg)
+            }
+            .navigationBarTitleDisplayMode(.inline)
+            .sheet(isPresented: $showingForgotPassword) {
+                SupabaseForgotPasswordScreen()
+            }
+            .onChange(of: authService.authState) { oldValue, newValue in
+                handleAuthStateChange(newValue)
+            }
+        }
+    }
+    
+    // MARK: - Private Methods
+    
+    private func handleSignIn() async {
+        errorMessage = nil
+        do {
+            if useMagicLink {
+                try await authService.signInWithMagicLink(email: email)
+            } else {
+                try await authService.signInWithEmail(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/Screens/SupabaseMagicLinkSentScreen.swift

@@ -0,0 +1,136 @@
+import SwiftUI
+
+/// Supabase magic link sent confirmation screen with "Check your email" message and resend option.
+struct SupabaseMagicLinkSentScreen: View {
+    @StateObject private var authService = SupabaseAuthService.shared
+    @State private var email: String
+    @State private var canResend = false
+    @State private var resendCountdown = 60
+    @State private var errorMessage: String?
+    
+    let onBack: (() -> Void)?
+    
+    init(email: String, onBack: (() -> Void)? = nil) {
+        self._email = State(initialValue: email)
+        self.onBack = onBack
+    }
+    
+    var body: some View {
+        VStack(spacing: AppConfig.Theme.Spacing.xl) {
+            Spacer()
+            
+            // Icon
+            Image(systemName: "envelope.fill")
+                .font(.system(size: 80))
+                .foregroundStyle(.blue)
+                .accessibilityIdentifier("supabase_magic_link_icon")
+            
+            // Title
+            Text(Strings.Supabase.magicLinkSentTitle)
+                .font(AppConfig.Theme.Typography.title)
+                .multilineTextAlignment(.center)
+                .accessibilityIdentifier("supabase_magic_link_title")
+            
+            // Message
+            VStack(spacing: AppConfig.Theme.Spacing.sm) {
+                Text(Strings.Supabase.magicLinkSentMessage(email: email))
+                    .font(AppConfig.Theme.Typography.body)
+                    .foregroundStyle(.secondary)
+                    .multilineTextAlignment(.center)
+                    .accessibilityIdentifier("supabase_magic_link_message")
+                
+                Text(Strings.Supabase.magicLinkInstructions)
+                    .font(AppConfig.Theme.Typography.caption)
+                    .foregroundStyle(.secondary)
+                    .multilineTextAlignment(.center)
+                    .accessibilityIdentifier("supabase_magic_link_instructions")
+            }
+            
+            // Error message
+            if let errorMessage = errorMessage {
+                Text(errorMessage)
+                    .font(AppConfig.Theme.Typography.caption)
+                    .foregroundStyle(.red)
+                    .multilineTextAlignment(.center)
+                    .accessibilityIdentifier("supabase_magic_link_error_message")
+            }
+            
+            Spacer()
+            
+            // Open Email button
+            Button {
+                if let url = URL(string: "message://") {
+                    UIApplication.shared.open(url)
+                }
+            } label: {
+                HStack {
+                    Image(systemName: "envelope")
+                    Text(Strings.Supabase.openEmail)
+                }
+                .font(AppConfig.Theme.Typography.body)
+                .frame(maxWidth: .infinity)
+                .frame(height: 50)
+            }
+            .buttonStyle(.borderedProminent)
+            .accessibilityIdentifier("supabase_magic_link_open_email_button")
+            
+            // Resend button
+            Button {
+                Task {
+                    await handleResend()
+                }
+            } label: {
+                if canResend {
+                    Text(Strings.Supabase.resendMagicLink)
+                } else {
+                    Text(Strings.Supabase.resendMagicLinkCountdown(seconds: resendCountdown))
+                }
+            }
+            .font(AppConfig.Theme.Typography.body)
+            .foregroundStyle(canResend ? .blue : .secondary)
+            .disabled(!canResend)
+            .accessibilityIdentifier("supabase_magic_link_resend_button")
+            
+            // Back button
+            if let onBack = onBack {
+                Button {
+                    onBack()
+                } label: {
+                    Text(Strings.Supabase.backToSignIn)
+                        .font(AppConfig.Theme.Typography.body)
+                        .foregroundStyle(.secondary)
+                }
+                .accessibilityIdentifier("supabase_magic_link_back_button")
+            }
+        }
+        .padding(AppConfig.Theme.Spacing.lg)
+        .onAppear {
+            startResendCountdown()
+        }
+    }
+    
+    // MARK: - Private Methods
+    
+    private func startResendCountdown() {
+        canResend = false
+        resendCountdown = 60
+        
+        Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { timer in
+            resendCountdown -= 1
+            if resendCountdown <= 0 {
+                canResend = true
+                timer.invalidate()
+            }
+        }
+    }
+    
+    private func handleResend() async {
+        errorMessage = nil
+        do {
+            try await authService.signInWithMagicLink(email: email)
+            startResendCountdown()
+        } catch {
+            errorMessage = error.localizedDescription
+        }
+    }
+}