refactor: Modularize project and introduce convention plugins

This commit refactors the project into a multi-module architecture and introduces Gradle convention plugins to streamline the build process. The core logic is separated into `core` and `feature` modules, each with distinct `data`, `domain`, and `presentation` layers. This modularization improves scalability, maintainability, and build times.

- **refactor(project)!**: Migrated from a monolithic `composeApp` to a multi-module architecture. Source code has been moved from `composeApp` into new `core` and `feature` modules.
- **feat(build)**: Introduced Gradle convention plugins (`cmp.application`, `cmp.library`, `cmp.feature`, `kmp.library`, `room`, `buildkonfig`) to standardize module configurations.
- **chore(build)**: Updated Gradle build scripts (`build.gradle.kts`, `settings.gradle.kts`, `gradle/libs.versions.toml`) to support the new modular structure and convention plugins.
- **chore(tests)**: Removed placeholder and boilerplate test files (`ExampleInstrumentedTest.kt`, `ExampleUnitTest.kt`) from all modules.
- **refactor(di)**: Updated Koin dependency injection modules to reflect the new module structure.
- **refactor(auth)**: Moved authentication-related models (`DeviceStart`, `DeviceTokenSuccess`) to the `core:domain` and `core:data` modules and renamed them for clarity (e.g., `GithubDeviceStart`).
- **refactor(network)**: Centralized `HttpClient` creation and rate-limiting logic into the `core:data` module.

Author: rainxchzed

build-logic/convention/build.gradle.kts

@@ -0,0 +1,74 @@
+import org.gradle.kotlin.dsl.compileOnly
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    `kotlin-dsl`
+}
+
+group = "zed.rainxch.convention.buildlogic"
+
+dependencies {
+    compileOnly(libs.android.gradlePlugin)
+    compileOnly(libs.android.tools.common)
+    compileOnly(libs.kotlin.gradlePlugin)
+    compileOnly(libs.compose.gradlePlugin)
+    compileOnly(libs.androidx.room.gradle.plugin)
+
+    implementation(libs.buildkonfig.gradlePlugin)
+    implementation(libs.buildkonfig.compiler)
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}
+
+kotlin {
+    compilerOptions {
+        jvmTarget = JvmTarget.JVM_17
+    }
+}
+
+tasks {
+    validatePlugins {
+        enableStricterValidation = true
+        failOnWarning = true
+    }
+}
+
+gradlePlugin {
+    plugins {
+        register("androidApplication") {
+            id = "zed.rainxch.convention.android.application"
+            implementationClass = "AndroidApplicationConventionPlugin"
+        }
+        register("androidComposeApplication") {
+            id = "zed.rainxch.convention.android.application.compose"
+            implementationClass = "AndroidApplicationComposeConventionPlugin"
+        }
+        register("cmpApplication") {
+            id = "zed.rainxch.convention.cmp.application"
+            implementationClass = "CmpApplicationConventionPlugin"
+        }
+        register("kmpLibrary") {
+            id = "zed.rainxch.convention.kmp.library"
+            implementationClass = "KmpLibraryConventionPlugin"
+        }
+        register("cmpLibrary") {
+            id = "zed.rainxch.convention.cmp.library"
+            implementationClass = "CmpLibraryConventionPlugin"
+        }
+        register("cmpFeature") {
+            id = "zed.rainxch.convention.cmp.feature"
+            implementationClass = "CmpFeatureConventionPlugin"
+        }
+        register("buildKonfig") {
+            id = "zed.rainxch.convention.buildkonfig"
+            implementationClass = "BuildKonfigConventionPlugin"
+        }
+        register("room") {
+            id = "zed.rainxch.convention.room"
+            implementationClass = "RoomConventionPlugin"
+        }
+    }
+}

build-logic/convention/src/main/kotlin/AndroidApplicationComposeConventionPlugin.kt

@@ -0,0 +1,19 @@
+import com.android.build.api.dsl.ApplicationExtension
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.getByType
+import zed.rainxch.githubstore.convention.configureAndroidCompose
+
+class AndroidApplicationComposeConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply("zed.rainxch.convention.android.application")
+                apply("org.jetbrains.kotlin.plugin.compose")
+            }
+
+            val commonExtension = extensions.getByType<ApplicationExtension>()
+            configureAndroidCompose(commonExtension)
+        }
+    }
+}

build-logic/convention/src/main/kotlin/AndroidApplicationConventionPlugin.kt

