tessl/maven-io-insert-koin--koin-core-jvm

Core dependency injection framework for Kotlin multiplatform applications with DSL-based configuration and type-safe dependency resolution.

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Koin Core

Name: tessl/maven-io-insert-koin--koin-core-jvm
Author: tessl

Koin Core is a pragmatic lightweight dependency injection framework for Kotlin multiplatform applications. It provides a DSL-based approach to dependency injection with type-safe resolution, scoped instance management, and zero external dependencies. The framework supports JVM, Android, JavaScript, Native, and WebAssembly targets.

Package Information

Package Name: koin-core
Package Type: maven
Language: Kotlin
Group ID: io.insert-koin
Installation: implementation("io.insert-koin:koin-core:4.1.0")

Core Imports

import org.koin.core.context.startKoin
import org.koin.core.context.stopKoin
import org.koin.core.module.Module
import org.koin.dsl.module
import org.koin.core.component.KoinComponent
import org.koin.core.component.inject
import org.koin.core.component.get

Basic Usage

import org.koin.core.context.startKoin
import org.koin.core.context.stopKoin
import org.koin.dsl.module
import org.koin.core.component.KoinComponent
import org.koin.core.component.inject

// Define a module with dependencies
val appModule = module {
    single<DatabaseService> { DatabaseServiceImpl() }
    factory<UserRepository> { UserRepositoryImpl(get()) }
    single<UserService> { UserServiceImpl(get()) }
}

// Start Koin with modules
startKoin {
    modules(appModule)
}

// Use dependencies in components
class UserController : KoinComponent {
    private val userService: UserService by inject()
    
    fun getUser(id: String) = userService.findById(id)
}

// Stop Koin when done
stopKoin()

Architecture

Koin Core is built around several key components:

Application Context: Global Koin context (startKoin, stopKoin) for application-wide dependency management
Module System: DSL-based module definition (module) for organizing and declaring dependencies
Definition Types: Multiple definition strategies (single, factory, scoped) for different lifecycle patterns
Component Integration: Interfaces (KoinComponent) and extension functions for seamless dependency injection
Scope Management: Hierarchical scoping system for controlling dependency lifecycles and isolation
Type Safety: Full Kotlin type safety with reified generics and compile-time dependency resolution

Capabilities

Application Setup & Configuration

Core application initialization and configuration functionality. Essential for setting up the dependency injection container and managing application lifecycle.

fun startKoin(appDeclaration: KoinAppDeclaration): KoinApplication
fun startKoin(koinApplication: KoinApplication): KoinApplication
fun startKoin(appConfiguration: KoinConfiguration): KoinApplication
fun stopKoin()

fun koinApplication(createEagerInstances: Boolean = true, appDeclaration: KoinAppDeclaration? = null): KoinApplication
fun koinApplication(appDeclaration: KoinAppDeclaration?): KoinApplication
fun koinApplication(configuration: KoinConfiguration?): KoinApplication

fun loadKoinModules(module: Module)
fun loadKoinModules(modules: List<Module>)
fun unloadKoinModules(module: Module)
fun unloadKoinModules(modules: List<Module>)

class KoinApplication {
    val koin: Koin
    fun modules(vararg modules: Module): KoinApplication
    fun modules(modules: List<Module>): KoinApplication
    fun properties(values: Map<String, Any>): KoinApplication
    fun logger(logger: Logger): KoinApplication
    fun printLogger(level: Level = Level.INFO): KoinApplication
    fun allowOverride(override: Boolean)
    fun createEagerInstances()
    fun options(vararg optionValue: Pair<KoinOption, Any>): KoinApplication
    fun close()
}

Application Setup

Module Definition & Dependencies

DSL-based module definition system for declaring and organizing dependencies. Supports multiple definition types including singletons, factories, and scoped instances.

fun module(createdAtStart: Boolean = false, moduleDeclaration: ModuleDeclaration): Module

class Module {
    inline fun <reified T> single(
        qualifier: Qualifier? = null,
        createdAtStart: Boolean = false,
        noinline definition: Definition<T>
    ): KoinDefinition<T>
    
