Replace Kotlin lib with lib generated using openapi-codegen

.github/workflows/kotlin-lint.yml

@@ -21,12 +21,7 @@ jobs:
           distribution: 'temurin'
           java-version: '11'
 
-      - name: Regen openapi libs
-        run: |
-          yarn
-          ./regen_openapi.sh
-
       - name: Build
         run: |
           cd kotlin
-          ./gradlew build -x test
+          ./gradlew build

ChangeLog.md

@@ -1,12 +1,20 @@
 # Changelog
 
 ## Unreleased
+
+* Libs/Kotlin **(VERY IMPORTANT)**: The parameter order `appId` and `msgId` were swapped on `Message.get` and `Message.expungeContent`
+* Libs/C#, Libs/Go and Libs/Kotlin **(Breaking)**: All uses of `ListOptions`/`PostOptions` are removed, and renamed to `{Resource}{Operation}Options`. For example in `Endpoint.List` you would now use `EndpointListOptions`
+* Libs/Kotlin **(Breaking)**: In the 4 `*Patch` patch models, nullable fields are of type `MaybeUnset<T>` instead of `T`. call `MaybeUnset.Present(val)` to initialize this value
+* Libs/Kotlin **(Breaking)**: `SvixOptions` no longer has `initialRetryDelayMillis` or `numRetries` instead use `retrySchedule`
+* Libs/Kotlin **(Breaking)**: All `{Resource}{Operation}Options` and model classes (`ApplicationIn`/`MessageOut`) are now data classes
+* Libs/Kotlin **(Breaking)**: Deprecated functions `MessageAttempt.list` and `MessageAttempt.listAttemptsForEndpoint` are removed
+* Libs/Kotlin **(Breaking)**: All uses of `java.time.OffsetDateTime` replaced with `kotlinx.datetime.Instant`
+* Libs/Kotlin **(Breaking)**: All uses of `java.net.URL` in request/response models are replaced with `String`
 * Libs/Go: Add `Authentication.ExpireAll` (and `ExpireAllWithOptions`)
 * Libs/Go **(Breaking)**: Excluding specific fields on the *Patch models (`ApplicationPatch` for example), all `Nullable{Type}` removed from the models
 * Libs/Go **(Breaking)**: All `Nullable{Type}` (for example `NullableString`) are replaced with a new generic `Nullable[T]` type, the new type can be imported from `github.com/svix/svix-webhooks/go/utils`
 * Libs/Go **(Breaking)**: All custom model types are now imported from `github.com/svix/svix-webhooks/go/models` instead of `github.com/svix/svix-webhooks/go`
 * Libs/Go **(Breaking)**: All `-WithOptions` methods are now removed. Their regular counterparts now take a pointer to an Options type which can be nil when not needed. For example in `Endpoint.RecoverWithOptions` is now `Endpoint.Recover`
-* Libs/C# and Libs/Go **(Breaking)**: All uses of `ListOptions`/`PostOptions` are removed, and renamed to `{Resource}{Operation}Options`. For example in `Endpoint.List` you would now use `EndpointListOptions`
 * Libs/C# **(Breaking)**: All `IdempotencyKey` method parameters are removed, and are now part of `{Resource}{Operation}Options`. For example in `Message.Create`; to the use `IdempotencyKey`, simply pass it in the `MessageCreateOptions`
 * Libs/C# **(Breaking)**: The `Throw` parameter is removed from `SvixOptions`
 * Libs/C# **(Breaking)**: All redundant interfaces along with the `Svix.Abstractions` namespace are removed
@@ -17,15 +25,9 @@
 * Libs/Python **(Breaking)**: `EndpointStatsOptions` is renamed to `EndpointGetStatsOptions`
 * Libs/Python **(Breaking)**: `MessageAttemptListOptions` is removed in favor of call specific `{Resource}{Operation}Options`
 * Libs/Python **(Breaking)**: For `Statistics` in the `aggregate_event_types` method the `task_id` parameter is removed, Please note that previously this parameter was ignored and had no affect (Both sync and async)
-* Libs/Kotlin **(Breaking)**: Mark `api` field of all API resource classes as `private` (previously
-  only some were private, accidentally)
 * Libs/Kotlin **(Breaking)**: Update `recover` to return `RecoverOut` (instead of nothing)
 * Libs/Kotlin **(Breaking)**: Update `replayMissing` to return `ReplayOut` (instead of nothing)
 * Libs/Kotlin **(Breaking)**: Update `sendExample` to return `MessageOut` (instead of nothing)