@@ -0,0 +1,42 @@
+import com.android.build.api.dsl.ApplicationExtension
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+import zed.rainxch.githubstore.convention.configureKotlinAndroid
+import zed.rainxch.githubstore.convention.libs
+
+class AndroidApplicationConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply("com.android.application")
+            }
+
+            extensions.configure<ApplicationExtension> {
+                namespace = "zed.rainxch.githubstore"
+                compileSdk = libs.findVersion("projectCompileSdkVersion").get().toString().toInt()
+
+                defaultConfig {
+                    applicationId = libs.findVersion("projectApplicationId").get().toString()
+                    minSdk = libs.findVersion("projectMinSdkVersion").get().toString().toInt()
+                    targetSdk = libs.findVersion("projectTargetSdkVersion").get().toString().toInt()
+                    versionCode = libs.findVersion("projectVersionCode").get().toString().toInt()
+                    versionName = libs.findVersion("projectVersionName").get().toString()
+                }
+                packaging {
+                    resources {
+                        excludes += "/META-INF/{AL2.0,LGPL2.1}"
+                    }
+                }
+                buildTypes {
+                    getByName("release") {
+                        isMinifyEnabled = false
+                    }
+                }
+
+                configureKotlinAndroid(this)
+            }
+        }
+    }
+
+}

build-logic/convention/src/main/kotlin/BuildKonfigConventionPlugin.kt

@@ -0,0 +1,37 @@
+import com.codingfeline.buildkonfig.compiler.FieldSpec
+import com.codingfeline.buildkonfig.gradle.BuildKonfigExtension
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+import zed.rainxch.githubstore.convention.libs
+import zed.rainxch.githubstore.convention.pathToPackageName
+import java.util.Properties
+
+class BuildKonfigConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply("com.codingfeline.buildkonfig")
+            }
+
+            extensions.configure<BuildKonfigExtension> {
+                packageName = target.pathToPackageName()
+
+                defaultConfigs {
+                    val localProps = Properties().apply {
+                        val file = rootProject.file("local.properties")
+                        if (file.exists()) file.inputStream().use { this.load(it) }
+                    }
+
+                    val githubClientId = (localProps.getProperty("GITHUB_CLIENT_ID")
+                        ?: "Ov23linTY28VFpFjFiI9").trim()
+
+                    val versionName = libs.findVersion("projectVersionName").get().toString()
+
+                    buildConfigField(FieldSpec.Type.STRING, "GITHUB_CLIENT_ID", githubClientId)
+                    buildConfigField(FieldSpec.Type.STRING, "VERSION_NAME", versionName)
+                }
+            }
+        }
+    }
+}

build-logic/convention/src/main/kotlin/CmpApplicationConventionPlugin.kt

@@ -0,0 +1,26 @@
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.dependencies
+import zed.rainxch.githubstore.convention.configureAndroidTarget
+import zed.rainxch.githubstore.convention.configureJvmTarget
+import zed.rainxch.githubstore.convention.libs
+
+class CmpApplicationConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply("zed.rainxch.convention.android.application.compose")
+                apply("org.jetbrains.kotlin.multiplatform")
+                apply("org.jetbrains.compose")
+                apply("org.jetbrains.kotlin.plugin.compose")
+            }
+
+            configureAndroidTarget()
+            configureJvmTarget()
+
+            dependencies {
+                "debugImplementation"(libs.findLibrary("androidx-compose-ui-tooling").get( ))
+            }
+        }
+    }
+}

build-logic/convention/src/main/kotlin/CmpFeatureConventionPlugin.kt

@@ -0,0 +1,39 @@
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.dependencies
+import zed.rainxch.githubstore.convention.libs
+
+class CmpFeatureConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply("zed.rainxch.convention.cmp.library")
+            }
+
+            dependencies {
+                "commonMainImplementation"(project(":core:presentation"))
+
+                "commonMainImplementation"(platform(libs.findLibrary("koin-bom").get()))
+                "androidMainImplementation"(platform(libs.findLibrary("koin-bom").get()))
+
+                "commonMainImplementation"(libs.findLibrary("koin-compose").get())
+                "commonMainImplementation"(libs.findLibrary("koin-compose-viewmodel").get())
+
+                "commonMainImplementation"(libs.findLibrary("jetbrains-compose-runtime").get())
+                "commonMainImplementation"(libs.findLibrary("jetbrains-compose-viewmodel").get())
+                "commonMainImplementation"(libs.findLibrary("jetbrains-lifecycle-viewmodel").get())
+                "commonMainImplementation"(libs.findLibrary("jetbrains-lifecycle-compose").get())
+
+                "commonMainImplementation"(libs.findLibrary("jetbrains-lifecycle-viewmodel-savedstate").get())
+                "commonMainImplementation"(libs.findLibrary("jetbrains-savedstate").get())
+                "commonMainImplementation"(libs.findLibrary("jetbrains-bundle").get())
+                "commonMainImplementation"(libs.findLibrary("jetbrains-compose-navigation").get())
+
+                "androidMainImplementation"(libs.findLibrary("koin-android").get())
+                "androidMainImplementation"(libs.findLibrary("koin-androidx-compose").get())
+                "androidMainImplementation"(libs.findLibrary("koin-androidx-navigation").get())
+                "androidMainImplementation"(libs.findLibrary("koin-core-viewmodel").get())
+            }
+        }
+    }
+}

