// core/data-jvm — the DESKTOP build of the same data layer the Android app // compiles (Development Plan §6, Phase 1 milestone M1a). // // Shape: sibling JVM module sharing :core:data's platform-neutral sources, // NOT one multiplatform module. Two reasons, both proven in the Phase-0 // spike (tools/DESKTOP_FEASIBILITY.md): // 1. ObjectBox's generator cannot read Kotlin common code, so entities have // to be compiled per-target anyway. // 2. objectbox-android and objectbox-java ship the same io.objectbox.* // classes; keeping them in separate modules is what stops a duplicate // classpath clash. Each module runs its own codegen and gets its own // MyObjectBox. // The shared model file is copied to objectbox-models/, and regenerating in a // second module reports "ID model file unchanged" — no UID churn. // The ObjectBox Gradle plugin publishes no plugin marker (same reason // :core/data/build.gradle.kts wires it through a buildscript classpath). buildscript { repositories { google() mavenCentral() } dependencies { classpath("io.objectbox:objectbox-gradle-plugin:${libs.versions.objectbox.get()}") } } plugins { alias(libs.plugins.kotlinJvm) } // SPIKE FINDING: `alias(libs.plugins.kotlinKapt)` fails here ("plugin is // already on the classpath with an unknown version") because the root build // already loads the Kotlin Gradle Plugin, which ships kapt. Applying by id // reuses that copy. apply(plugin = "org.jetbrains.kotlin.kapt") apply(plugin = "io.objectbox") java { sourceCompatibility = JavaVersion.VERSION_17 targetCompatibility = JavaVersion.VERSION_17 } kotlin { jvmToolchain(17) } sourceSets { main { kotlin.setSrcDirs( listOf( "build/generated/source/objectbox", "src/main/kotlin", // The platform-neutral data layer, compiled from :core:data's // directory. Nothing in here may import android.*. "../data/src/main/kotlin", ), ) } } dependencies { api(project(":core:domain")) implementation(libs.kotlinx.coroutines.core) // Phase 1 (M2): the backup bridge, for the backupSmoke round-trip probe. // No classpath risk here — :core:backup carries no ObjectBox at all. implementation(project(":core:backup")) implementation(libs.kotlinx.serialization.json) // JVM counterparts of the objectbox-android the Android build uses. implementation(libs.objectbox.java) implementation(libs.objectbox.kotlin) // Native database library for the build/host OS. Declared explicitly so a // packaged desktop app knows what it must bundle (objectbox-macos / // objectbox-windows on other platforms). runtimeOnly(libs.objectbox.linux) } /** * `./gradlew :core:data-jvm:smoke` — boots the shared data layer against a * real ObjectBox store on the JVM and round-trips a note. Temporary until * :desktopApp provides the real entry point (Phase 1, M1b). */ tasks.register("smoke") { group = "verification" description = "Opens a JVM ObjectBox store through the shared data layer." classpath = sourceSets["main"].runtimeClasspath mainClass.set("org.incido.data.jvm.StoreSmokeKt") args = listOf(layout.buildDirectory.dir("data-jvm-smoke").get().asFile.absolutePath) } /** * `./gradlew :core:data-jvm:backupSmoke --args=" [libDir]"` * — feeds a REAL Android backup file through the :core:backup bridge on the * JVM: preview, import into a fresh library, re-export and compare, then the * encrypted-envelope path (including wrong-passphrase rejection). Runs * against a fresh library every time (the script deletes libDir first). */ tasks.register("backupSmoke") { group = "verification" description = "Round-trips a real Android backup export through BackupBridge on the JVM." classpath = sourceSets["main"].runtimeClasspath mainClass.set("org.incido.data.jvm.BackupRoundTripKt") }