koinGenerator

1.1.0-fixindexed

Generates Koin modules from simple annotations, eliminating boilerplate while producing lifecycle-organized loaders and support for singletons, factories, scoped instances and ViewModel bindings.

AndroidJSJVMNative·the-best-is-best/koinGenerator

Stars

—

Used by

dependents

—

Health

/ 100

Koin Generator 🚀

Koin Generator is a powerful KSP (Kotlin Symbol Processing) library that automates the creation of Koin modules for your Kotlin Multiplatform projects. By simply annotating your classes, you can eliminate boilerplate code and ensure a clean, scalable dependency injection setup.

It includes:

Automatic generation of Koin modules from simple annotations.

Versions

🛠️ Important: Initial Build Step

Because this library relies on KSP to generate code, you must manually trigger the metadata generation the first time you set up the project or after adding new annotations. Run the following commands in your terminal:

./gradlew core : kspCommonMainKotlinMetadata --no - configuration - cache
    ./ gradlew sharedUI:kspCommonMainKotlinMetadata-- no -configuration - cache

📦 Installation

Note: Please replace x.y.z with the latest version.

1. Add the dependencies

In your build.gradle.kts file for your shared module (e.g., core, shared):

// Add the annotations library
implementation("io.github.the-best-is-best:koingenerator-annotations:x.y.z")

// Add the KSP processor
ksp("io.github.the-best-is-best:koingenerator-processor:x.y.z")

2. Configure KSP

In the same build.gradle.kts, configure the KSP processor to specify which packages to scan and where to place the generated loader file.

ksp {
    // Required: Comma-separated list of base packages to scan for @Module annotations.
    // The processor will scan these packages and all their sub-packages.
    arg("packageName", "io.github.tbib.core,io.github.tbib.koingeneratorapp")

    // Optional: The package where the generated 'KoinModuleLoader.kt' file will be created.
    // Defaults to the package of the first module found.
    arg("koinLoaderPackageName", "io.github.tbib.koingeneratorapp.di")

  // Options: "public" or "internal". Defaults to "public".
  arg("koinGeneratorVisible", "public")
}

3. Include Generated Code

Ensure the generated code is included in your source sets.

kotlin {
    sourceSets.named("commonMain").configure {
        kotlin.srcDir("build/generated/ksp/metadata/commonMain/kotlin")
    }
}

🧩 Available Annotations

`@Module`

Marks an interface as a definition for a Koin module. The processor will generate an implementation for it.

@Module
interface AppModule {
    val module: org.koin.core.module.Module
}

`@Single`, `@Factory`, `@KoinViewModel`, `@Scoped`

Attach to a class to define how it should be provided by Koin.

// Provided as a singleton
@Single
class MyRepository

// Provided as a new instance every time
@Factory
class MyPresenter(  repo: MyRepository)



 (  presenter: MyPresenter)

🧪 Example Usage

1. Annotate Your Classes

// core/src/commonMain/kotlin/.../repository/MyRepository.kt
@Single
class MyRepository { ... }

// core/src/commonMain/kotlin/.../presenter/MyPresenter.kt
@Factory
class MyPresenter(private val repository: MyRepository)

2. Define Your Module Interfaces

// core/src/commonMain/kotlin/.../di/CoreDI.kt
@Module
interface CoreDI {
    val module: org.koin.core.module.Module
}

// composeApp/src/commonmain/kotlin/.../di/AppDI.kt
@Module
interface DI {
    val module: org.koin.core.module.Module
}

3. Initialize Koin in Your App

After building, the processor generates KoinModuleLoader.kt in the package you specified ( io.github.tbib.koingeneratorapp.di). Use the generated functions to start Koin.

// composeApp/src/commonMain/kotlin/.../App.kt

import io.github.tbib.koingeneratorapp.di.loadApplicationModules
import io.github.tbib.koingeneratorapp.di.loadDIModules // Specific loader for the 'DI' module

fun initKoin() {
    startKoin {
        // Load all modules
        modules(loadApplicationModules() + loadDIModules())
    }
}