    inline fun <reified T> factory(
        qualifier: Qualifier? = null,
        noinline definition: Definition<T>
    ): KoinDefinition<T>
    
    fun <T> scope(scopeSet: ScopeSet): ScopeDSL
}

interface Definition<T> : (Scope, ParametersHolder) -> T

Module Definition

Constructor Reference DSL

Reflection-free dependency injection using constructor references. Provides type-safe constructor resolution without runtime reflection overhead.

inline fun <reified R> Module.singleOf(
    crossinline constructor: () -> R,
    noinline options: DefinitionOptions<R>? = null
): KoinDefinition<R>

inline fun <reified R> Module.factoryOf(
    crossinline constructor: () -> R,
    noinline options: DefinitionOptions<R>? = null
): KoinDefinition<R>

inline fun <reified R> Scope.new(constructor: () -> R): R

Constructor Reference DSL

Component Integration & Injection

Component integration interfaces and extension functions for seamless dependency injection into classes and objects.

interface KoinComponent {
    fun getKoin(): Koin
}

interface KoinScopeComponent : KoinComponent {
    val scope: Scope
}

inline fun <reified T> KoinComponent.inject(
    qualifier: Qualifier? = null,
    mode: LazyThreadSafetyMode = LazyThreadSafetyMode.SYNCHRONIZED,
    noinline parameters: ParametersDefinition? = null
): Lazy<T>

inline fun <reified T> KoinComponent.get(
    qualifier: Qualifier? = null,
    noinline parameters: ParametersDefinition? = null
): T

Component Integration

Scope Management

Hierarchical scope system for controlling dependency lifecycles and providing isolated dependency contexts for specific application areas.

class Scope(
    val scopeQualifier: Qualifier,
    val id: ScopeID,
    val isRoot: Boolean = false,
    val scopeArchetype: TypeQualifier? = null,
    private val _koin: Koin
) {
    val closed: Boolean
    
    inline fun <reified T> inject(
        qualifier: Qualifier? = null,
        mode: LazyThreadSafetyMode = LazyThreadSafetyMode.SYNCHRONIZED,
        noinline parameters: ParametersDefinition? = null
    ): Lazy<T>
    
    inline fun <reified T> get(
        qualifier: Qualifier? = null,
        noinline parameters: ParametersDefinition? = null
    ): T
    
    inline fun <reified T> getOrNull(
        qualifier: Qualifier? = null,
        noinline parameters: ParametersDefinition? = null
    ): T?
    
    inline fun <reified T> getAll(): List<T>
    inline fun <reified T> getSource(): T?
    
    inline fun <reified T> declare(
        instance: T,
        qualifier: Qualifier? = null,
        secondaryTypes: List<KClass<*>> = emptyList(),
        allowOverride: Boolean = true,
        holdInstance: Boolean = false
    )
    
    fun linkTo(vararg scopes: Scope)
    fun unlink(vararg scopes: Scope)
    fun registerCallback(callback: ScopeCallback)
    fun close()
    fun getKoin(): Koin
}

typealias ScopeID = String

Scope Management

Qualifiers & Parameters

Type-safe qualifier system for distinguishing between multiple instances of the same type, and parameter injection for runtime dependency configuration.

interface Qualifier {
    val value: String
}

fun named(name: String): Qualifier
fun named(name: Enum<*>): Qualifier
inline fun <reified T> named(): Qualifier

class ParametersHolder(
    private val values: MutableList<Any?> = mutableListOf(),
    private val useIndexedValues: Boolean? = null
) {
    fun <T> get(index: Int): T
    fun <T> getOrNull(index: Int): T?
    fun size(): Int
    fun isEmpty(): Boolean
}

fun parametersOf(vararg values: Any?): ParametersHolder

Qualifiers & Parameters

Configuration & Logging

Application configuration system with structured logging support for debugging and monitoring dependency injection lifecycle.

