@xmobitea/gn-typescript-client 2.6.12 → 2.6.13

package/srcSwift/Sources/GearN/runtime/helper/EnumUtility.swift

@@ -0,0 +1,34 @@
+import Foundation
+
+public class EnumUtility {
+    // Swift has native RawRepresentable support, simplified logic.
+    
+    public static func parse<T: RawRepresentable>(enumType: T.Type, value: String, ignoreCase: Bool = false) -> T? where T.RawValue == String {
+         // This assumes String raw value. But most enums here are Int.
+         // If generic T has RawValue == String, this works.
+         // For Int enums, parsing from String requires name matching, which equates to "custom parsing".
+         // Since CaseIterable exists, we can iterate.
+         return nil
+    }
+    
+    // Helper for Int enums if name is passed
+    public static func parseGameLoop<T: CaseIterable>(enumType: T.Type, value: String, ignoreCase: Bool = true) -> T? {
+        for caseVal in enumType.allCases {
+            let label = String(describing: caseVal)
+            if ignoreCase {
+                if label.caseInsensitiveCompare(value) == .orderedSame {
+                    return caseVal
+                }
+            } else {
+                if label == value {
+                    return caseVal
+                }
+            }
+        }
+        return nil
+    }
+    
+    public static func toString<T>(enumType: T, value: Any) -> String {
+        return String(describing: value)
+    }
+}

package/srcSwift/Sources/GearN/runtime/helper/GNSupport.swift

@@ -0,0 +1,41 @@
+import Foundation
+
+public enum PlatformType: String {
+    case Cocos = "cocos"
+    case Browser = "browser"
+    case NodeJS = "nodejs"
+    case iOS = "ios"
+    case Windows = "windows" // Adding local context
+}
+
+public class GNSupport {
+    private static var isBrowserVar: Bool = false
+    private static var isCocosCreatorVar: Bool = false
+    private static var platformTypeVar: PlatformType = .Windows // Defaulting to native
+    
+    public static func initSupport() {
+        // Detection logic in pure Swift is less relevant for "Browser/Node/Cocos" unless using those bridges.
+        // We will assume native.
+        #if canImport(UIKit)
+        self.platformTypeVar = .iOS
+        #else
+        self.platformTypeVar = .Windows // or Generic
+        #endif
+    }
+    
+    public static func initialize() {
+        initSupport()
+    }
+    
+    public static func isBrowser() -> Bool {
+        return self.isBrowserVar
+    }
+    
+    public static func isCocosCreator() -> Bool {
+        return self.isCocosCreatorVar
+    }
+    
+    public static func getPlatformType() -> PlatformType {
+        return self.platformTypeVar
+    }
+}

package/srcSwift/Sources/GearN/runtime/helper/GNUtils.swift

@@ -0,0 +1,66 @@
+import Foundation
+
+public class GNUtils {
+    public static func toDatasDictionary(datas: [GenericModels.DataItem]?) -> [String: GenericModels.DataItem]? {
+        guard let datas = datas else { return nil }
+        var answer = [String: GenericModels.DataItem]()
+        for data in datas {
+            answer[data.key] = data
+        }
+        return answer
+    }
+
+    public static func toTagsDictionary(tags: [GenericModels.TagItem]?) -> [String: GenericModels.TagItem]? {
+        guard let tags = tags else { return nil }
+        var answer = [String: GenericModels.TagItem]()
+        for tag in tags {
+            answer[tag.key] = tag
+        }
+        return answer
+    }
+    
+    public static func toCurrenciesDictionary(currencies: [GenericModels.CurrencyItem]?) -> [String: GenericModels.CurrencyItem]? {
+        guard let currencies = currencies else { return nil }
+        var answer = [String: GenericModels.CurrencyItem]()
+        for currency in currencies {
+            answer[currency.key] = currency
+        }
+        return answer
+    }
+    
+    public static func toStatisticsDictionary(statistics: [GenericModels.StatisticsItem]?) -> [String: GenericModels.StatisticsItem]? {
+        guard let statistics = statistics else { return nil }
+        var answer = [String: GenericModels.StatisticsItem]()
+        for statistic in statistics {
+            answer[statistic.key] = statistic
+        }
+        return answer
+    }
+    
+    public static func toInventoriesDictionary(inventories: [GenericModels.InventoryItem]?) -> [String: GenericModels.InventoryItem]? {
+        guard let inventories = inventories else { return nil }
+        var answer = [String: GenericModels.InventoryItem]()
+        for inventory in inventories {
+            answer[inventory.itemId] = inventory
+        }
+        return answer
+    }
+    
+    public static func toGroupDictionary(groups: [GenericModels.GroupItem]?) -> [String: GenericModels.GroupItem]? {
+        guard let groups = groups else { return nil }
+        var answer = [String: GenericModels.GroupItem]()
+        for group in groups {
+            answer[group.groupId] = group
+        }
+        return answer
+    }
+
+    public static func toFriendDictionary(friends: [GenericModels.FriendItem]?) -> [String: GenericModels.FriendItem]? {
+        guard let friends = friends else { return nil }
+        var answer = [String: GenericModels.FriendItem]()
+        for friend in friends {
+            answer[friend.friendId] = friend
+        }
+        return answer
+    }
+}

