@thelacanians/vue-native-cli 0.4.2 → 0.4.4

package/native/ios/VueNativeCore/Sources/VueNativeCore/Modules/SocialAuthModule.swift

@@ -0,0 +1,240 @@
+#if canImport(UIKit)
+import UIKit
+import AuthenticationServices
+
+/// Native module for social authentication (Apple Sign In, Google Sign In).
+///
+/// Methods:
+///   - signInWithApple() -- present Apple Sign In sheet
+///   - signInWithGoogle(clientId: String) -- present Google OAuth web flow
+///   - signOut(provider: String) -- clear cached credentials
+///   - getCurrentUser(provider: String) -- check for existing session
+///
+/// Events:
+///   - auth:appleCredentialRevoked -- fired when Apple credential is revoked
+final class SocialAuthModule: NSObject, NativeModule, ASAuthorizationControllerDelegate, ASAuthorizationControllerPresentationContextProviding {
+    let moduleName = "SocialAuth"
+    private weak var bridge: NativeBridge?
+    private var appleSignInCallback: ((Any?, String?) -> Void)?
+    private var credentialObserver: NSObjectProtocol?
+
+    init(bridge: NativeBridge? = nil) {
+        self.bridge = bridge
+        super.init()
+        observeAppleCredentialRevocation()
+    }
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        switch method {
+        case "signInWithApple":
+            handleAppleSignIn(callback: callback)
+
+        case "signInWithGoogle":
+            guard let clientId = args.first as? String else {
+                callback(nil, "signInWithGoogle: expected clientId string")
+                return
+            }
+            handleGoogleSignIn(clientId: clientId, callback: callback)
+
+        case "signOut":
+            let provider = args.first as? String ?? "apple"
+            handleSignOut(provider: provider, callback: callback)
+
+        case "getCurrentUser":
+            let provider = args.first as? String ?? "apple"
+            handleGetCurrentUser(provider: provider, callback: callback)
+
+        default:
+            callback(nil, "SocialAuthModule: unknown method '\(method)'")
+        }
+    }
+
+    // MARK: - Apple Sign In
+
+    private func handleAppleSignIn(callback: @escaping (Any?, String?) -> Void) {
+        appleSignInCallback = callback
+
+        let request = ASAuthorizationAppleIDProvider().createRequest()
+        request.requestedScopes = [.fullName, .email]
+
+        let controller = ASAuthorizationController(authorizationRequests: [request])
+        controller.delegate = self
+        controller.presentationContextProvider = self
+        controller.performRequests()
+    }
+
+    // ASAuthorizationControllerDelegate
+    func authorizationController(controller: ASAuthorizationController, didCompleteWithAuthorization authorization: ASAuthorization) {
+        guard let credential = authorization.credential as? ASAuthorizationAppleIDCredential else {
+            appleSignInCallback?(nil, "signInWithApple: unexpected credential type")
+            appleSignInCallback = nil
+            return
+        }
+
+        var result: [String: Any] = [
+            "userId": credential.user,
+        ]
+
+        if let email = credential.email {
+            result["email"] = email
+        }
+
+        if let fullName = credential.fullName {
+            let name = [fullName.givenName, fullName.familyName]
+                .compactMap { $0 }
+                .joined(separator: " ")
+            if !name.isEmpty {
+                result["fullName"] = name
+            }
+        }
+
+        if let tokenData = credential.identityToken, let token = String(data: tokenData, encoding: .utf8) {
+            result["identityToken"] = token
+        }
+
+        if let codeData = credential.authorizationCode, let code = String(data: codeData, encoding: .utf8) {
+            result["authorizationCode"] = code
+        }
+
+        // Persist user ID for session check
+        UserDefaults.standard.set(credential.user, forKey: "vn_apple_userId")
+
+        appleSignInCallback?(result, nil)
+        appleSignInCallback = nil
+    }
+
+    func authorizationController(controller: ASAuthorizationController, didCompleteWithError error: Error) {
+        let nsError = error as NSError
+        if nsError.domain == ASAuthorizationError.errorDomain && nsError.code == ASAuthorizationError.canceled.rawValue {
+            appleSignInCallback?(nil, "signInWithApple: user cancelled")
+        } else {
+            appleSignInCallback?(nil, "signInWithApple: \(error.localizedDescription)")
+        }
+        appleSignInCallback = nil
+    }
+
+    func presentationAnchor(for controller: ASAuthorizationController) -> ASPresentationAnchor {
+        return UIApplication.shared.connectedScenes
+            .compactMap { $0 as? UIWindowScene }
+            .first?.windows.first { $0.isKeyWindow } ?? UIWindow()
+    }
+
+    // MARK: - Google Sign In (URL-based OAuth)
+
+    private func handleGoogleSignIn(clientId: String, callback: @escaping (Any?, String?) -> Void) {
+        // URL-based OAuth flow using ASWebAuthenticationSession for zero dependencies
+        let redirectURI = "com.googleusercontent.apps.\(clientId.components(separatedBy: ".").first ?? clientId):/oauthredirect"
+        let scope = "openid email profile"
+        let urlString = "https://accounts.google.com/o/oauth2/v2/auth?client_id=\(clientId)&redirect_uri=\(redirectURI)&response_type=code&scope=\(scope.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) ?? scope)"
+
+        guard let url = URL(string: urlString) else {
+            callback(nil, "signInWithGoogle: invalid OAuth URL")
+            return
+        }
+
+        DispatchQueue.main.async {
+            let scheme = redirectURI.components(separatedBy: ":").first
+            let session = ASWebAuthenticationSession(url: url, callbackURLScheme: scheme) { callbackURL, error in
+                if let error = error {
+                    let nsError = error as NSError
+                    if nsError.domain == ASWebAuthenticationSessionError.errorDomain &&
+                       nsError.code == ASWebAuthenticationSessionError.canceledLogin.rawValue {
+                        callback(nil, "signInWithGoogle: user cancelled")
+                    } else {
+                        callback(nil, "signInWithGoogle: \(error.localizedDescription)")
+                    }
+                    return
+                }
+
+                guard let callbackURL = callbackURL,
+                      let components = URLComponents(url: callbackURL, resolvingAgainstBaseURL: false),
+                      let code = components.queryItems?.first(where: { $0.name == "code" })?.value else {
+                    callback(nil, "signInWithGoogle: no authorization code received")
+                    return
+                }
+
+                let result: [String: Any] = [
+                    "userId": code, // The auth code — exchange server-side for tokens
+                    "authorizationCode": code,
+                ]
+
+                UserDefaults.standard.set(code, forKey: "vn_google_authCode")
+                callback(result, nil)
+            }
+
+            session.prefersEphemeralWebBrowserSession = false
+
+            // Find the presentation anchor
+            if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene,
+               let window = windowScene.windows.first {
+                session.presentationContextProvider = window.rootViewController as? ASWebAuthenticationPresentationContextProviding
+            }
+
+            session.start()
+        }
+    }
+
+    // MARK: - Sign Out
+
+    private func handleSignOut(provider: String, callback: @escaping (Any?, String?) -> Void) {
+        switch provider {
+        case "apple":
+            UserDefaults.standard.removeObject(forKey: "vn_apple_userId")
+        case "google":
+            UserDefaults.standard.removeObject(forKey: "vn_google_authCode")
+        default:
+            break
+        }
+        callback(nil, nil)
+    }
+
+    // MARK: - Get Current User
+
+    private func handleGetCurrentUser(provider: String, callback: @escaping (Any?, String?) -> Void) {
+        switch provider {
+        case "apple":
+            guard let userId = UserDefaults.standard.string(forKey: "vn_apple_userId") else {
+                callback(nil, nil)
+                return
+            }
+            // Verify the credential is still valid
+            ASAuthorizationAppleIDProvider().getCredentialState(forUserID: userId) { state, _ in
+                switch state {
+                case .authorized:
+                    callback(["userId": userId], nil)
+                default:
+                    UserDefaults.standard.removeObject(forKey: "vn_apple_userId")
+                    callback(nil, nil)
+                }
+            }
+        case "google":
+            if let code = UserDefaults.standard.string(forKey: "vn_google_authCode") {
+                callback(["userId": code], nil)
+            } else {
+                callback(nil, nil)
+            }
+        default:
+            callback(nil, nil)
+        }
+    }
+
+    // MARK: - Credential Revocation Observer
+
+    private func observeAppleCredentialRevocation() {
+        credentialObserver = NotificationCenter.default.addObserver(
+            forName: ASAuthorizationAppleIDProvider.credentialRevokedNotification,
+            object: nil,
+            queue: .main
+        ) { [weak self] _ in
+            UserDefaults.standard.removeObject(forKey: "vn_apple_userId")
+            self?.bridge?.emitGlobalEvent("auth:appleCredentialRevoked", payload: [:])
+        }
+    }
+
+    deinit {
+        if let observer = credentialObserver {
+            NotificationCenter.default.removeObserver(observer)
+        }
+    }
+}
+#endif

