From c26a5fdbd449c2b0ce77ca36ec9549d330087fd9 Mon Sep 17 00:00:00 2001 From: stainless-bot Date: Mon, 22 Jul 2024 23:13:29 +0000 Subject: [PATCH] chore(internal): codegen related update --- .stats.yml | 2 +- .../openlayer/api/client/OpenlayerClient.kt | 2 + .../api/client/OpenlayerClientAsync.kt | 2 + .../api/client/OpenlayerClientAsyncImpl.kt | 4 + .../api/client/OpenlayerClientImpl.kt | 4 + .../models/StoragePresignedUrlCreateParams.kt | 156 ++++++++++++++++++ .../StoragePresignedUrlCreateResponse.kt | 152 +++++++++++++++++ .../api/services/async/StorageServiceAsync.kt | 12 ++ .../services/async/StorageServiceAsyncImpl.kt | 24 +++ .../async/storage/PresignedUrlServiceAsync.kt | 20 +++ .../storage/PresignedUrlServiceAsyncImpl.kt | 56 +++++++ .../api/services/blocking/StorageService.kt | 12 ++ .../services/blocking/StorageServiceImpl.kt | 22 +++ .../blocking/storage/PresignedUrlService.kt | 19 +++ .../storage/PresignedUrlServiceImpl.kt | 54 ++++++ .../StoragePresignedUrlCreateParamsTest.kt | 31 ++++ .../StoragePresignedUrlCreateResponseTest.kt | 25 +++ .../services/blocking/StorageServiceTest.kt | 9 + .../storage/PresignedUrlServiceTest.kt | 29 ++++ 19 files changed, 634 insertions(+), 1 deletion(-) create mode 100644 openlayer-java-core/src/main/kotlin/com/openlayer/api/models/StoragePresignedUrlCreateParams.kt create mode 100644 openlayer-java-core/src/main/kotlin/com/openlayer/api/models/StoragePresignedUrlCreateResponse.kt create mode 100644 openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/StorageServiceAsync.kt create mode 100644 openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/StorageServiceAsyncImpl.kt create mode 100644 openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/storage/PresignedUrlServiceAsync.kt create mode 100644 openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/storage/PresignedUrlServiceAsyncImpl.kt create mode 100644 openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/StorageService.kt create mode 100644 openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/StorageServiceImpl.kt create mode 100644 openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/storage/PresignedUrlService.kt create mode 100644 openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/storage/PresignedUrlServiceImpl.kt create mode 100644 openlayer-java-core/src/test/kotlin/com/openlayer/api/models/StoragePresignedUrlCreateParamsTest.kt create mode 100644 openlayer-java-core/src/test/kotlin/com/openlayer/api/models/StoragePresignedUrlCreateResponseTest.kt create mode 100644 openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/StorageServiceTest.kt create mode 100644 openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/storage/PresignedUrlServiceTest.kt diff --git a/.stats.yml b/.stats.yml index de47912..af63a6f 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1 +1 @@ -configured_endpoints: 9 +configured_endpoints: 10 diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClient.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClient.kt index 1f528fc..3a24286 100644 --- a/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClient.kt +++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClient.kt @@ -16,4 +16,6 @@ interface OpenlayerClient { fun commits(): CommitService fun inferencePipelines(): InferencePipelineService + + fun storage(): StorageService } diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientAsync.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientAsync.kt index 57d71e1..7d8847c 100644 --- a/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientAsync.kt +++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientAsync.kt @@ -16,4 +16,6 @@ interface OpenlayerClientAsync { fun commits(): CommitServiceAsync fun inferencePipelines(): InferencePipelineServiceAsync + + fun storage(): StorageServiceAsync } diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientAsyncImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientAsyncImpl.kt index a6a4ee6..d3c13ec 100644 --- a/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientAsyncImpl.kt +++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientAsyncImpl.kt @@ -26,6 +26,8 @@ constructor( InferencePipelineServiceAsyncImpl(clientOptions) } + private val storage: StorageServiceAsync by lazy { StorageServiceAsyncImpl(clientOptions) } + override fun sync(): OpenlayerClient = sync override fun projects(): ProjectServiceAsync = projects @@ -33,4 +35,6 @@ constructor( override fun commits(): CommitServiceAsync = commits override fun inferencePipelines(): InferencePipelineServiceAsync = inferencePipelines + + override fun storage(): StorageServiceAsync = storage } diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientImpl.kt index e8378b1..29a6187 100644 --- a/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientImpl.kt +++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/client/OpenlayerClientImpl.kt @@ -26,6 +26,8 @@ constructor( InferencePipelineServiceImpl(clientOptions) } + private val storage: StorageService by lazy { StorageServiceImpl(clientOptions) } + override fun async(): OpenlayerClientAsync = async override fun projects(): ProjectService = projects @@ -33,4 +35,6 @@ constructor( override fun commits(): CommitService = commits override fun inferencePipelines(): InferencePipelineService = inferencePipelines + + override fun storage(): StorageService = storage } diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/StoragePresignedUrlCreateParams.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/StoragePresignedUrlCreateParams.kt new file mode 100644 index 0000000..e5085a5 --- /dev/null +++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/StoragePresignedUrlCreateParams.kt @@ -0,0 +1,156 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openlayer.api.models + +import com.openlayer.api.core.JsonValue +import com.openlayer.api.core.NoAutoDetect +import com.openlayer.api.core.toUnmodifiable +import com.openlayer.api.models.* +import java.util.Objects +import java.util.Optional + +class StoragePresignedUrlCreateParams +constructor( + private val objectName: String, + private val additionalQueryParams: Map>, + private val additionalHeaders: Map>, + private val additionalBodyProperties: Map, +) { + + fun objectName(): String = objectName + + @JvmSynthetic + internal fun getBody(): Optional> { + return Optional.ofNullable(additionalBodyProperties.ifEmpty { null }) + } + + @JvmSynthetic + internal fun getQueryParams(): Map> { + val params = mutableMapOf>() + this.objectName.let { params.put("objectName", listOf(it.toString())) } + params.putAll(additionalQueryParams) + return params.toUnmodifiable() + } + + @JvmSynthetic internal fun getHeaders(): Map> = additionalHeaders + + fun _additionalQueryParams(): Map> = additionalQueryParams + + fun _additionalHeaders(): Map> = additionalHeaders + + fun _additionalBodyProperties(): Map = additionalBodyProperties + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is StoragePresignedUrlCreateParams && + this.objectName == other.objectName && + this.additionalQueryParams == other.additionalQueryParams && + this.additionalHeaders == other.additionalHeaders && + this.additionalBodyProperties == other.additionalBodyProperties + } + + override fun hashCode(): Int { + return Objects.hash( + objectName, + additionalQueryParams, + additionalHeaders, + additionalBodyProperties, + ) + } + + override fun toString() = + "StoragePresignedUrlCreateParams{objectName=$objectName, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders, additionalBodyProperties=$additionalBodyProperties}" + + fun toBuilder() = Builder().from(this) + + companion object { + + @JvmStatic fun builder() = Builder() + } + + @NoAutoDetect + class Builder { + + private var objectName: String? = null + private var additionalQueryParams: MutableMap> = mutableMapOf() + private var additionalHeaders: MutableMap> = mutableMapOf() + private var additionalBodyProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(storagePresignedUrlCreateParams: StoragePresignedUrlCreateParams) = + apply { + this.objectName = storagePresignedUrlCreateParams.objectName + additionalQueryParams(storagePresignedUrlCreateParams.additionalQueryParams) + additionalHeaders(storagePresignedUrlCreateParams.additionalHeaders) + additionalBodyProperties(storagePresignedUrlCreateParams.additionalBodyProperties) + } + + /** The name of the object. */ + fun objectName(objectName: String) = apply { this.objectName = objectName } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllQueryParams(additionalQueryParams) + } + + fun putQueryParam(name: String, value: String) = apply { + this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + } + + fun putQueryParams(name: String, values: Iterable) = apply { + this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + } + + fun putAllQueryParams(additionalQueryParams: Map>) = apply { + additionalQueryParams.forEach(this::putQueryParams) + } + + fun removeQueryParam(name: String) = apply { + this.additionalQueryParams.put(name, mutableListOf()) + } + + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllHeaders(additionalHeaders) + } + + fun putHeader(name: String, value: String) = apply { + this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + } + + fun putHeaders(name: String, values: Iterable) = apply { + this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + } + + fun putAllHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(this::putHeaders) + } + + fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + + fun additionalBodyProperties(additionalBodyProperties: Map) = apply { + this.additionalBodyProperties.clear() + this.additionalBodyProperties.putAll(additionalBodyProperties) + } + + fun putAdditionalBodyProperty(key: String, value: JsonValue) = apply { + this.additionalBodyProperties.put(key, value) + } + + fun putAllAdditionalBodyProperties(additionalBodyProperties: Map) = + apply { + this.additionalBodyProperties.putAll(additionalBodyProperties) + } + + fun build(): StoragePresignedUrlCreateParams = + StoragePresignedUrlCreateParams( + checkNotNull(objectName) { "`objectName` is required but was not set" }, + additionalQueryParams.mapValues { it.value.toUnmodifiable() }.toUnmodifiable(), + additionalHeaders.mapValues { it.value.toUnmodifiable() }.toUnmodifiable(), + additionalBodyProperties.toUnmodifiable(), + ) + } +} diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/StoragePresignedUrlCreateResponse.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/StoragePresignedUrlCreateResponse.kt new file mode 100644 index 0000000..57c2fca --- /dev/null +++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/models/StoragePresignedUrlCreateResponse.kt @@ -0,0 +1,152 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openlayer.api.models + +import com.fasterxml.jackson.annotation.JsonAnyGetter +import com.fasterxml.jackson.annotation.JsonAnySetter +import com.fasterxml.jackson.annotation.JsonProperty +import com.fasterxml.jackson.databind.annotation.JsonDeserialize +import com.openlayer.api.core.ExcludeMissing +import com.openlayer.api.core.JsonField +import com.openlayer.api.core.JsonMissing +import com.openlayer.api.core.JsonValue +import com.openlayer.api.core.NoAutoDetect +import com.openlayer.api.core.toUnmodifiable +import java.util.Objects + +@JsonDeserialize(builder = StoragePresignedUrlCreateResponse.Builder::class) +@NoAutoDetect +class StoragePresignedUrlCreateResponse +private constructor( + private val url: JsonField, + private val fields: JsonValue, + private val storageUri: JsonField, + private val additionalProperties: Map, +) { + + private var validated: Boolean = false + + private var hashCode: Int = 0 + + /** The presigned url. */ + fun url(): String = url.getRequired("url") + + /** The storage URI to send back to the backend after the upload was completed. */ + fun storageUri(): String = storageUri.getRequired("storageUri") + + /** The presigned url. */ + @JsonProperty("url") @ExcludeMissing fun _url() = url + + /** Fields to include in the body of the upload. Only needed by s3. */ + @JsonProperty("fields") @ExcludeMissing fun _fields() = fields + + /** The storage URI to send back to the backend after the upload was completed. */ + @JsonProperty("storageUri") @ExcludeMissing fun _storageUri() = storageUri + + @JsonAnyGetter + @ExcludeMissing + fun _additionalProperties(): Map = additionalProperties + + fun validate(): StoragePresignedUrlCreateResponse = apply { + if (!validated) { + url() + storageUri() + validated = true + } + } + + fun toBuilder() = Builder().from(this) + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is StoragePresignedUrlCreateResponse && + this.url == other.url && + this.fields == other.fields && + this.storageUri == other.storageUri && + this.additionalProperties == other.additionalProperties + } + + override fun hashCode(): Int { + if (hashCode == 0) { + hashCode = + Objects.hash( + url, + fields, + storageUri, + additionalProperties, + ) + } + return hashCode + } + + override fun toString() = + "StoragePresignedUrlCreateResponse{url=$url, fields=$fields, storageUri=$storageUri, additionalProperties=$additionalProperties}" + + companion object { + + @JvmStatic fun builder() = Builder() + } + + class Builder { + + private var url: JsonField = JsonMissing.of() + private var fields: JsonValue = JsonMissing.of() + private var storageUri: JsonField = JsonMissing.of() + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(storagePresignedUrlCreateResponse: StoragePresignedUrlCreateResponse) = + apply { + this.url = storagePresignedUrlCreateResponse.url + this.fields = storagePresignedUrlCreateResponse.fields + this.storageUri = storagePresignedUrlCreateResponse.storageUri + additionalProperties(storagePresignedUrlCreateResponse.additionalProperties) + } + + /** The presigned url. */ + fun url(url: String) = url(JsonField.of(url)) + + /** The presigned url. */ + @JsonProperty("url") + @ExcludeMissing + fun url(url: JsonField) = apply { this.url = url } + + /** Fields to include in the body of the upload. Only needed by s3. */ + @JsonProperty("fields") + @ExcludeMissing + fun fields(fields: JsonValue) = apply { this.fields = fields } + + /** The storage URI to send back to the backend after the upload was completed. */ + fun storageUri(storageUri: String) = storageUri(JsonField.of(storageUri)) + + /** The storage URI to send back to the backend after the upload was completed. */ + @JsonProperty("storageUri") + @ExcludeMissing + fun storageUri(storageUri: JsonField) = apply { this.storageUri = storageUri } + + fun additionalProperties(additionalProperties: Map) = apply { + this.additionalProperties.clear() + this.additionalProperties.putAll(additionalProperties) + } + + @JsonAnySetter + fun putAdditionalProperty(key: String, value: JsonValue) = apply { + this.additionalProperties.put(key, value) + } + + fun putAllAdditionalProperties(additionalProperties: Map) = apply { + this.additionalProperties.putAll(additionalProperties) + } + + fun build(): StoragePresignedUrlCreateResponse = + StoragePresignedUrlCreateResponse( + url, + fields, + storageUri, + additionalProperties.toUnmodifiable(), + ) + } +} diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/StorageServiceAsync.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/StorageServiceAsync.kt new file mode 100644 index 0000000..6a59073 --- /dev/null +++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/StorageServiceAsync.kt @@ -0,0 +1,12 @@ +// File generated from our OpenAPI spec by Stainless. + +@file:Suppress("OVERLOADS_INTERFACE") // See https://youtrack.jetbrains.com/issue/KT-36102 + +package com.openlayer.api.services.async + +import com.openlayer.api.services.async.storage.PresignedUrlServiceAsync + +interface StorageServiceAsync { + + fun presignedUrl(): PresignedUrlServiceAsync +} diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/StorageServiceAsyncImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/StorageServiceAsyncImpl.kt new file mode 100644 index 0000000..2dd732c --- /dev/null +++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/StorageServiceAsyncImpl.kt @@ -0,0 +1,24 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openlayer.api.services.async + +import com.openlayer.api.core.ClientOptions +import com.openlayer.api.core.http.HttpResponse.Handler +import com.openlayer.api.errors.OpenlayerError +import com.openlayer.api.services.async.storage.PresignedUrlServiceAsync +import com.openlayer.api.services.async.storage.PresignedUrlServiceAsyncImpl +import com.openlayer.api.services.errorHandler + +class StorageServiceAsyncImpl +constructor( + private val clientOptions: ClientOptions, +) : StorageServiceAsync { + + private val errorHandler: Handler = errorHandler(clientOptions.jsonMapper) + + private val presignedUrl: PresignedUrlServiceAsync by lazy { + PresignedUrlServiceAsyncImpl(clientOptions) + } + + override fun presignedUrl(): PresignedUrlServiceAsync = presignedUrl +} diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/storage/PresignedUrlServiceAsync.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/storage/PresignedUrlServiceAsync.kt new file mode 100644 index 0000000..933abd8 --- /dev/null +++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/storage/PresignedUrlServiceAsync.kt @@ -0,0 +1,20 @@ +// File generated from our OpenAPI spec by Stainless. + +@file:Suppress("OVERLOADS_INTERFACE") // See https://youtrack.jetbrains.com/issue/KT-36102 + +package com.openlayer.api.services.async.storage + +import com.openlayer.api.core.RequestOptions +import com.openlayer.api.models.StoragePresignedUrlCreateParams +import com.openlayer.api.models.StoragePresignedUrlCreateResponse +import java.util.concurrent.CompletableFuture + +interface PresignedUrlServiceAsync { + + /** Retrieve a presigned url to post storage artifacts. */ + @JvmOverloads + fun create( + params: StoragePresignedUrlCreateParams, + requestOptions: RequestOptions = RequestOptions.none() + ): CompletableFuture +} diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/storage/PresignedUrlServiceAsyncImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/storage/PresignedUrlServiceAsyncImpl.kt new file mode 100644 index 0000000..65a6972 --- /dev/null +++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/async/storage/PresignedUrlServiceAsyncImpl.kt @@ -0,0 +1,56 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openlayer.api.services.async.storage + +import com.openlayer.api.core.ClientOptions +import com.openlayer.api.core.RequestOptions +import com.openlayer.api.core.http.HttpMethod +import com.openlayer.api.core.http.HttpRequest +import com.openlayer.api.core.http.HttpResponse.Handler +import com.openlayer.api.errors.OpenlayerError +import com.openlayer.api.models.StoragePresignedUrlCreateParams +import com.openlayer.api.models.StoragePresignedUrlCreateResponse +import com.openlayer.api.services.errorHandler +import com.openlayer.api.services.json +import com.openlayer.api.services.jsonHandler +import com.openlayer.api.services.withErrorHandler +import java.util.concurrent.CompletableFuture + +class PresignedUrlServiceAsyncImpl +constructor( + private val clientOptions: ClientOptions, +) : PresignedUrlServiceAsync { + + private val errorHandler: Handler = errorHandler(clientOptions.jsonMapper) + + private val createHandler: Handler = + jsonHandler(clientOptions.jsonMapper) + .withErrorHandler(errorHandler) + + /** Retrieve a presigned url to post storage artifacts. */ + override fun create( + params: StoragePresignedUrlCreateParams, + requestOptions: RequestOptions + ): CompletableFuture { + val request = + HttpRequest.builder() + .method(HttpMethod.POST) + .addPathSegments("storage", "presigned-url") + .putAllQueryParams(clientOptions.queryParams) + .putAllQueryParams(params.getQueryParams()) + .putAllHeaders(clientOptions.headers) + .putAllHeaders(params.getHeaders()) + .apply { params.getBody().ifPresent { body(json(clientOptions.jsonMapper, it)) } } + .build() + return clientOptions.httpClient.executeAsync(request, requestOptions).thenApply { response + -> + response + .use { createHandler.handle(it) } + .apply { + if (requestOptions.responseValidation ?: clientOptions.responseValidation) { + validate() + } + } + } + } +} diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/StorageService.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/StorageService.kt new file mode 100644 index 0000000..bd8b0a0 --- /dev/null +++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/StorageService.kt @@ -0,0 +1,12 @@ +// File generated from our OpenAPI spec by Stainless. + +@file:Suppress("OVERLOADS_INTERFACE") // See https://youtrack.jetbrains.com/issue/KT-36102 + +package com.openlayer.api.services.blocking + +import com.openlayer.api.services.blocking.storage.PresignedUrlService + +interface StorageService { + + fun presignedUrl(): PresignedUrlService +} diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/StorageServiceImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/StorageServiceImpl.kt new file mode 100644 index 0000000..25ff043 --- /dev/null +++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/StorageServiceImpl.kt @@ -0,0 +1,22 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openlayer.api.services.blocking + +import com.openlayer.api.core.ClientOptions +import com.openlayer.api.core.http.HttpResponse.Handler +import com.openlayer.api.errors.OpenlayerError +import com.openlayer.api.services.blocking.storage.PresignedUrlService +import com.openlayer.api.services.blocking.storage.PresignedUrlServiceImpl +import com.openlayer.api.services.errorHandler + +class StorageServiceImpl +constructor( + private val clientOptions: ClientOptions, +) : StorageService { + + private val errorHandler: Handler = errorHandler(clientOptions.jsonMapper) + + private val presignedUrl: PresignedUrlService by lazy { PresignedUrlServiceImpl(clientOptions) } + + override fun presignedUrl(): PresignedUrlService = presignedUrl +} diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/storage/PresignedUrlService.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/storage/PresignedUrlService.kt new file mode 100644 index 0000000..6cc179e --- /dev/null +++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/storage/PresignedUrlService.kt @@ -0,0 +1,19 @@ +// File generated from our OpenAPI spec by Stainless. + +@file:Suppress("OVERLOADS_INTERFACE") // See https://youtrack.jetbrains.com/issue/KT-36102 + +package com.openlayer.api.services.blocking.storage + +import com.openlayer.api.core.RequestOptions +import com.openlayer.api.models.StoragePresignedUrlCreateParams +import com.openlayer.api.models.StoragePresignedUrlCreateResponse + +interface PresignedUrlService { + + /** Retrieve a presigned url to post storage artifacts. */ + @JvmOverloads + fun create( + params: StoragePresignedUrlCreateParams, + requestOptions: RequestOptions = RequestOptions.none() + ): StoragePresignedUrlCreateResponse +} diff --git a/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/storage/PresignedUrlServiceImpl.kt b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/storage/PresignedUrlServiceImpl.kt new file mode 100644 index 0000000..dabbfe5 --- /dev/null +++ b/openlayer-java-core/src/main/kotlin/com/openlayer/api/services/blocking/storage/PresignedUrlServiceImpl.kt @@ -0,0 +1,54 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openlayer.api.services.blocking.storage + +import com.openlayer.api.core.ClientOptions +import com.openlayer.api.core.RequestOptions +import com.openlayer.api.core.http.HttpMethod +import com.openlayer.api.core.http.HttpRequest +import com.openlayer.api.core.http.HttpResponse.Handler +import com.openlayer.api.errors.OpenlayerError +import com.openlayer.api.models.StoragePresignedUrlCreateParams +import com.openlayer.api.models.StoragePresignedUrlCreateResponse +import com.openlayer.api.services.errorHandler +import com.openlayer.api.services.json +import com.openlayer.api.services.jsonHandler +import com.openlayer.api.services.withErrorHandler + +class PresignedUrlServiceImpl +constructor( + private val clientOptions: ClientOptions, +) : PresignedUrlService { + + private val errorHandler: Handler = errorHandler(clientOptions.jsonMapper) + + private val createHandler: Handler = + jsonHandler(clientOptions.jsonMapper) + .withErrorHandler(errorHandler) + + /** Retrieve a presigned url to post storage artifacts. */ + override fun create( + params: StoragePresignedUrlCreateParams, + requestOptions: RequestOptions + ): StoragePresignedUrlCreateResponse { + val request = + HttpRequest.builder() + .method(HttpMethod.POST) + .addPathSegments("storage", "presigned-url") + .putAllQueryParams(clientOptions.queryParams) + .putAllQueryParams(params.getQueryParams()) + .putAllHeaders(clientOptions.headers) + .putAllHeaders(params.getHeaders()) + .apply { params.getBody().ifPresent { body(json(clientOptions.jsonMapper, it)) } } + .build() + return clientOptions.httpClient.execute(request, requestOptions).let { response -> + response + .use { createHandler.handle(it) } + .apply { + if (requestOptions.responseValidation ?: clientOptions.responseValidation) { + validate() + } + } + } + } +} diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/StoragePresignedUrlCreateParamsTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/StoragePresignedUrlCreateParamsTest.kt new file mode 100644 index 0000000..6ae03e8 --- /dev/null +++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/StoragePresignedUrlCreateParamsTest.kt @@ -0,0 +1,31 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openlayer.api.models + +import com.openlayer.api.models.* +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Test + +class StoragePresignedUrlCreateParamsTest { + + @Test + fun createStoragePresignedUrlCreateParams() { + StoragePresignedUrlCreateParams.builder().objectName("objectName").build() + } + + @Test + fun getQueryParams() { + val params = StoragePresignedUrlCreateParams.builder().objectName("objectName").build() + val expected = mutableMapOf>() + expected.put("objectName", listOf("objectName")) + assertThat(params.getQueryParams()).isEqualTo(expected) + } + + @Test + fun getQueryParamsWithoutOptionalFields() { + val params = StoragePresignedUrlCreateParams.builder().objectName("objectName").build() + val expected = mutableMapOf>() + expected.put("objectName", listOf("objectName")) + assertThat(params.getQueryParams()).isEqualTo(expected) + } +} diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/StoragePresignedUrlCreateResponseTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/StoragePresignedUrlCreateResponseTest.kt new file mode 100644 index 0000000..c6dd2f5 --- /dev/null +++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/models/StoragePresignedUrlCreateResponseTest.kt @@ -0,0 +1,25 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openlayer.api.models + +import com.openlayer.api.core.JsonValue +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Test + +class StoragePresignedUrlCreateResponseTest { + + @Test + fun createStoragePresignedUrlCreateResponse() { + val storagePresignedUrlCreateResponse = + StoragePresignedUrlCreateResponse.builder() + .storageUri("storageUri") + .url("url") + .fields(JsonValue.from(mapOf())) + .build() + assertThat(storagePresignedUrlCreateResponse).isNotNull + assertThat(storagePresignedUrlCreateResponse.storageUri()).isEqualTo("storageUri") + assertThat(storagePresignedUrlCreateResponse.url()).isEqualTo("url") + assertThat(storagePresignedUrlCreateResponse._fields()) + .isEqualTo(JsonValue.from(mapOf())) + } +} diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/StorageServiceTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/StorageServiceTest.kt new file mode 100644 index 0000000..5c66b4e --- /dev/null +++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/StorageServiceTest.kt @@ -0,0 +1,9 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openlayer.api.services.blocking + +import com.openlayer.api.TestServerExtension +import com.openlayer.api.models.* +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) class StorageServiceTest diff --git a/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/storage/PresignedUrlServiceTest.kt b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/storage/PresignedUrlServiceTest.kt new file mode 100644 index 0000000..558cb7c --- /dev/null +++ b/openlayer-java-core/src/test/kotlin/com/openlayer/api/services/blocking/storage/PresignedUrlServiceTest.kt @@ -0,0 +1,29 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openlayer.api.services.blocking.storage + +import com.openlayer.api.TestServerExtension +import com.openlayer.api.client.okhttp.OpenlayerOkHttpClient +import com.openlayer.api.models.* +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +class PresignedUrlServiceTest { + + @Test + fun callCreate() { + val client = + OpenlayerOkHttpClient.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val presignedUrlService = client.storage().presignedUrl() + val storagePresignedUrlCreateResponse = + presignedUrlService.create( + StoragePresignedUrlCreateParams.builder().objectName("objectName").build() + ) + println(storagePresignedUrlCreateResponse) + storagePresignedUrlCreateResponse.validate() + } +}