@shaykec/app-agent 1.0.5 → 1.0.6

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

@@ -0,0 +1,117 @@
+import Foundation
+import Supabase
+
+/// Supabase Realtime service for subscribing to Postgres Changes.
+/// Provides AsyncStream-based subscriptions for real-time database updates.
+class SupabaseRealtimeService {
+    static let shared = SupabaseRealtimeService()
+    
+    private let client: SupabaseClient
+    private var channels: [String: RealtimeChannel] = [:]
+    
+    private init() {
+        let url = URL(string: SecretsConfig.supabaseUrl)!
+        let key = SecretsConfig.supabaseAnonKey
+        client = SupabaseClient(supabaseURL: url, supabaseKey: key)
+    }
+    
+    // MARK: - Realtime Change Types
+    
+    enum RealtimeEvent {
+        case insert
+        case update
+        case delete
+        case all
+    }
+    
+    struct RealtimeChange<T: Codable> {
+        let event: RealtimeEvent
+        let old: T?
+        let new: T?
+    }
+    
+    // MARK: - Subscribe
+    
+    /// Subscribes to real-time changes for a table.
+    /// Returns an AsyncStream that emits changes as they occur.
+    func subscribe<T: Codable>(
+        table: String,
+        event: RealtimeEvent = .all
+    ) -> AsyncStream<RealtimeChange<T>> {
+        AsyncStream { continuation in
+            let channelName = "\(table)_changes"
+            let channel = client.realtime.channel(channelName)
+            
+            // Subscribe to postgres_changes
+            channel.onPostgresChange(
+                InsertAction.self,
+                filter: PostgresChangeFilter(
+                    schema: "public",
+                    table: table,
+                    filter: nil
+                )
+            ) { [weak self] message in
+                if event == .insert || event == .all {
+                    if let newRecord: T = try? message.decodeRecord() {
+                        continuation.yield(RealtimeChange(event: .insert, old: nil, new: newRecord))
+                    }
+                }
+            }
+            
+            channel.onPostgresChange(
+                UpdateAction.self,
+                filter: PostgresChangeFilter(
+                    schema: "public",
+                    table: table,
+                    filter: nil
+                )
+            ) { [weak self] message in
+                if event == .update || event == .all {
+                    if let oldRecord: T = try? message.decodeOldRecord(),
+                       let newRecord: T = try? message.decodeRecord() {
+                        continuation.yield(RealtimeChange(event: .update, old: oldRecord, new: newRecord))
+                    }
+                }
+            }
+            
+            channel.onPostgresChange(
+                DeleteAction.self,
+                filter: PostgresChangeFilter(
+                    schema: "public",
+                    table: table,
+                    filter: nil
+                )
+            ) { [weak self] message in
+                if event == .delete || event == .all {
+                    if let oldRecord: T = try? message.decodeOldRecord() {
+                        continuation.yield(RealtimeChange(event: .delete, old: oldRecord, new: nil))
+                    }
+                }
+            }
+            
+            Task {
+                try? await channel.subscribe()
+                self.channels[channelName] = channel
+            }
+            
+            continuation.onTermination = { @Sendable _ in
+                Task {
+                    try? await channel.unsubscribe()
+                    self.channels.removeValue(forKey: channelName)
+                }
+            }
+        }
+    }
+    
+    // MARK: - Unsubscribe
+    
+    /// Unsubscribes from all real-time channels.
+    func unsubscribe() {
+        Task {
+            for (_, channel) in channels {
+                try? await channel.unsubscribe()
+            }
+            channels.removeAll()
+        }
+    }
+}

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