package/native/ios/VueNativeCore/Sources/VueNativeCore/Modules/WebSocketModule.swift

@@ -0,0 +1,213 @@
+#if canImport(UIKit)
+import Foundation
+
+/// Native module for WebSocket connections.
+///
+/// Supports multiple simultaneous connections keyed by connection ID.
+///
+/// Methods:
+///   - connect(url: String, connectionId: String)
+///   - send(connectionId: String, data: String)
+///   - close(connectionId: String, code: Int?, reason: String?)
+///
+/// Global events dispatched on bridge:
+///   "websocket:open"    { connectionId }
+///   "websocket:message" { connectionId, data }
+///   "websocket:close"   { connectionId, code, reason }
+///   "websocket:error"   { connectionId, message }
+final class WebSocketModule: NativeModule {
+    var moduleName: String { "WebSocket" }
+    private weak var bridge: NativeBridge?
+
+    /// Active WebSocket tasks keyed by connectionId
+    private var connections: [String: URLSessionWebSocketTask] = [:]
+    private var sessions: [String: URLSession] = [:]
+
+    init(bridge: NativeBridge) {
+        self.bridge = bridge
+    }
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        switch method {
+        case "connect":
+            guard let url = args.first as? String,
+                  let connectionId = args.count > 1 ? args[1] as? String : nil else {
+                callback(nil, "WebSocketModule: expected (url, connectionId)")
+                return
+            }
+            connect(url: url, connectionId: connectionId, callback: callback)
+
+        case "send":
+            guard let connectionId = args.first as? String,
+                  let data = args.count > 1 ? args[1] as? String : nil else {
+                callback(nil, "WebSocketModule: expected (connectionId, data)")
+                return
+            }
+            send(connectionId: connectionId, data: data, callback: callback)
+
+        case "close":
+            guard let connectionId = args.first as? String else {
+                callback(nil, "WebSocketModule: expected (connectionId)")
+                return
+            }
+            let code = args.count > 1 ? args[1] as? Int : nil
+            let reason = args.count > 2 ? args[2] as? String : nil
+            close(connectionId: connectionId, code: code, reason: reason, callback: callback)
+
+        default:
+            callback(nil, "WebSocketModule: Unknown method '\(method)'")
+        }
+    }
+
+    // MARK: - Connect
+
+    private func connect(url: String, connectionId: String, callback: @escaping (Any?, String?) -> Void) {
+        guard let wsURL = URL(string: url) else {
+            callback(nil, "WebSocketModule: invalid URL '\(url)'")
+            return
+        }
+
+        // Clean up existing connection with same ID if any
+        closeConnection(connectionId)
+
+        let session = URLSession(configuration: .default)
+        let task = session.webSocketTask(with: wsURL)
+        connections[connectionId] = task
+        sessions[connectionId] = session
+
+        task.resume()
+
+        // Dispatch open event once resumed
+        let weakBridge = bridge
+        DispatchQueue.main.async {
+            weakBridge?.dispatchGlobalEvent("websocket:open", payload: [
+                "connectionId": connectionId
+            ])
+        }
+
+        // Start receive loop
+        receiveLoop(connectionId: connectionId, task: task)
+
+        callback(true, nil)
+    }
+
+    // MARK: - Receive loop
+
+    private func receiveLoop(connectionId: String, task: URLSessionWebSocketTask) {
+        task.receive { [weak self] result in
+            guard let self = self else { return }
+            // Check if connection still exists (may have been closed)
+            guard self.connections[connectionId] != nil else { return }
+
+            switch result {
+            case .success(let message):
+                let data: String
+                switch message {
+                case .string(let text):
+                    data = text
+                case .data(let bytes):
+                    data = String(data: bytes, encoding: .utf8) ?? ""
+                @unknown default:
+                    data = ""
+                }
+
+                let weakBridge = self.bridge
+                DispatchQueue.main.async {
+                    weakBridge?.dispatchGlobalEvent("websocket:message", payload: [
+                        "connectionId": connectionId,
+                        "data": data
+                    ])
+                }
+
+                // Continue receiving
+                self.receiveLoop(connectionId: connectionId, task: task)
+
+            case .failure(let error):
+                let weakBridge = self.bridge
+                let errorMessage = error.localizedDescription
+                DispatchQueue.main.async {
+                    // Check if this is a normal close or an actual error
+                    let nsError = error as NSError
+                    if nsError.domain == NSPOSIXErrorDomain && nsError.code == 57 {
+                        // Socket not connected — normal close, dispatch close event
+                        weakBridge?.dispatchGlobalEvent("websocket:close", payload: [
+                            "connectionId": connectionId,
+                            "code": 1000,
+                            "reason": ""
+                        ])
+                    } else {
+                        weakBridge?.dispatchGlobalEvent("websocket:error", payload: [
+                            "connectionId": connectionId,
+                            "message": errorMessage
+                        ])
+                        weakBridge?.dispatchGlobalEvent("websocket:close", payload: [
+                            "connectionId": connectionId,
+                            "code": 1006,
+                            "reason": errorMessage
+                        ])
+                    }
+                }
+                self.connections.removeValue(forKey: connectionId)
+                self.sessions[connectionId]?.invalidateAndCancel()
+                self.sessions.removeValue(forKey: connectionId)
+            }
+        }
+    }
+
+    // MARK: - Send
+
+    private func send(connectionId: String, data: String, callback: @escaping (Any?, String?) -> Void) {
+        guard let task = connections[connectionId] else {
+            callback(nil, "WebSocketModule: no connection '\(connectionId)'")
+            return
+        }
+        task.send(.string(data)) { error in
+            if let error = error {
+                callback(nil, error.localizedDescription)
+            } else {
+                callback(true, nil)
+            }
+        }
+    }
+
+    // MARK: - Close
+
+    private func close(connectionId: String, code: Int?, reason: String?, callback: @escaping (Any?, String?) -> Void) {
+        guard let task = connections[connectionId] else {
+            callback(nil, nil) // Already closed, not an error
+            return
+        }
+
+        let closeCode = URLSessionWebSocketTask.CloseCode(rawValue: code ?? 1000) ?? .normalClosure
+        let reasonData = reason?.data(using: .utf8)
+        task.cancel(with: closeCode, reason: reasonData)
+
+        let weakBridge = bridge
+        DispatchQueue.main.async {
+            weakBridge?.dispatchGlobalEvent("websocket:close", payload: [
+                "connectionId": connectionId,
+                "code": code ?? 1000,
+                "reason": reason ?? ""
+            ])
+        }
+
+        connections.removeValue(forKey: connectionId)
+        sessions[connectionId]?.invalidateAndCancel()
+        sessions.removeValue(forKey: connectionId)
+
+        callback(true, nil)
+    }
+
+    // MARK: - Helpers
+
+    private func closeConnection(_ connectionId: String) {
+        guard let task = connections[connectionId] else { return }
+        task.cancel(with: .normalClosure, reason: nil)
+        connections.removeValue(forKey: connectionId)
+        sessions[connectionId]?.invalidateAndCancel()
+        sessions.removeValue(forKey: connectionId)
+    }
+
+    func invokeSync(method: String, args: [Any]) -> Any? { nil }
+}
+#endif

package/native/ios/VueNativeCore/Sources/VueNativeCore/Resources/vue-native-placeholder.js

@@ -0,0 +1,8 @@
+// Placeholder: Vue Native JS bundle will be generated by Vite build pipeline.
+// This file is included as an SPM resource so the package structure is valid.
+// Replace with the actual IIFE bundle from: pnpm build (in the app project).
+(function() {
+    if (typeof __VN_log === 'function') {
+        __VN_log('vue-native-bundle.js placeholder loaded');
+    }
+})();