CtrlK
BlogDocsLog inGet started
Tessl Logo

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
Overview
Eval results
Files

constructor-reference.mddocs/

Constructor Reference DSL

Reflection-free dependency injection using constructor references. Provides type-safe constructor resolution without runtime reflection overhead, enabling better performance and compile-time safety.

Capabilities

SingleOf Constructor References

Define singleton instances using constructor references with full type safety and dependency resolution.

/**
 * Create singleton instance using constructor reference (0 parameters)
 * @param constructor - Constructor reference function
 * @param options - Optional definition configuration
 * @return KoinDefinition for the singleton
 */
inline fun <reified R> Module.singleOf(
    crossinline constructor: () -> R,
    noinline options: DefinitionOptions<R>? = null
): KoinDefinition<R>

/**
 * Create singleton instance using constructor reference (1 parameter)
 * @param constructor - Constructor reference function with 1 dependency
 * @param options - Optional definition configuration
 * @return KoinDefinition for the singleton
 */
inline fun <reified R, reified T1> Module.singleOf(
    crossinline constructor: (T1) -> R,
    noinline options: DefinitionOptions<R>? = null
): KoinDefinition<R>

/**
 * Create singleton instance using constructor reference (2 parameters)
 * @param constructor - Constructor reference function with 2 dependencies
 * @param options - Optional definition configuration
 * @return KoinDefinition for the singleton
 */
inline fun <reified R, reified T1, reified T2> Module.singleOf(
    crossinline constructor: (T1, T2) -> R,
    noinline options: DefinitionOptions<R>? = null
): KoinDefinition<R>

Usage Examples:

import org.koin.dsl.module
import org.koin.core.module.dsl.singleOf

// Zero parameter constructor
class Logger
val appModule = module {
    singleOf(::Logger)
}

// Single parameter constructor
class UserService(private val repository: UserRepository)
val serviceModule = module {
    singleOf(::UserRepository)
    singleOf(::UserService)
}

// Multiple parameter constructor
class NotificationService(
    private val userService: UserService,
    private val emailService: EmailService
)
val notificationModule = module {
    singleOf(::UserService)
    singleOf(::EmailService)
    singleOf(::NotificationService)
}

// With options
class DatabaseConfig
val configModule = module {
    singleOf(::DatabaseConfig) {
        createdAtStart()
        bind<ConfigurationInterface>()
    }
}

FactoryOf Constructor References

Define factory instances using constructor references for new instances on each injection.

/**
 * Create factory instance using constructor reference (0 parameters)
 * @param constructor - Constructor reference function
 * @param options - Optional definition configuration
 * @return KoinDefinition for the factory
 */
inline fun <reified R> Module.factoryOf(
    crossinline constructor: () -> R,
    noinline options: DefinitionOptions<R>? = null
): KoinDefinition<R>

/**
 * Create factory instance using constructor reference (1 parameter)
 * @param constructor - Constructor reference function with 1 dependency
 * @param options - Optional definition configuration
 * @return KoinDefinition for the factory
 */
inline fun <reified R, reified T1> Module.factoryOf(
    crossinline constructor: (T1) -> R,
    noinline options: DefinitionOptions<R>? = null
): KoinDefinition<R>

/**
 * Create factory instance using constructor reference (2 parameters)
 * @param constructor - Constructor reference function with 2 dependencies
 * @param options - Optional definition configuration
 * @return KoinDefinition for the factory
 */
inline fun <reified R, reified T1, reified T2> Module.factoryOf(
    crossinline constructor: (T1, T2) -> R,
    noinline options: DefinitionOptions<R>? = null
): KoinDefinition<R>

Usage Examples:

import org.koin.dsl.module
import org.koin.core.module.dsl.factoryOf

// Request-scoped objects
class RequestContext
class RequestHandler(private val context: RequestContext)

val webModule = module {
    factoryOf(::RequestContext)
    factoryOf(::RequestHandler)
}

// Processing objects with dependencies
class DataProcessor(
    private val validator: DataValidator,
    private val transformer: DataTransformer
)
val processingModule = module {
    singleOf(::DataValidator)
    singleOf(::DataTransformer)
    factoryOf(::DataProcessor)
}

New Constructor Helper

Direct constructor resolution for immediate instance creation within definitions.

/**
 * Create new instance using constructor reference within a definition
 * @param constructor - Constructor reference function
 * @return New instance of type R
 */
inline fun <reified R> Scope.new(constructor: () -> R): R

/**
 * Create new instance using constructor reference with 1 dependency
 * @param constructor - Constructor reference function with 1 dependency
 * @return New instance of type R
 */
inline fun <reified R, reified T1> Scope.new(constructor: (T1) -> R): R

/**
 * Create new instance using constructor reference with 2 dependencies
 * @param constructor - Constructor reference function with 2 dependencies
 * @return New instance of type R
 */
inline fun <reified R, reified T1, reified T2> Scope.new(constructor: (T1, T2) -> R): R

Usage Examples:

import org.koin.dsl.module

class DatabaseConnection(private val config: DatabaseConfig)
class ConnectionPool(connections: List<DatabaseConnection>)

val databaseModule = module {
    single<DatabaseConfig> { DatabaseConfig() }
    
    single<ConnectionPool> {
        // Create multiple connections using new()
        val connections = (1..5).map { 
            new(::DatabaseConnection)
        }
        ConnectionPool(connections)
    }
}

// Complex object creation
class ComplexService(
    private val dependency1: ServiceA,
    private val dependency2: ServiceB,
    private val helper: HelperClass
)
class HelperClass(private val config: Config)

val complexModule = module {
    singleOf(::ServiceA)
    singleOf(::ServiceB)
    singleOf(::Config)
    
    single<ComplexService> {
        ComplexService(
            get<ServiceA>(),
            get<ServiceB>(),
            new(::HelperClass) // Direct creation of helper
        )
    }
}

Types

Definition Options

typealias DefinitionOptions<T> = BeanDefinition<T>.() -> Unit

// Available options
fun BeanDefinition<*>.createdAtStart()
inline fun <reified T> BeanDefinition<out T>.bind()
fun BeanDefinition<*>.binds(classes: List<KClass<*>>)
fun BeanDefinition<*>.named(name: String)
inline fun <reified T> BeanDefinition<*>.named()
fun <T> BeanDefinition<T>.onClose(onClose: OnCloseCallback<T>)

Install with Tessl CLI

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

docs

application-setup.md

component-integration.md

configuration-logging.md

constructor-reference.md

index.md

java-interop.md

module-definition.md

property-management.md

qualifiers-parameters.md

scope-management.md

tile.json