open-api/kotlin: catch up

jknack · jknack · commit a261e78539ac · 2025-08-03T11:45:59.000-03:00
- kotlin: sync runApp funcion fix #3743 - open-api/kotlin: it fails to parse new server bootstrap fix #3746
diff --git a/modules/jooby-kotlin/src/main/kotlin/io/jooby/kt/Kooby.kt b/modules/jooby-kotlin/src/main/kotlin/io/jooby/kt/Kooby.kt
@@ -313,26 +313,50 @@ fun cors(init: Cors.() -> Unit): Cors {
 }
 
 /** runApp: */
+// Consumers:
+fun runApp(args: Array<String>, init: Kooby.() -> Unit) {
+  runApp(args, ExecutionMode.DEFAULT, init)
+}
+
 fun runApp(args: Array<String>, mode: ExecutionMode, init: Kooby.() -> Unit) {
-  configurePackage(init)
-  Jooby.runApp(args, mode, fun() = Kooby(init))
+  runApp(args, Server.loadServer(), mode, init)
 }
 
-fun runApp(args: Array<String>, init: Kooby.() -> Unit) {
+fun runApp(args: Array<String>, server: Server, init: Kooby.() -> Unit) {
+  runApp(args, server, ExecutionMode.DEFAULT, init)
+}
+
+fun runApp(args: Array<String>, server: Server, mode: ExecutionMode, init: Kooby.() -> Unit) {
   configurePackage(init)
-  Jooby.runApp(args, ExecutionMode.DEFAULT, fun() = Kooby(init))
+  Jooby.runApp(args, server, mode, fun() = Kooby(init))
 }
 
+// Suppliers:
 fun <T : Jooby> runApp(args: Array<String>, provider: () -> T) {
   runApp(args, ExecutionMode.DEFAULT, provider)
 }
 
+fun <T : Jooby> runApp(args: Array<String>, server: Server, provider: () -> T) {
+  runApp(args, server, ExecutionMode.DEFAULT, provider)
+}
+
 fun <T : Jooby> runApp(args: Array<String>, mode: ExecutionMode, provider: () -> T) {
-  Jooby.runApp(args, mode, provider)
+  runApp(args, Server.loadServer(), mode, provider)
+}
+
+fun <T : Jooby> runApp(
+  args: Array<String>,
+  server: Server,
+  mode: ExecutionMode,
+  provider: () -> T,
+) {
+  configurePackage(provider)
+  Jooby.runApp(args, server, mode, provider)
 }
 
+// List of Suppliers:
 fun <T : Jooby> runApp(args: Array<String>, vararg provider: () -> T) {
-  runApp(args, Server.loadServer(), ExecutionMode.DEFAULT, *provider)
+  runApp(args, ExecutionMode.DEFAULT, *provider)
 }
 
 fun <T : Jooby> runApp(args: Array<String>, mode: ExecutionMode, vararg provider: () -> T) {
diff --git a/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/RouteParser.java b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/RouteParser.java
@@ -14,7 +14,6 @@
 import static io.jooby.internal.openapi.TypeFactory.KT_FUN_1;
 import static io.jooby.internal.openapi.TypeFactory.OBJECT;
 import static io.jooby.internal.openapi.TypeFactory.STRING;
-import static io.jooby.internal.openapi.TypeFactory.STRING_ARRAY;
 import static org.objectweb.asm.Opcodes.GETSTATIC;
 
 import java.lang.reflect.Modifier;
@@ -420,7 +419,8 @@ private List<OperationExt> routeHandler(ParserContext ctx, String prefix, Method
                   ctx,
                   prefix,
                   node,
-                  signature.matches("runApp", STRING_ARRAY, TypeFactory.KT_FUN_0)));
+                  signature.endsWith("runApp", TypeFactory.KT_FUN_0)
+                      || signature.endsWith("runApp", TypeFactory.KT_FUN_0_ARRAY)));
         } else if (signature.matches(Route.class, "produces", MediaType[].class)) {
           if (instructionTo != null) {
             OperationExt route = handlerList.get(handlerList.size() - 1);
diff --git a/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/Signature.java b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/Signature.java
@@ -53,6 +53,16 @@ public boolean matches(String method, Type... parameterTypes) {
     return false;
   }
 
+  public boolean endsWith(String method, Type parameterType) {
+    if (matches(method)) {
+      return argumentTypes.length > 0
+          && argumentTypes[argumentTypes.length - 1]
+              .getInternalName()
+              .equals(parameterType.getInternalName());
+    }
+    return false;
+  }
+
   public boolean matches(Class owner, String method, Class... parameterTypes) {
     if (Type.getType(owner).equals(this.owner)) {
       return matches(method, parameterTypes);
diff --git a/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/TypeFactory.java b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/TypeFactory.java
@@ -46,6 +46,7 @@ public class TypeFactory {
   public static final Type KT_KLASS = Type.getType("Lkotlin/reflect/KClass;");
 
   public static final Type KT_FUN_0 = Type.getType("Lkotlin/jvm/functions/Function0;");
+  public static final Type KT_FUN_0_ARRAY = Type.getType("[Lkotlin/jvm/functions/Function0;");
 
   public static final Type KT_FUN_1 = Type.getType("Lkotlin/jvm/functions/Function1;");
 
diff --git a/modules/jooby-openapi/src/test/java/issues/i3746/Issue3746.java b/modules/jooby-openapi/src/test/java/issues/i3746/Issue3746.java
@@ -0,0 +1,49 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package issues.i3746;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import io.jooby.openapi.OpenAPITest;
+import io.jooby.openapi.RouteIterator;
+import kt.i3746.RunAppInlineWithServerKt;
+import kt.i3746.RunAppInlineWithServerModeKt;
+import kt.i3746.RunAppWithServerKt;
+import kt.i3746.RunAppWithServerModeKt;
+
+public class Issue3746 {
+
+  @OpenAPITest(value = RunAppWithServerKt.class)
+  public void shouldParseRunAppWithServer(RouteIterator iterator) {
+    checkApp(iterator);
+  }
+
+  @OpenAPITest(value = RunAppInlineWithServerKt.class)
+  public void shouldParseRunAppInlineWithServer(RouteIterator iterator) {
+    checkApp(iterator);
+  }
+
+  @OpenAPITest(value = RunAppInlineWithServerModeKt.class)
+  public void shouldParseRunAppInlineWithServerMode(RouteIterator iterator) {
+    checkApp(iterator);
+  }
+
+  @OpenAPITest(value = RunAppWithServerModeKt.class)
+  public void shouldParseRunAppWithServerMode(RouteIterator iterator) {
+    checkApp(iterator);
+  }
+
+  private static void checkApp(RouteIterator iterator) {
+    iterator
+        .next(
+            route -> {
+              assertEquals("GET /3746", route.toString());
+              assertEquals(Object.class.getName(), route.getDefaultResponse().getJavaType());
+              assertEquals("get3746", route.getOperationId());
+            })
+        .verify();
+  }
+}
diff --git a/modules/jooby-openapi/src/test/kotlin/kt/i3746/App3746.kt b/modules/jooby-openapi/src/test/kotlin/kt/i3746/App3746.kt
@@ -0,0 +1,10 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package kt.i3746
+
+import io.jooby.kt.Kooby
+
+class App3746 : Kooby({ get("/3746") { ctx.requestPath } })
diff --git a/modules/jooby-openapi/src/test/kotlin/kt/i3746/RunAppInlineWithServer.kt b/modules/jooby-openapi/src/test/kotlin/kt/i3746/RunAppInlineWithServer.kt
@@ -0,0 +1,12 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package kt.i3746
+
+import io.jooby.kt.runApp
+
+fun main(args: Array<String>) {
+  runApp(args, Server3746()) { get("/3746") { ctx.requestPath } }
+}
diff --git a/modules/jooby-openapi/src/test/kotlin/kt/i3746/RunAppInlineWithServerMode.kt b/modules/jooby-openapi/src/test/kotlin/kt/i3746/RunAppInlineWithServerMode.kt
@@ -0,0 +1,13 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package kt.i3746
+
+import io.jooby.ExecutionMode
+import io.jooby.kt.runApp
+
+fun main(args: Array<String>) {
+  runApp(args, Server3746(), ExecutionMode.WORKER) { get("/3746") { ctx.requestPath } }
+}
diff --git a/modules/jooby-openapi/src/test/kotlin/kt/i3746/RunAppWithServer.kt b/modules/jooby-openapi/src/test/kotlin/kt/i3746/RunAppWithServer.kt
@@ -0,0 +1,12 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package kt.i3746
+
+import io.jooby.kt.runApp
+
+fun main(args: Array<String>) {
+  runApp(args, Server3746(), ::App3746)
+}
diff --git a/modules/jooby-openapi/src/test/kotlin/kt/i3746/RunAppWithServerMode.kt b/modules/jooby-openapi/src/test/kotlin/kt/i3746/RunAppWithServerMode.kt
@@ -0,0 +1,13 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package kt.i3746
+
+import io.jooby.ExecutionMode
+import io.jooby.kt.runApp
+
+fun main(args: Array<String>) {
+  runApp(args, Server3746(), ExecutionMode.EVENT_LOOP, ::App3746)
+}
diff --git a/modules/jooby-openapi/src/test/kotlin/kt/i3746/Server3746.kt b/modules/jooby-openapi/src/test/kotlin/kt/i3746/Server3746.kt
@@ -0,0 +1,28 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package kt.i3746
+
+import io.jooby.Jooby
+import io.jooby.Server
+import io.jooby.output.OutputFactory
+
+class Server3746 : Server.Base() {
+  override fun getOutputFactory(): OutputFactory {
+    TODO("Not yet implemented")
+  }
+
+  override fun getName(): String {
+    TODO("Not yet implemented")
+  }
+
+  override fun start(vararg application: Jooby?): Server {
+    TODO("Not yet implemented")
+  }
+
+  override fun stop(): Server {
+    TODO("Not yet implemented")
+  }
+}
diff --git a/tests/src/test/java/io/jooby/i3743/EnsureRunAppTest.java b/tests/src/test/java/io/jooby/i3743/EnsureRunAppTest.java
@@ -0,0 +1,65 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package io.jooby.i3743;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Type;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.Test;
+
+import io.jooby.Jooby;
+import io.jooby.kt.KoobyKt;
+
+public class EnsureRunAppTest {
+  private static final Map<Type, Type> TO_JAVA =
+      Map.of(
+          kotlin.jvm.functions.Function0.class, Supplier.class,
+          kotlin.jvm.functions.Function1.class, Consumer.class,
+          kotlin.jvm.functions.Function0[].class, List.class);
+
+  @Test
+  public void ensureRunApp() {
+    var javaRunApp = runAppMethods(Jooby.class);
+    var kotlinRunApp = runAppMethods(KoobyKt.class);
+    assertEquals(javaRunApp.size(), kotlinRunApp.size());
+    for (var method : javaRunApp) {
+      kotlinRunApp.stream()
+          .filter(it -> matches(method.getParameterTypes(), it.getParameterTypes()))
+          .findFirst()
+          .orElseThrow(() -> new AssertionError("Method " + method + " not found on Kotlin"));
+    }
+  }
+
+  private static List<Method> runAppMethods(Class<?> owner) {
+    return Stream.of(owner.getDeclaredMethods())
+        .filter(method -> method.getName().equals("runApp"))
+        .filter(
+            method ->
+                Modifier.isStatic(method.getModifiers())
+                    && Modifier.isPublic(method.getModifiers()))
+        .toList();
+  }
+
+  private boolean matches(Class<?>[] javaParams, Class<?>[] ktParams) {
+    if (javaParams.length != ktParams.length) {
+      return false;
+    }
+    for (int i = 0; i < javaParams.length; i++) {
+      if (!javaParams[i].equals(TO_JAVA.getOrDefault(ktParams[i], ktParams[i]))) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
