Support displaying typings from both sources

Author: krzema12

composeApp/src/commonMain/kotlin/App.kt

@@ -1,4 +1,5 @@
 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
@@ -21,10 +22,13 @@ fun App() {
     MaterialTheme {
         var actionCoords by remember { mutableStateOf("actions/checkout@v4") }
         var manifest: Metadata? by remember { mutableStateOf(null) }
+        var typingFromAction: Typing? by remember { mutableStateOf(null) }
+        var typingFromCatalog: Typing? by remember { mutableStateOf(null) }
 
         LaunchedEffect(actionCoords) {
-            val actionManifestYaml = fetchManifest(actionCoords)
-            manifest = actionManifestYaml
+            manifest = fetchManifest(actionCoords)
+            typingFromAction = fetchTypingFromAction(actionCoords)
+            typingFromCatalog = fetchTypingFromCatalog(actionCoords)
         }
 
         Column(Modifier.fillMaxWidth(), horizontalAlignment = Alignment.CenterHorizontally) {
@@ -35,26 +39,59 @@ fun App() {
             )
             Spacer(Modifier.height(10.dp))
 
-
-            Column(Modifier.verticalScroll(rememberScrollState())) {
-                Text("Inputs", fontWeight = FontWeight.Bold)
-                if (manifest?.inputs?.isEmpty() == true) {
-                    Text("<none>")
-                }
-                manifest?.inputs?.forEach {
-                    Text(it.key)
-                }
-
-                Spacer(Modifier.height(10.dp))
-
-                Text("Outputs", fontWeight = FontWeight.Bold)
-                if (manifest?.outputs?.isEmpty() == true) {
-                    Text("<none>")
-                }
-                manifest?.outputs?.forEach {
-                    Text(it.key)
-                }
+            Row {
+                manifest(manifest)
+                typing(typingFromAction, source = "action")
+                typing(typingFromCatalog, source = "catalog")
             }
         }
     }
 }
+
+@Composable
+private fun manifest(manifest: Metadata?) {
+    Column(Modifier.verticalScroll(rememberScrollState())) {
+        Text("Manifest:")
+        Text("Inputs", fontWeight = FontWeight.Bold)
+        if (manifest?.inputs?.isEmpty() == true) {
+            Text("<none>")
+        }
+        manifest?.inputs?.forEach {
+            Text(it.key)
+        }
+
+        Spacer(Modifier.height(10.dp))
+
+        Text("Outputs", fontWeight = FontWeight.Bold)
+        if (manifest?.outputs?.isEmpty() == true) {
+            Text("<none>")
+        }
+        manifest?.outputs?.forEach {
+            Text(it.key)
+        }
+    }
+}
+
+@Composable
+private fun typing(typing: Typing?, source: String) {
+    Column(Modifier.verticalScroll(rememberScrollState())) {
+        Text("Typing from $source:")
+        Text("Inputs", fontWeight = FontWeight.Bold)
+        if (typing?.inputs?.isEmpty() == true) {
+            Text("<none>")
+        }
+        typing?.inputs?.forEach {
+            Text("${it.key}: ${it.value.type}")
+        }
+
+        Spacer(Modifier.height(10.dp))
+
+        Text("Outputs", fontWeight = FontWeight.Bold)
+        if (typing?.outputs?.isEmpty() == true) {
+            Text("<none>")
+        }
+        typing?.outputs?.forEach {
+            Text("${it.key}: ${it.value.type}")
+        }
+    }
+}

composeApp/src/commonMain/kotlin/ManifestFetching.kt

@@ -4,23 +4,35 @@ import io.ktor.client.request.get
 import io.ktor.http.HttpStatusCode
 import kotlinx.serialization.decodeFromString
 
-suspend fun fetchManifest(actionCoords: String): Metadata? {
-    val yaml = listOf("yml", "yaml").firstNotNullOfOrNull { extension ->
+suspend fun fetchManifest(actionCoords: String): Metadata? =
+    fetchYaml(urlWithoutExtension = "https://raw.githubusercontent.com/${actionCoords.replace("@", "/")}/action")
+        ?.let { decodeYamlFromString(it) }
+
+suspend fun fetchTypingFromAction(actionCoords: String): Typing? =
+    fetchYaml(urlWithoutExtension = "https://raw.githubusercontent.com/${actionCoords.replace("@", "/")}/action-types")
+        ?.let { decodeYamlFromString(it) }
+
+suspend fun fetchTypingFromCatalog(actionCoords: String): Typing? =
+    fetchYaml(urlWithoutExtension = "https://raw.githubusercontent.com/typesafegithub/github-actions-typing-catalog/main/typings/${actionCoords.replace("@", "/")}/action-types")
+        ?.let { decodeYamlFromString(it) }
+
+suspend fun fetchYaml(urlWithoutExtension: String): String? =
+    listOf("yml", "yaml").firstNotNullOfOrNull { extension ->
         val response = client
-            .get(urlString = "https://raw.githubusercontent.com/${actionCoords.replace("@", "/")}/action.$extension")
+            .get(urlString = "${urlWithoutExtension}.$extension")
         if (response.status == HttpStatusCode.OK) {
             response.body<String>()
         } else {
             null
         }
-    } ?: return null
+    }
 
-    return try {
-        myYaml.decodeFromString<Metadata>(yaml)
+private inline fun <reified T> decodeYamlFromString(yaml: String): T? =
+    try {
+        myYaml.decodeFromString<T>(yaml)
     } catch (e: Exception) {
         println("Exception: $e")
         null
     }
-}
 
 private val myYaml = Yaml(configuration = Yaml.default.configuration.copy(strictMode = false))

composeApp/src/commonMain/kotlin/TypingsModel.kt

@@ -0,0 +1,42 @@
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class Typing(
+    val inputs: Map<String, ActionType> = emptyMap(),
+    val outputs: Map<String, ActionType> = emptyMap(),
+)
+
+@Serializable
+data class ActionType(
+    val type: ActionTypeEnum,
+    val name: String? = null,
+    @SerialName("named-values")
+    val namedValues: Map<String, Int> = emptyMap(),
+    val separator: String = "",
+    @SerialName("allowed-values")
+    val allowedValues: List<String> = emptyList(),
+    @SerialName("list-item")
+    val listItem: ActionType? = null,
+)
+
+@Serializable
+enum class ActionTypeEnum {
+    @SerialName("string")
+    String,
+
+    @SerialName("boolean")
+    Boolean,
+
+    @SerialName("integer")
+    Integer,
+
+    @SerialName("float")
+    Float,
+
+    @SerialName("list")
+    List,
+
+    @SerialName("enum")
+    Enum,
+}