package/srcSwift/Sources/GearN/runtime/helper/MessagePackConverterService.swift

@@ -0,0 +1,21 @@
+import Foundation
+// Assuming a MsgPack library is available or will be implemented.
+// TS used @msgpack/msgpack. Unity likely uses a C# MsgPack lib.
+// Swift has MessagePack libraries. For now we will stub or assume basic Data if logic allows.
+// But the service signature requires ser/deser.
+
+public class MessagePackConverterService {
+    public static func serialize<T>(_ tObj: T) -> Data? {
+        // Placeholder: Implementation requires external MsgPack library
+        // For now returning nil to satisfy compilation, or use JSON as fallback? 
+        // No, must follow MsgPack.
+        // Assuming user will provide MsgPack dependency or we create a wrapper later.
+        print("Warning: MessagePack serialization not fully implemented without dependency.")
+        return nil
+    }
+    
+    public static func deserialize<T>(_ data: Data) -> T? {
+         // Placeholder
+         return nil
+    }
+}

package/srcSwift/Sources/GearN/runtime/helper/StorageService.swift

@@ -0,0 +1,29 @@
+import Foundation
+
+public class StorageService {
+    private static var _storage: [String: Any] = [:]
+    
+    // In a real Swift SDK (iOS/macOS), we would use UserDefaults
+    // For now, mirroring the "NodeJS" in-memory approach or UserDefaults if available
+    
+    public static func get(key: String, defaultValue: Any = "") -> Any {
+        if let val = UserDefaults.standard.object(forKey: key) {
+            return val
+        }
+        return defaultValue
+    }
+    
+    public static func set(key: String, value: Any) {
+        UserDefaults.standard.set(value, forKey: key)
+    }
+    
+    public static func remove(key: String) {
+        UserDefaults.standard.removeObject(forKey: key)
+    }
+    
+    public static func clear() {
+        if let bundleID = Bundle.main.bundleIdentifier {
+            UserDefaults.standard.removePersistentDomain(forName: bundleID)
+        }
+    }
+}

package/srcSwift/Sources/GearN/runtime/logger/GNDebug.swift

@@ -0,0 +1,33 @@
+import Foundation
+
+public class GNDebug {
+    private static var _logType: LogType = .All
+    
+    public static func setLogType(logType: LogType) {
+        self._logType = logType
+    }
+    
+    public static func log(_ message: Any) {
+        if self._logType.rawValue >= LogType.All.rawValue {
+            print(message)
+        }
+    }
+    
+    public static func logException(_ exception: Error) {
+        if self._logType.rawValue >= LogType.Exception.rawValue {
+            print("Exception: \(exception)")
+        }
+    }
+    
+    public static func logWarning(_ message: Any) {
+        if self._logType.rawValue >= LogType.Warning.rawValue {
+             print("Warning: \(message)")
+        }
+    }
+    
+    public static func logError(_ message: Any) {
+        if self._logType.rawValue >= LogType.Error.rawValue {
+             print("Error: \(message)")
+        }
+    }
+}

package/srcSwift/Sources/GearN/runtime/networking/AuthenticateStatus.swift

@@ -0,0 +1,24 @@
+import Foundation
+
+public class AuthenticateStatus {
+    private var authToken: String = ""
+    private var userId: String = ""
+    
+    public init() {}
+    
+    public func getAuthToken() -> String {
+        return authToken
+    }
+    
+    public func setAuthToken(authToken: String) {
+        self.authToken = authToken
+    }
+    
+    public func getUserId() -> String {
+        return userId
+    }
+    
+    public func setUserId(userId: String) {
+        self.userId = userId
+    }
+}