@@ -0,0 +1,48 @@
+import Foundation
+import Supabase
+
+/// Supabase Storage service for file uploads, downloads, and public URL generation.
+/// Manages files in Supabase Storage buckets.
+class SupabaseStorageService {
+    static let shared = SupabaseStorageService()
+    
+    private let client: SupabaseClient
+    
+    private init() {
+        let url = URL(string: SecretsConfig.supabaseUrl)!
+        let key = SecretsConfig.supabaseAnonKey
+        client = SupabaseClient(supabaseURL: url, supabaseKey: key)
+    }
+    
+    // MARK: - Upload
+    
+    /// Uploads data to a storage bucket at the specified path.
+    /// Returns the public URL of the uploaded file.
+    func upload(bucket: String, path: String, data: Data) async throws -> String {
+        try await client.storage.from(bucket).upload(path: path, file: data, options: FileOptions(upsert: true))
+        return getPublicUrl(bucket: bucket, path: path).absoluteString
+    }
+    
+    // MARK: - Download
+    
+    /// Downloads file data from a storage bucket at the specified path.
+    func download(bucket: String, path: String) async throws -> Data {
+        let data = try await client.storage.from(bucket).download(path: path)
+        return data
+    }
+    
+    // MARK: - Public URL
+    
+    /// Generates a public URL for a file in a storage bucket.
+    /// Note: The bucket must have public access enabled for this URL to work.
+    func getPublicUrl(bucket: String, path: String) -> URL {
+        client.storage.from(bucket).publicURL(path: path)
+    }
+    
+    // MARK: - Remove
+    
+    /// Removes one or more files from a storage bucket.
+    func remove(bucket: String, paths: [String]) async throws {
+        try await client.storage.from(bucket).remove(paths: paths)
+    }
+}

package/templates/shared/ios/SupabaseProvider/INTEGRATION.md

