Merge pull request #654 from gsmet/support-no-installation

Support events not containing an installation

Author: gsmet

deployment/src/main/java/io/quarkiverse/githubapp/deployment/GitHubAppProcessor.java

@@ -58,6 +58,7 @@
 
 import io.quarkiverse.githubapp.ConfigFile;
 import io.quarkiverse.githubapp.GitHubEvent;
+import io.quarkiverse.githubapp.TokenGitHubClients;
 import io.quarkiverse.githubapp.deployment.DispatchingConfiguration.EventAnnotation;
 import io.quarkiverse.githubapp.deployment.DispatchingConfiguration.EventAnnotationLiteral;
 import io.quarkiverse.githubapp.deployment.DispatchingConfiguration.EventDispatchingConfiguration;
@@ -106,6 +107,8 @@
 import io.quarkus.deployment.builditem.nativeimage.ReflectiveClassBuildItem;
 import io.quarkus.deployment.builditem.nativeimage.ReflectiveHierarchyBuildItem;
 import io.quarkus.gizmo.AnnotatedElement;
+import io.quarkus.gizmo.AssignableResultHandle;
+import io.quarkus.gizmo.BranchResult;
 import io.quarkus.gizmo.BytecodeCreator;
 import io.quarkus.gizmo.CatchBlockCreator;
 import io.quarkus.gizmo.ClassCreator;
