@shaykec/app-agent 1.0.5 → 1.0.6

package/templates/shared/ios/WixMemberBackend/WixAuthService.swift

@@ -0,0 +1,483 @@
+import Foundation
+import UIKit
+import AuthenticationServices
+import Combine
+import CryptoKit
+
+// MARK: - Wix Auth Service
+/// Visitor-first authentication service. Auto-generates visitor token on init.
+/// Member login via OAuth PKCE flow when needed for transactions.
+@MainActor
+class WixAuthService: ObservableObject {
+    
+    // MARK: - Published Properties
+    
+    @Published var authState: WixAuthState = .visitor("")
+    @Published var isLoading: Bool = false
+    
+    // MARK: - Computed Properties
+    
+    var isLoggedIn: Bool {
+        if case .member = authState {
+            return true
+        }
+        return false
+    }
+    
+    var currentMember: WixMember? {
+        if case .member(_, _, let member) = authState {
+            return member
+        }
+        return nil
+    }
+    
+    // MARK: - Private Properties
+    
+    private let siteId: String
+    private let clientId: String
+    private let redirectURL: String
+    private var cancellables = Set<AnyCancellable>()
+    
+    // MARK: - Initialization
+    
+    init(siteId: String, clientId: String, redirectURL: String) {
+        self.siteId = siteId
+        self.clientId = clientId
+        self.redirectURL = redirectURL
+        
+        // Auto-fetch visitor token on init
+        Task {
+            await fetchVisitorToken()
+        }
+    }
+    
+    // MARK: - Token Management
+    
+    func getCurrentToken() throws -> String {
+        switch authState {
+        case .visitor(let token):
+            return token
+        case .member(let accessToken, _, _):
+            return accessToken
+        case .authenticating:
+            throw WixAuthError.notAuthenticated
+        case .error(let error):
+            throw error
+        }
+    }
+    
+    // MARK: - Visitor Token
+    
+    private func fetchVisitorToken() async {
+        isLoading = true
+        defer { isLoading = false }
+        
+        do {
+            // Check if we have a stored visitor token
+            if let storedToken = KeychainHelper.get(key: "wix_visitor_token") {
+                authState = .visitor(storedToken)
+                return
+            }
+            
+            // Fetch new visitor token from Wix
+            let url = URL(string: "https://www.wixapis.com/visitor/v1/tokens")!
+            var request = URLRequest(url: url)
+            request.httpMethod = "POST"
+            request.setValue(siteId, forHTTPHeaderField: "wix-site-id")
+            request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+            
+            let (data, response) = try await URLSession.shared.data(for: request)
+            
+            guard let httpResponse = response as? HTTPURLResponse,
+                  (200...299).contains(httpResponse.statusCode) else {
+                throw WixAuthError.visitorTokenFailed
+            }
+            
+            struct VisitorTokenResponse: Codable {
+                let accessToken: String
+            }
+            
+            let decoder = JSONDecoder()
+            decoder.keyDecodingStrategy = .convertFromSnakeCase
+            let tokenResponse = try decoder.decode(VisitorTokenResponse.self, from: data)
+            
+            // Store token in keychain
+            KeychainHelper.set(key: "wix_visitor_token", value: tokenResponse.accessToken)
+            
+            authState = .visitor(tokenResponse.accessToken)
+        } catch {
+            authState = .error(.visitorTokenFailed)
+        }
+    }
+    
+    // MARK: - OAuth Login
+    
+    func loginWithOAuth() async throws {
+        isLoading = true
+        authState = .authenticating
+        defer { isLoading = false }
+        
+        // Generate PKCE code verifier and challenge
+        let codeVerifier = generateCodeVerifier()
+        let codeChallenge = generateCodeChallenge(from: codeVerifier)
+        
+        // Store code verifier for later exchange
+        KeychainHelper.set(key: "wix_code_verifier", value: codeVerifier)
+        
+        // Build authorization URL
+        var components = URLComponents(string: "https://www.wix.com/oauth/authorize")!
+        components.queryItems = [
+            URLQueryItem(name: "client_id", value: clientId),
+            URLQueryItem(name: "redirect_uri", value: redirectURL),
+            URLQueryItem(name: "response_type", value: "code"),
+            URLQueryItem(name: "code_challenge", value: codeChallenge),
+            URLQueryItem(name: "code_challenge_method", value: "S256"),
+            URLQueryItem(name: "scope", value: "offline_access")
+        ]
+        
+        guard let authURL = components.url else {
+            throw WixAuthError.invalidAuthURL
+        }
+        
+        // Present ASWebAuthenticationSession
+        let authSession = ASWebAuthenticationSession(
+            url: authURL,
+            callbackURLScheme: URL(string: redirectURL)?.scheme
+        ) { [weak self] callbackURL, error in
+            Task { @MainActor in
+                if let error = error {
+                    if let authError = error as? ASWebAuthenticationSessionError,
+                       authError.code == .canceledLogin {
+                        self?.authState = .visitor(try! self?.getCurrentToken() ?? "")
+                        return
+                    }
+                    self?.authState = .error(.authenticationFailed)
+                    return
+                }
+                
+                guard let callbackURL = callbackURL,
+                      let components = URLComponents(url: callbackURL, resolvingAgainstBaseURL: false),
+                      let code = components.queryItems?.first(where: { $0.name == "code" })?.value else {
+                    self?.authState = .error(.invalidCallback)
+                    return
+                }
+                
+                do {
+                    try await self?.exchangeCodeForTokens(code: code)
+                } catch {
+                    self?.authState = .error(.authenticationFailed)
+                }
+            }
+        }
+        
+        authSession.presentationContextProvider = self
+        authSession.prefersEphemeralWebBrowserSession = false
+        
+        guard authSession.start() else {
+            throw WixAuthError.authenticationFailed
+        }
+    }
+    
+    private func exchangeCodeForTokens(code: String) async throws {
+        guard let codeVerifier = KeychainHelper.get(key: "wix_code_verifier") else {
+            throw WixAuthError.invalidState
+        }
+        
+        let url = URL(string: "https://www.wix.com/oauth/access")!
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        
+        struct TokenRequest: Codable {
+            let clientId: String
+            let code: String
+            let codeVerifier: String
+            let redirectUri: String
+            let grantType: String = "authorization_code"
+        }
+        
+        let tokenRequest = TokenRequest(
+            clientId: clientId,
+            code: code,
+            codeVerifier: codeVerifier,
+            redirectUri: redirectURL
+        )
+        
+        let encoder = JSONEncoder()
+        encoder.keyEncodingStrategy = .convertToSnakeCase
+        request.httpBody = try encoder.encode(tokenRequest)
+        
+        let (data, response) = try await URLSession.shared.data(for: request)
+        
+        guard let httpResponse = response as? HTTPURLResponse,
+              (200...299).contains(httpResponse.statusCode) else {
+            throw WixAuthError.authenticationFailed
+        }
+        
+        struct TokenResponse: Codable {
+            let accessToken: String
+            let refreshToken: String
+        }
+        
+        let decoder = JSONDecoder()
+        decoder.keyDecodingStrategy = .convertFromSnakeCase
+        let tokenResponse = try decoder.decode(TokenResponse.self, from: data)
+        
+        // Store tokens
+        KeychainHelper.set(key: "wix_access_token", value: tokenResponse.accessToken)
+        KeychainHelper.set(key: "wix_refresh_token", value: tokenResponse.refreshToken)
+        
+        // Clear code verifier
+        KeychainHelper.delete(key: "wix_code_verifier")
+        
+        // Fetch member info
+        let member = try await fetchMemberInfo(accessToken: tokenResponse.accessToken)
+        
+        authState = .member(
+            accessToken: tokenResponse.accessToken,
+            refreshToken: tokenResponse.refreshToken,
+            member: member
+        )
+    }
+    
+    private func fetchMemberInfo(accessToken: String) async throws -> WixMember {
+        let url = URL(string: "https://www.wixapis.com/members/v1/members/current")!
+        var request = URLRequest(url: url)
+        request.setValue("Bearer \(accessToken)", forHTTPHeaderField: "Authorization")
+        request.setValue(siteId, forHTTPHeaderField: "wix-site-id")
+        
+        let (data, response) = try await URLSession.shared.data(for: request)
+        
+        guard let httpResponse = response as? HTTPURLResponse,
+              (200...299).contains(httpResponse.statusCode) else {
+            throw WixAuthError.memberInfoFailed
+        }
+        
+        struct MemberResponse: Codable {
+            let member: WixMember
+        }
+        
+        let decoder = JSONDecoder()
+        decoder.keyDecodingStrategy = .convertFromSnakeCase
+        let memberResponse = try decoder.decode(MemberResponse.self, from: data)
+        
+        return memberResponse.member
+    }
+    
+    // MARK: - Token Refresh
+    
+    func refreshToken() async throws {
+        guard let refreshToken = KeychainHelper.get(key: "wix_refresh_token") else {
+            throw WixAuthError.notAuthenticated
+        }
+        
+        let url = URL(string: "https://www.wix.com/oauth/access")!
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        
+        struct RefreshRequest: Codable {
+            let clientId: String
+            let refreshToken: String
+            let grantType: String = "refresh_token"
+        }
+        
+        let refreshRequest = RefreshRequest(
+            clientId: clientId,
+            refreshToken: refreshToken
+        )
+        
+        let encoder = JSONEncoder()
+        encoder.keyEncodingStrategy = .convertToSnakeCase
+        request.httpBody = try encoder.encode(refreshRequest)
+        
+        let (data, response) = try await URLSession.shared.data(for: request)
+        
+        guard let httpResponse = response as? HTTPURLResponse,
+              (200...299).contains(httpResponse.statusCode) else {
+            // Refresh failed, logout
+            await logout()
+            throw WixAuthError.tokenRefreshFailed
+        }
+        
+        struct TokenResponse: Codable {
+            let accessToken: String
+            let refreshToken: String?
+        }
+        
+        let decoder = JSONDecoder()
+        decoder.keyDecodingStrategy = .convertFromSnakeCase
+        let tokenResponse = try decoder.decode(TokenResponse.self, from: data)
+        
+        // Update stored tokens
+        KeychainHelper.set(key: "wix_access_token", value: tokenResponse.accessToken)
+        if let newRefreshToken = tokenResponse.refreshToken {
+            KeychainHelper.set(key: "wix_refresh_token", value: newRefreshToken)
+        }
+        
+        // Update state if we have member info
+        if case .member(_, _, let member) = authState {
+            authState = .member(
+                accessToken: tokenResponse.accessToken,
+                refreshToken: tokenResponse.refreshToken ?? refreshToken,
+                member: member
+            )
+        }
+    }
+    
+    // MARK: - Logout
+    
+    func logout() async {
+        // Clear member tokens
+        KeychainHelper.delete(key: "wix_access_token")
+        KeychainHelper.delete(key: "wix_refresh_token")
+        
+        // Revert to visitor token
+        if let visitorToken = KeychainHelper.get(key: "wix_visitor_token") {
+            authState = .visitor(visitorToken)
+        } else {
+            await fetchVisitorToken()
+        }
+    }
+    
+    // MARK: - Require Login
+    
+    func requireLogin<T>(action: @escaping () async throws -> T) async throws -> T {
+        if isLoggedIn {
+            return try await action()
+        } else {
+            try await loginWithOAuth()
+            return try await action()
+        }
+    }
+    
+    // MARK: - PKCE Helpers
+    
+    private func generateCodeVerifier() -> String {
+        let characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~"
+        return String((0..<128).map { _ in characters.randomElement()! })
+    }
+    
+    private func generateCodeChallenge(from verifier: String) -> String {
+        let data = verifier.data(using: .utf8)!
+        let hash = data.sha256()
+        return hash.base64URLEncodedString()
+    }
+}
+
+// MARK: - Wix Auth State
+
+enum WixAuthState {
+    case visitor(String) // visitor token
+    case authenticating
+    case member(accessToken: String, refreshToken: String, member: WixMember)
+    case error(WixAuthError)
+}
+
+// MARK: - Wix Auth Error
+
+enum WixAuthError: LocalizedError {
+    case visitorTokenFailed
+    case invalidAuthURL
+    case invalidCallback
+    case invalidState
+    case authenticationFailed
+    case tokenRefreshFailed
+    case memberInfoFailed
+    case notAuthenticated
+    
+    var errorDescription: String? {
+        switch self {
+        case .visitorTokenFailed:
+            return Strings.WixMember.errorVisitorTokenFailed
+        case .invalidAuthURL:
+            return Strings.WixMember.errorInvalidAuthURL
+        case .invalidCallback:
+            return Strings.WixMember.errorInvalidCallback
+        case .invalidState:
+            return Strings.WixMember.errorInvalidState
+        case .authenticationFailed:
+            return Strings.WixMember.errorAuthenticationFailed
+        case .tokenRefreshFailed:
+            return Strings.WixMember.errorTokenRefreshFailed
+        case .memberInfoFailed:
+            return Strings.WixMember.errorMemberInfoFailed
+        case .notAuthenticated:
+            return Strings.WixMember.errorNotAuthenticated
+        }
+    }
+}
+
+// MARK: - ASWebAuthenticationPresentationContextProviding
+
+extension WixAuthService: ASWebAuthenticationPresentationContextProviding {
+    func presentationAnchor(for session: ASWebAuthenticationSession) -> ASPresentationAnchor {
+        // Get the first window scene's window
+        if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene,
+           let window = windowScene.windows.first {
+            return window
+        }
+        // Fallback (shouldn't happen in normal app flow)
+        return UIWindow()
+    }
+}
+
+// MARK: - Keychain Helper
+
+private class KeychainHelper {
+    static func set(key: String, value: String) {
+        let data = value.data(using: .utf8)!
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrAccount as String: key,
+            kSecValueData as String: data
+        ]
+        
+        SecItemDelete(query as CFDictionary)
+        SecItemAdd(query as CFDictionary, nil)
+    }
+    
+    static func get(key: String) -> String? {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrAccount as String: key,
+            kSecReturnData as String: true
+        ]
+        
+        var result: AnyObject?
+        let status = SecItemCopyMatching(query as CFDictionary, &result)
+        
+        guard status == errSecSuccess,
+              let data = result as? Data,
+              let value = String(data: data, encoding: .utf8) else {
+            return nil
+        }
+        
+        return value
+    }
+    
+    static func delete(key: String) {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrAccount as String: key
+        ]
+        
+        SecItemDelete(query as CFDictionary)
+    }
+}
+
+// MARK: - Data Extensions
+
+private extension Data {
+    func sha256() -> Data {
+        let hash = SHA256.hash(data: self)
+        return Data(hash)
+    }
+    
+    func base64URLEncodedString() -> String {
+        return self.base64EncodedString()
+            .replacingOccurrences(of: "+", with: "-")
+            .replacingOccurrences(of: "/", with: "_")
+            .replacingOccurrences(of: "=", with: "")
+    }
+}