@@ -0,0 +1,251 @@
+# SupabaseProvider Module — Integration Guide
+
+## Prerequisites
+
+### iOS
+1. **Add Supabase Swift SDK via Swift Package Manager:**
+   - In Xcode: File → Add Packages...
+   - URL: `https://github.com/supabase/supabase-swift`
+   - Select: `Supabase` package
+
+2. **Create Supabase Project:**
+   - Sign up at https://supabase.com
+   - Create a new project
+   - Note your project URL and anon key from Project Settings → API
+
+### Android
+See `templates/shared/android/SupabaseProvider/INTEGRATION.md` for Android setup.
+
+## AppConfig Additions
+
+Add to `AppConfig.Features`:
+
+```swift
+// CUSTOMIZE:FEATURES
+static let enableSupabase = true
+```
+
+Update `AppConfig.DataSource`:
+
+```swift
+// CUSTOMIZE:DATASOURCE
+struct DataSource {
+    enum SourceType {
+        case localStorage   // Core Data — real local database
+        case mock           // In-memory seed data — for development/testing only
+        case supabase       // Supabase PostgreSQL — cloud database
+    }
+    static let active: SourceType = .supabase  // CUSTOMIZE
+}
+```
+
+## DataSourceResolver Wiring
+
+Update `DataSourceResolver` to include Supabase:
+
+```swift
+enum DataSourceResolver {
+    static var repository: any DataRepository {
+        switch AppConfig.DataSource.active {
+        case .localStorage:
+            return LocalStorageProvider.shared
+        case .mock:
+            return MockDataProvider.shared
+        case .supabase:
+            // CUSTOMIZE: Wrap with CachedRepository for offline support
+            return SupabaseDataProvider.shared
+            // Or with caching:
+            // return CachedRepository(wrapping: SupabaseDataProvider.shared)
+        }
+    }
+}
+```
+
+**Important:** Once DataSourceResolver is configured, app code (including tests) should use `DataSourceResolver.repository` instead of directly accessing `MockDataProvider.shared` or other providers. This ensures code works with any configured data source.
+
+## Offline Support
+
+**Important:** Supabase does NOT have built-in offline persistence like Firebase. For offline support, wrap `SupabaseDataProvider` with `CachedRepository`:
+
+```swift
+case .supabase:
+    return CachedRepository(wrapping: SupabaseDataProvider.shared)
+```
+
+See `templates/shared/ios/CachedRepository/INTEGRATION.md` for details.
+
+## Navigation Wiring
+
+### Auth Flow
+
+Add authentication gate to Profile tab or as onboarding:
+
+```swift
+import Supabase
+
+struct ProfileView: View {
+    @StateObject private var authService = SupabaseAuthService.shared
+    
+    var body: some View {
+        if authService.isAuthenticated {
+            // Profile content
+        } else {
+            SupabaseAuthView()
+        }
+    }
+}
+```
+
+### Auth View (Create)
+
+Create `SupabaseAuthView.swift` in your app:
+
+```swift
+import SwiftUI
+
+struct SupabaseAuthView: View {
+    @StateObject private var authService = SupabaseAuthService.shared
+    @State private var email = ""
+    @State private var password = ""
+    @State private var isSignUp = false
+    @State private var useMagicLink = false
+    
+    var body: some View {
+        VStack(spacing: 20) {
+            Text(isSignUp ? Strings.Supabase.signUp : Strings.Supabase.signIn)
+                .font(.largeTitle)
+            
+            TextField(Strings.Supabase.email, text: $email)
+                .textFieldStyle(.roundedBorder)
+                .autocapitalization(.none)
+                .keyboardType(.emailAddress)
+            
+            if !useMagicLink {
+                SecureField(Strings.Supabase.password, text: $password)
+                    .textFieldStyle(.roundedBorder)
+            }
+            
+            Button(action: {
+                Task {
+                    if useMagicLink {
+                        try? await authService.signInWithMagicLink(email: email)
+                    } else if isSignUp {
+                        try? await authService.signUp(email: email, password: password)
+                    } else {
+                        try? await authService.signIn(email: email, password: password)
+                    }
+                }
+            }) {
+                Text(useMagicLink ? Strings.Supabase.magicLink : (isSignUp ? Strings.Supabase.signUp : Strings.Supabase.signIn))
+                    .frame(maxWidth: .infinity)
+            }
+            .buttonStyle(.borderedProminent)
+            .disabled(authService.isLoading)
+            
+            Button(useMagicLink ? "Use Password" : "Use Magic Link") {
+                useMagicLink.toggle()
+            }
+            
+            Button(isSignUp ? Strings.Supabase.signIn : Strings.Supabase.signUp) {
+                isSignUp.toggle()
+            }
+        }
+        .padding()
+    }
+}
+```
+
+## Database Schema
+
+Create these tables in Supabase SQL Editor:
+
+```sql
+-- Items table
+CREATE TABLE items (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    title TEXT NOT NULL,
+    subtitle TEXT,
+    description TEXT,
+    "imageURL" TEXT,
+    category TEXT,
+    "isFavorite" BOOLEAN DEFAULT false,
+    "createdAt" TIMESTAMPTZ DEFAULT now(),
+    "userId" UUID REFERENCES auth.users(id),
+    metadata JSONB DEFAULT '{}'::jsonb
+);
+
+-- Categories table
+CREATE TABLE categories (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    name TEXT NOT NULL,
+    icon TEXT,
+    "itemCount" INTEGER DEFAULT 0
+);
+
+-- Enable Row Level Security
+ALTER TABLE items ENABLE ROW LEVEL SECURITY;
+ALTER TABLE categories ENABLE ROW LEVEL SECURITY;
+
+-- See SupabaseConfig.rlsPolicyHint for policy examples
+```
+
+## String Merge
+
+Add `Strings.Supabase` enum to the app's `Strings.swift` file. All strings are in the module's `Strings.swift`.
+
+## Test IDs
+
+| Test ID | Element |
+|---------|---------|
+| `supabase_auth_email_field` | Email text field |
+| `supabase_auth_password_field` | Password text field |
+| `supabase_auth_sign_in_button` | Sign in button |
+| `supabase_auth_sign_up_button` | Sign up button |
+| `supabase_auth_magic_link_button` | Magic link button |
+| `supabase_auth_sign_out_button` | Sign out button |
+| `supabase_auth_error_message` | Error message label |
+| `supabase_auth_google_button` | Google OAuth button |
+| `supabase_auth_apple_button` | Apple OAuth button |
+
+## Module Dependencies
+
+- **CachedRepository** (recommended) — for offline support and caching
+- **ErrorHandling** (optional) — for displaying auth errors
+- **NetworkBanner** (optional) — for connectivity awareness
+
+## Usage Notes
+
+- **No Built-in Offline:** Supabase does NOT cache data offline automatically. Use `CachedRepository` wrapper for offline support.
+- **Real-time Updates:** `SupabaseDataProvider` uses Supabase real-time subscriptions for live updates (requires WebSocket connection).
+- **User Isolation:** Items are filtered by `userId` field. Ensure `userId` is set when creating items.
+- **Row-Level Security:** Configure RLS policies in Supabase Dashboard. See `SupabaseConfig.rlsPolicyHint` for examples.
+- **Table Names:** Customize table names in `SupabaseConfig.Tables` to match your domain (e.g., "recipes" instead of "items").
+- **Magic Links:** Magic link authentication sends an email with a sign-in link. Handle the deep link in your app.
+- **OAuth Setup:** Configure OAuth providers in Supabase Dashboard → Authentication → Providers.
+
+## Supabase Data Structure
+
+Items are stored with this structure:
+```json
+{
+  "id": "uuid",
+  "title": "Item Title",
+  "subtitle": "Subtitle",
+  "description": "Description",
+  "category": "Category Name",
+  "isFavorite": false,
+  "createdAt": "2024-01-01T00:00:00Z",
+  "userId": "uuid",
+  "metadata": {}
+}
+```
+
+Categories are stored as:
+```json
+{
+  "id": "uuid",
+  "name": "Category Name",
+  "icon": "folder.fill",
+  "itemCount": 5
+}
+```

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

