Kotlin compose multiplatform - sqldelight - Unresolved reference: SqlDriver

Question

I converted my jetpack compose application(without the ios) to a compose multiplatform.

When I tried to configure the iOS part and tried to build the shared module to use in the iOS, the build failed with 2 errors:

Cannot access class 'app.cash.sqldelight.db.SqlSchema'. Check your module classpath for missing or conflicting dependencies

Unresolved reference: SqlDriver

This is the configuration

plugins {
    alias(libs.plugins.kotlin.multiplatform)
    alias(libs.plugins.android.library)
    alias(libs.plugins.sqldelight)
    alias(libs.plugins.compose)
    alias(libs.plugins.kotlin.serialization)
    alias(libs.plugins.kotlin.cocoapods)
    id("dev.icerock.mobile.multiplatform-resources")
}

android {
    namespace = "com.vboxcomm.cdapplication"
    compileSdk = 34
    defaultConfig {
        minSdk = 26
    }
}

dependencies {
    implementation(libs.firebase.database.ktx)
    commonMainApi(libs.bundles.moko.resources)
}

@OptIn(org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi::class)
kotlin {
    applyDefaultHierarchyTemplate()

    android {
        compilations.all {
            kotlinOptions {
                jvmTarget = "1.8"
            }
        }
    }

    val iOSBinaryFlags =
        listOf(
            "-linker-option", "-framework", "-linker-option", "Metal",
            "-linker-option", "-framework", "-linker-option", "CoreText",
            "-linker-option", "-framework", "-linker-option", "CoreGraphics",
        )

    // Targets
    iosX64 {
        binaries.forEach { it.freeCompilerArgs += iOSBinaryFlags }
    }
    iosArm64 {
        binaries.forEach { it.freeCompilerArgs += iOSBinaryFlags }
    }
    iosSimulatorArm64 {
        binaries.forEach { it.freeCompilerArgs += iOSBinaryFlags }
    }
//    tvosArm64()
//    tvosX64()

    version = "1.0"

    cocoapods {
        summary = "Some description for the Shared Module"
        homepage = "Link to the Shared Module homepage"
        version = "1.0"
        ios.deploymentTarget = "16.0"
        podfile = project.file("../apple/Podfile")

        framework {
            baseName = "shared"
            isStatic = false
            linkerOpts += "-lsqlite3"
            export(libs.moko.resource)
            export(libs.decompose.router)
        }
    }

    sourceSets {
        val commonMain by getting {
            dependencies {

                implementation(libs.bundles.compose)
                api(compose.runtime)
                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3") {
                    version { strictly("1.7.3") }
                }

//                implementation(libs.coroutines.extensions)
                implementation(libs.multiplatform.settings)
                api(libs.koin.core)
                api(libs.koin.compose)

                implementation(libs.sqldelight.coroutines.extensions)
                implementation(libs.sqldelight.primitive.adapters)

                implementation(libs.stately.common)
                implementation(libs.ktor.network)
                implementation(libs.ktor.network.tls)
                implementation(libs.ktor.client.core)
                implementation(libs.ktor.client.cio)
                implementation(libs.ktor.client.websockets)
                implementation(libs.ktor.serialization.kotlinx.json)
                implementation(libs.ktor.client.serialization)
                implementation(libs.kotlinx.serialization.core)

                implementation(kotlin("stdlib-common"))
                implementation(libs.kermit)
                implementation("javax.servlet:javax.servlet-api:3.1.0")
                //implementation("javax.servlet:servlet-api:3.1.0")
                api("jakarta.servlet:jakarta.servlet-api:6.0.0")

                api(libs.decompose.router)

                api("io.github.kevinnzou:compose-webview-multiplatform:1.8.8")

                // You will probably need to also bring in decompose and essenty
                implementation(libs.decompose)
                implementation(libs.decompose.compose.multiplatform)
                implementation(libs.essenty.parcelable)
                implementation(libs.molecule.runtime)

                implementation("media.kamel:kamel-image:0.9.0")

                api(libs.permissions.compose)
            }
        }

        val commonTest by getting {
            dependencies {
                implementation(kotlin("test"))
            }
        }

        val androidMain by getting {
            dependsOn(commonMain)
            dependencies {
                implementation(kotlin("reflect"))
                implementation(libs.sqldelight.android.driver)

                implementation(libs.kotlinx.coroutines.android)
                implementation(libs.androidx.lifecycle.viewmodel.ktx)
                implementation(libs.timber)

            }
        }

        iosMain.dependencies {
            implementation(libs.sqldelight.native.driver)
            implementation(libs.ktor.client.darwin)
            api(compose.runtime)
        }

//        val iosX64Main by getting
//        val iosArm64Main by getting
//        val iosSimulatorArm64Main by getting
//        val tvosArm64Main by getting
//        val tvosX64Main by getting
    }
}

sqldelight {
    databases {
        create("CdApplicationDb") {
            packageName.set("com.vboxcomm.shared.database")
            dialect(libs.sqldelight.sqlite.dialect)
            schemaOutputDirectory.set(file("src/commonMain/sqldelight/com/vbox/shared/database"))
            verifyMigrations.set(true)
        }
    }
}

multiplatformResources {
    multiplatformResourcesPackage = "com.vboxcomm.cdapplication"
    multiplatformResourcesClassName = "SharedRes"
}

To configure the database, I followed the guide on the sqldelight sites

I also tried to fix it with this solution:

Kotlin Multiplatform. Cannot access class SqlDriver.Schema. Check your module classpath for missing or conflicting dependencies

but without success.

I'm using the version 2.0.1