feat(api): streamline public facing API

Author: PascalHonegger

codegen/src/main/kotlin/tools/samt/codegen/PublicApiMapper.kt

@@ -142,7 +142,10 @@ class PublicApiMapper(
             else -> controller.reportGlobalError("Multiple transport configuration parsers found for transport '$name'")
         }
 
-        return object : TransportConfiguration {}
+        return object : TransportConfiguration {
+            override val name: String
+                get() = this@toPublicTransport.name
+        }
     }
 
     private fun tools.samt.semantic.ProviderType.Implements.toPublicImplements() = object : ProvidedService {
@@ -169,7 +172,7 @@ class PublicApiMapper(
         override val name get() = this@toPublicAlias.name
         override val qualifiedName by unsafeLazy { this@toPublicAlias.getQualifiedName() }
         override val aliasedType by unsafeLazy { this@toPublicAlias.aliasedType.toPublicTypeReference() }
-        override val fullyResolvedType by unsafeLazy { this@toPublicAlias.fullyResolvedType.toPublicTypeReference() }
+        override val runtimeType by unsafeLazy { this@toPublicAlias.fullyResolvedType.toPublicTypeReference() }
     }
 
     private inline fun <reified T : tools.samt.semantic.ResolvedTypeReference.Constraint> List<tools.samt.semantic.ResolvedTypeReference.Constraint>.findConstraint() =

codegen/src/main/kotlin/tools/samt/codegen/http/HttpTransport.kt

@@ -9,8 +9,7 @@ import tools.samt.api.transports.http.SerializationMode
 import tools.samt.api.transports.http.TransportMode
 
 object HttpTransportConfigurationParser : TransportConfigurationParser {
-    override val transportName: String
-        get() = "http"
+    override val transportName: String get() = HttpTransportConfiguration.name
 
     private val isValidRegex = Regex("""\w+\s+\S+(\s+\{.*?\s+in\s+\S+})*""")
     private val methodEndpointRegex = Regex("""(\w+)\s+(\S+)(.*)""")
@@ -212,6 +211,8 @@ class HttpTransportConfiguration(
     override val serializationMode: SerializationMode,
     val services: List<ServiceConfiguration>,
 ) : SamtHttpTransport {
+    override val name: String = HttpTransportConfiguration.name
+
     class ServiceConfiguration(
         val name: String,
         val path: String,
@@ -284,4 +285,8 @@ class HttpTransportConfiguration(
             TransportMode.Body
         }
     }
+
+    companion object {
+        const val name = "http"
+    }
 }

codegen/src/main/kotlin/tools/samt/codegen/kotlin/ktor/KotlinKtorGeneratorUtilities.kt

@@ -121,16 +121,16 @@ private fun StringBuilder.appendDecodeRecordField(field: RecordField, options: M
 private fun StringBuilder.appendEncodeAlias(alias: AliasType, options: Map<String, String>) {
     appendLine("/** Encode alias ${alias.qualifiedName} to JSON */")
     appendLine("fun `encode ${alias.name}`(value: ${alias.getQualifiedName(options)}): JsonElement =")
-    appendLine("    ${encodeJsonElement(alias.fullyResolvedType, options, valueName = "value")}")
+    appendLine("    ${encodeJsonElement(alias.runtimeType, options, valueName = "value")}")
 }
 
 private fun StringBuilder.appendDecodeAlias(alias: AliasType, options: Map<String, String>) {
     appendLine("/** Decode alias ${alias.qualifiedName} from JSON */")
-    appendLine("fun `decode ${alias.name}`(json: JsonElement): ${alias.fullyResolvedType.getQualifiedName(options)} {")
-    if (alias.fullyResolvedType.isRuntimeOptional) {
+    appendLine("fun `decode ${alias.name}`(json: JsonElement): ${alias.runtimeType.getQualifiedName(options)} {")
+    if (alias.runtimeType.isRuntimeOptional) {
         appendLine("    if (json is JsonNull) return null")
     }
-    appendLine("    return ${decodeJsonElement(alias.fullyResolvedType, options, valueName = "json")}")
+    appendLine("    return ${decodeJsonElement(alias.runtimeType, options, valueName = "json")}")
     appendLine("}")
 }
 

public-api/src/main/kotlin/tools/samt/api/plugin/Transport.kt

@@ -26,7 +26,13 @@ interface TransportConfigurationParser {
  * A base interface for transport configurations.
  * This interface is intended to be sub-typed and extended by transport configuration implementations.
  */
-interface TransportConfiguration
+interface TransportConfiguration {
+    /**
+     * The name of this transport protocol.
+     * Can be used to display to a user.
+     */
+    val name: String
+}
 
 /**
  * The parameters for a [TransportConfigurationParser].

public-api/src/main/kotlin/tools/samt/api/types/UserTypes.kt

@@ -20,9 +20,9 @@ interface AliasType : UserType {
     val aliasedType: TypeReference
 
     /**
-     * The fully resolved type, will not contain any type aliases anymore, just the underlying merged type
+     * The runtime type, which will not contain any type aliases, just the underlying merged type
      */
-    val fullyResolvedType: TypeReference
+    val runtimeType: TypeReference
 }
 
 /**