How to store data in room database after fetching from server using retrofit

I am creating a login for my app and would like to save the user details retrieved from the server. I am using mvvm. How do i save the data I receive into my roomdb?

Here is my response from from the server

{
        "isSuccessful": true,
        "message": "successful",
        "user": [
            {
                "name": "Raymond Jezz",
                "email": "rayjezz@gmail.com",
                "phone": "254XXXXXXX"
            }
        ]
}

my UserModel

data class User(
    val name: String,
    val email:String,
    val phone:String
)

login response model

data class LoginResponse(
        val isSuccessful:Boolean,
        val message: String,
        val user: List<User>
)

Room entity

@Entity(tableName = "user_table")
        data class UserRoom(val name:String, val email:String, val phone:String) {
            @PrimaryKey(autoGenerate = true)
            var id: Int = 0
}

Dao class

@Dao
    interface UserDao {
        @Insert
        fun insert(userRoom: UserRoom)

        @Query("SELECT * FROM user_table")
        fun getUserDetails(): LiveData<List<UserRoom>>
}

RoomDatabase

@Database(entities = [UserRoom::class], version = 1)
        abstract class UserDatabase : RoomDatabase() {
        abstract fun userDao(): UserDao



        companion object {
            private var instance: UserDatabase? = null
            fun getInstance( context: Context): UserDatabase? {
                if (instance == null) {
                    synchronized(UserDatabase::class.java) {
                        instance = Room.databaseBuilder(context.applicationContext, UserDatabase::class.java, "users_database")
                            .fallbackToDestructiveMigration()
                            .build()
                    }
                }
                return instance
            }
        }
}

Repository class

class UserRepository(application: Application) {

        private lateinit var userDao: UserDao

        private var userDetails: LiveData<List<UserRoom>>

        init {
            val database: UserDatabase? = UserDatabase.getInstance(application)
            if (database != null) {
                userDao = database.userDao()
            }
            userDetails = userDao.getUserDetails()
        }

        fun insert(userRoom: UserRoom){
            val insertUserAsyncTask = InsertUserAsyncTask(userDao).execute(userRoom)
        }

        fun getUserDetails():LiveData<List<UserRoom>>{
            return userDetails
        }

        private class InsertUserAsyncTask(userDao: UserDao) : AsyncTask<UserRoom, Unit, Unit>() {
            val userDao = userDao

            override fun doInBackground(vararg p0: UserRoom?) {
                userDao.insert(p0[0]!!)
            }
        }

    }

View model class

class LoginViewModel : ViewModel() {

        fun userLogin(email: String, password: String): LiveData<String> {
            val loginResponse = MutableLiveData<String>()

            RetrofitClient.makeRetrofitApi().userLogin(email, password)
                .enqueue(object : Callback<LoginResponse> {
                    override fun onFailure(call: Call<LoginResponse>, t: Throwable) {
                        loginResponse.value = t.message
                    }

                    override fun onResponse(call: Call<LoginResponse>, response: Response<LoginResponse>) {
                        if (response.isSuccessful){
                            loginResponse.value = response.body()?.message.toString()

                        }else{
                            loginResponse.value = response.body()?.message.toString()
                        }
                    }

                })
            return loginResponse
        }
}