I'm kinda new to koin, also I'm lazy so sometimes ...

# koin

[Rafal]

I'm kinda new to koin, also I'm lazy so sometimes I'm making private extensions in my modules. Is there any downside to this approach? Or is it ok to extend Scope that way

private val Scope.bffApiKey: String
    get() = get(named(BFF_API_KEY))

single {
    ApiClass(
       apiKey=bffApiKey,
    )
}

[Matt Rea]

I add little extensions like this too. Only downside is that they often get broken by koin updates 🙃

[Adam Brown]

I do something some what similiar:

val mainModule = module {
    ...
    // This is a scope that is created & destroyed, possibly multiple times during lifetime of process
    scope<ProjectDefScope> {
        // IdRepositoryOkio takes in a `ProjectDef` as a ctor argument
        scopedOf(::IdRepositoryOkio) bind IdRepository::class
    }
}

ProjectDef is the thing I care about, it is injected via constructor. Each one of the things injected in this scope inherit from ProjectScoped

abstract class IdRepository(private val projectDef: ProjectDef) : ProjectScoped {
    override val projectScope = ProjectDefScope(projectDef)
    // This custom inject does the work
    private val projectSynchronizer: ClientProjectSynchronizer by projectInject()
    ...

And then I have the ext function projectInject that grabs the projectDef and passes it as an argument to the inject call.

interface ProjectScoped : KoinComponent {
	val projectScope: ProjectDefScope
}

/**
 * Injects objects from the Project Scope which all require a ProjectDef
 * parameter during injection.
 */
inline fun <reified T : Any> ProjectScoped.projectInject(
	qualifier: Qualifier? = null,
	mode: LazyThreadSafetyMode = KoinPlatformTools.defaultLazyMode(),
	noinline parameters: ParametersDefinition? = null
): Lazy<T> =
	lazy(mode) {
		val newParameters = if (parameters != null) {
			val params = parameters()
			parametersOf(arrayOf(params.values.toMutableList().add(projectScope.projectDef)))
		} else {
			parametersOf(projectScope.projectDef)
		}
		projectScope.get<T>(qualifier) { newParameters }
	}