@apollo-deploy/tesseract 0.9.1 → 1.2.0

package/templates/kotlin/build-gradle.hbs

@@ -0,0 +1,151 @@
+plugins {
+    kotlin("jvm") version "1.9.25"
+    kotlin("plugin.serialization") version "1.9.25"
+    `java-library`
+    `maven-publish`
+    signing
+}
+
+group = {{json groupId}}
+version = {{#if packageVersion}}{{json packageVersion}}{{else}}"0.1.0"{{/if}}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    api(kotlin("stdlib"))
+    api("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.3")
+    api("io.ktor:ktor-client-core:2.3.12")
+
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.1")
+    implementation("io.ktor:ktor-client-cio:2.3.12")
+    implementation("io.ktor:ktor-client-content-negotiation:2.3.12")
+    implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.12")
+
+    testImplementation(kotlin("test"))
+    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.8.1")
+}
+
+kotlin {
+    jvmToolchain(17)
+}
+
+tasks.test {
+    useJUnitPlatform()
+}
+
+java {
+    withSourcesJar()
+    withJavadocJar()
+}
+
+publishing {
+    publications {
+        create<MavenPublication>("maven") {
+            groupId = project.group.toString()
+            artifactId = {{json artifactId}}
+            version = project.version.toString()
+
+            from(components["java"])
+
+            pom {
+                name.set({{json title}})
+                description.set({{json pomDescription}})
+
+                providers.gradleProperty("pomUrl")
+                    .orElse(providers.environmentVariable("POM_URL"))
+                    .orNull
+                    ?.let { url.set(it) }
+
+                licenses {
+                    license {
+                        name.set("MIT")
+                        url.set("https://opensource.org/licenses/MIT")
+                    }
+                }
+
+                val pomDeveloperId = providers.gradleProperty("pomDeveloperId")
+                    .orElse(providers.environmentVariable("POM_DEVELOPER_ID"))
+                    .orNull
+                val pomDeveloperName = providers.gradleProperty("pomDeveloperName")
+                    .orElse(providers.environmentVariable("POM_DEVELOPER_NAME"))
+                    .orNull
+
+                if (pomDeveloperId != null || pomDeveloperName != null) {
+                    developers {
+                        developer {
+                            pomDeveloperId?.let { id.set(it) }
+                            pomDeveloperName?.let { name.set(it) }
+                        }
+                    }
+                }
+
+                val pomScmUrl = providers.gradleProperty("pomScmUrl")
+                    .orElse(providers.environmentVariable("POM_SCM_URL"))
+                    .orNull
+                val pomScmConnection = providers.gradleProperty("pomScmConnection")
+                    .orElse(providers.environmentVariable("POM_SCM_CONNECTION"))
+                    .orNull
+                val pomScmDeveloperConnection = providers.gradleProperty("pomScmDeveloperConnection")
+                    .orElse(providers.environmentVariable("POM_SCM_DEVELOPER_CONNECTION"))
+                    .orNull
+
+                if (pomScmUrl != null || pomScmConnection != null || pomScmDeveloperConnection != null) {
+                    scm {
+                        pomScmUrl?.let { url.set(it) }
+                        pomScmConnection?.let { connection.set(it) }
+                        pomScmDeveloperConnection?.let { developerConnection.set(it) }
+                    }
+                }
+            }
+        }
+    }
+
+    repositories {
+        maven {
+            name = providers.gradleProperty("mavenRepositoryName")
+                .orElse(providers.environmentVariable("MAVEN_REPOSITORY_NAME"))
+                .orElse("generated")
+                .get()
+
+            url = uri(
+                providers.gradleProperty("mavenRepositoryUrl")
+                    .orElse(providers.environmentVariable("MAVEN_REPOSITORY_URL"))
+                    .orElse(layout.buildDirectory.dir("maven-repository").map { it.asFile.toURI().toString() })
+                    .get()
+            )
+
+            val publishUsername = providers.gradleProperty("mavenRepositoryUsername")
+                .orElse(providers.environmentVariable("MAVEN_REPOSITORY_USERNAME"))
+                .orNull
+            val publishPassword = providers.gradleProperty("mavenRepositoryPassword")
+                .orElse(providers.environmentVariable("MAVEN_REPOSITORY_PASSWORD"))
+                .orNull
+
+            if (publishUsername != null || publishPassword != null) {
+                credentials {
+                    username = publishUsername
+                    password = publishPassword
+                }
+            }
+        }
+    }
+}
+
+val signingKey = providers.gradleProperty("signingInMemoryKey")
+    .orElse(providers.environmentVariable("SIGNING_IN_MEMORY_KEY"))
+    .orNull
+    ?.replace("\\n", "\n")
+val signingPassword = providers.gradleProperty("signingInMemoryKeyPassword")
+    .orElse(providers.environmentVariable("SIGNING_IN_MEMORY_KEY_PASSWORD"))
+    .orNull
+
+signing {
+    isRequired = signingKey != null
+
+    if (signingKey != null) {
+        useInMemoryPgpKeys(signingKey, signingPassword)
+        sign(publishing.publications["maven"])
+    }
+}

package/templates/kotlin/client.hbs

@@ -0,0 +1,57 @@
+package {{packageName}}
+
+import kotlinx.coroutines.*
+
+/**
+ * Configuration for the {{title}} API client.
+ */
+data class ClientConfig(
+    val baseUrl: String = "{{baseUrl}}",
+{{#each securitySchemes}}
+{{#if (eq type "apiKey")}}
+    /** API key for the `{{name}}` security scheme. */
+    val {{configKey}}: String? = null,
+{{/if}}
+{{#if (and (eq type "http") (eq scheme "bearer"))}}
+    /** Bearer token for the `{{name}}` security scheme. */
+    val {{configKey}}: String? = null,
+{{/if}}
+{{#if (eq type "oauth2")}}
+    /** OAuth2 access token for the `{{name}}` security scheme. */
+    val {{configKey}}: String? = null,
+{{/if}}
+{{#if (eq type "openIdConnect")}}
+    /** OpenID Connect access token for the `{{name}}` security scheme. */
+    val {{configKey}}: String? = null,
+{{/if}}
+{{/each}}
+    /** Request timeout in milliseconds. */
+    val timeoutMs: Long = 15000,
+    /** Maximum number of retry attempts. */
+    val maxRetries: Int = 3,
+)
+
+/**
+ * Primary API client for {{title}}.
+ *
+ * Provides access to all domain-specific API groups.
+ */
+class {{clientName}}Client(
+    config: ClientConfig = ClientConfig()
+) {
+    private val transport: Transport = Transport(
+        TransportConfig(
+            baseUrl = config.baseUrl,
+{{#each securitySchemes}}
+            {{configKey}} = config.{{configKey}},
+{{/each}}
+            timeoutMs = config.timeoutMs,
+            maxRetries = config.maxRetries,
+        )
+    )
+
+{{#each groups}}
+    /** {{#if description}}{{description}}{{else}}{{interfaceName}} operations.{{/if}} */
+    val {{name}}: {{interfaceName}} = {{interfaceName}}(transport)
+{{/each}}
+}

package/templates/kotlin/domain.hbs

@@ -0,0 +1,73 @@
+package {{packageName}}
+
+import io.ktor.http.*
+import kotlinx.coroutines.*
+
+/**
+ * {{#if description}}{{description}}{{else}}{{interfaceName}} API operations.{{/if}}
+ */
+class {{interfaceName}}(
+    private val transport: Transport
+) {
+{{#each operations}}
+    {{#if summary}}
+    /**
+     * {{summary}}{{#if description}}
+     *
+     * {{description}}{{/if}}
+     */
+    {{/if}}
+    {{#if deprecated}}
+    @Deprecated(
+        message = "{{#if deprecationMessage}}{{deprecationMessage}}{{else}}This operation is deprecated.{{/if}}",
+    )
+    {{/if}}
+    suspend fun {{name}}(
+{{#each pathParams}}
+        {{name}}: {{{kotlinType type}}},
+{{/each}}
+{{#if requestBody}}
+        body: {{{requestBody.kotlinType}}},
+{{/if}}
+{{#if queryType}}
+        query: {{{kotlinType queryType}}}? = null,
+{{/if}}
+    ): {{{kotlinResponseType}}} {
+        val path = "{{path}}"{{#each pathParams}}.replace("{" + "{{name}}" + "}", {{name}}.toString()){{/each}}
+
+        {{#if (hasQueryParams this)}}
+        val queryMap = mutableMapOf<String, String?>()
+        {{#each _queryParams}}
+        queryMap["{{originalName}}"] = null // TODO: extract from typed query if available
+        {{/each}}
+        {{else if queryType}}
+        val queryMap: Map<String, String?>? = null // TODO: serialize query type
+        {{else}}
+        val queryMap: Map<String, String?>? = null
+        {{/if}}
+
+        {{#if (or (hasRequestBody this) (needsRequestHeaders this))}}
+        val headers = mutableMapOf<String, String>()
+        {{#if (hasRequestBody this)}}
+        {{#if (and (neq requestBody.contentType "application/json") (neq requestBody.contentType "multipart/form-data"))}}
+        headers["Content-Type"] = "{{requestBody.contentType}}"
+        {{/if}}
+        {{/if}}
+        {{#each headerParams}}
+        // TODO: inject header param '{{originalName}}' from header options
+        {{/each}}
+        {{else}}
+        val headers: Map<String, String>? = null
+        {{/if}}
+
+        return transport.execute<{{{kotlinResponseType}}}>(
+            method = HttpMethod.{{httpMethod}},
+            path = path,
+            query = queryMap,
+            body = {{#if requestBody}}body{{else}}null{{/if}},
+            headers = headers{{#unless (or (hasRequestBody this) (needsRequestHeaders this))}}{{/unless}},
+        )
+    }
+
+{{/each}}
+}

package/templates/kotlin/errors.hbs

@@ -0,0 +1,42 @@
+package {{packageName}}
+
+/**
+ * Primary exception type for the {{packageName}} SDK.
+ *
+ * All API methods throw [SdkException] on failure.
+ */
+class SdkException(
+    /** HTTP status code, if this is an API error. */
+    val status: Int?,
+    /** Machine-readable error code (if available). */
+    val code: String?,
+    /** Human-readable error message. */
+    override val message: String,
+    /** Server-assigned request ID for support. */
+    val requestId: String?,
+    /** The underlying cause, if any. */
+    cause: Throwable? = null,
+) : Exception(message, cause) {
+
+    /** Returns `true` if this error was caused by the server (5xx). */
+    fun isServerError(): Boolean = status != null && status in 500..599
+
+    /** Returns `true` if this error was caused by the client (4xx). */
+    fun isClientError(): Boolean = status != null && status in 400..499
+
+    /** Returns `true` if this is a network error (should be retried safely). */
+    fun isNetworkError(): Boolean = status == null
+
+    /** Returns `true` if this error is retryable. */
+    fun isRetryable(): Boolean = isNetworkError() || status in setOf(429, 502, 503, 504)
+
+    override fun toString(): String {
+        val sb = StringBuilder("SdkException(")
+        if (status != null) sb.append("status=$status, ")
+        if (code != null) sb.append("code='$code', ")
+        sb.append("message='$message'")
+        if (requestId != null) sb.append(", requestId='$requestId'")
+        sb.append(")")
+        return sb.toString()
+    }
+}

package/templates/kotlin/gradle-properties.hbs

@@ -0,0 +1,2 @@
+kotlin.code.style=official
+org.gradle.jvmargs=-Xmx1g

package/templates/kotlin/readme.hbs

@@ -0,0 +1,133 @@
+# {{title}}
+
+{{#if description}}{{description}}{{/if}}
+
+{{#unless description}}An auto-generated Kotlin SDK for the {{title}} API.{{/unless}}
+
+## Installation
+
+### Gradle
+
+Add the dependency to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    // If publishing to a private repository, add it here.
+}
+
+dependencies {
+    implementation("{{groupId}}:{{artifactId}}:{{#if packageVersion}}{{packageVersion}}{{else}}0.1.0{{/if}}")
+}
+```
+
+### Maven
+
+```xml
+<dependency>
+    <groupId>{{groupId}}</groupId>
+    <artifactId>{{artifactId}}</artifactId>
+    <version>{{#if packageVersion}}{{packageVersion}}{{else}}0.1.0{{/if}}</version>
+</dependency>
+```
+
+## Publishing
+
+Publish to your local Maven cache:
+
+```bash
+gradle publishToMavenLocal
+```
+
+Publish to a Maven repository:
+
+```bash
+MAVEN_REPOSITORY_URL="https://maven.example.com/releases" \
+MAVEN_REPOSITORY_USERNAME="username" \
+MAVEN_REPOSITORY_PASSWORD="password" \
+gradle publish
+```
+
+The generated Gradle project also supports equivalent Gradle properties:
+
+- `mavenRepositoryUrl`
+- `mavenRepositoryUsername`
+- `mavenRepositoryPassword`
+- `mavenRepositoryName`
+
+For signed publications, provide `SIGNING_IN_MEMORY_KEY` and `SIGNING_IN_MEMORY_KEY_PASSWORD` or the matching Gradle properties `signingInMemoryKey` and `signingInMemoryKeyPassword`.
+
+For repositories that require richer POM metadata, set `POM_URL`, `POM_SCM_URL`, `POM_SCM_CONNECTION`, `POM_SCM_DEVELOPER_CONNECTION`, `POM_DEVELOPER_ID`, and `POM_DEVELOPER_NAME` or the equivalent lower-camel Gradle properties.
+
+## Quick Start
+
+```kotlin
+import {{packageName}}.Client
+import {{packageName}}.ClientConfig
+import kotlinx.coroutines.runBlocking
+
+fun main() = runBlocking {
+    val config = ClientConfig(
+{{#each securitySchemes}}
+{{#if (eq type "apiKey")}}
+        {{configKey}} = "your-api-key",
+{{/if}}
+{{#if (and (eq type "http") (eq scheme "bearer"))}}
+        {{configKey}} = "your-bearer-token",
+{{/if}}
+{{/each}}
+    )
+
+    val client = Client(config)
+
+{{#each groups}}
+{{#if @first}}
+    // val result = client.{{name}}.someOperation()
+{{/if}}
+{{/each}}
+}
+```
+
+## API Reference
+
+{{#each groups}}
+### {{interfaceName}}
+
+{{#if description}}
+{{description}}
+{{/if}}
+
+| Method | HTTP | Description |
+|--------|------|-------------|
+{{#each operations}}
+| `{{name}}()` | `{{httpMethod}}` | {{#if summary}}{{summary}}{{else}}—{{/if}} |
+{{/each}}
+
+{{/each}}
+
+## Error Handling
+
+All API methods throw `SdkException` on failure. The exception contains:
+
+- `status`: HTTP status code (for API errors)
+- `code`: Machine-readable error code (if available)
+- `message`: Human-readable error message
+- `requestId`: Server-assigned request ID for support
+
+```kotlin
+try {
+    val result = client.users.getUser("user-123")
+    println("Success: $result")
+} catch (e: SdkException) {
+    when {
+        e.isClientError() -> println("Bad request: ${e.message}")
+        e.isServerError() -> println("Server error (${e.status}): ${e.message}")
+        e.isNetworkError() -> println("Network error: ${e.message}")
+        else -> println("Error: ${e.message}")
+    }
+}
+```
+
+## License
+
+MIT

package/templates/kotlin/settings-gradle.hbs

@@ -0,0 +1 @@
+rootProject.name = "{{artifactId}}"