feat(client): ensure compat with proguard

Author: stainless-app[bot]

README.md

@@ -362,6 +362,12 @@ both of which will raise an error if the signature is invalid.
 Note that the "body" parameter must be the raw JSON string sent from the server (do not parse it first).
 The `.unwrap()` method can parse this JSON for you.
 
+## ProGuard and R8
+
+Although the SDK uses reflection, it is still usable with [ProGuard](https://github.com/Guardsquare/proguard) and [R8](https://developer.android.com/topic/performance/app-optimization/enable-app-optimization) because `lithic-java-core` is published with a [configuration file](lithic-java-core/src/main/resources/META-INF/proguard/lithic-java-core.pro) containing [keep rules](https://www.guardsquare.com/manual/configuration/usage).
+
+ProGuard and R8 should automatically detect and use the published rules, but you can also manually copy the keep rules if necessary.
+
 ## Jackson
 
 The SDK depends on [Jackson](https://github.com/FasterXML/jackson) for JSON serialization/deserialization. It is compatible with version 2.13.4 or higher, but depends on version 2.18.2 by default.

lithic-java-core/src/main/resources/META-INF/proguard/lithic-java-core.pro

@@ -0,0 +1,32 @@
+# Jackson uses reflection and depends heavily on runtime attributes.
+-keepattributes
+
+# Jackson uses Kotlin reflection utilities, which themselves use reflection to access things.
+-keep class kotlin.reflect.** { *; }
+-keep class kotlin.Metadata { *; }
+
+# Jackson uses reflection to access enum members (e.g. via `java.lang.Class.getEnumConstants()`).
+-keepclassmembers class com.fasterxml.jackson.** extends java.lang.Enum {
+    <fields>;
+    public static **[] values();
+    public static ** valueOf(java.lang.String);
+}
+
+# Jackson uses reflection to access annotation members.
+-keepclassmembers @interface com.fasterxml.jackson.annotation.** {
+    *;
+}
+
+# Jackson uses reflection to access the default constructors of serializers and deserializers.
+-keepclassmembers class * extends com.lithic.api.core.BaseSerializer {
+    <init>();
+}
+-keepclassmembers class * extends com.lithic.api.core.BaseDeserializer {
+    <init>();
+}
+
+# Jackson uses reflection to serialize and deserialize our classes based on their constructors and annotated members.
+-keepclassmembers class com.lithic.api.** {
+    <init>(...);
+    @com.fasterxml.jackson.annotation.* *;
+}

lithic-java-proguard-test/build.gradle.kts

@@ -0,0 +1,74 @@
+plugins {
+    id("lithic.kotlin")
+    id("com.gradleup.shadow") version "8.3.8"
+}
+
+buildscript {
+    dependencies {
+        classpath("com.guardsquare:proguard-gradle:7.4.2")
+    }
+}
+
+dependencies {
+    testImplementation(project(":lithic-java"))
+    testImplementation(kotlin("test"))
+    testImplementation("org.junit.jupiter:junit-jupiter-api:5.9.3")
+    testImplementation("org.assertj:assertj-core:3.25.3")
+    testImplementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.13.4")
+    testImplementation("org.junit.platform:junit-platform-console:1.10.1")
+}
+
+tasks.shadowJar {
+    from(sourceSets.test.get().output)
+    configurations = listOf(project.configurations.testRuntimeClasspath.get())
+}
+
+val proguardJarPath = "${layout.buildDirectory.get()}/libs/${project.name}-${project.version}-proguard.jar"
+val proguardJar by tasks.registering(proguard.gradle.ProGuardTask::class) {
+    group = "verification"
+    dependsOn(tasks.shadowJar)
+    notCompatibleWithConfigurationCache("ProGuard")
+
+    injars(tasks.shadowJar)
+    outjars(proguardJarPath)
+    printmapping("${layout.buildDirectory.get()}/proguard-mapping.txt")
+
+    verbose()
+    dontwarn()
+
+    val javaHome = System.getProperty("java.home")
+    if (System.getProperty("java.version").startsWith("1.")) {
+        // Before Java 9, the runtime classes were packaged in a single jar file.
+        libraryjars("$javaHome/lib/rt.jar")
+    } else {
+        // As of Java 9, the runtime classes are packaged in modular jmod files.
+        libraryjars(
+            // Filters must be specified first, as a map.
+            mapOf("jarfilter" to "!**.jar", "filter" to "!module-info.class"),
+            "$javaHome/jmods/java.base.jmod"
+        )
+    }
+
+    configuration("./test.pro")
+    configuration("../lithic-java-core/src/main/resources/META-INF/proguard/lithic-java-core.pro")
+}
+
+val testProGuard by tasks.registering(JavaExec::class) {
+    group = "verification"
+    dependsOn(proguardJar)
+    notCompatibleWithConfigurationCache("ProGuard")
+
+    mainClass.set("org.junit.platform.console.ConsoleLauncher")
+    classpath = files(proguardJarPath)
+    args = listOf(
+        "--classpath", proguardJarPath,
+        "--scan-classpath",
+        "--details", "verbose",
+    )
+}
+
+tasks.test {
+    dependsOn(testProGuard)
+    // We defer to the tests run via the ProGuard JAR.
+    enabled = false
+}