build-logic/convention/src/main/kotlin/CmpLibraryConventionPlugin.kt

@@ -0,0 +1,28 @@
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.dependencies
+import zed.rainxch.githubstore.convention.libs
+import kotlin.text.get
+
+class CmpLibraryConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply("zed.rainxch.convention.kmp.library")
+                apply("org.jetbrains.kotlin.plugin.compose")
+                apply("org.jetbrains.compose")
+            }
+
+            dependencies {
+                "commonMainImplementation"(libs.findLibrary("jetbrains-compose-ui").get())
+                "commonMainImplementation"(libs.findLibrary("jetbrains-compose-foundation").get())
+                "commonMainImplementation"(libs.findLibrary("jetbrains-compose-material3").get())
+                "commonMainImplementation"(libs.findLibrary("jetbrains-compose-material-icons-extended").get())
+
+                "debugImplementation"(libs.findLibrary("androidx-compose-ui-tooling").get())
+            }
+        }
+    }
+
+
+}

build-logic/convention/src/main/kotlin/KmpLibraryConventionPlugin.kt

@@ -0,0 +1,36 @@
+import com.android.build.api.dsl.LibraryExtension
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.dependencies
+import zed.rainxch.githubstore.convention.configureKotlinAndroid
+import zed.rainxch.githubstore.convention.configureKotlinMultiplatform
+import zed.rainxch.githubstore.convention.libs
+import zed.rainxch.githubstore.convention.pathToResourcePrefix
+
+class KmpLibraryConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+             with(pluginManager) {
+                apply("com.android.library")
+                apply("org.jetbrains.kotlin.multiplatform")
+                apply("org.jetbrains.kotlin.plugin.serialization")
+            }
+
+            configureKotlinMultiplatform()
+
+            extensions.configure<LibraryExtension> {
+                configureKotlinAndroid(this)
+
+                resourcePrefix = this@with.pathToResourcePrefix()
+
+                experimentalProperties["android.experimental.kmp.enableAndroidResources"] = "true"
+            }
+
+            dependencies {
+                "commonMainImplementation"(libs.findLibrary("kotlinx-serialization-json").get())
+                "commonTestImplementation"(libs.findLibrary("kotlin-test").get())
+            }
+        }
+    }
+}

build-logic/convention/src/main/kotlin/RoomConventionPlugin.kt

@@ -0,0 +1,28 @@
+import androidx.room.gradle.RoomExtension
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.dependencies
+import zed.rainxch.githubstore.convention.libs
+
+class RoomConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply("com.google.devtools.ksp")
+                apply("androidx.room")
+            }
+
+            extensions.configure<RoomExtension> {
+                schemaDirectory("$projectDir/schemas")
+            }
+
+            dependencies {
+                "commonMainApi"(libs.findLibrary("androidx-room-runtime").get())
+                "commonMainApi"(libs.findLibrary("sqlite-bundled").get())
+                "kspAndroid"(libs.findLibrary("androidx-room-compiler").get())
+                "kspJvm"(libs.findLibrary("androidx-room-compiler").get())
+            }
+        }
+    }
+}

build-logic/convention/src/main/kotlin/zed/rainxch/githubstore/convention/AndroidCompose.kt

@@ -0,0 +1,24 @@
+package zed.rainxch.githubstore.convention
+
+import com.android.build.api.dsl.CommonExtension
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.dependencies
+
+fun Project.configureAndroidCompose(
+    commonExtension: CommonExtension<*, *, *, *, *, *>
+) {
+    with(commonExtension) {
+        buildFeatures {
+            compose = true
+        }
+
+        dependencies {
+            val composeBom = libs.findLibrary("androidx-compose-bom").get()
+
+            "implementation"(platform(composeBom))
+            "testImplementation"(platform(composeBom))
+            "debugImplementation"(libs.findLibrary("androidx-compose-ui-tooling-preview").get())
+            "debugImplementation"(libs.findLibrary("androidx-compose-ui-tooling").get())
+        }
+    }
+}