Merge pull request #12 from bee-produced/11-bee-persistent-blaze

Better alternatives to entity graph: `bee.persistent.blaze`

Author: kurbaniec

.github/workflows/github-actions.yaml

@@ -21,6 +21,7 @@ jobs:
       - name: Make gradlew executable
         run: |
           chmod +x ./bee.persistent/gradlew
+          chmod +x ./bee.persistent.test/gradlew
           chmod +x ./bee.functional/gradlew
           chmod +x ./bee.functional.test/gradlew
           chmod +x ./bee.buzz/gradlew
@@ -31,6 +32,9 @@ jobs:
       - name: Build & Test bee.persistent
         working-directory: ./bee.persistent
         run: ./gradlew build
+      - name: Test bee.persistent.blaze
+        working-directory: ./bee.persistent.test
+        run: ./gradlew build
       - name: Build & Test bee.generative
         working-directory: ./bee.generative
         run: ./gradlew build

README.md

@@ -14,17 +14,10 @@ An example project showcasing `bee-built` can be found under [example](./example
 
 ### Modules
 
-Extend DGS:
-
-* `bee.fetched`      
-  Automatically generate nested data fetchers for usage with data loaders, [documentation](./bee.fetched/README.md)
-
----
-
-Some changes are currently being made:
-
 * `bee.persistent`      
-  Easier data handling for GraphQL + JPA, [documentation](./bee.persistent/README.md)
+  Easier data handling for GraphQL + JPA, [choose implementation](./bee.persistent/README.md)
+* `bee.fetched`      
+  Automatically generate nested data fetchers for usage with data loaders in DGS, [documentation](./bee.fetched/README.md)
 * `bee.functional`      
   Functional Kotlin bindings, integration with DGS, `bee.persistent` & more,   [documentation](./bee.functional/README.md)    
 * `bee.buzz`       

bee.fetched/src/processor/kotlin/com/beeproduced/bee/fetched/codegen/BeeFetchedCodegen.kt

@@ -10,6 +10,7 @@ import com.beeproduced.bee.fetched.codegen.BeeFetchedCodegen.PoetConstants._PROP
 import com.beeproduced.bee.fetched.codegen.BeeFetchedCodegen.PoetConstants.__DATA_LOADER_NAME
 import com.beeproduced.bee.fetched.codegen.BeeFetchedCodegen.PoetConstants.__DTO_NAME
 import com.beeproduced.bee.generative.util.*
+import com.beeproduced.bee.generative.util.PoetMap.Companion.addNStatementBuilder
 import com.google.devtools.ksp.processing.CodeGenerator
 import com.google.devtools.ksp.processing.Dependencies
 import com.google.devtools.ksp.processing.KSPLogger
@@ -45,7 +46,7 @@ class BeeFetchedCodegen(
     private lateinit var typedInternals: Map<String, List<FetcherInternalTypeDefinition>>
     private lateinit var typedSafeModeOverrides: Map<String, List<FetcherSafeModeOverrideDefinition>>
 
-    private val poetMap: PoetMap = mutableMapOf()
+    private val poetMap: PoetMap = PoetMap()
     private fun FunSpec.Builder.addNStatement(format: String)
         = addNStatementBuilder(format, poetMap)
     @Suppress("ConstPropertyName")

bee.generative/src/main/kotlin/com/beeproduced/bee/generative/BeeGenerativePlugin.kt

@@ -30,15 +30,40 @@ open class BeeDependencies(private val dependencies: DependencyHandler) {
         val main = dependencies.add("implementation", dependencyNotation)
         val processorMain = dependencies.add("ksp", dependencyNotation)
         val processorCapability = dependencies.add("ksp", dependencyNotation, closureOf<DefaultExternalModuleDependency> {
-            val capabilityNotation = if (version != null) {
-                "$group:$name-processor:$version"
-            } else "$group:$name-processor"
+            val capabilityNotation = "$group:$name-processor${versionString(version)}"
             capabilities {
                 requireCapability(capabilityNotation)
             }
         })
         return Triple(main, processorMain, processorCapability)
     }
+
+    operator fun invoke(dependencyNotation: String, capability: String): Triple<Dependency?, Dependency?, Dependency?> {
+        val capabilityMain = dependencies.add("implementation", dependencyNotation, closureOf<DefaultExternalModuleDependency> {
+            val capabilityNotation = "$group:$name-$capability${versionString(version)}"
+            capabilities {
+                requireCapability(capabilityNotation)
+            }
+        })
+        val processorMain = dependencies.add("ksp", dependencyNotation, closureOf<DefaultExternalModuleDependency> {
+            val capabilityNotation = "$group:$name-$capability${versionString(version)}"
+            capabilities {
+                requireCapability(capabilityNotation)
+            }
+        })
+        val processorCapability = dependencies.add("ksp", dependencyNotation, closureOf<DefaultExternalModuleDependency> {
+            val capabilityNotation = "$group:$name-$capability-processor${versionString(version)}"
+            capabilities {
+                requireCapability(capabilityNotation)
+            }
+        })
+        return Triple(capabilityMain, processorMain, processorCapability)
+    }
+
+    private fun versionString(version: String?): String {
+        return if (version == null)  ""
+        else ":$version"
+    }
 }
 
 class BeeGenerativePlugin : Plugin<Project>{

bee.generative/src/main/kotlin/com/beeproduced/bee/generative/util/DummyKsp.kt

@@ -0,0 +1,170 @@
+package com.beeproduced.bee.generative.util
+
+/**
+ *
+ *
+ * @author Kacper Urbaniec
+ * @version 2023-12-16
+ */
+
+
+import com.google.devtools.ksp.symbol.*
+
+object DummyKsp {
+    val propertyDeclaration = DummyKSPropertyDeclaration()
+    val type = DummyKSType()
+}
+
+class DummyKSPropertyDeclaration : KSPropertyDeclaration {
+    override val annotations: Sequence<KSAnnotation>
+        get() = emptySequence() // Empty sequence for dummy implementation
+
+    override val containingFile: KSFile?
+        get() = null // Null for dummy implementation
+
+    override val docString: String?
+        get() = null // Null for dummy implementation
+
+    override val extensionReceiver: KSTypeReference?
+        get() = null // Null for dummy implementation
+
+    override val getter: KSPropertyGetter?
+        get() = null // Null for dummy implementation
+
+    override val hasBackingField: Boolean
+        get() = false // Default to false
+
+    override val isActual: Boolean
+        get() = false // Default to false
+
+    override val isExpect: Boolean
+        get() = false // Default to false
+
+    override val isMutable: Boolean
+        get() = false // Default to false
+
+    override val location: Location
+        get() = NonExistLocation // Using Location.None for simplicity
+
+    override val modifiers: Set<Modifier>
+        get() = emptySet() // Empty set for dummy implementation
+
+    override val origin: Origin
+        get() = Origin.SYNTHETIC // Using SYNTHETIC for dummy implementation
+
+    override val packageName: KSName
+        get() = DummyKSName()
+
+    override val parent: KSNode?
+        get() = null // Null for dummy implementation
+
+    override val parentDeclaration: KSDeclaration?
+        get() = null // Null for dummy implementation
+
+    override val qualifiedName: KSName?
+        get() = DummyKSName()
+
+    override val setter: KSPropertySetter?
+        get() = null // Null for dummy implementation
+
+    override val simpleName: KSName
+        get() = DummyKSName()
+
+    override val type: KSTypeReference
+        get() = DummyKSTypeReference() // A dummy type reference
+
+    override val typeParameters: List<KSTypeParameter>
+        get() = emptyList() // Empty list for dummy implementation
+
+    override fun <D, R> accept(visitor: KSVisitor<D, R>, data: D): R {
+        throw NotImplementedError("Dummy implementation does not support this method.")
+    }
+
+    override fun asMemberOf(containing: KSType): KSType {
+        throw NotImplementedError("Dummy implementation does not support this method.")
+    }
+
+    override fun findActuals(): Sequence<KSDeclaration> {
+        return emptySequence() // Empty sequence for dummy implementation
+    }
+
+    override fun findExpects(): Sequence<KSDeclaration> {
+        return emptySequence() // Empty sequence for dummy implementation
+    }
+
+    override fun findOverridee(): KSPropertyDeclaration? {
+        return null // Null for dummy implementation
+    }
+
+    override fun isDelegated(): Boolean {
+        return false // Default to false
+    }
+}
+
+class DummyKSName : KSName {
+    override fun asString(): String = ""
+
+    override fun getQualifier(): String = ""
+
+    override fun getShortName(): String = ""
+}
+
+class DummyKSTypeReference : KSTypeReference {
+    override val annotations: Sequence<KSAnnotation>
+        get() = emptySequence()
+
+    override val element: KSReferenceElement
+        get() = throw NotImplementedError("Dummy implementation does not support this property.")
+    override val location: Location
+        get() = NonExistLocation
+    override val modifiers: Set<Modifier>
+        get() = emptySet()
+
+    override val origin: Origin
+        get() = Origin.SYNTHETIC
+
+    override val parent: KSNode?
+        get() = null
+
+    override fun resolve(): KSType {
+        throw NotImplementedError("Dummy implementation does not support this method.")
+    }
+
+    override fun <D, R> accept(visitor: KSVisitor<D, R>, data: D): R {
+        throw NotImplementedError("Dummy implementation does not support this method.")
+    }
+}
+
+class DummyKSType : KSType {
+    override val annotations: Sequence<KSAnnotation>
+        get() = emptySequence()
+    override val arguments: List<KSTypeArgument>
+        get() = emptyList()
+    override val declaration: KSDeclaration
+        get() = TODO("Not yet implemented")
+    override val isError: Boolean
+        get() = false
+    override val isFunctionType: Boolean
+        get() = false
+    override val isMarkedNullable: Boolean
+        get() = false
+    override val isSuspendFunctionType: Boolean
+        get() = false
+    override val nullability: Nullability
+        get() = Nullability.NOT_NULL
+
+    override fun isAssignableFrom(that: KSType): Boolean = false
+
+    override fun isCovarianceFlexible(): Boolean = false
+
+    override fun isMutabilityFlexible(): Boolean = false
+
+    override fun makeNotNullable(): KSType = DummyKSType()
+
+    override fun makeNullable(): KSType = DummyKSType()
+
+    override fun replace(arguments: List<KSTypeArgument>): KSType = DummyKSType()
+
+    override fun starProjection(): KSType = DummyKSType()
+
+}

bee.generative/src/main/kotlin/com/beeproduced/bee/generative/util/EasyNamedKotlinPoet.kt

@@ -1,6 +1,6 @@
 package com.beeproduced.bee.generative.util
 
-import com.squareup.kotlinpoet.FunSpec
+import com.squareup.kotlinpoet.*
 
 /**
  *
@@ -9,28 +9,66 @@ import com.squareup.kotlinpoet.FunSpec
  * @version 2023-10-15
  */
 
-typealias PoetMap = MutableMap<String, Any>
+class PoetMap {
+    private val poetMappings = mutableMapOf<String, Any>()
+    private val originalMappings = mutableMapOf<String, Any>()
+    private val literalMappings = mutableMapOf<String, String>()
+    private val stringMappings = mutableMapOf<String, String>()
+    private val classMappings = mutableMapOf<String, ClassName>()
 
-fun PoetMap.addMapping(key: String, mapping: Any) {
-    put(mappingKey(key), mapping)
-}
+    val args get(): Map<String, Any> = poetMappings
+    val mappings get(): Map<String, Any> = originalMappings
 
-fun PoetMap.addMappings(map: Map<String, Any>) {
-    map
-        .mapKeys { (k) -> mappingKey(k) }
-        .let { m -> putAll(m) }
-}
+    fun literalMapping(key: String) = literalMappings.getValue(key)
+    fun stringMapping(key: String) = stringMappings.getValue(key)
+    fun classMapping(key: String) = classMappings.getValue(key)
+
+    fun addMapping(key: String, mapping: Any) {
+        originalMappings[key] = mapping
+        addSpecialisedMapping(key, mapping)
+        poetMappings[mappingKey(key)] = mapping
+    }
+
+    fun addMappings(map: Map<String, Any>) {
+        originalMappings.putAll(map)
+        map.forEach(::addSpecialisedMapping)
+        map
+            .mapKeys { (k) -> mappingKey(k) }
+            .let { m -> poetMappings.putAll(m) }
+    }
+
+    private fun addSpecialisedMapping(key: String, mapping: Any) {
+        if (key.endsWith(":L") && mapping is String) literalMappings[key] = mapping
+        else if (key.endsWith(":S") && mapping is String) stringMappings[key] = mapping
+        else if (key.endsWith(":T") && mapping is ClassName) classMappings[key] = mapping
+    }
+
+    private fun mappingKey(input: String): String {
+        // Check if the string starts with "%" and remove it if true
+        val withoutPrefix = if (input.startsWith("%")) input.substring(1) else input
+        // Check if the string has a ":" followed by another character and remove them if true
+        return if (withoutPrefix.contains(":")) withoutPrefix.substring(
+            0,
+            withoutPrefix.lastIndexOf(":")
+        ) else withoutPrefix
+    }
 
-fun FunSpec.Builder.addNStatementBuilder(format: String, map: PoetMap): FunSpec.Builder {
-    return addNamedCode(format, map).addStatement("")
+    companion object {
+        fun FunSpec.Builder.addNStatementBuilder(format: String, map: PoetMap): FunSpec.Builder {
+            return addNamedCode(format, map.args).addStatement("")
+        }
+
+        fun CodeBlock.Builder.addNStatementBuilder(format: String, map: PoetMap): CodeBlock.Builder {
+            return addNamed(format, map.args).addStatement("")
+        }
+
+        fun FileSpec.Builder.addNStatementBuilder(format: String, map: PoetMap): FileSpec.Builder {
+            return addStatement(format, map.args).addStatement("")
+        }
+    }
 }
 
-private fun mappingKey(input: String): String {
-    // Check if the string starts with "%" and remove it if true
-    val withoutPrefix = if (input.startsWith("%")) input.substring(1) else input
-    // Check if the string has a ":" followed by another character and remove them if true
-    return if (withoutPrefix.contains(":")) withoutPrefix.substring(
-        0,
-        withoutPrefix.lastIndexOf(":")
-    ) else withoutPrefix
-}
+
+
+
+