package/templates/shared/ios/WixMemberBackend/WixBlogService.swift

@@ -0,0 +1,96 @@
+import Foundation
+import Combine
+
+// MARK: - Wix Blog Service
+/// Manages Wix Blog posts, categories, and comments.
+@MainActor
+class WixBlogService: ObservableObject {
+    
+    // MARK: - Published Properties
+    
+    @Published var posts: [WixBlogPost] = []
+    @Published var isLoading: Bool = false
+    
+    // MARK: - Private Properties
+    
+    private let apiClient: WixAPIClient
+    private let authService: WixAuthService
+    
+    // MARK: - Initialization
+    
+    init(apiClient: WixAPIClient, authService: WixAuthService) {
+        self.apiClient = apiClient
+        self.authService = authService
+    }
+    
+    // MARK: - Posts
+    
+    func listPosts(limit: Int = 20) async throws {
+        isLoading = true
+        defer { isLoading = false }
+        
+        let queryItems = [
+            URLQueryItem(name: "limit", value: String(limit))
+        ]
+        
+        let response: WixListResponse<WixBlogPost> = try await apiClient.get(
+            path: "/blog/v1/posts",
+            queryItems: queryItems
+        )
+        
+        posts = response.items ?? []
+    }
+    
+    func getPost(id: String) async throws -> WixBlogPost {
+        let response: WixBlogPost = try await apiClient.get(
+            path: "/blog/v1/posts/\(id)"
+        )
+        return response
+    }
+    
+    // MARK: - Categories
+    
+    func listCategories() async throws -> [WixBlogCategory] {
+        let response: WixListResponse<WixBlogCategory> = try await apiClient.get(
+            path: "/blog/v1/categories"
+        )
+        
+        return response.items ?? []
+    }
+    
+    // MARK: - Comments
+    
+    func listComments(postId: String) async throws -> [WixComment] {
+        let queryItems = [
+            URLQueryItem(name: "postId", value: postId)
+        ]
+        
+        let response: WixListResponse<WixComment> = try await apiClient.get(
+            path: "/blog/v1/comments",
+            queryItems: queryItems
+        )
+        
+        return response.items ?? []
+    }
+    
+    func addComment(postId: String, text: String) async throws -> WixComment {
+        return try await authService.requireLogin {
+            struct CommentRequest: Codable {
+                let postId: String
+                let content: String
+            }
+            
+            let request = CommentRequest(
+                postId: postId,
+                content: text
+            )
+            
+            let response: WixComment = try await self.apiClient.post(
+                path: "/blog/v1/comments",
+                body: request
+            )
+            
+            return response
+        }
+    }
+}

