Update CHANGELOG.md

0.19.6

CHANGELOG.md

@@ -1,9 +1,58 @@
 # Changelog
 
+## 0.19.7
+
+* `Versions`:
+    * `Coroutines`: `1.7.1` -> `1.7.2`
+
+## 0.19.6
+
+* `Versions`:
+    * `Coroutines`: `1.6.4` -> `1.7.1`
+    * `Ktor`: `2.3.1` -> `2.3.2`
+    * `Compose`: `1.4.0` -> `1.4.1`
+
+## 0.19.5
+
+* `Repos`:
+    * `Generator`:
+        * Fixes in new type generation
+
+## 0.19.4
+
+* `Versions`:
+    * `Koin`: `3.4.1` -> `3.4.2`
+    * `Android Fragments`: `1.5.7` -> `1.6.0`
+* `Koin`
+    * `Generator`
+        * Fixes in new generic generator part
+
+## 0.19.3
+
+* `Koin`
+    * `Generator`
+        * New getter methods now available with opportunity to use parameters
+        * Old notation `*Single` and `*Factory` is deprecated since this release. With old
+          will be generated new `single*` and `factory*` notations for new generations
+        * Add opportunity to use generic-oriented koin definitions
+
+## 0.19.2
+
+* `Versions`:
+    * `Ktor`: `2.3.0` -> `2.3.1`
+    * `Koin`: `3.4.0` -> `3.4.1`
+    * `Uuid`: `0.7.0` -> `0.7.1`
+
+## 0.19.1
+
+* `Versions`:
+    * `Korlibs`: `4.0.1` -> `4.0.3`
+    * `Kotlin Poet`: `1.13.2` -> `1.14.0`
+
 ## 0.19.0
 
 * `Versions`:
-    * `Korlibs`: `4.0.1`
+    * `Korlibs`: `3.4.0` -> `4.0.1`
 
 ## 0.18.4
 

build.gradle

@@ -17,6 +17,10 @@ buildscript {
     }
 }
 