@@ -0,0 +1,44 @@
+import Foundation
+
+// MARK: - Supabase Strings
+extension Strings {
+    enum Supabase {
+        // Auth
+        static let signIn = "Sign In"
+        static let signUp = "Sign Up"
+        static let signOut = "Sign Out"
+        static let email = "Email"
+        static let password = "Password"
+        static let confirmPassword = "Confirm Password"
+        static let magicLink = "Send Magic Link"
+        static let magicLinkSent = "Check your email for the magic link"
+        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"
+        
+        // Errors
+        static let authError = "Authentication Error"
+        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"
+        
+        // Status
+        static let signingIn = "Signing in..."
+        static let signingUp = "Creating account..."
+        static let authenticated = "Authenticated"
+        static let notAuthenticated = "Not authenticated"
+        static let checkingSession = "Checking session..."
+        
+        // Data
+        static let loadingData = "Loading data..."
+        static let syncError = "Sync error"
+        static let realtimeConnected = "Real-time connected"
+        static let realtimeDisconnected = "Real-time disconnected"
+    }
+}

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

@@ -0,0 +1,142 @@
+import Foundation
+import Supabase
+
+/// Supabase Authentication service supporting email, magic link, and OAuth.
+class SupabaseAuthService: ObservableObject {
+    static let shared = SupabaseAuthService()
+    
+    @Published var currentUser: Any? // CUSTOMIZE: Replace with your User type
+    @Published var isAuthenticated: Bool = false
+    @Published var isLoading: Bool = false
+    @Published var errorMessage: String?
+    
+    private let client: SupabaseClient
+    
+    private init() {
+        client = SupabaseClient(
+            supabaseURL: URL(string: SupabaseConfig.supabaseURL)!,
+            supabaseKey: SupabaseConfig.supabaseAnonKey
+        )
+        checkSession()
+    }
+    
+    // MARK: - Session Management
+    
+    private func checkSession() {
+        Task {
+            do {
+                // CUSTOMIZE: Adjust based on Supabase Swift SDK version
+                // The session API may vary
+                let session = try await client.auth.session
+                await MainActor.run {
+                    // CUSTOMIZE: Map Supabase user to your User type
+                    // self.currentUser = mapSupabaseUser(session.user)
+                    self.isAuthenticated = true
+                }
+            } catch {
+                await MainActor.run {
+                    self.currentUser = nil
+                    self.isAuthenticated = false
+                }
+            }
+        }
+    }
+    
+    // MARK: - Email Auth
+    
+    func signIn(email: String, password: String) async throws {
+        isLoading = true
+        defer { isLoading = false }
+        do {
+            // CUSTOMIZE: Adjust based on Supabase Swift SDK version
+            let session = try await client.auth.signIn(email: email, password: password)
+            await MainActor.run {
+                // CUSTOMIZE: Map Supabase user to your User type
+                // self.currentUser = mapSupabaseUser(session.user)
+                self.isAuthenticated = true
+                self.errorMessage = nil
+            }
+        } catch {
+            await MainActor.run {
+                self.errorMessage = error.localizedDescription
+            }
+            throw error
+        }
+    }
+    
+    func signUp(email: String, password: String) async throws {
+        isLoading = true
+        defer { isLoading = false }
+        do {
+            // CUSTOMIZE: Adjust based on Supabase Swift SDK version
+            let session = try await client.auth.signUp(email: email, password: password)
+            await MainActor.run {
+                // CUSTOMIZE: Map Supabase user to your User type
+                // self.currentUser = mapSupabaseUser(session.user)
+                self.isAuthenticated = true
+                self.errorMessage = nil
+            }
+        } catch {
+            await MainActor.run {
+                self.errorMessage = error.localizedDescription
+            }
+            throw error
+        }
+    }
+    
+    func signOut() throws {
+        Task {
+            try await client.auth.signOut()
+            await MainActor.run {
+                self.currentUser = nil
+                self.isAuthenticated = false
+                self.errorMessage = nil
+            }
+        }
+    }
+    
+    // MARK: - Magic Link
+    
+    func signInWithMagicLink(email: String) async throws {
+        isLoading = true
+        defer { isLoading = false }
+        do {
+            try await client.auth.signInWithOTP(email: email)
+            await MainActor.run {
+                self.errorMessage = nil
+            }
+        } catch {
+            await MainActor.run {
+                self.errorMessage = error.localizedDescription
+            }
+            throw error
+        }
+    }
+    
+    // MARK: - OAuth
+    
+    func signInWithOAuth(provider: OAuthProvider) async throws {
+        isLoading = true
+        defer { isLoading = false }
+        do {
+            try await client.auth.signInWithOAuth(provider: provider)
+            await MainActor.run {
+                self.errorMessage = nil
+            }
+        } catch {
+            await MainActor.run {
+                self.errorMessage = error.localizedDescription
+            }
+            throw error
+        }
+    }
+}
+
+// MARK: - OAuth Provider
+
+enum OAuthProvider: String {
+    case google = "google"
+    case apple = "apple"
+    case github = "github"
+    case facebook = "facebook"
+}

