I’m facing an issue with multiplatform project dependencies in my ktor plugins project, and i don’t know if it’s expected behaviour, a limitation or a bug Here’s the deal. I have a task scheduler plugin. It has: • a core module that defines the the plugin itself, configurations, and abstractions, targeting jvm and native • a module for providing locking using redis, targeting jvm and native (the redis client is an expect class that in jvm is actualised by Kreds (kotlin/jvm SDK) and in native is actualised by interop with hiredis (c SDK) • a module for providing locking with jdbc (exposed) targeting jvm only • a module for providing locking with mongodb, targeting jvm only My issue is that when i add the core project as dependency in the jdbc/mongo modules, the abstractions defined there (in commonMain) are not available in jvmMain. they are available in commonMain, but obviously the exposed stuff isnt. If that dependency (core) would have been a published library, the platform specific artifact would be automatically resolved. It seems though that in this case, as it’s a project dependency, that’s not happening. See details in thread -->

@Ido Flax your post is very long, reducing visibility of the other posts here (as does the one above yours). What people usually do is write a short summary in the main post and then post all the lengthy details in the thread (which is where your reply is) 🙂

Gotcha

Could you please report an issue to YouTrack kotl.in/issue? Also, if I’m not mistaken,

ktor-server-plugin-conventions

is your own convention plugin? If yes, knowing what’s inside of it will be necessary for investigating the issue

Here’s the gist of the conventions relevant to this:

extensions.findByType(KotlinMultiplatformExtension::class)?.apply {
                explicitApi()
                jvm {
                    jvmToolchain(versionOf("java").toInt())
                    tasks.named("jvmJar", Jar::class).configure {
                        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
                        from(
                            listOf(
                                configurations["jvmCompileClasspath"],
                                configurations["jvmRuntimeClasspath"],
                            ).map { it.map { if (it.isDirectory) it else zipTree(it) } },
                        )
                    }
                }

                this.sourceSets.apply {
                    commonMain {
                        dependencies {
                            implementation(library("kotlinx-datetime"))
                            implementation(library("kotlinx-coroutines-core"))
                            implementation(library("arrow-core"))
                            implementation(library("arrow-fx-coroutines"))
                            implementation(library("kotlin-logging"))
                        }
                    }

                    commonTest {
                        dependencies {
                            implementation(kotlin("test"))
                            implementation(library("kotlinx-coroutines-test"))
                            implementation(library("kotest-framework-engine"))
                            implementation(library("kotest-framework-datatest"))
                            implementation(library("kotest-assertions-core"))
                        }
                    }
                    jvmTest {
                        dependencies {
                            implementation(library("kotest-runner-junit5"))
                            implementation(library("logback-classic"))
                            implementation(library("mockk"))
                        }
                    }
                }
                this.conventionSpecifics()
            }

...

override fun KotlinMultiplatformExtension.conventionSpecifics() {
        // Support mac OS?
        // macosArm64()
        // macosX64()
        linuxX64("native")
    nativeTarget.apply {
        binaries {
            sharedLib {
                this.baseName = "ktor"
            }
        }
        configure()
    }
        sourceSets.apply {
            commonMain {
                with(this.project) {
                    dependencies {
                        implementation(library("ktor-server-core"))
                        implementation(library("ktor-server-config-yaml"))
                        implementation(library("ktor-server-auth"))
                    }
                }
            }
            commonTest {
                with(this.project) {
                    dependencies {
                        implementation(library("ktor-server-test-host"))
                        implementation(library("ktor-server-status-pages"))
                    }
                }
            }
        }

Doesn’t ring the bell, sorry. Is it possible for you to share non-minimized, or a partially minimized reproducer?

@dsavvinov, you can checkout this commit: https://github.com/Flaxoos/extra-ktor-plugins/tree/a244c44c8fa678fe3cd4e60e4ea7d3ea435afeeb In Conventions.kt, uncomment these:

open class Conventions : Plugin<Project> {
    open fun KotlinMultiplatformExtension.conventionSpecifics() {}
    override fun apply(project: Project) {
        with(project) {
            with(plugins) {
//                apply("org.gradle.java-library")
//                apply("java-library-distribution")

Or just one of them. Then after building, the projects in

ktor-server

should be broken

The specified commit with

apply("org.gradle.java-library")

and

apply("java-library-distribution")

uncommented works for me in: IntelliJ 2032.2.4 (latest stable), build #IU-232.10203.10 Could you please create a YouTrack issue at kotl.in/issue ? We have dedicated Support Engineers working there, they will be able to handle this faster and more reliably than me (as I might not be able to respond quick enough, as now, for example)

Done: https://youtrack.jetbrains.com/issue/KT-63356/Multiplatform-project-dependencies-break-when-java-library-plugin-applied