+plugins {
+    alias(libs.plugins.versions)
+}
+
 allprojects {
     repositories {
         mavenLocal()
@@ -38,3 +42,4 @@ allprojects {
 
 apply from: "./extensions.gradle"
 apply from: "./github_release.gradle"
+apply from: "./versions_plugin_setup.gradle"

dokka/build.gradle

@@ -13,10 +13,10 @@ repositories {
 
 kotlin {
     jvm()
-//    js(IR) {
-//        browser()
-//        nodejs()
-//    }
+    js(IR) {
+        browser()
+        nodejs()
+    }
     android {}
 
     sourceSets {
@@ -26,44 +26,44 @@ kotlin {
 
                 project.parent.subprojects.forEach {
                     if (
-                        it != project
-                        && it.hasProperty("kotlin")
-                        && it.kotlin.sourceSets.any { it.name.contains("commonMain") }
-//                        && it.kotlin.sourceSets.any { it.name.contains("jsMain") }
-                        && it.kotlin.sourceSets.any { it.name.contains("jvmMain") }
-                        && it.kotlin.sourceSets.any { it.name.contains("androidMain") }
+                            it != project
+                                    && it.hasProperty("kotlin")
+                                    && it.kotlin.sourceSets.any { it.name.contains("commonMain") }
+                                    && it.kotlin.sourceSets.any { it.name.contains("jsMain") }
+                                    && it.kotlin.sourceSets.any { it.name.contains("jvmMain") }
+                                    && it.kotlin.sourceSets.any { it.name.contains("androidMain") }
                     ) {
                         api it
                     }
                 }
             }
         }
-//        jsMain {
-//            dependencies {
-//                implementation kotlin('stdlib')
+        jsMain {
+            dependencies {
+                implementation kotlin('stdlib')
 
-//                project.parent.subprojects.forEach {
-//                    if (
-//                        it != project
-//                        && it.hasProperty("kotlin")
-//                        && it.kotlin.sourceSets.any { it.name.contains("commonMain") }
-//                        && it.kotlin.sourceSets.any { it.name.contains("jsMain") }
-//                    ) {
-//                        api it
-//                    }
-//                }
-//            }
-//        }
+                project.parent.subprojects.forEach {
+                    if (
+                            it != project
+                                    && it.hasProperty("kotlin")
+                                    && it.kotlin.sourceSets.any { it.name.contains("commonMain") }
+                                    && it.kotlin.sourceSets.any { it.name.contains("jsMain") }
+                    ) {
+                        api it
+                    }
+                }
+            }
+        }
         jvmMain {
             dependencies {
                 implementation kotlin('stdlib')
 
                 project.parent.subprojects.forEach {
                     if (
-                        it != project
-                        && it.hasProperty("kotlin")
-                        && it.kotlin.sourceSets.any { it.name.contains("commonMain") }
-                        && it.kotlin.sourceSets.any { it.name.contains("jvmMain") }
+                            it != project
+                                    && it.hasProperty("kotlin")
+                                    && it.kotlin.sourceSets.any { it.name.contains("commonMain") }
+                                    && it.kotlin.sourceSets.any { it.name.contains("jvmMain") }
                     ) {
                         api it
                     }
@@ -76,10 +76,10 @@ kotlin {
 
                 project.parent.subprojects.forEach {
                     if (
-                        it != project
-                        && it.hasProperty("kotlin")
-                        && it.kotlin.sourceSets.any { it.name.contains("commonMain") }
-                        && it.kotlin.sourceSets.any { it.name.contains("androidMain") }
+                            it != project
+                                    && it.hasProperty("kotlin")
+                                    && it.kotlin.sourceSets.any { it.name.contains("commonMain") }
+                                    && it.kotlin.sourceSets.any { it.name.contains("androidMain") }
                     ) {
                         api it
                     }
@@ -116,9 +116,9 @@ tasks.dokkaHtml {
             sourceRoots.setFrom(findSourcesWithName("commonMain"))
         }
 
-//        named("jsMain") {
-//            sourceRoots.setFrom(findSourcesWithName("jsMain", "commonMain"))
-//        }
+        named("jsMain") {
+            sourceRoots.setFrom(findSourcesWithName("jsMain"))
+        }
 
         named("jvmMain") {
             sourceRoots.setFrom(findSourcesWithName("jvmMain"))

gradle.properties

@@ -14,5 +14,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.19.0
-android_code_version=196
+version=0.19.7
+android_code_version=203

gradle/libs.versions.toml

@@ -2,27 +2,29 @@
 
 kt = "1.8.20"
 kt-serialization = "1.5.1"
-kt-coroutines = "1.6.4"
+kt-coroutines = "1.7.2"
 
 kslog = "1.1.1"
 
-jb-compose = "1.4.0"
+jb-compose = "1.4.1"
 jb-exposed = "0.41.1"
-jb-dokka = "1.8.10"
+jb-dokka = "1.8.20"
 
-korlibs = "4.0.1"
-uuid = "0.7.0"
+korlibs = "4.0.3"
+uuid = "0.7.1"
 
-ktor = "2.3.0"
+ktor = "2.3.2"
 
 gh-release = "2.4.1"
 
-koin = "3.4.0"
+koin = "3.4.2"
 
 okio = "3.3.0"
 
 ksp = "1.8.20-1.0.11"
-kotlin-poet = "1.13.2"
+kotlin-poet = "1.14.2"
+
+versions = "0.47.0"
 
 android-gradle = "7.4.2"
 dexcount = "4.0.0"
@@ -30,7 +32,7 @@ dexcount = "4.0.0"
 android-coreKtx = "1.10.1"
 android-recyclerView = "1.3.0"
 android-appCompat = "1.6.1"
-android-fragment = "1.5.7"
+android-fragment = "1.6.0"
 android-espresso = "3.5.1"
 android-test = "1.1.5"
 
@@ -109,3 +111,5 @@ buildscript-android-dexcount = { module = "com.getkeepsafe.dexcount:dexcount-gra
 [plugins]
 
 jb-compose = { id = "org.jetbrains.compose", version.ref = "jb-compose" }
+
+versions = { id = "com.github.ben-manes.versions", version.ref = "versions" }

koin/generator/build.gradle

@@ -13,3 +13,8 @@ dependencies {
     api libs.kotlin.poet
     api libs.ksp
 }
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}

koin/generator/src/main/kotlin/Processor.kt

@@ -9,19 +9,28 @@ import com.google.devtools.ksp.processing.Resolver
 import com.google.devtools.ksp.processing.SymbolProcessor
 import com.google.devtools.ksp.symbol.KSAnnotated
 import com.google.devtools.ksp.symbol.KSFile
+import com.google.devtools.ksp.symbol.Modifier
+import com.squareup.kotlinpoet.AnnotationSpec
 import com.squareup.kotlinpoet.ClassName
+import com.squareup.kotlinpoet.CodeBlock
 import com.squareup.kotlinpoet.FileSpec
 import com.squareup.kotlinpoet.FunSpec
+import com.squareup.kotlinpoet.KModifier
 import com.squareup.kotlinpoet.ParameterSpec
+import com.squareup.kotlinpoet.ParameterizedTypeName
 import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
 import com.squareup.kotlinpoet.PropertySpec
+import com.squareup.kotlinpoet.TypeName
+import com.squareup.kotlinpoet.TypeVariableName
 import com.squareup.kotlinpoet.asTypeName
 import com.squareup.kotlinpoet.ksp.toClassName
 import com.squareup.kotlinpoet.ksp.toTypeName
 import com.squareup.kotlinpoet.ksp.writeTo
+import dev.inmo.micro_utils.koin.annotations.GenerateGenericKoinDefinition
 import dev.inmo.micro_utils.koin.annotations.GenerateKoinDefinition
 import org.koin.core.Koin
 import org.koin.core.module.Module
+import org.koin.core.parameter.ParametersDefinition
 import org.koin.core.scope.Scope
 import java.io.File
 import kotlin.reflect.KClass
@@ -32,11 +41,236 @@ class Processor(
     private val definitionClassName = ClassName("org.koin.core.definition", "Definition")
     private val koinDefinitionClassName = ClassName("org.koin.core.definition", "KoinDefinition")
 
+    private fun FileSpec.Builder.addCodeForType(
+        targetType: TypeName,
+        name: String,
+        nullable: Boolean,
+        generateSingle: Boolean,
+        generateFactory: Boolean,
+    ) {
+        val targetTypeAsGenericType = (targetType as? TypeVariableName) ?.copy(reified = true)
+
+        fun addGetterProperty(
+            receiver: KClass<*>
+        ) {
+            addProperty(
+                PropertySpec.builder(
+                    name,
+                    targetType,
+                ).apply {
+                    addKdoc(
+                        """
+                            @return Definition by key "${name}"
+                        """.trimIndent()
+                    )
+                    getter(
+                        FunSpec.getterBuilder().apply {
+                            targetTypeAsGenericType ?.let {
+                                addModifiers(KModifier.INLINE)
+                            }
+                            addCode(
+                                "return " + (if (nullable) {
+                                    "getOrNull"
+                                } else {
+                                    "get"
+                                }) + "(named(\"${name}\"))"
+                            )
+                        }.build()
+                    )
+                    targetTypeAsGenericType ?.let {
+                        addTypeVariable(it)
+                    }
+                    receiver(receiver)
+                }.build()
+            )
+        }
+
+        if (targetTypeAsGenericType == null) {
+            addGetterProperty(Scope::class)
+            addGetterProperty(Koin::class)
+        }
+
+        val parametersDefinitionClassName = ClassName(
+            "org.koin.core.parameter",
+            "ParametersDefinition"
+        )
+        fun addGetterMethod(
+            receiver: KClass<*>
+        ) {
+            addFunction(
+                FunSpec.builder(
+                    name
+                ).apply {
+                    addKdoc(
+                        """
+                            @return Definition by key "${name}" with [parameters]
+                        """.trimIndent()
+                    )
+                    receiver(receiver)
+                    addParameter(
+                        ParameterSpec(
+                            "parameters",
+                            parametersDefinitionClassName.let {
+                                if (targetTypeAsGenericType != null) {
+                                    it.copy(nullable = true)
+                                } else {
+                                    it
+                                }
+                            },
+                            KModifier.NOINLINE
+                        ).toBuilder().apply {
+                            if (targetTypeAsGenericType != null) {
+                                defaultValue("null")
+                            }
+                        }.build()
+                    )
+                    addModifiers(KModifier.INLINE)
+                    targetTypeAsGenericType ?.let {
+                        addTypeVariable(it)
+                        returns(it.copy(nullable = nullable))
+                    } ?: returns(targetType)
+                    addCode(
+                        "return " + (if (nullable) {
+                            "getOrNull"
+                        } else {
+                            "get"
+                        }) + "(named(\"${name}\"), parameters)"
+                    )
+                }.build()
+            )
+        }
+
+        addGetterMethod(Scope::class)
+        addGetterMethod(Koin::class)
+
+        fun FunSpec.Builder.addDefinitionParameter() {
+            val definitionModifiers = if (targetTypeAsGenericType == null) {
+                arrayOf()
+            } else {
+                arrayOf(KModifier.NOINLINE)
+            }
+            addParameter(
+                ParameterSpec.builder(
+                    "definition",
+                    definitionClassName.parameterizedBy(targetType.copy(nullable = false)),
+                    *definitionModifiers
+                ).build()
+            )
+        }
+
+        if (generateSingle) {
+            fun FunSpec.Builder.configure(
+                useInstead: String? = null
+            ) {
+                addKdoc(
+                    """
+                        Will register [definition] with [org.koin.core.module.Module.single] and key "${name}"
+                    """.trimIndent()
+                )
+                receiver(Module::class)
+                addParameter(
+                    ParameterSpec.builder(
+                        "createdAtStart",
+                        Boolean::class
+                    ).apply {
+                        defaultValue("false")
+                    }.build()
+                )
+                addDefinitionParameter()
+                returns(koinDefinitionClassName.parameterizedBy(targetType.copy(nullable = false)))
+                addCode(
+                    "return single(named(\"${name}\"), createdAtStart = createdAtStart, definition = definition)"
+                )
+                targetTypeAsGenericType ?.let {
+                    addTypeVariable(it)
+                    addModifiers(KModifier.INLINE)
+                }
+                if (useInstead != null) {
+                    addAnnotation(
+                        AnnotationSpec.builder(
+                            Deprecated::class
+                        ).apply {
+                            addMember(
+                                CodeBlock.of(
+                                    """
+                                        "This definition is old style and should not be used anymore. Use $useInstead instead"
+                                    """.trimIndent()
+                                )
+                            )
+                            addMember(CodeBlock.of("ReplaceWith(\"$useInstead\")"))
+                        }.build()
+                    )
+                }
+            }
+
+            val actualSingleName = "single${name.replaceFirstChar { it.uppercase() }}"
+            if (targetTypeAsGenericType == null) { // classic type
+                addFunction(
+                    FunSpec.builder("${name}Single").apply { configure(actualSingleName) }.build()
+                )
+            }
+
+            addFunction(
+                FunSpec.builder(actualSingleName).apply { configure() }.build()
+            )
+        }
+
+        if (generateFactory) {
+            fun FunSpec.Builder.configure(
+                useInstead: String? = null
+            ) {
+                addKdoc(
+                    """
+                        Will register [definition] with [org.koin.core.module.Module.factory] and key "${name}"
+                    """.trimIndent()
+                )
+                receiver(Module::class)
+                addDefinitionParameter()
+                returns(koinDefinitionClassName.parameterizedBy(targetType.copy(nullable = false)))
+                addCode(
+                    "return factory(named(\"${name}\"), definition = definition)"
+                )
+                targetTypeAsGenericType ?.let {
+                    addTypeVariable(it)
+                    addModifiers(KModifier.INLINE)
+                }
+                if (useInstead != null) {
+                    addAnnotation(
+                        AnnotationSpec.builder(
+                            Deprecated::class
+                        ).apply {
+                            addMember(
+                                CodeBlock.of(
+                                    """
+                                        "This definition is old style and should not be used anymore. Use $useInstead instead"
+                                    """.trimIndent()
+                                )
+                            )
+                            addMember(CodeBlock.of("ReplaceWith(\"$useInstead\")"))
+                        }.build()
+                    )
+                }
+            }
+            val actualFactoryName = "factory${name.replaceFirstChar { it.uppercase() }}"
+            if (targetTypeAsGenericType == null) { // classic type
+                addFunction(
+                    FunSpec.builder("${name}Factory").apply { configure(useInstead = actualFactoryName) }.build()
+                )
+            }
+            addFunction(
+                FunSpec.builder(actualFactoryName).apply { configure() }.build()
+            )
+        }
+        addImport("org.koin.core.qualifier", "named")
+    }
+
     @OptIn(KspExperimental::class)
     override fun process(resolver: Resolver): List<KSAnnotated> {
-        resolver.getSymbolsWithAnnotation(
+        (resolver.getSymbolsWithAnnotation(
             GenerateKoinDefinition::class.qualifiedName!!
-        ).filterIsInstance<KSFile>().forEach { ksFile ->
+        ) + resolver.getSymbolsWithAnnotation(
+            GenerateGenericKoinDefinition::class.qualifiedName!!
+        )).filterIsInstance<KSFile>().forEach { ksFile ->
             FileSpec.builder(
                 ksFile.packageName.asString(),
                 "GeneratedDefinitions${ksFile.fileName.removeSuffix(".kt")}"
@@ -72,92 +306,12 @@ class Processor(
                     }.copy(
                         nullable = it.nullable
                     )
-                    fun addGetterProperty(
-                        receiver: KClass<*>
-                    ) {
-                        addProperty(
-                            PropertySpec.builder(
-                                it.name,
-                                targetType,
-                            ).apply {
-                                addKdoc(
-                                    """
-                                        @return Definition by key "${it.name}"
-                                    """.trimIndent()
-                                )
-                                getter(
-                                    FunSpec.getterBuilder().apply {
-                                        addCode(
-                                            "return " + (if (it.nullable) {
-                                                "getOrNull"
-                                            } else {
-                                                "get"
-                                            }) + "(named(\"${it.name}\"))"
-                                        )
-                                    }.build()
-                                )
-                                receiver(receiver)
-                            }.build()
-                        )
-                    }
 
-                    addGetterProperty(Scope::class)
-                    addGetterProperty(Koin::class)
-
-                    if (it.generateSingle) {
-                        addFunction(
-                            FunSpec.builder("${it.name}Single").apply {
-                                addKdoc(
-                                    """
-                                        Will register [definition] with [org.koin.core.module.Module.single] and key "${it.name}"
-                                    """.trimIndent()
-                                )
-                                receiver(Module::class)
-                                addParameter(
-                                    ParameterSpec.builder(
-                                        "createdAtStart",
-                                        Boolean::class
-                                    ).apply {
-                                        defaultValue("false")
-                                    }.build()
-                                )
-                                addParameter(
-                                    ParameterSpec.builder(
-                                        "definition",
-                                        definitionClassName.parameterizedBy(targetType.copy(nullable = false))
-                                    ).build()
-                                )
-                                returns(koinDefinitionClassName.parameterizedBy(targetType.copy(nullable = false)))
-                                addCode(
-                                    "return single(named(\"${it.name}\"), createdAtStart = createdAtStart, definition = definition)"
-                                )
-                            }.build()
-                        )
-                    }
-
-                    if (it.generateFactory) {
-                        addFunction(
-                            FunSpec.builder("${it.name}Factory").apply {
-                                addKdoc(
-                                    """
-                                        Will register [definition] with [org.koin.core.module.Module.factory] and key "${it.name}"
-                                    """.trimIndent()
-                                )
-                                receiver(Module::class)
-                                addParameter(
-                                    ParameterSpec.builder(
-                                        "definition",
-                                        definitionClassName.parameterizedBy(targetType.copy(nullable = false))
-                                    ).build()
-                                )
-                                returns(koinDefinitionClassName.parameterizedBy(targetType.copy(nullable = false)))
-                                addCode(
-                                    "return factory(named(\"${it.name}\"), definition = definition)"
-                                )
-                            }.build()
-                        )
-                    }
-                    addImport("org.koin.core.qualifier", "named")
+                    addCodeForType(targetType, it.name, it.nullable, it.generateSingle, it.generateFactory)
+                }
+                ksFile.getAnnotationsByType(GenerateGenericKoinDefinition::class).forEach {
+                    val targetType = TypeVariableName("T", Any::class)
+                    addCodeForType(targetType, it.name, it.nullable, it.generateSingle, it.generateFactory)
                 }
             }.build().let {
                 File(

koin/generator/test/src/commonMain/kotlin/GeneratedDefinitionsTest.kt

@@ -3,12 +3,15 @@
 // ORIGINAL FILE: Test.kt
 package dev.inmo.micro_utils.koin.generator.test
 
+import kotlin.Any
 import kotlin.Boolean
+import kotlin.Deprecated
 import kotlin.String
 import org.koin.core.Koin
 import org.koin.core.definition.Definition
 import org.koin.core.definition.KoinDefinition
 import org.koin.core.module.Module
+import org.koin.core.parameter.ParametersDefinition
 import org.koin.core.qualifier.named
 import org.koin.core.scope.Scope
 
@@ -24,15 +27,98 @@ public val Scope.sampleInfo: Test<String>
 public val Koin.sampleInfo: Test<String>
   get() = get(named("sampleInfo"))
 
+/**
+ * @return Definition by key "sampleInfo" with [parameters]
+ */
+public inline fun Scope.sampleInfo(noinline parameters: ParametersDefinition): Test<String> =
+    get(named("sampleInfo"), parameters)
+
+/**
+ * @return Definition by key "sampleInfo" with [parameters]
+ */
+public inline fun Koin.sampleInfo(noinline parameters: ParametersDefinition): Test<String> =
+    get(named("sampleInfo"), parameters)
+
 /**
  * Will register [definition] with [org.koin.core.module.Module.single] and key "sampleInfo"
  */
+@Deprecated(
+  "This definition is old style and should not be used anymore. Use singleSampleInfo instead",
+  ReplaceWith("singleSampleInfo"),
+)
 public fun Module.sampleInfoSingle(createdAtStart: Boolean = false,
     definition: Definition<Test<String>>): KoinDefinition<Test<String>> =
     single(named("sampleInfo"), createdAtStart = createdAtStart, definition = definition)
 
+/**
+ * Will register [definition] with [org.koin.core.module.Module.single] and key "sampleInfo"
+ */
+public fun Module.singleSampleInfo(createdAtStart: Boolean = false,
+    definition: Definition<Test<String>>): KoinDefinition<Test<String>> =
+    single(named("sampleInfo"), createdAtStart = createdAtStart, definition = definition)
+
 /**
  * Will register [definition] with [org.koin.core.module.Module.factory] and key "sampleInfo"
  */
+@Deprecated(
+  "This definition is old style and should not be used anymore. Use factorySampleInfo instead",
+  ReplaceWith("factorySampleInfo"),
+)
 public fun Module.sampleInfoFactory(definition: Definition<Test<String>>):
     KoinDefinition<Test<String>> = factory(named("sampleInfo"), definition = definition)
+
+/**
+ * Will register [definition] with [org.koin.core.module.Module.factory] and key "sampleInfo"
+ */
+public fun Module.factorySampleInfo(definition: Definition<Test<String>>):
+    KoinDefinition<Test<String>> = factory(named("sampleInfo"), definition = definition)
+
+/**
+ * @return Definition by key "test" with [parameters]
+ */
+public inline fun <reified T : Any> Scope.test(noinline parameters: ParametersDefinition? = null): T
+    = get(named("test"), parameters)
+
+/**
+ * @return Definition by key "test" with [parameters]
+ */
+public inline fun <reified T : Any> Koin.test(noinline parameters: ParametersDefinition? = null): T
+    = get(named("test"), parameters)
+
+/**
+ * Will register [definition] with [org.koin.core.module.Module.single] and key "test"
+ */
+public inline fun <reified T : Any> Module.singleTest(createdAtStart: Boolean = false, noinline
+    definition: Definition<T>): KoinDefinition<T> = single(named("test"), createdAtStart =
+    createdAtStart, definition = definition)
+
+/**
+ * Will register [definition] with [org.koin.core.module.Module.factory] and key "test"
+ */
+public inline fun <reified T : Any> Module.factoryTest(noinline definition: Definition<T>):
+    KoinDefinition<T> = factory(named("test"), definition = definition)
+
+/**
+ * @return Definition by key "testNullable" with [parameters]
+ */
+public inline fun <reified T : Any> Scope.testNullable(noinline parameters: ParametersDefinition? =
+    null): T? = getOrNull(named("testNullable"), parameters)
+
+/**
+ * @return Definition by key "testNullable" with [parameters]
+ */
+public inline fun <reified T : Any> Koin.testNullable(noinline parameters: ParametersDefinition? =
+    null): T? = getOrNull(named("testNullable"), parameters)
+
+/**
+ * Will register [definition] with [org.koin.core.module.Module.single] and key "testNullable"
+ */
+public inline fun <reified T : Any> Module.singleTestNullable(createdAtStart: Boolean = false,
+    noinline definition: Definition<T>): KoinDefinition<T> = single(named("testNullable"),
+    createdAtStart = createdAtStart, definition = definition)
+
+/**
+ * Will register [definition] with [org.koin.core.module.Module.factory] and key "testNullable"
+ */
+public inline fun <reified T : Any> Module.factoryTestNullable(noinline definition: Definition<T>):
+    KoinDefinition<T> = factory(named("testNullable"), definition = definition)

koin/generator/test/src/commonMain/kotlin/Test.kt

@@ -1,6 +1,9 @@
 @file:GenerateKoinDefinition("sampleInfo", Test::class, String::class, nullable = false)
+@file:GenerateGenericKoinDefinition("test", nullable = false)
+@file:GenerateGenericKoinDefinition("testNullable", nullable = true)
 package dev.inmo.micro_utils.koin.generator.test
 
+import dev.inmo.micro_utils.koin.annotations.GenerateGenericKoinDefinition
 import dev.inmo.micro_utils.koin.annotations.GenerateKoinDefinition
 import org.koin.core.Koin
 

koin/src/commonMain/kotlin/annotations/GenerateGenericKoinDefinition.kt

@@ -0,0 +1,26 @@
+package dev.inmo.micro_utils.koin.annotations
+
+import kotlin.reflect.KClass
+
+/**
+ * Use this annotation to mark files near to which generator should place generated extensions for koin [org.koin.core.scope.Scope]
+ * and [org.koin.core.Koin]
+ *
+ * @param name Name for definitions. This name will be available as extension for [org.koin.core.scope.Scope] and [org.koin.core.Koin]
+ * @param type Type of extensions. It is base star-typed class
+ * @param typeArgs Generic types for [type]. For example, if [type] == `Something::class` and [typeArgs] == `G1::class,
+ * G2::class`, the result type will be `Something<G1, G2>`
+ * @param nullable In case when true, extension will not throw error when definition has not been registered in koin
+ * @param generateSingle Generate definition factory with [org.koin.core.module.Module.single]. You will be able to use
+ * the extension [org.koin.core.module.Module].[name]Single(createdAtStart/* default false */) { /* your definition */ }
+ * @param generateFactory Generate definition factory with [org.koin.core.module.Module.factory]. You will be able to use
+ * the extension [org.koin.core.module.Module].[name]Factory { /* your definition */ }
+ */
+@Target(AnnotationTarget.FILE)
+@Repeatable
+annotation class GenerateGenericKoinDefinition(
+    val name: String,
+    val nullable: Boolean = true,
+    val generateSingle: Boolean = true,
+    val generateFactory: Boolean = true
+)

repos/generator/build.gradle

@@ -14,3 +14,8 @@ dependencies {
     api libs.kotlin.poet
     api libs.ksp
 }
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}

repos/generator/src/main/kotlin/Processor.kt

@@ -100,7 +100,11 @@ class Processor(
                         primaryConstructor(
                             FunSpec.constructorBuilder().apply {
                                 ksClassProperties.forEach {
-                                    addParameter(it.simpleName.getShortName(), it.typeName)
+                                    addParameter(
+                                        ParameterSpec.builder(it.simpleName.getShortName(), it.typeName).apply {
+                                            annotations += it.annotations.map { it.toAnnotationSpec() }
+                                        }.build()
+                                    )
                                     typeBuilder.addProperty(
                                         PropertySpec.builder(it.simpleName.getShortName(), it.typeName, KModifier.OVERRIDE).apply {
                                             initializer(it.simpleName.getShortName())

repos/generator/test/src/commonMain/kotlin/GeneratedModelsTest.kt

@@ -11,18 +11,20 @@ import kotlinx.serialization.Serializable
 @Serializable
 @SerialName(value = "NewTest")
 public data class NewTest(
-  public override val property1: String,
-  public override val property2: Int,
-  public override val parent: ParentTypeId?,
+  override val property1: String,
+  override val property2: Int,
+  @Serializable
+  override val parent: ParentTypeId?,
 ) : Test
 
 @Serializable
 @SerialName(value = "RegisteredTest")
 public data class RegisteredTest(
-  public override val id: TestId,
-  public override val property1: String,
-  public override val property2: Int,
-  public override val parent: ParentTypeId?,
+  override val id: TestId,
+  override val property1: String,
+  override val property2: Int,
+  @Serializable
+  override val parent: ParentTypeId?,
 ) : Test, IRegisteredTest
 
 public fun Test.asNew(): NewTest = NewTest(property1, property2, parent)

repos/generator/test/src/commonMain/kotlin/Test.kt

@@ -17,6 +17,7 @@ typealias ParentTypeId = TestId
 sealed interface Test {
     val property1: String
     val property2: Int
+    @Serializable
     val parent: ParentTypeId?
 
     @GenerateCRUDModelExcludeOverride

versions_plugin_setup.gradle

@@ -0,0 +1,11 @@
+def isNonStable = { String version ->
+    def stableKeyword = ['RELEASE', 'FINAL', 'GA'].any { it -> version.toUpperCase().contains(it) }
+    def regex = /^[0-9,.v-]+(-r)?$/
+    return !stableKeyword && !(version ==~ regex)
+}
+
+tasks.named("dependencyUpdates").configure {
+    rejectVersionIf {
+        isNonStable(it.candidate.version)
+    }
+}