User Management

Table of contents

1. Get Current User Details
2. Get Specific User Details
3. Get All Users
4. Count Users
5. Error Handling
6. Session Context

---

The UserManager provides offline-first access to user data with session-aware methods.

Get Current User Details

Get the current logged-in user’s details from local storage:

when (val result = zync.users.getCurrentUserDetails()) {
    is GetUserResult.Success -> {
        val currentUser = result.data
        println("User: ${currentUser.firstName} ${currentUser.lastName}")
        println("UID: ${currentUser.userUid}")
    }
    is GetUserResult.Failure -> {
        println("Error: ${result.error.message}")
        when (result.error) {
            is ZyncError.Network -> {
                println("Check your internet connection")
            }
            is ZyncError.Error -> {
                result.error.code?.let { code ->
                    println("Error code: $code")
                }
            }
        }
    }
}

if let zync.users = zync.users {
    let result = await zync.users.getCurrentUserDetails()
    switch onEnum(of: result) {
    case .success(let success):
        let currentUser = success.data
        print("User: \(currentUser.firstName) \(currentUser.lastName)")
        print("UID: \(currentUser.userUid)")
    case .failure(let failure):
        print("Error: \(failure.error.message)")
        switch onEnum(of: failure.error) {
        case .network:
            print("Check your internet connection")
        case .error(let error):
            print("Error: \(error.message)")
            if let code = error.code {
                print("Error code: \(code)")
            }
        }
    }
}

Get Specific User Details

Retrieve detailed information for a specific user:

when (val result = zync.users.getUserDetail("user-a1b2c3d4-e5f6-7890-abcd-ef1234567890")) {
    is GetUserResult.Success -> {
        val user = result.data
        println("Found user: ${user.firstName} ${user.lastName}")
        println("UID: ${user.userUid}")
    }
    is GetUserResult.Failure -> {
        println("Error: ${result.error.message}")
        when (result.error) {
            is ZyncError.Network -> {
                println("Check your internet connection")
            }
            is ZyncError.Error -> {
                result.error.code?.let { code ->
                    println("Error code: $code")
                }
            }
        }
    }
}

if let zync.users = zync.users {
    let result = await zync.users.getUserDetail(userUid: "user-a1b2c3d4-e5f6-7890-abcd-ef1234567890")
    switch onEnum(of: result) {
    case .success(let success):
        let user = success.data
        print("Found user: \(user.firstName) \(user.lastName)")
        print("UID: \(user.userUid)")
    case .failure(let failure):
        print("Error: \(failure.error.message)")
        switch onEnum(of: failure.error) {
        case .network:
            print("Check your internet connection")
        case .error(let error):
            print("Error: \(error.message)")
            if let code = error.code {
                print("Error code: \(code)")
            }
        }
    }
}

Get All Users

Retrieve all users from local storage:

when (val result = zync.users.getAllUsers()) {
    is GetUsersResult.Success -> {
        val allUsers = result.data
        println("Total users: ${allUsers.size}")
        
        allUsers.forEach { user ->
            println("${user.firstName} ${user.lastName}")
        }
    }
    is GetUsersResult.Failure -> {
        println("Error: ${result.error.message}")
        when (result.error) {
            is ZyncError.Network -> {
                println("Check your internet connection")
            }
            is ZyncError.Error -> {
                result.error.code?.let { code ->
                    println("Error code: $code")
                }
            }
        }
    }
}

if let zync.users = zync.users {
    let result = await zync.users.getAllUsers()
    switch onEnum(of: result) {
    case .success(let success):
        let allUsers = success.data
        print("Total users: \(allUsers.count)")
        
        for user in allUsers {
            print("\(user.firstName) \(user.lastName)")
        }
    case .failure(let failure):
        print("Error: \(failure.error.message)")
        switch onEnum(of: failure.error) {
        case .network:
            print("Check your internet connection")
        case .error(let error):
            print("Error: \(error.message)")
            if let code = error.code {
                print("Error code: \(code)")
            }
        }
    }
}

Count Users

Get the total number of users in local storage:

when (val result = zync.users.countUsers()) {
    is GetUserCountResult.Success -> {
        val userCount = result.count
        println("Total users in database: $userCount")
    }
    is GetUserCountResult.Failure -> {
        println("Error: ${result.error.message}")
        when (result.error) {
            is ZyncError.Network -> {
                println("Check your internet connection")
            }
            is ZyncError.Error -> {
                result.error.code?.let { code ->
                    println("Error code: $code")
                }
            }
        }
    }
}

if let zync.users = zync.users {
    let result = await zync.users.countUsers()
    switch onEnum(of: result) {
    case .success(let success):
        let userCount = success.count
        print("Total users in database: \(userCount)")
    case .failure(let failure):
        print("Error: \(failure.error.message)")
        switch onEnum(of: failure.error) {
        case .network:
            print("Check your internet connection")
        case .error(let error):
            print("Error: \(error.message)")
            if let code = error.code {
                print("Error code: \(code)")
            }
        }
    }
}

Error Handling

All UserManager methods return result types with proper success/failure handling:

// Proper result handling pattern
when (val result = zync.users.getCurrentUserDetails()) {
    is GetUserResult.Success -> {
        val currentUser = result.data
        // Use currentUser safely
        processUser(currentUser)
    }
    is GetUserResult.Failure -> {
        println("User data not available: ${result.error.message}")
        when (result.error) {
            is ZyncError.Network -> {
                println("Check your internet connection")
            }
            is ZyncError.Error -> {
                result.error.code?.let { code ->
                    println("Error code: $code")
                    if (code == "NO_SESSION") {
                        // Handle session error
                    }
                }
            }
        }
        return
    }
}

// Proper result handling pattern
if let zync.users = zync.users {
    let result = await zync.users.getCurrentUserDetails()
    switch onEnum(of: result) {
    case .success(let success):
        let currentUser = success.data
        // Use currentUser safely
        processUser(currentUser)
    case .failure(let failure):
        print("User data not available: \(failure.error.message)")
        switch onEnum(of: failure.error) {
        case .network:
            print("Check your internet connection")
        case .error(let error):
            print("Error: \(error.message)")
            if let code = error.code {
                print("Error code: \(code)")
                if code == "NO_SESSION" {
                    // Handle session error
                }
            }
        }
        return
    }
}

Session Context

All UserManager methods are session-aware:

• getCurrentUserDetails() automatically uses the current session’s user UID
• No need to manually pass user identifiers
• Returns null if no valid session exists

This ensures that user operations are always performed in the correct user context.