How to enqueue sequential coroutines blocks

I'd follow the Go language slogan "Don't communicate by sharing memory; share memory by communicating", that means instead of maintaining atomic variables or jobs and trying to synchronize between them, model your operations as messages and use Coroutines actors to handle them.

sealed class Message {
   data AddSuggestions(val suggestions: List<String>) : Message()
   data AddPin(val pin: String) : Message()
}

And in your class

private val parentScope = CoroutineScope(Job())

private val actor = parentScope.actor<Message>(Dispatchers.IO) {
        for (msg in channel) {
            when (msg) {
                is Message.AddSuggestions -> TODO("Map to the Suggestion and do suggestionDAO.insert(suggestions)")
                is Message.AddPin -> TODO("Map to the Pin and do suggestionDAO.insert(pin)")
            }
        }
    }

fun addSuggestions(suggestions: List<String>) {
    actor.offer(Message.AddSuggestions(suggestions))
}

fun addPin(pin: String) {
    actor.offer(Message.AddPin(pin))
}

By using actors you'll be able to queue messages and they will be processed in FIFO order.

By default when you call .launch{}, it launches a new coroutine without blocking the current thread and returns a reference to the coroutine as a Job. The coroutine is canceled when the resulting job is canceled.

It doesn't care or wait for other parts of your code it just runs.

But you can pass a parameter to basically tell it to run immediately or wait for other Coroutine to finish(LAZY).

For Example:

       val work_1 = CoroutineScope(IO).launch( start = CoroutineStart.LAZY ){
       
              //do dome work
        }

       val work_2 = CoroutineScope(IO).launch( start = CoroutineStart.LAZY ){
            //do dome work
            work_1.join()
        }

        val work_3 = CoroutineScope(IO).launch(  ) {
            //do dome work
            work_2.join()
        }

When you execute the above code first work_3 will finish and invoke work_2 when inturn invoke Work_1 and so on,

The summary of coroutine start options is:

DEFAULT -- immediately schedules coroutine for execution according to its context

LAZY -- starts coroutine lazily, only when it is needed

ATOMIC -- atomically (in a non-cancellable way) schedules coroutine for execution according to its context

UNDISPATCHED -- immediately executes coroutine until its first suspension point in the current thread.

So by default when you call .launch{} start = CoroutineStart.DEFAULT is passed because it is default parameter.

Don't launch coroutines from your database or repository. Use suspending functions and then switch dispatchers like:

suspend fun addPin(pin: String) {
    ...
    withContext(Dispatchers.IO) {
        suggestionDAO.insert(suggestion)
    }
}

Then from your ViewModel (or Activity/Fragment) make the call:

fun addSuggestionsAndPinFirst(suggestions: List<Suggestion>) {
    myCoroutineScope.launch {
        repository.addSuggestions(suggestions)
        repository.addPin(suggestions.first())
    }
}

Why do you have a separate addPin() function anyways? You can just modify a suggestion and then store it:

fun pinAndStoreSuggestion(suggestion: Suggestion) {
    myCoroutineScope.launch {
        repository.storeSuggestion(suggestion.copy(type = SuggestionType.PINNED)
    }
}

Also be careful using a Job like that. If any coroutine fails all your coroutines will be cancelled. Use a SupervisorJob instead. Read more on that here.

Disclaimer: I do not approve of the solution below. I'd rather use an old-fashioned ExecutorService and submit() my Runnable's

So if you really want to synchronize your coroutines in a way that the first function called is also the first one to write to your database. (I'm not sure it is guaranteed since your DAO functions are also suspending and Room uses it's own threads too). Try something like the following unit test:

class TestCoroutineSynchronization {

    private val jobId = AtomicInteger(0)
    private val jobToRun = AtomicInteger(0)
    private val jobMap = mutableMapOf<Int, () -> Unit>()
    
    @Test
    fun testCoroutines() = runBlocking {
        first()
        second()

        delay(2000) // delay so our coroutines finish
    }

    private fun first() {
        val jobId = jobId.getAndIncrement()
        CoroutineScope(SupervisorJob() + Dispatchers.Default).launch {
            delay(1000) // intentionally delay your first coroutine
            withContext(Dispatchers.IO) {
                submitAndTryRunNextJob(jobId) { println(1) }
            }
        }
    }

    private fun second() {
        val jobId = jobId.getAndIncrement()
        CoroutineScope(SupervisorJob()).launch(Dispatchers.IO) {
            submitAndTryRunNextJob(jobId) { println(2) }
        }
    }

    private fun submitAndTryRunNextJob(jobId: Int, action: () -> Unit) {
        synchronized(jobMap) {
            jobMap[jobId] = action
            tryRunNextJob()
        }
    }

    private fun tryRunNextJob() {
        var action = jobMap.remove(jobToRun.get())
        while (action != null) {
            action()
            action = jobMap.remove(jobToRun.incrementAndGet())
        }
    }
}

So what I do on each call is increment a value (jobId) that is later used to prioritize what action to run first. Since you are using suspending function you probably need to add that modifier to the action submitted too (e.g. suspend () -> Unit).