package/templates/shared/ios/SupabaseProvider/SupabaseConfig.swift

@@ -0,0 +1,48 @@
+import Foundation
+
+/// Supabase project configuration.
+/// Replace placeholder values with your Supabase project credentials.
+struct SupabaseConfig {
+    // CUSTOMIZE: Replace with your Supabase project values
+    // Find these in Supabase Dashboard → Project Settings → API
+    
+    static let supabaseURL = "https://your-project.supabase.co"  // CUSTOMIZE
+    static let supabaseAnonKey = "your-anon-key"                 // CUSTOMIZE
+    
+    /// Database table names — customize for your domain
+    struct Tables {
+        static let items = "items"           // CUSTOMIZE: e.g., "recipes", "products"
+        static let categories = "categories" // CUSTOMIZE: e.g., "cuisines", "brands"
+        static let users = "users"
+        static let favorites = "favorites"
+    }
+    
+    /// Row-level security (RLS) policy hints for PostgreSQL
+    static let rlsPolicyHint = """
+    -- Enable RLS on tables
+    ALTER TABLE items ENABLE ROW LEVEL SECURITY;
+    ALTER TABLE categories ENABLE ROW LEVEL SECURITY;
+    
+    -- Items: Users can only read/write their own items
+    CREATE POLICY "Users can read own items"
+        ON items FOR SELECT
+        USING (auth.uid() = userId);
+    
+    CREATE POLICY "Users can insert own items"
+        ON items FOR INSERT
+        WITH CHECK (auth.uid() = userId);
+    
+    CREATE POLICY "Users can update own items"
+        ON items FOR UPDATE
+        USING (auth.uid() = userId);
+    
+    CREATE POLICY "Users can delete own items"
+        ON items FOR DELETE
+        USING (auth.uid() = userId);
+    
+    -- Categories: Public read, no write
+    CREATE POLICY "Categories are publicly readable"
+        ON categories FOR SELECT
+        USING (true);
+    """
+}