package/templates/shared/ios/WixMemberBackend/WixBookingsService.swift

@@ -0,0 +1,98 @@
+import Foundation
+import Combine
+
+// MARK: - Wix Bookings Service
+/// Manages Wix Bookings services, time slots, and bookings.
+@MainActor
+class WixBookingsService: ObservableObject {
+    
+    // MARK: - Published Properties
+    
+    @Published var services: [WixService] = []
+    @Published var isLoading: Bool = false
+    
+    // MARK: - Private Properties
+    
+    private let apiClient: WixAPIClient
+    private let authService: WixAuthService
+    
+    // MARK: - Initialization
+    
+    init(apiClient: WixAPIClient, authService: WixAuthService) {
+        self.apiClient = apiClient
+        self.authService = authService
+    }
+    
+    // MARK: - Services
+    
+    func listServices() async throws {
+        isLoading = true
+        defer { isLoading = false }
+        
+        let response: WixListResponse<WixService> = try await apiClient.get(
+            path: "/bookings/v1/services"
+        )
+        
+        services = response.items ?? []
+    }
+    
+    func getService(id: String) async throws -> WixService {
+        let response: WixService = try await apiClient.get(
+            path: "/bookings/v1/services/\(id)"
+        )
+        return response
+    }
+    
+    // MARK: - Time Slots
+    
+    func getAvailableSlots(
+        serviceId: String,
+        start: Date,
+        end: Date
+    ) async throws -> [WixTimeSlot] {
+        let formatter = ISO8601DateFormatter()
+        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        
+        let queryItems = [
+            URLQueryItem(name: "serviceId", value: serviceId),
+            URLQueryItem(name: "start", value: formatter.string(from: start)),
+            URLQueryItem(name: "end", value: formatter.string(from: end))
+        ]
+        
+        let response: WixListResponse<WixTimeSlot> = try await apiClient.get(
+            path: "/bookings/v1/availability/calendar",
+            queryItems: queryItems
+        )
+        
+        return response.items ?? []
+    }
+    
+    // MARK: - Bookings
+    
+    func bookService(
+        serviceId: String,
+        slotId: String,
+        contact: WixContactInfo
+    ) async throws -> WixBooking {
+        return try await authService.requireLogin {
+            struct BookingRequest: Codable {
+                let serviceId: String
+                let slotId: String
+                let contact: WixContactInfo
+            }
+            
+            let request = BookingRequest(
+                serviceId: serviceId,
+                slotId: slotId,
+                contact: contact
+            )
+            
+            let response: WixBooking = try await self.apiClient.post(
+                path: "/bookings/v1/bookings",
+                body: request
+            )
+            
+            return response
+        }
+    }
+}