[WIP] support templates

Heavily WIP, depends on google/ksp#2068

Author: SIMULATAN

integration-plugin/src/main/kotlin/me/snoty/integration/plugin/processor/NodeKoinModulesProcessor.kt

@@ -34,6 +34,7 @@ class NodeKoinModulesProcessor(private val logger: KSPLogger, private val codeGe
 		val generatedModule = TypeSpec.objectBuilder(getGeneratedModule(clazz))
 			.addAnnotation(Module::class)
 			.addSerializersModule(node)
+			.addTemplateModule(node)
 			.build()
 
 		val defaultModule = TypeSpec.objectBuilder(getDefaultModule(clazz))

integration-plugin/src/main/kotlin/me/snoty/integration/plugin/processor/NodeMetadataProcessor.kt

@@ -6,6 +6,8 @@ import com.google.devtools.ksp.processing.*
 import com.google.devtools.ksp.symbol.KSAnnotated
 import com.google.devtools.ksp.symbol.KSClassDeclaration
 import com.squareup.kotlinpoet.FileSpec
+import com.squareup.kotlinpoet.FunSpec
+import com.squareup.kotlinpoet.PropertySpec
 import com.squareup.kotlinpoet.ksp.writeTo
 import me.snoty.integration.common.annotation.RegisterNode
 import me.snoty.integration.common.model.metadata.NodeMetadata
@@ -50,11 +52,20 @@ class NodeMetadataProcessor(private val logger: KSPLogger, private val codeGener
 		)
 
 		val fileSpec = FileSpec.scriptBuilder("${clazz.simpleName.asString()}Metadata", clazz.packageName.asString())
-			.addCode("internal val $NODE_METADATA = %T(\n", NodeMetadata::class)
-			.addDataClassInitializer(metadata, replacements = mapOf(
-				NodeMetadata::settingsClass.name to "${settingsClass.simpleName.asString()}::class",
-			))
-			.addCode(")\n")
+			.addProperty(
+				PropertySpec.builder(NODE_METADATA, NodeMetadata::class)
+					.initializer("provideMetadata()")
+					.build()
+			)
+			.addFunction(
+				FunSpec.builder("provideMetadata")
+					.addCode("return ")
+					.addDataClassInitializer(metadata, replacements = mapOf(
+						NodeMetadata::settingsClass.name to "${settingsClass.simpleName.asString()}::class",
+					))
+					.returns(NodeMetadata::class)
+					.build()
+			)
 			.build()
 
 		fileSpec

integration-plugin/src/main/kotlin/me/snoty/integration/plugin/processor/PluginKoinModules.kt

@@ -7,20 +7,22 @@ import com.squareup.kotlinpoet.ksp.toClassName
 import kotlinx.serialization.InternalSerializationApi
 import kotlinx.serialization.modules.SerializersModule
 import me.snoty.integration.common.annotation.RegisterNode
+import me.snoty.integration.common.wiring.node.NodeDescriptor
 import me.snoty.integration.common.wiring.node.NodeSettings
+import me.snoty.integration.common.wiring.node.template.NodeTemplate
+import me.snoty.integration.plugin.utils.addDataClassInitializer
+import me.snoty.integration.plugin.utils.getTemplateFiles
 import org.koin.core.annotation.Scope
 import org.koin.core.annotation.Scoped
 import org.koin.core.annotation.Single
+import org.slf4j.LoggerFactory
 import kotlin.reflect.KClass
 
 fun TypeSpec.Builder.addSerializersModule(registerNode: RegisterNode): TypeSpec.Builder {
 	val serializationModule = "kotlinx.serialization.modules"
 
 	return addFunction(
-		FunSpec.builder("provide${registerNode.type}SerializersModule")
-			.addAnnotation(Single::class)
-			.addAnnotation(Scoped::class)
-			.addAnnotation(AnnotationSpec.get(Scope(name = registerNode.type)))
+		providerBuilder(registerNode.type, registerNode)
 			.returns(SerializersModule::class)
 			.addAnnotation(AnnotationSpec.get(OptIn(InternalSerializationApi::class)))
 			.addStatement(
@@ -42,6 +44,28 @@ fun TypeSpec.Builder.addSerializersModule(registerNode: RegisterNode): TypeSpec.
 	)
 }
 
+fun TypeSpec.Builder.addTemplateModule(registerNode: RegisterNode): TypeSpec.Builder = apply {
+	val descriptor = NodeDescriptor(registerNode.subsystem, registerNode.type)
+	val templates = getTemplateFiles(descriptor) ?: return@apply
+
+	LoggerFactory.getLogger("NodeKoinModulesProcessor").info("Generating templates for $descriptor")
+
+	templates.forEach { (file, content) ->
+		addFunction(
+			providerBuilder(file.nameWithoutExtension, registerNode)
+				.returns(NodeTemplate::class)
+				.addDataClassInitializer(NodeTemplate(node = descriptor, name = file.nameWithoutExtension, template = content))
+				.build()
+		)
+	}
+}
+
+fun providerBuilder(name: String, registerNode: RegisterNode) = FunSpec.builder("provide$name")
+	.addAnnotation(Single::class)
+	.addAnnotation(Scoped::class)
+	.addAnnotation(AnnotationSpec.get(Scope(name = registerNode.type)))
+
+
 @OptIn(KspExperimental::class)
 fun <T : Any> gimmeTypeName(get: () -> KClass<T>) = runCatching {
 	get().asClassName()

integration-plugin/src/main/kotlin/me/snoty/integration/plugin/utils/InitializerUtils.kt

@@ -1,6 +1,6 @@
 package me.snoty.integration.plugin.utils
 
-import com.squareup.kotlinpoet.FileSpec
+import com.squareup.kotlinpoet.FunSpec
 import com.squareup.kotlinpoet.asTypeName
 import kotlin.reflect.KClass
 import kotlin.reflect.full.isSubtypeOf
@@ -10,7 +10,14 @@ import kotlin.reflect.full.withNullability
 import kotlin.reflect.typeOf
 
 // TODO: support generics
-fun FileSpec.Builder.addDataClassInitializer(copyFrom: Any, level: Int = 1, replacements: Map<String, Any> = emptyMap()): FileSpec.Builder = apply {
+
+fun FunSpec.Builder.addDataClassInitializer(copyFrom: Any, replacements: Map<String, Any> = emptyMap()): FunSpec.Builder = apply {
+	addCode("%T(\n", copyFrom::class.asTypeName())
+	addDataClassInitializer(copyFrom, level = 1, replacements = replacements)
+	addCode(")\n")
+}
+
+fun FunSpec.Builder.addDataClassInitializer(copyFrom: Any, level: Int, replacements: Map<String, Any> = emptyMap()): FunSpec.Builder = apply {
 	copyFrom::class.primaryConstructor!!.parameters.forEach { param ->
 		val prop = copyFrom::class.memberProperties.first { it.name == param.name }
 		val value = prop.call(copyFrom)

integrations/api/src/main/kotlin/me/snoty/integration/common/wiring/node/template/NodeTemplate.kt

@@ -0,0 +1,11 @@
+package me.snoty.integration.common.wiring.node.template
+
+import kotlinx.serialization.Serializable
+import me.snoty.integration.common.wiring.node.NodeDescriptor
+
+@Serializable
+data class NodeTemplate(
+	val node: NodeDescriptor,
+	val name: String,
+	val template: String,
+)

integrations/api/src/main/kotlin/me/snoty/integration/common/wiring/node/template/NodeTemplateRegistry.kt

@@ -0,0 +1,7 @@
+package me.snoty.integration.common.wiring.node.template
+
+import me.snoty.integration.common.wiring.node.NodeDescriptor
+
+interface NodeTemplateRegistry {
+	fun getAllTemplates(): Map<NodeDescriptor, List<NodeTemplate>>
+}

integrations/builtin/src/main/resources/node/integration/ical/node_bottom.liquid

@@ -0,0 +1 @@
+Hello World!

src/main/kotlin/me/snoty/backend/integration/flow/node/NodeTemplateRegistryImpl.kt

@@ -0,0 +1,15 @@
+package me.snoty.backend.integration.flow.node
+
+import me.snoty.integration.common.wiring.node.NodeDescriptor
+import me.snoty.integration.common.wiring.node.template.NodeTemplate
+import me.snoty.integration.common.wiring.node.template.NodeTemplateRegistry
+import org.koin.core.annotation.Single
+
+@Single
+class NodeTemplateRegistryImpl(templates: List<NodeTemplate>) : NodeTemplateRegistry {
+	private val templates: Map<NodeDescriptor, List<NodeTemplate>> = templates
+		.groupBy { it.node }
+
+	override fun getAllTemplates(): Map<NodeDescriptor, List<NodeTemplate>>
+		= templates
+}

src/main/kotlin/me/snoty/backend/server/resources/WiringResources.kt

@@ -5,6 +5,7 @@ import io.ktor.server.routing.*
 import kotlinx.serialization.json.Json
 import me.snoty.backend.hooks.HookRegistry
 import me.snoty.backend.server.resources.wiring.flowResource
+import me.snoty.backend.server.resources.wiring.nodeMetadataResource
 import me.snoty.backend.server.resources.wiring.nodeResource
 import me.snoty.backend.server.routing.Resource
 import org.koin.core.annotation.Named
@@ -15,6 +16,10 @@ import org.koin.core.annotation.Single
 fun wiringResources(json: Json, hookRegistry: HookRegistry) = Resource {
 	route("wiring/node") {
 		hookRegistry.executeHooks(Routing::class, this)
+
+		route("metadata") {
+			nodeMetadataResource()
+		}
 	}
 
 	authenticate("jwt-auth") {

src/main/kotlin/me/snoty/backend/server/resources/wiring/NodeMetadataResource.kt

@@ -0,0 +1,37 @@
+package me.snoty.backend.server.resources.wiring
+
+import io.ktor.server.response.*
+import io.ktor.server.routing.*
+import kotlinx.serialization.Serializable
+import me.snoty.integration.common.wiring.node.template.NodeTemplate
+import me.snoty.integration.common.wiring.node.template.NodeTemplateRegistry
+import me.snoty.backend.server.koin.get as getDependency
+import me.snoty.integration.common.model.metadata.NodeMetadata
+import me.snoty.integration.common.wiring.node.NodeDescriptor
+import me.snoty.integration.common.wiring.node.NodeRegistry
+
+fun Routing.nodeMetadataResource() {
+	val nodeRegistry: NodeRegistry = getDependency()
+	get {
+		@Serializable
+		data class NodeDescription(val descriptor: NodeDescriptor, val metadata: NodeMetadata)
+
+		val nodeDescriptions = nodeRegistry.getMetadata().map { (descriptor, metadata) ->
+			NodeDescription(descriptor, metadata)
+		}
+
+		call.respond(nodeDescriptions)
+	}
+
+	val nodeTemplateRegistry: NodeTemplateRegistry = getDependency()
+	get("/template") {
+		@Serializable
+		data class NodeTemplates(val descriptor: NodeDescriptor, val templates: List<NodeTemplate>)
+
+		val nodeTemplates = nodeTemplateRegistry.getAllTemplates().map { (descriptor, templates) ->
+			NodeTemplates(descriptor, templates)
+		}
+
+		call.respond(nodeTemplates)
+	}
+}

src/main/kotlin/me/snoty/backend/server/resources/wiring/NodeResource.kt

@@ -36,16 +36,6 @@ fun Routing.nodeResource(json: Json) {
 		return json.decodeFromJsonElement(serializer, settingsJson)
 	}
 
-	get("list") {
-		@Serializable
-		data class NodeDescription(val descriptor: NodeDescriptor, val metadata: NodeMetadata)
-
-		val nodeDescriptions = nodeRegistry.getMetadata().map { (descriptor, metadata) ->
-			NodeDescription(descriptor, metadata)
-		}
-
-		call.respond(nodeDescriptions)
-	}
 	post("create") {
 		val user = call.getUser()