-* Libs/Kotlin **(Breaking)**: Update `MessageAttempt` list methods to each have its own type for
-  list options, since they don't all support the exact same set of parameters and some of the
-  parameters that could be set before would just get ignored
-* Libs/Kotlin: Fix the parameter names of `Endpoint.get` - `appId` and `endpointId` were swapped
 * Libs/Kotlin: Fix a bug in `EventType.list` where `options.order` was not getting honored
 * Libs/Rust **(Breaking)**: Add optional `EventTypeDeleteOptions` parameter to `EventType::delete`
 * Libs/Rust **(Breaking)**: Add optional `options` parameters to `Endpoint::recover`,

kotlin/build.gradle

@@ -1,13 +1,5 @@
-group GROUP
-version VERSION_NAME
-
-wrapper {
-    gradleVersion = '8.7'
-    distributionUrl = "https://services.gradle.org/distributions/gradle-$gradleVersion-all.zip"
-}
-
 buildscript {
-    ext.kotlin_version = '1.9.23'
+    ext.kotlin_version = '2.1.10'
     ext.spotless_version = "6.25.0"
 
     repositories {
@@ -21,6 +13,21 @@ buildscript {
     }
 }
 
+plugins {
+    id 'org.jetbrains.kotlin.jvm' version '2.1.10'
+    id 'org.jetbrains.kotlin.plugin.serialization' version '2.1.10'
+}
+
+group GROUP
+version VERSION_NAME
+
+
+wrapper {
+    gradleVersion = '8.7'
+    distributionUrl = "https://services.gradle.org/distributions/gradle-$gradleVersion-all.zip"
+}
+
+
 apply plugin: 'kotlin'
 apply plugin: 'com.diffplug.spotless'
 
@@ -30,23 +37,29 @@ repositories {
 
 sourceSets {
     main.kotlin.srcDirs += 'lib/src/main/kotlin'
-    main.kotlin.srcDirs += 'lib/generated/openapi/src/main/kotlin'        
+    // main.kotlin.srcDirs += 'lib/generated/openapi/src/main/kotlin'
     sourceSets.test.kotlin.srcDirs = ["lib/src/test/main/kotlin"]
     test.kotlin.srcDirs = ['lib/src/test']
 }
 
 test {
     useJUnitPlatform()
+    testLogging {
+		events "failed"
+		exceptionFormat "full"
+	}
 }
 
 dependencies {
+    implementation 'org.jetbrains.kotlinx:kotlinx-datetime:0.6.2'
+    implementation 'org.jetbrains.kotlinx:kotlinx-serialization-json:1.8.0'
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
     implementation "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.2"
-    implementation "com.squareup.moshi:moshi-kotlin:1.12.0"
-    implementation "com.squareup.okhttp3:okhttp:4.9.1"
+    implementation "com.squareup.okhttp3:okhttp:4.12.0"
     testImplementation 'junit:junit:4.13.2'
     testImplementation 'org.jetbrains.kotlin:kotlin-test-junit5:1.5.21'
+    testImplementation "org.wiremock:wiremock:3.12.0"
 }
 
 jar {

kotlin/deploy.gradle

@@ -48,12 +48,10 @@ nexusPublishing {
 }
 
 task sourcesJar(type: Jar) {
-    classifier = "sources"
     from sourceSets.main.allSource
 }
 
 task javadocJar(type: Jar, dependsOn: javadoc) {
-    classifier = "javadoc"
     from javadoc.destinationDir
 }
 

kotlin/gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.4-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-all.zip
 zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists
+zipStorePath=wrapper/dists

kotlin/lib/src/main/kotlin/Application.kt

@@ -1,106 +1,103 @@
-// this file is @generated (with minor manual changes)
+// this file is @generated
 package com.svix.kotlin
 
-import com.svix.kotlin.exceptions.ApiException
-import com.svix.kotlin.internal.apis.ApplicationApi
 import com.svix.kotlin.models.ApplicationIn
 import com.svix.kotlin.models.ApplicationOut
 import com.svix.kotlin.models.ApplicationPatch
 import com.svix.kotlin.models.ListResponseApplicationOut
 import com.svix.kotlin.models.Ordering
+import okhttp3.Headers
 
-class ApplicationListOptions {
-    var limit: Int? = null
-    var iterator: String? = null
-    var order: Ordering? = null
+data class ApplicationListOptions(
+    val limit: ULong? = null,
+    val iterator: String? = null,
+    val order: Ordering? = null,
+)
 
-    /** Limit the number of returned items */
-    fun limit(limit: Int) = apply { this.limit = limit }
+data class ApplicationCreateOptions(val idempotencyKey: String? = null)
 
-    /** The iterator returned from a prior invocation */
-    fun iterator(iterator: String) = apply { this.iterator = iterator }
-
-    /** The sorting order of the returned items */
-    fun order(order: Ordering) = apply { this.order = order }
-}
-
-class Application internal constructor(token: String, options: SvixOptions) {
-    private val api = ApplicationApi(options.serverUrl)
-
-    init {
-        api.accessToken = token
-        api.userAgent = options.getUA()
-        options.initialRetryDelayMillis?.let { api.initialRetryDelayMillis = it }
-        options.numRetries?.let { api.numRetries = it }
-    }
+class Application(private val client: SvixHttpClient) {
 
     /** List of all the organization's applications. */
     suspend fun list(
         options: ApplicationListOptions = ApplicationListOptions()
     ): ListResponseApplicationOut {
-        try {
-            return api.v1ApplicationList(options.limit, options.iterator, options.order)
-        } catch (e: Exception) {
-            throw ApiException.wrap(e)
-        }
+        val url = client.newUrlBuilder().encodedPath("/api/v1/app")
+        options.limit?.let { url.addQueryParameter("limit", serializeQueryParam(it)) }
+        options.iterator?.let { url.addQueryParameter("iterator", it) }
+        options.order?.let { url.addQueryParameter("order", serializeQueryParam(it)) }
+        return client.executeRequest<Any, ListResponseApplicationOut>("GET", url.build())
     }
 
     /** Create a new application. */
     suspend fun create(
         applicationIn: ApplicationIn,
-        options: PostOptions = PostOptions(),
+        options: ApplicationCreateOptions = ApplicationCreateOptions(),
     ): ApplicationOut {
-        try {
-            return api.v1ApplicationCreate(applicationIn, null, options.idempotencyKey)
-        } catch (e: Exception) {
-            throw ApiException.wrap(e)
-        }
+        val url = client.newUrlBuilder().encodedPath("/api/v1/app")
+        val headers = Headers.Builder()
+        options.idempotencyKey?.let { headers.add("idempotency-key", it) }
+
+        return client.executeRequest<ApplicationIn, ApplicationOut>(
+            "POST",
+            url.build(),
+            headers = headers.build(),
+            reqBody = applicationIn,
+        )
     }
 
+    /** Get or create an application. */
     suspend fun getOrCreate(
         applicationIn: ApplicationIn,
-        options: PostOptions = PostOptions(),
+        options: ApplicationCreateOptions = ApplicationCreateOptions(),
     ): ApplicationOut {
-        try {
-            return api.v1ApplicationCreate(applicationIn, true, options.idempotencyKey)
-        } catch (e: Exception) {
-            throw ApiException.wrap(e)
-        }
+        val url =
+            client
+                .newUrlBuilder()
+                .encodedPath("/api/v1/app")
+                .addQueryParameter("get_if_exists", "true")
+        var headers = Headers.Builder()
+        options.idempotencyKey?.let { headers = headers.add("idempotency-key", it) }
+
+        return client.executeRequest<ApplicationIn, ApplicationOut>(
+            "POST",
+            url.build(),
+            headers = headers.build(),
+            reqBody = applicationIn,
+        )
     }
 
     /** Get an application. */
     suspend fun get(appId: String): ApplicationOut {
-        try {
-            return api.v1ApplicationGet(appId)
-        } catch (e: Exception) {
-            throw ApiException.wrap(e)
-        }
+        val url = client.newUrlBuilder().encodedPath("/api/v1/app/$appId")
+        return client.executeRequest<Any, ApplicationOut>("GET", url.build())
     }
 
     /** Update an application. */
     suspend fun update(appId: String, applicationIn: ApplicationIn): ApplicationOut {
-        try {
-            return api.v1ApplicationUpdate(appId, applicationIn)
-        } catch (e: Exception) {
-            throw ApiException.wrap(e)
-        }
+        val url = client.newUrlBuilder().encodedPath("/api/v1/app/$appId")
+
+        return client.executeRequest<ApplicationIn, ApplicationOut>(
+            "PUT",
+            url.build(),
+            reqBody = applicationIn,
+        )
     }
 
     /** Delete an application. */
     suspend fun delete(appId: String) {
-        try {
-            api.v1ApplicationDelete(appId)
-        } catch (e: Exception) {
-            throw ApiException.wrap(e)
-        }
+        val url = client.newUrlBuilder().encodedPath("/api/v1/app/$appId")
+        client.executeRequest<Any, Boolean>("DELETE", url.build())
     }
 
     /** Partially update an application. */
     suspend fun patch(appId: String, applicationPatch: ApplicationPatch): ApplicationOut {
-        try {
-            return api.v1ApplicationPatch(appId, applicationPatch)
-        } catch (e: Exception) {
-            throw ApiException.wrap(e)
-        }
+        val url = client.newUrlBuilder().encodedPath("/api/v1/app/$appId")
+
+        return client.executeRequest<ApplicationPatch, ApplicationOut>(
+            "PATCH",
+            url.build(),
+            reqBody = applicationPatch,
+        )
     }
 }