@@ -221,7 +224,8 @@ void additionalBeans(CombinedIndexBuildItem index, BuildProducer<AdditionalBeanB
                 DefaultErrorHandler.class,
                 GitHubFileDownloader.class,
                 GitHubConfigFileProviderImpl.class,
-                CheckedConfigProvider.class)
+                CheckedConfigProvider.class,
+                TokenGitHubClients.class)
                 .setUnremovable();
 
         for (ClassInfo errorHandler : index.getIndex().getAllKnownImplementors(GitHubAppDotNames.ERROR_HANDLER)) {
@@ -554,24 +558,45 @@ private static void generateDispatcher(ClassOutput beanClassOutput,
 
         TryBlock tryBlock = dispatchMethodCreator.tryBlock();
 
-        ResultHandle gitHubRh = tryBlock.invokeVirtualMethod(
+        // if the installation id is defined, we can push the installation client
+        // if not, we have to use the very limited application client
+        AssignableResultHandle gitHubRh = tryBlock.createVariable(GitHub.class);
+        AssignableResultHandle gitHubGraphQLClientRh = tryBlock.createVariable(DynamicGraphQLClient.class);
+        BranchResult testInstallationId = tryBlock.ifNotNull(installationIdRh);
+        BytecodeCreator installationIdSet = testInstallationId.trueBranch();
+        installationIdSet.assign(gitHubRh, installationIdSet.invokeVirtualMethod(
                 MethodDescriptor.ofMethod(GitHubService.class, "getInstallationClient", GitHub.class, long.class),
-                tryBlock.readInstanceField(
+                installationIdSet.readInstanceField(
                         FieldDescriptor.of(dispatcherClassCreator.getClassName(), GITHUB_SERVICE_FIELD, GitHubService.class),
-                        tryBlock.getThis()),
-                installationIdRh);
-
-        ResultHandle gitHubGraphQLClientRh = tryBlock.loadNull();
-
+                        installationIdSet.getThis()),
+                installationIdRh));
         if (dispatchingConfiguration.requiresGraphQLClient()) {
-            gitHubGraphQLClientRh = tryBlock.invokeVirtualMethod(
+            installationIdSet.assign(gitHubGraphQLClientRh, installationIdSet.invokeVirtualMethod(
                     MethodDescriptor.ofMethod(GitHubService.class, "getInstallationGraphQLClient", DynamicGraphQLClient.class,
                             long.class),
-                    tryBlock.readInstanceField(
+                    installationIdSet.readInstanceField(
                             FieldDescriptor.of(dispatcherClassCreator.getClassName(), GITHUB_SERVICE_FIELD,
                                     GitHubService.class),
-                            tryBlock.getThis()),
-                    installationIdRh);
+                            installationIdSet.getThis()),
+                    installationIdRh));
+        } else {
+            installationIdSet.assign(gitHubGraphQLClientRh, installationIdSet.loadNull());
+        }
+        BytecodeCreator installationIdNull = testInstallationId.falseBranch();
+        installationIdNull.assign(gitHubRh, installationIdNull.invokeVirtualMethod(
+                MethodDescriptor.ofMethod(GitHubService.class, "getTokenOrApplicationClient", GitHub.class),
+                installationIdNull.readInstanceField(
+                        FieldDescriptor.of(dispatcherClassCreator.getClassName(), GITHUB_SERVICE_FIELD, GitHubService.class),
+                        installationIdNull.getThis())));
+        if (dispatchingConfiguration.requiresGraphQLClient()) {
+            installationIdNull.assign(gitHubGraphQLClientRh, installationIdNull.invokeVirtualMethod(
+                    MethodDescriptor.ofMethod(GitHubService.class, "getTokenGraphQLClientOrNull", DynamicGraphQLClient.class),
+                    installationIdNull.readInstanceField(
+                            FieldDescriptor.of(dispatcherClassCreator.getClassName(), GITHUB_SERVICE_FIELD,
+                                    GitHubService.class),
+                            installationIdNull.getThis())));
+        } else {
+            installationIdNull.assign(gitHubGraphQLClientRh, installationIdNull.loadNull());
         }
 
         for (EventDispatchingConfiguration eventDispatchingConfiguration : dispatchingConfiguration.getEventConfigurations()

deployment/src/test/java/io/quarkiverse/githubapp/deployment/TokenGitHubClientsInjectionTest.java

@@ -0,0 +1,41 @@
+package io.quarkiverse.githubapp.deployment;
+
+import jakarta.inject.Inject;
+
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.kohsuke.github.GHEventPayload;
+
+import io.quarkiverse.githubapp.TokenGitHubClients;
+import io.quarkiverse.githubapp.event.Label;
+import io.quarkus.test.QuarkusUnitTest;
+
+public class TokenGitHubClientsInjectionTest {
+
+    @RegisterExtension
+    static final QuarkusUnitTest config = new QuarkusUnitTest()
+            .setArchiveProducer(() -> ShrinkWrap.create(JavaArchive.class)
+                    .addClass(ListeningClass.class).addClass(ListeningClass2.class))
+            .withConfigurationResource("application-token.properties");
+
+    @Test
+    public void testGitHubGraphQLClientInjection() {
+    }
+
+    static class ListeningClass {
+
+        @Inject
+        TokenGitHubClients tokenGitHubClients;
+
+        void createLabel(@Label.Created GHEventPayload.Label labelPayload) {
+        }
+    }
+
+    static class ListeningClass2 {
+
+        void createLabel(@Label.Created GHEventPayload.Label labelPayload, TokenGitHubClients tokenGitHubClients) {
+        }
+    }
+}

deployment/src/test/resources/application-token.properties

@@ -0,0 +1,2 @@
+quarkus.github-app.app-name=quarkus-github-app-test
+quarkus.github-app.personal-access-token=ghp_mytoken

docs/modules/ROOT/pages/developer-reference.adoc

@@ -343,11 +343,41 @@ The injected `DynamicGraphQLClient` instance is authenticated as an installation
 `DynamicGraphQLClient` is a dynamic SmallRye GraphQL client.
 You can find more information about the SmallRye GraphQL client https://quarkus.io/guides/smallrye-graphql-client[here] and https://github.com/smallrye/smallrye-graphql[here].
 
-== Configuration Reference
+== Webhook events
 
-The Quarkus GitHub App extension exposes the following configuration properties:
+While Quarkus GitHub App was primarily designed as a tool to develop GitHub Apps,
+it is also possible to use it to handle your webhook requests.
 
-include::includes/quarkus-github-app.adoc[]
+It will take care of all the ceremony of authenticating the requests and will save you a lot of boilerplate.
+
+There are a few differences though:
+
+- You will have to use `@RawEvent` to listen to the events and get the raw JSON of the payload.
+- Webhook requests don't provide an installation id so we can't initialize an installation GitHub client nor a GraphQL client.
+
+The default `GitHub` REST client instance that can be injected is an application client and has so few permissions that it is not really useful.
+
+While it could be a major inconvenience, we present a nice feature dedicated to this use case in the following section.
+
+== Providing a personal access token
+
+When using Quarkus GitHub App, in most cases, the REST and GraphQL clients provided by the installation are what you are looking for:
+they have the permissions allowed for this GitHub App and it should be enough to do what your GitHub App has been designed for.
+
+However, there are corner cases where you might need a client with additional permissions,
+the most common one is when you deal with webhooks as presented in the previous section.
+
+For this situation, you can define a personal access token by using the `quarkus.github-app.personal-access-token` configuration property.
+The personal access token provided in this property will be used to initialize:
+
+- an authenticated `GitHub` REST client
+- an authenticated `DynamicGraphQL` GraphQL client
+
+These clients will be automatically injected in your methods when injecting clients *if the payload doesn't provide an installation id*
+(if it does provide one, the regular installation clients will be injected).
+
+It is also possible to directly obtain the clients authenticated with the personal access token by injecting the `TokenGitHubClients` CDI bean.
+It provides methods to get the authenticated REST and GraphQL clients.
 
 == Credentials provider
 
@@ -389,6 +419,12 @@ public class MyGitHubCustomizer implements GitHubCustomizer {
 }
 ----
 
+== Configuration Reference
+
+The Quarkus GitHub App extension exposes the following configuration properties:
+
+include::includes/quarkus-github-app.adoc[]
+
 == Architecture Overview
 
 image::architecture.png[Architecture]

docs/modules/ROOT/pages/includes/attributes.adoc

@@ -1,4 +1,4 @@
-:quarkus-version: 3.11.3
+:quarkus-version: 3.13.3
 :quarkus-github-app-version: 2.6.0
 
 :github-api-javadoc-root-url: https://github-api.kohsuke.org/apidocs/org/kohsuke/github

docs/modules/ROOT/pages/includes/quarkus-github-app.adoc

@@ -241,6 +241,29 @@ endif::add-copy-button-to-env-var[]
 |`${quarkus.github-app.instance-endpoint}/graphql`
 
 
+a| [[quarkus-github-app_quarkus-github-app-personal-access-token]]`link:#quarkus-github-app_quarkus-github-app-personal-access-token[quarkus.github-app.personal-access-token]`
+
+
+[.description]
+--
+A personal access token for use with `TokenGitHubClients`.
+
+For standard use cases, you will use the installation client which comes with the installation permissions. It can be injected directly in your method.
+
+However, if your payload comes from a webhook and doesn't have an installation id, it's handy to be able to use a client authenticated with a personal access token as the application client permissions are very limited.
+
+This token will be used to authenticate the clients provided by `TokenGitHubClients`.
+
+ifdef::add-copy-button-to-env-var[]
+Environment variable: env_var_with_copy_button:+++QUARKUS_GITHUB_APP_PERSONAL_ACCESS_TOKEN+++[]
+endif::add-copy-button-to-env-var[]
+ifndef::add-copy-button-to-env-var[]
+Environment variable: `+++QUARKUS_GITHUB_APP_PERSONAL_ACCESS_TOKEN+++`
+endif::add-copy-button-to-env-var[]
+--|string 
+|
+
+
 a| [[quarkus-github-app_quarkus-github-app-debug-payload-directory]]`link:#quarkus-github-app_quarkus-github-app-debug-payload-directory[quarkus.github-app.debug.payload-directory]`
 
 

integration-tests/app/src/main/java/io/quarkiverse/githubapp/it/app/RawEventListener.java

@@ -6,11 +6,12 @@
 
 import io.quarkiverse.githubapp.GitHubEvent;
 import io.quarkiverse.githubapp.event.RawEvent;
+import io.smallrye.graphql.client.dynamic.api.DynamicGraphQLClient;
 
 public class RawEventListener {
 
-    void testRawEventListenedTo(@RawEvent(event = "issues", action = "opened") GitHubEvent gitHubEvent, GitHub gitHub)
-            throws IOException {
+    void testRawEventListenedTo(@RawEvent(event = "issues", action = "opened") GitHubEvent gitHubEvent, GitHub gitHub,
+            DynamicGraphQLClient graphQLClient) throws IOException {
         assert gitHubEvent.getEvent().equals("issues");
         assert gitHubEvent.getAction().equals("opened");
 
@@ -35,8 +36,8 @@ void testRawEventCatchAllAction(@RawEvent(event = "issues") GitHubEvent gitHubEv
     }
 
     void testRawEventCatchAllEventAction(@RawEvent GitHubEvent gitHubEvent, GitHub gitHub) throws IOException {
-        assert gitHubEvent.getEvent().equals("issues");
-        assert gitHubEvent.getAction().equals("opened");
+        assert gitHubEvent.getEvent() != null;
+        assert gitHubEvent.getAction() != null;
 
         gitHub.getRepository("test/test").getIssue(1).addLabels("testRawEventCatchAllEventAction");
     }

integration-tests/app/src/main/java/io/quarkiverse/githubapp/it/app/RawEventListenerWithoutInstallation.java

@@ -0,0 +1,26 @@
+package io.quarkiverse.githubapp.it.app;
+
+import java.io.IOException;
+
+import org.kohsuke.github.GitHub;
+
+import io.quarkiverse.githubapp.GitHubEvent;
+import io.quarkiverse.githubapp.event.RawEvent;
+import io.smallrye.graphql.client.dynamic.api.DynamicGraphQLClient;
+
+public class RawEventListenerWithoutInstallation {
+
+    public static final String EVENT_TYPE = "sponsor";
+
+    void testRawEventListenerWithoutInstallation(@RawEvent(event = EVENT_TYPE, action = "sponsored") GitHubEvent gitHubEvent,
+            GitHub gitHub,
+            DynamicGraphQLClient graphQLClient) throws IOException {
+        assert gitHubEvent.getEvent().equals(EVENT_TYPE);
+        assert gitHubEvent.getAction().equals("sponsored");
+
+        assert graphQLClient != null;
+        assert gitHub != null;
+
+        gitHub.getRepository("test/test").getIssue(1).addLabels("testRawEventListenerWithoutInstallation");
+    }
+}

integration-tests/app/src/main/resources/application.properties

@@ -28,3 +28,4 @@ E0/FAoGATJvuAfgy9uiKR7za7MigYVacE0u4aD1sF7v6D4AFqBOGquPQQhePSdz9\
 G/UUwySoo+AQ+rd2EPhyexjqXBhRGe+EDGFVFivaQzTT8/5bt/VddbTcw2IpmXYj\
 LW6V8BbcP5MRhd2JQSRh16nWwSQJ2BdpUZFwayEEQ6UcrMfqvA0=\
 -----END RSA PRIVATE KEY-----
+%test.quarkus.github-app.personal-access-token=ghp_mytoken

integration-tests/app/src/test/java/io/quarkiverse/githubapp/it/app/RawEventWithoutInstallationTest.java

@@ -0,0 +1,33 @@
+package io.quarkiverse.githubapp.it.app;
+
+import static io.quarkiverse.githubapp.testing.GitHubAppTesting.given;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.io.IOException;
+
+import org.junit.jupiter.api.Test;
+
+import io.quarkiverse.githubapp.testing.GitHubAppTest;
+import io.quarkus.test.junit.QuarkusTest;
+
+@QuarkusTest
+@GitHubAppTest
+public class RawEventWithoutInstallationTest {
+
+    @Test
+    void testRawEventWithoutInstallation() throws IOException {
+        given().github(mocks -> {
+            when(mocks.repository("test/test").getIssue(1))
+                    .thenReturn(mocks.issue(1L));
+        })
+                .when().payloadFromClasspath("/event-without-installation.json")
+                .rawEvent(RawEventListenerWithoutInstallation.EVENT_TYPE)
+                .then().github(mocks -> {
+                    verify(mocks.issue(1))
+                            .addLabels("testRawEventListenerWithoutInstallation");
+                    verify(mocks.issue(1))
+                            .addLabels("testRawEventCatchAllEventAction");
+                });
+    }
+}