class KoinConfiguration(val config: KoinApplication.() -> Unit) {
    operator fun invoke(): KoinApplication.() -> Unit
    val appDeclaration: KoinApplication.() -> Unit
}

fun koinConfiguration(declaration: KoinAppDeclaration): KoinConfiguration

abstract class Logger(var level: Level = Level.INFO) {
    abstract fun display(level: Level, msg: MESSAGE)
    fun debug(msg: MESSAGE)
    fun info(msg: MESSAGE)
    fun warn(msg: MESSAGE)
    fun error(msg: MESSAGE)
    fun log(lvl: Level, msg: String)
}

enum class Level {
    DEBUG, INFO, WARNING, ERROR, NONE
}

Configuration & Logging

Property Management

Property injection and management system for configuration values and runtime parameters with type-safe access patterns.

fun <T : Any> Koin.getProperty(key: String, defaultValue: T): T
fun <T : Any> Koin.getProperty(key: String): T?
fun Koin.setProperty(key: String, value: Any)
fun Koin.deleteProperty(key: String)

inline fun <reified T> KMutableProperty0<T>.inject()
inline fun <reified T> KMutableProperty0<T>.inject(koin: Koin)
inline fun <reified T> KMutableProperty0<T>.inject(scope: Scope)

Property Management

Java Interoperability

Java-specific API for dependency injection in mixed Kotlin/Java projects with static access patterns.

object KoinJavaComponent {
    @JvmStatic
    fun <T> inject(
        clazz: Class<*>,
        qualifier: Qualifier? = null,
        parameters: ParametersDefinition? = null
    ): Lazy<T>
    
    @JvmStatic
    fun <T> get(
        clazz: Class<*>,
        qualifier: Qualifier? = null,
        parameters: ParametersDefinition? = null
    ): T
    
    @JvmStatic
    fun getKoin(): Koin
}

Java Interoperability

Types

Core Types

typealias KoinAppDeclaration = KoinApplication.() -> Unit
typealias ModuleDeclaration = Module.() -> Unit
typealias ParametersDefinition = () -> ParametersHolder
typealias DefinitionOptions<T> = BeanDefinition<T>.() -> Unit
typealias Definition<T> = Scope.(ParametersHolder) -> T
typealias QualifierValue = String
typealias ScopeID = String
typealias MESSAGE = String
typealias OnCloseCallback<T> = (T) -> Unit

data class StringQualifier(override val value: String) : Qualifier
data class TypeQualifier(val kClass: KClass<*>) : Qualifier

enum class KoinOption {
    VIEWMODEL_SCOPE_FACTORY
}

enum class Level {
    DEBUG, INFO, WARNING, ERROR, NONE
}

Core Interface Types

interface Qualifier {
    val value: QualifierValue
}

interface KoinComponent {
    fun getKoin(): Koin
}

interface KoinScopeComponent : KoinComponent {
    val scope: Scope
}

abstract class Logger(var level: Level = Level.INFO) {
    abstract fun display(level: Level, msg: MESSAGE)
}

Exception Types

class NoDefinitionFoundException(msg: String) : Exception(msg)
class InstanceCreationException(msg: String) : Exception(msg)
class ClosedScopeException(msg: String) : Exception(msg)
class DefinitionOverrideException(msg: String) : Exception(msg)
class DefinitionParameterException(msg: String) : Exception(msg)
class KoinApplicationAlreadyStartedException(msg: String) : Exception(msg)
class MissingPropertyException(msg: String) : Exception(msg)
class MissingScopeValueException(msg: String) : Exception(msg)
class NoParameterFoundException(msg: String) : Exception(msg)
class NoPropertyFileFoundException(msg: String) : Exception(msg)
class NoScopeDefFoundException(msg: String) : Exception(msg)
class ScopeAlreadyCreatedException(msg: String) : Exception(msg)
class ScopeNotCreatedException(msg: String) : Exception(msg)

Workspace: tessl
Visibility: Public
Created: 6 months ago
Last updated: about 2 months ago
Describes: pkg:maven/io.insert-koin/koin-core@4.1.x
Publish Source: CLI
Badge