package/srcSwift/Sources/GearN/runtime/networking/IPeer.swift

@@ -0,0 +1,8 @@
+import Foundation
+
+public protocol IPeer {
+    func initPeer()
+    func enqueue(requestType: RequestType, role: RequestRole, operationRequest: OperationRequest, onOperationResponse: Action1<OperationResponse>?, authToken: String?, secretKey: String?, customTags: GNHashtable?, gameId: String?)
+    func isUsing() -> Bool
+    func service()
+}

package/srcSwift/Sources/GearN/runtime/networking/NetworkingPeer.swift

@@ -0,0 +1,368 @@
+import Foundation
+
+public class NetworkingPeer {
+    
+    // MARK: - Constants
+    internal static let SYNC_TS: String = "ts"
+    internal static let GET_AUTH_INFO: String = "getAuthInfo"
+    internal static let HEALTH_CHECK: String = "healthcheck"
+    internal static let API_JSON: String = "api/json"
+    internal static let API_MSG_PACK: String = "api/msgpack"
+    internal static let UPLOAD_FILE: String = "upload"
+    internal static let DOWNLOAD_FILE: String = "download"
+    
+    // MARK: - Properties
+    private var socketPeer: SocketPeer!
+    private var httpPeer: HttpPeer!
+    
+    public var authenticateStatus: AuthenticateStatus = AuthenticateStatus()
+    public var gameId: String = ""
+    
+    private var onEventHandler: Action1<OperationEvent>?
+    private var onConnectHandlers: [Action0] = []
+    private var onDisconnectHandlers: [Action0] = []
+    private var serverEventHandlers: [IServerEventHandler] = []
+    
+    // MARK: - Initialization
+    public init() {
+        self.socketPeer = SocketPeer()
+        self.httpPeer = HttpPeer()
+    }
+    
+    public func initPeer() {
+        self.socketPeer.initPeer()
+        self.httpPeer.initPeer()
+    }
+    
+    // MARK: - Getters
+    public func getPing() -> Int {
+        return socketPeer?.getPing() ?? -1
+    }
+    
+    public func getClientId() -> String {
+        return socketPeer?.getClientId() ?? ""
+    }
+    
+    public func getServerTimestamp() -> Int64 {
+        let currentTime = Int64(Date().timeIntervalSince1970 * 1000)
+        return currentTime + Int64(GNNetwork.serverTimeOffset)
+    }
+    
+    public func getSocketPeer() -> SocketPeer {
+        return self.socketPeer
+    }
+    
+    public func getHttpPeer() -> HttpPeer {
+        return self.httpPeer
+    }
+    
+    // MARK: - Time Sync
+    public func setServerTimeMilliseconds(currentServerMilliseconds: Double) {
+        let timeOffset = currentServerMilliseconds - Double(Date().timeIntervalSince1970 * 1000)
+        GNNetwork.serverTimeOffset = timeOffset
+    }
+    
+    // MARK: - Service Loop
+    public func service() {
+        self.socketPeer?.service()
+        self.httpPeer?.service()
+    }
+    
+    // MARK: - Socket Connection
+    public func connectSocket(onSocketConnect: Action0? = nil) {
+        socketPeer?.connect(onConnect: onSocketConnect)
+    }
+    
+    public func disconnectSocket(onSocketDisconnect: Action0? = nil) {
+        socketPeer?.disconnect(onDisconnect: onSocketDisconnect)
+    }
+    
+    public func sendRequestAuthSocket() {
+        socketPeer?.sendRequestAuth()
+    }
+    
+    // MARK: - Event Handlers
+    public func setOnEventHandler(onEventHandler: Action1<OperationEvent>?) {
+        self.onEventHandler = onEventHandler
+    }
+    
+    public func setOnConnectHandler(onConnectHandler: @escaping Action0) {
+        onConnectHandlers.append(onConnectHandler)
+    }
+    
+    public func setOnDisconnectHandler(onDisconnectHandler: @escaping Action0) {
+        onDisconnectHandlers.append(onDisconnectHandler)
+    }
+    
+    public func removeOnConnectHandler(onConnectHandler: @escaping Action0) {
+        // Note: Swift closures are not directly comparable, so this is a simplified implementation
+        // In production, consider using identifiable handlers
+    }
+    
+    public func removeOnDisconnectHandler(onDisconnectHandler: @escaping Action0) {
+        // Note: Swift closures are not directly comparable, so this is a simplified implementation
+    }
+    
+    public func subscribeServerEventHandler(serverEventHandler: IServerEventHandler) {
+        serverEventHandlers.append(serverEventHandler)
+    }
+    
+    internal func notifyOnConnect() {
+        for handler in onConnectHandlers {
+            handler()
+        }
+    }
+    
+    internal func notifyOnDisconnect() {
+        for handler in onDisconnectHandlers {
+            handler()
+        }
+    }
+    
+    internal func notifyOnEvent(event: OperationEvent) {
+        onEventHandler?(event)
+        for handler in serverEventHandlers {
+            handler.onEvent(event: event)
+        }
+    }
+    
+    // MARK: - Send Methods
+    public func sendViaSocket(
+        requestType: RequestType,
+        role: RequestRole,
+        request: OperationRequest,
+        onResponse: Action1<OperationResponse>?,
+        overrideAuthToken: String = "",
+        overrideSecretKey: String = "",
+        customTags: GNHashtable? = nil
+    ) {
+        guard let settings = GNNetwork.getGNServerSettings() else { return }
+        
+        let auth = overrideAuthToken.isEmpty ? authenticateStatus.getAuthToken() : overrideAuthToken
+        
+        // Determine secret key based on role if not overridden
+        var secret = overrideSecretKey
+        if secret.isEmpty {
+            switch role {
+            case .Admin:
+                secret = settings.getAdminSecretKey() ?? ""
+            case .Server:
+                secret = settings.getServerSecretKey() ?? ""
+            case .Client:
+                secret = settings.getClientSecretKey() ?? ""
+            default:
+                break
+            }
+        }
+        
+        let game = gameId.isEmpty ? settings.getGameId() : gameId
+        
+        socketPeer.enqueue(
+            requestType: requestType,
+            role: role,
+            operationRequest: request,
+            onOperationResponse: onResponse,
+            authToken: auth,
+            secretKey: secret,
+            customTags: customTags,
+            gameId: game
+        )
+    }
+    
+    public func sendViaHttp(
+        requestType: RequestType,
+        role: RequestRole,
+        request: OperationRequest,
+        onResponse: Action1<OperationResponse>?,
+        overrideAuthToken: String = "",
+        overrideSecretKey: String = "",
+        customTags: GNHashtable? = nil
+    ) {
+        guard let settings = GNNetwork.getGNServerSettings() else { return }
+        
+        let auth = overrideAuthToken.isEmpty ? authenticateStatus.getAuthToken() : overrideAuthToken
+        
+        // Determine secret key based on role if not overridden
+        var secret = overrideSecretKey
+        if secret.isEmpty {
+            switch role {
+            case .Admin:
+                secret = settings.getAdminSecretKey() ?? ""
+            case .Server:
+                secret = settings.getServerSecretKey() ?? ""
+            case .Client:
+                secret = settings.getClientSecretKey() ?? ""
+            default:
+                break
+            }
+        }
+        
+        let game = gameId.isEmpty ? settings.getGameId() : gameId
+        
+        httpPeer.enqueue(
+            requestType: requestType,
+            role: role,
+            operationRequest: request,
+            onOperationResponse: onResponse,
+            authToken: auth,
+            secretKey: secret,
+            customTags: customTags,
+            gameId: game
+        )
+    }
+    
+    public func request(
+        requestType: RequestType,
+        role: RequestRole,
+        operationRequest: OperationRequest,
+        onOperationResponse: Action1<OperationResponse>?,
+        authToken: String = "",
+        secretKey: String = "",
+        customTags: GNHashtable? = nil,
+        gameId: String = ""
+    ) {
+        guard let settings = GNNetwork.getGNServerSettings() else { return }
+        
+        let auth = authToken.isEmpty ? authenticateStatus.getAuthToken() : authToken
+        let game = gameId.isEmpty ? settings.getGameId() : gameId
+        
+        if settings.isUseSocket() && socketPeer.isConnected() {
+            socketPeer.enqueue(
+                requestType: requestType,
+                role: role,
+                operationRequest: operationRequest,
+                onOperationResponse: onOperationResponse,
+                authToken: auth,
+                secretKey: secretKey,
+                customTags: customTags,
+                gameId: game
+            )
+        } else if settings.isUseHttp() {
+            httpPeer.enqueue(
+                requestType: requestType,
+                role: role,
+                operationRequest: operationRequest,
+                onOperationResponse: onOperationResponse,
+                authToken: auth,
+                secretKey: secretKey,
+                customTags: customTags,
+                gameId: game
+            )
+        } else {
+            GNDebug.logError("Cannot send request, no active peer connection or configuration.")
+        }
+    }
+    
+    // MARK: - Utility Methods
+    public func syncTs(onResponse: Action1<Int64>? = nil) {
+        guard let settings = GNNetwork.getGNServerSettings() else {
+            onResponse?(Int64(Date().timeIntervalSince1970 * 1000))
+            return
+        }
+        
+        let url = "\(settings.getHttpUrl())/\(NetworkingPeer.API_JSON)/sync"
+        
+        httpPeer.sendRawRequest(url: url, method: "GET", body: nil) { [weak self] data, response, error in
+            guard let data = data,
+                  let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+                  let serverTs = json["ts"] as? Int64 else {
+                onResponse?(Int64(Date().timeIntervalSince1970 * 1000))
+                return
+            }
+            
+            self?.setServerTimeMilliseconds(currentServerMilliseconds: Double(serverTs))
+            onResponse?(serverTs)
+        }
+    }
+    
+    public func getAuthInfo(authToken: String, onResponse: Action1<GetAuthInfoResponse>? = nil) {
+        guard let settings = GNNetwork.getGNServerSettings() else {
+            let response = GetAuthInfoResponse()
+            onResponse?(response)
+            return
+        }
+        
+        let url = "\(settings.getHttpUrl())/\(NetworkingPeer.API_JSON)/auth/info"
+        var headers: [String: String] = [:]
+        headers["Authorization"] = "Bearer \(authToken)"
+        
+        httpPeer.sendRawRequest(url: url, method: "GET", headers: headers, body: nil) { data, response, error in
+            let authInfoResponse = GetAuthInfoResponse()
+            
+            if let data = data,
+               let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
+                authInfoResponse.parseFromJson(json: json)
+            }
+            
+            onResponse?(authInfoResponse)
+        }
+    }
+    
+    public func healthCheck(onResponse: Action1<HealthCheckResponse>? = nil) {
+        guard let settings = GNNetwork.getGNServerSettings() else {
+            let response = HealthCheckResponse()
+            onResponse?(response)
+            return
+        }
+        
+        let url = "\(settings.getHttpUrl())/health"
+        
+        httpPeer.sendRawRequest(url: url, method: "GET", body: nil) { data, response, error in
+            let healthResponse = HealthCheckResponse()
+            
+            if let data = data,
+               let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
+                healthResponse.parseFromJson(json: json)
+            }
+            
+            onResponse?(healthResponse)
+        }
+    }
+    
+    public func uploadFile(
+        fileId: String,
+        content: Data,
+        filename: String,
+        mimetype: String,
+        onResponse: Action1<UploadFileResponse>? = nil
+    ) {
+        guard let settings = GNNetwork.getGNServerSettings() else {
+            let response = UploadFileResponse()
+            onResponse?(response)
+            return
+        }
+        
+        let url = "\(settings.getHttpUrl())/\(NetworkingPeer.UPLOAD_FILE)"
+        let boundary = UUID().uuidString
+        
+        var body = Data()
+        
+        // Add file id field
+        body.append("--\(boundary)\r\n".data(using: .utf8)!)
+        body.append("Content-Disposition: form-data; name=\"fileId\"\r\n\r\n".data(using: .utf8)!)
+        body.append("\(fileId)\r\n".data(using: .utf8)!)
+        
+        // Add file content
+        body.append("--\(boundary)\r\n".data(using: .utf8)!)
+        body.append("Content-Disposition: form-data; name=\"file\"; filename=\"\(filename)\"\r\n".data(using: .utf8)!)
+        body.append("Content-Type: \(mimetype)\r\n\r\n".data(using: .utf8)!)
+        body.append(content)
+        body.append("\r\n".data(using: .utf8)!)
+        body.append("--\(boundary)--\r\n".data(using: .utf8)!)
+        
+        var headers: [String: String] = [:]
+        headers["Content-Type"] = "multipart/form-data; boundary=\(boundary)"
+        headers["Authorization"] = "Bearer \(authenticateStatus.getAuthToken())"
+        
+        httpPeer.sendRawRequest(url: url, method: "POST", headers: headers, body: body) { data, response, error in
+            let uploadResponse = UploadFileResponse()
+            
+            if let data = data,
+               let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
+                uploadResponse.parseFromJson(json: json)
+            }
+            
+            onResponse?(uploadResponse)
+        }
+    }
+}